@zip.js/zip.js 2.5.11 → 2.5.14

package/lib/core/codec-pool-worker.js

@@ -44,7 +44,9 @@ export {
 	getWorker
 };
 
-function getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts) {
+function getWorker(workerData, stream, workerOptions, onTaskFinished) {
+	const { readable, writable } = stream;
+	const { options, config, streamOptions, webWorker, scripts, codecConstructor } = workerOptions;
 	Object.assign(workerData, {
 		busy: true,
 		codecConstructor,
@@ -63,36 +65,47 @@ function getWorker(workerData, codecConstructor, readable, writable, options, co
 			onTaskFinished(workerData);
 		}
 	});
-	const { signal, onprogress, size } = streamOptions;
-	if (signal || onprogress) {
+	const { signal, size, onstart, onprogress, onend } = streamOptions;
+	if (signal || onstart || onprogress || onend) {
 		let chunkOffset = 0;
 		const transformer = {};
+		if (onstart) {
+			transformer.start = () => callHandler(onstart, size());
+		}
 		if (onprogress) {
-			transformer.transform = (chunk, controller) => {
+			transformer.transform = async (chunk, controller) => {
 				chunkOffset += chunk.length;
-				try {
-					onprogress(chunkOffset, size());
-				} catch (_error) {
-					// ignored
-				}
+				await callHandler(onprogress, chunkOffset, size());
 				controller.enqueue(chunk);
 			};
 		}
-		workerData.readable = readable.pipeThrough(new TransformStream(transformer), { signal });
+		if (onend) {
+			transformer.flush = () => callHandler(onend);
+		}
+		workerData.readable = readable.pipeThrough(new TransformStream(transformer, { highWaterMark: 1, size: () => config.chunkSize }), { signal });
 	}
 	return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 }
 
+async function callHandler(handler, ...parameters) {
+	try {
+		await handler(...parameters);
+	} catch (_error) {
+		// ignored
+	}
+}
+
 function createWorkerInterface(workerData, config) {
 	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
+	const { onTaskFinished } = workerData;
 	const codec = {
 		abort() {
 			interfaceCodec.abort();
-			workerData.onTaskFinished();
+			onTaskFinished();
 		},
-		run() {
-			const result = interfaceCodec.run();
-			workerData.onTaskFinished();
+		async run() {
+			const result = await interfaceCodec.run();
+			onTaskFinished();
 			return result;
 		}
 	};
@@ -101,11 +114,14 @@ function createWorkerInterface(workerData, config) {
 
 function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	const workerOptions = { type: "module" };
-	workerData.reader = workerData.readable.getReader();
-	workerData.writer = workerData.writable.getWriter();
-	workerData.result = new Promise((resolve, reject) => {
-		workerData.resolveResult = resolve;
-		workerData.rejectResult = reject;
+	const { readable, writable } = workerData;
+	Object.assign(workerData, {
+		reader: readable.getReader(),
+		writer: writable.getWriter(),
+		result: new Promise((resolve, reject) => {
+			workerData.resolveResult = resolve;
+			workerData.rejectResult = reject;
+		})
 	});
 	if (!workerData.interface) {
 		if (!classicWorkersSupported) {
@@ -126,7 +142,7 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				workerData.onTaskFinished();
 			},
 			run() {
-				const options = workerData.options;
+				const { options } = workerData;
 				const scripts = workerData.scripts.slice(1);
 				sendMessage({ type: MESSAGE_START, scripts, options, config: { chunkSize } });
 				return workerData.result;
@@ -150,12 +166,13 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	}
 
 	function sendMessage(message) {
-		const worker = workerData.worker;
+		const { worker, writer, onTaskFinished } = workerData;
 		try {
 			let { data } = message;
 			if (data) {
 				try {
-					if (data.length != data.buffer.byteLength) {
+					const { buffer, length } = data;
+					if (length != buffer.byteLength) {
 						data = new Uint8Array(data);
 					}
 					message.data = data.buffer;
@@ -167,43 +184,48 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				worker.postMessage(message);
 			}
 		} catch (error) {
-			workerData.writer.releaseLock();
-			workerData.onTaskFinished();
+			writer.releaseLock();
+			onTaskFinished();
 			throw error;
 		}
 	}
 
 	async function onMessage(event) {
 		const message = event.data;
+		const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
+		const { type, data, messageId, result } = message;
 		const reponseError = message.error;
 		try {
 			if (reponseError) {
-				const error = new Error(reponseError.message);
-				error.stack = reponseError.stack;
-				workerData.rejectResult(error);
-				workerData.writer.releaseLock();
-				workerData.onTaskFinished();
+				const { message, stack } = reponseError;
+				const error = new Error(message);
+				error.stack = stack;
+				close(error);
 			} else {
-				if (message.type == MESSAGE_PULL) {
-					const { value, done } = await workerData.reader.read();
-					sendMessage({ type: MESSAGE_DATA, data: value, done, messageId: message.messageId });
+				if (type == MESSAGE_PULL) {
+					const { value, done } = await reader.read();
+					sendMessage({ type: MESSAGE_DATA, data: value, done, messageId });
 				}
-				if (message.type == MESSAGE_DATA) {
-					let { data } = message;
-					data = new Uint8Array(data);
-					await workerData.writer.ready;
-					await workerData.writer.write(data);
+				if (type == MESSAGE_DATA) {
+					await writer.ready;
+					await writer.write(new Uint8Array(data));
 				}
-				if (message.type == MESSAGE_CLOSE) {
-					workerData.resolveResult(message.result);
-					workerData.writer.releaseLock();
-					workerData.onTaskFinished();
+				if (type == MESSAGE_CLOSE) {
+					close(null, result);
 				}
 			}
 		} catch (error) {
-			workerData.rejectResult(error);
-			workerData.writer.releaseLock();
-			workerData.onTaskFinished();
+			close(error);
+		}
+
+		function close(error, result) {
+			if (error) {
+				rejectResult(error);
+			} else {
+				resolveResult(result);
+			}
+			writer.releaseLock();
+			onTaskFinished();
 		}
 	}
 }

package/lib/core/codec-pool.js

@@ -41,7 +41,7 @@ let pool = [];
 const pendingRequests = [];
 
 export {
-	runCodec,
+	runWorker,
 	terminateWorkers,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
@@ -52,24 +52,27 @@ export {
 
 let indexWorker = 0;
 
-async function runCodec(codecConstructor, readable, writable, options, config, streamOptions) {
+async function runWorker(stream, workerOptions) {
+	const { options, config, streamOptions } = workerOptions;
 	const streamCopy = !options.compressed && !options.signed && !options.encrypted;
-	const webWorker = !streamCopy && (options.useWebWorkers || (options.useWebWorkers === undefined && config.useWebWorkers));
-	const scripts = webWorker && config.workerScripts ? config.workerScripts[options.codecType] : [];
-	options.useCompressionStream = options.useCompressionStream === undefined ? config.useCompressionStream : options.useCompressionStream;
+	const { useWebWorkers, useCompressionStream, codecType } = options;
+	const { workerScripts } = config;
+	workerOptions.webWorker = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
+	workerOptions.scripts = workerOptions.webWorker && workerScripts ? workerScripts[codecType] : [];
+	options.useCompressionStream = useCompressionStream === undefined ? config.useCompressionStream : useCompressionStream;
 	let codec;
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };
 		indexWorker++;
 		pool.push(workerData);
-		codec = getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts);
+		codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
 	} else {
 		const workerData = pool.find(workerData => !workerData.busy);
 		if (workerData) {
 			clearTerminateTimeout(workerData);
-			codec = getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts);
+			codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
 		} else {
-			codec = await new Promise(resolve => pendingRequests.push({ resolve, codecConstructor, readable, writable, options, webWorker, scripts }));
+			codec = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
 		}
 	}
 	const { signal } = streamOptions;
@@ -86,15 +89,16 @@ async function runCodec(codecConstructor, readable, writable, options, config, s
 
 	function onTaskFinished(workerData) {
 		if (pendingRequests.length) {
-			const [{ resolve, codecConstructor, readable, writable, options, webWorker, scripts }] = pendingRequests.splice(0, 1);
-			resolve(getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts));
+			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
+			resolve(getWorker(workerData, stream, workerOptions, onTaskFinished));
 		} else if (workerData.worker) {
+			const { terminateWorkerTimeout } = config;
 			clearTerminateTimeout(workerData);
-			if (Number.isFinite(config.terminateWorkerTimeout) && config.terminateWorkerTimeout >= 0) {
+			if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
 				workerData.terminateTimeout = setTimeout(() => {
 					pool = pool.filter(data => data != workerData);
 					workerData.terminate();
-				}, config.terminateWorkerTimeout);
+				}, terminateWorkerTimeout);
 			}
 		} else {
 			pool = pool.filter(data => data != workerData);
@@ -103,8 +107,9 @@ async function runCodec(codecConstructor, readable, writable, options, config, s
 }
 
 function clearTerminateTimeout(workerData) {
-	if (workerData.terminateTimeout) {
-		clearTimeout(workerData.terminateTimeout);
+	const { terminateTimeout } = workerData;
+	if (terminateTimeout) {
+		clearTimeout(terminateTimeout);
 		workerData.terminateTimeout = null;
 	}
 }

package/lib/core/configuration.js

@@ -29,6 +29,7 @@
 /* global navigator */
 
 const MINIMUM_CHUNK_SIZE = 64;
+const UNDEFINED_TYPE = undefined;
 const DEFAULT_CONFIGURATION = {
 	chunkSize: 512 * 1024,
 	maxWorkers: (typeof navigator != "undefined" && navigator.hardwareConcurrency) || 2,
@@ -54,48 +55,59 @@ function getChunkSize(config) {
 }
 
 function configure(configuration) {
-	if (configuration.baseURL !== undefined) {
-		config.baseURL = configuration.baseURL;
+	const {
+		baseURL,
+		chunkSize,
+		maxWorkers,
+		terminateWorkerTimeout,
+		useCompressionStream,
+		useWebWorkers,
+		Deflate,
+		Inflate,
+		workerScripts
+	} = configuration;
+	if (baseURL !== UNDEFINED_TYPE) {
+		config.baseURL = baseURL;
 	}
-	if (configuration.chunkSize !== undefined) {
-		config.chunkSize = configuration.chunkSize;
+	if (chunkSize !== UNDEFINED_TYPE) {
+		config.chunkSize = chunkSize;
 	}
-	if (configuration.maxWorkers !== undefined) {
-		config.maxWorkers = configuration.maxWorkers;
+	if (maxWorkers !== UNDEFINED_TYPE) {
+		config.maxWorkers = maxWorkers;
 	}
-	if (configuration.terminateWorkerTimeout !== undefined) {
-		config.terminateWorkerTimeout = configuration.terminateWorkerTimeout;
+	if (terminateWorkerTimeout !== UNDEFINED_TYPE) {
+		config.terminateWorkerTimeout = terminateWorkerTimeout;
 	}
-	if (configuration.useCompressionStream !== undefined) {
-		config.useCompressionStream = configuration.useCompressionStream;
+	if (useCompressionStream !== UNDEFINED_TYPE) {
+		config.useCompressionStream = useCompressionStream;
 	}
-	if (configuration.useWebWorkers !== undefined) {
-		config.useWebWorkers = configuration.useWebWorkers;
+	if (useWebWorkers !== UNDEFINED_TYPE) {
+		config.useWebWorkers = useWebWorkers;
 	}
-	if (configuration.Deflate !== undefined) {
-		config.Deflate = configuration.Deflate;
+	if (Deflate !== UNDEFINED_TYPE) {
+		config.Deflate = Deflate;
 	}
-	if (configuration.Inflate !== undefined) {
-		config.Inflate = configuration.Inflate;
+	if (Inflate !== UNDEFINED_TYPE) {
+		config.Inflate = Inflate;
 	}
-	if (configuration.workerScripts !== undefined) {
-		if (configuration.workerScripts.deflate) {
-			if (!Array.isArray(configuration.workerScripts.deflate)) {
-				throw new Error("workerScripts.deflate must be an array");
-			}
+	if (workerScripts !== UNDEFINED_TYPE) {
+		const { deflate, inflate } = workerScripts;
+		if (deflate || inflate) {
 			if (!config.workerScripts) {
 				config.workerScripts = {};
 			}
-			config.workerScripts.deflate = configuration.workerScripts.deflate;
 		}
-		if (configuration.workerScripts.inflate) {
-			if (!Array.isArray(configuration.workerScripts.inflate)) {
-				throw new Error("workerScripts.inflate must be an array");
+		if (deflate) {
+			if (!Array.isArray(deflate)) {
+				throw new Error("workerScripts.deflate must be an array");
 			}
-			if (!config.workerScripts) {
-				config.workerScripts = {};
+			config.workerScripts.deflate = deflate;
+		}
+		if (inflate) {
+			if (!Array.isArray(inflate)) {
+				throw new Error("workerScripts.inflate must be an array");
 			}
-			config.workerScripts.inflate = configuration.workerScripts.inflate;
+			config.workerScripts.inflate = inflate;
 		}
 	}
 }

package/lib/core/io.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Blob, FileReader, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream, TransformStream */
+/* global Blob, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream, TransformStream */
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
@@ -55,7 +55,7 @@ class Stream {
 
 class Reader extends Stream {
 
-	getStream({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
+	getReadable({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
 		const reader = this;
 		return new ReadableStream({
 			start() {
@@ -76,7 +76,7 @@ class Reader extends Stream {
 
 class WriterStream extends Stream {
 
-	getStream() {
+	get writable() {
 		const writer = this;
 		return new WritableStream({
 			write(chunk) {
@@ -127,16 +127,7 @@ class TextWriter extends Writer {
 
 	getData() {
 		const writer = this;
-		if (writer.blob.text) {
-			return writer.blob.text();
-		} else {
-			const reader = new FileReader();
-			return new Promise((resolve, reject) => {
-				reader.onload = event => resolve(event.target.result);
-				reader.onerror = () => reject(reader.error);
-				reader.readAsText(writer.blob, writer.encoding);
-			});
-		}
+		return writer.blob.text();
 	}
 }
 
@@ -210,16 +201,7 @@ class BlobReader extends Reader {
 
 	async readUint8Array(offset, length) {
 		const reader = this;
-		if (reader.blob.arrayBuffer) {
-			return new Uint8Array(await reader.blob.slice(offset, offset + length).arrayBuffer());
-		} else {
-			const reader = new FileReader();
-			return new Promise((resolve, reject) => {
-				reader.onload = event => resolve(new Uint8Array(event.target.result));
-				reader.onerror = () => reject(reader.error);
-				reader.readAsArrayBuffer(reader.blob.slice(offset, offset + length));
-			});
-		}
+		return new Uint8Array(await reader.blob.slice(offset, offset + length).arrayBuffer());
 	}
 }
 
@@ -227,9 +209,10 @@ class BlobWriter extends Writer {
 
 	constructor(contentType) {
 		super();
-		this.contentType = contentType;
-		this.arrayBuffersMaxlength = 8;
-		initArrayBuffers(this);
+		const writer = this;
+		writer.contentType = contentType;
+		writer.arrayBuffersMaxlength = 8;
+		initArrayBuffers(writer);
 	}
 
 	writeUint8Array(array) {
@@ -266,9 +249,12 @@ function flushArrayBuffers(blobWriter) {
 
 class ReadableStreamReader {
 
-	constructor(readableStream) {
+	constructor(readable) {
 		const reader = this;
-		reader.readableStream = readableStream.pipeThrough(new TransformStream({
+		if (!readable) {
+			readable = new ReadableStream({});
+		}
+		reader.readable = readable.pipeThrough(new TransformStream({
 			transform(chunk, controller) {
 				if (chunk) {
 					reader.size += chunk.length;
@@ -283,33 +269,33 @@ class ReadableStreamReader {
 		this.initialized = true;
 	}
 
-	getStream() {
-		return this.readableStream;
+	getReadable() {
+		return this.readable;
 	}
 }
 
 class WritableStreamWriter extends Writer {
 
-	constructor(writable) {
+	constructor(writable, { preventClose } = {}) {
 		super();
-		const writer = this;
-		writer.writable = writable;
-	}
-
-	async writeUint8Array(array) {
-		await this.writer.ready;
-		const writer = this.writable.getWriter();
-		await writer.write(array);
-		writer.releaseLock();
-	}
-
-	getStream() {
-		return this.writable;
+		this.preventClose = preventClose;
+		if (!writable) {
+			writable = new WritableStream({});
+		}
+		Object.defineProperty(this, "writable", {
+			get() {
+				return writable;
+			}
+		});
 	}
 
 	async getData() {
-		await this.writable.getWriter().close();
-		return this.writable;
+		const writer = this;
+		const { writable } = writer;
+		if (!writer.preventClose) {
+			await writable.getWriter().close();
+		}
+		return writable;
 	}
 }
 
@@ -322,11 +308,11 @@ class FetchReader extends Reader {
 		reader.preventHeadRequest = options.preventHeadRequest;
 		reader.useRangeHeader = options.useRangeHeader;
 		reader.forceRangeRequests = options.forceRangeRequests;
-		reader.options = Object.assign({}, options);
-		delete reader.options.preventHeadRequest;
-		delete reader.options.useRangeHeader;
-		delete reader.options.forceRangeRequests;
-		delete reader.options.useXHR;
+		reader.options = options = Object.assign({}, options);
+		delete options.preventHeadRequest;
+		delete options.useRangeHeader;
+		delete options.forceRangeRequests;
+		delete options.useXHR;
 	}
 
 	async init() {
@@ -494,12 +480,9 @@ class HttpReader extends Reader {
 
 	constructor(url, options = {}) {
 		super();
-		this.url = url;
-		if (options.useXHR) {
-			this.reader = new XHRReader(url, options);
-		} else {
-			this.reader = new FetchReader(url, options);
-		}
+		const reader = this;
+		reader.url = url;
+		reader.reader = options.useXHR ? new XHRReader(url, options) : new FetchReader(url, options);
 	}
 
 	set size(value) {
@@ -546,7 +529,7 @@ class Uint8ArrayWriter extends Writer {
 
 	constructor() {
 		super();
-		this.array = new Uint8Array(0);
+		this.array = new Uint8Array();
 	}
 
 	writeUint8Array(array) {
@@ -590,4 +573,4 @@ export {
 	WritableStreamWriter,
 	ERR_HTTP_RANGE,
 	ERR_NOT_SEEKABLE_READER
-};
+};

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

@@ -74,7 +74,7 @@ class AESDecryptionStream extends TransformStream {
 					password,
 					signed,
 					strength: strength - 1,
-					pending: new Uint8Array(0)
+					pending: new Uint8Array()
 				});
 			},
 			async transform(chunk, controller) {
@@ -100,7 +100,7 @@ class AESDecryptionStream extends TransformStream {
 				const pending = aesCrypto.pending;
 				const chunkToDecrypt = subarray(pending, 0, pending.length - SIGNATURE_LENGTH);
 				const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
-				let decryptedChunkArray = new Uint8Array(0);
+				let decryptedChunkArray = new Uint8Array();
 				if (chunkToDecrypt.length) {
 					const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
 					aesCrypto.hmac.update(encryptedChunk);
@@ -133,12 +133,12 @@ class AESEncryptionStream extends TransformStream {
 					ready: new Promise(resolve => this.resolveReady = resolve),
 					password,
 					strength: strength - 1,
-					pending: new Uint8Array(0)
+					pending: new Uint8Array()
 				});
 			},
 			async transform(chunk, controller) {
 				const aesCrypto = this;
-				let preamble = new Uint8Array(0);
+				let preamble = new Uint8Array();
 				if (aesCrypto.password) {
 					const password = aesCrypto.password;
 					aesCrypto.password = null;
@@ -156,7 +156,7 @@ class AESEncryptionStream extends TransformStream {
 			async flush(controller) {
 				const aesCrypto = this;
 				await aesCrypto.ready;
-				let encryptedChunkArray = new Uint8Array(0);
+				let encryptedChunkArray = new Uint8Array();
 				if (aesCrypto.pending.length) {
 					const encryptedChunk = aesCrypto.ctr.update(toBits(codecBytes, aesCrypto.pending));
 					aesCrypto.hmac.update(encryptedChunk);

package/lib/core/streams/codecs/deflate.js

@@ -1891,7 +1891,7 @@ const ZipDeflate = (() => {
 	}
 
 	ZStream.prototype = {
-		deflateInit: function (level, bits) {
+		deflateInit(level, bits) {
 			const that = this;
 			that.dstate = new Deflate();
 			if (!bits)
@@ -1899,7 +1899,7 @@ const ZipDeflate = (() => {
 			return that.dstate.deflateInit(that, level, bits);
 		},
 
-		deflate: function (flush) {
+		deflate(flush) {
 			const that = this;
 			if (!that.dstate) {
 				return Z_STREAM_ERROR;
@@ -1907,7 +1907,7 @@ const ZipDeflate = (() => {
 			return that.dstate.deflate(that, flush);
 		},
 
-		deflateEnd: function () {
+		deflateEnd() {
 			const that = this;
 			if (!that.dstate)
 				return Z_STREAM_ERROR;
@@ -1916,14 +1916,14 @@ const ZipDeflate = (() => {
 			return ret;
 		},
 
-		deflateParams: function (level, strategy) {
+		deflateParams(level, strategy) {
 			const that = this;
 			if (!that.dstate)
 				return Z_STREAM_ERROR;
 			return that.dstate.deflateParams(that, level, strategy);
 		},
 
-		deflateSetDictionary: function (dictionary, dictLength) {
+		deflateSetDictionary(dictionary, dictLength) {
 			const that = this;
 			if (!that.dstate)
 				return Z_STREAM_ERROR;
@@ -1935,7 +1935,7 @@ const ZipDeflate = (() => {
 		// this function so some applications may wish to modify it to avoid
 		// allocating a large strm->next_in buffer and copying from it.
 		// (See also flush_pending()).
-		read_buf: function (buf, start, size) {
+		read_buf(buf, start, size) {
 			const that = this;
 			let len = that.avail_in;
 			if (len > size)
@@ -1953,7 +1953,7 @@ const ZipDeflate = (() => {
 		// through this function so some applications may wish to modify it
 		// to avoid allocating a large strm->next_out buffer and copying into it.
 		// (See also read_buf()).
-		flush_pending: function () {
+		flush_pending() {
 			const that = this;
 			let len = that.dstate.pending;
 
@@ -2029,7 +2029,7 @@ const ZipDeflate = (() => {
 					bufferIndex += chunk.length;
 				});
 			} else {
-				array = buffers[0] || new Uint8Array(0);
+				array = buffers[0] || new Uint8Array();
 			}
 			return array;
 		};