@zip.js/zip.js 2.5.13 → 2.5.16

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

@@ -97,14 +97,15 @@ async function callHandler(handler, ...parameters) {
 
 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;
 		}
 	};
@@ -113,11 +114,15 @@ 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;
+		}),
+		aborted: false
 	});
 	if (!workerData.interface) {
 		if (!classicWorkersSupported) {
@@ -133,6 +138,7 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
 		workerData.interface = {
 			abort() {
+				workerData.aborted = true;
 				sendMessage({ type: MESSAGE_ABORT });
 				workerData.writer.releaseLock();
 				workerData.onTaskFinished();
@@ -162,12 +168,13 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	}
 
 	function sendMessage(message) {
-		const { worker } = workerData;
+		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;
@@ -179,43 +186,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 && !workerData.aborted) {
+				rejectResult(error);
+			} else {
+				resolveResult(result);
+			}
+			writer.releaseLock();
+			onTaskFinished();
 		}
 	}
 }

package/lib/core/codec-pool.js

@@ -55,11 +55,12 @@ let indexWorker = 0;
 async function runWorker(stream, workerOptions) {
 	const { options, config, streamOptions } = workerOptions;
 	const streamCopy = !options.compressed && !options.signed && !options.encrypted;
-	workerOptions.webWorker = !streamCopy && (options.useWebWorkers || (options.useWebWorkers === undefined && config.useWebWorkers));
-	workerOptions.scripts = workerOptions.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++;
@@ -91,12 +92,13 @@ async function runWorker(stream, workerOptions) {
 			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);
@@ -105,8 +107,9 @@ async function runWorker(stream, workerOptions) {
 }
 
 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";
@@ -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());
 	}
 }
 
@@ -267,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;
@@ -285,14 +270,18 @@ class ReadableStreamReader {
 	}
 
 	getReadable() {
-		return this.readableStream;
+		return this.readable;
 	}
 }
 
 class WritableStreamWriter extends Writer {
 
-	constructor(writable) {
+	constructor(writable, { preventClose } = {}) {
 		super();
+		this.preventClose = preventClose;
+		if (!writable) {
+			writable = new WritableStream({});
+		}
 		Object.defineProperty(this, "writable", {
 			get() {
 				return writable;
@@ -300,16 +289,13 @@ class WritableStreamWriter extends Writer {
 		});
 	}
 
-	async writeUint8Array(array) {
-		await this.writer.ready;
-		const writer = this.writable.getWriter();
-		await writer.write(array);
-		writer.releaseLock();
-	}
-
 	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;
 	}
 }
 
@@ -543,7 +529,7 @@ class Uint8ArrayWriter extends Writer {
 
 	constructor() {
 		super();
-		this.array = new Uint8Array(0);
+		this.array = new Uint8Array();
 	}
 
 	writeUint8Array(array) {

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

@@ -2029,7 +2029,7 @@ const ZipDeflate = (() => {
 					bufferIndex += chunk.length;
 				});
 			} else {
-				array = buffers[0] || new Uint8Array(0);
+				array = buffers[0] || new Uint8Array();
 			}
 			return array;
 		};

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

@@ -2155,7 +2155,7 @@ const ZipInflate = (() => {
 					bufferIndex += chunk.length;
 				});
 			} else {
-				array = buffers[0] || new Uint8Array(0);
+				array = buffers[0] || new Uint8Array();
 			}
 			return array;
 		};

package/lib/core/util/decode-text.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TextDecoder, FileReader, Blob */
+/* global TextDecoder */
 
 import decodeCP437 from "./cp437-decode.js";
 
@@ -35,13 +35,6 @@ export default decodeText;
 function decodeText(value, encoding) {
 	if (encoding && encoding.trim().toLowerCase() == "cp437") {
 		return decodeCP437(value);
-	} else if (typeof TextDecoder == "undefined") {
-		const fileReader = new FileReader();
-		return new Promise((resolve, reject) => {
-			fileReader.onload = event => resolve(event.target.result);
-			fileReader.onerror = () => reject(fileReader.error);
-			fileReader.readAsText(new Blob([value]));
-		});
 	} else {
 		return new TextDecoder(encoding).decode(value);
 	}

package/lib/core/util/stream-codec-shim.js

@@ -61,7 +61,7 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 			return getResponse(this);
 		}
 		flush() {
-			this.codec.push(new Uint8Array(0), true);
+			this.codec.push(new Uint8Array(), true);
 			return getResponse(this);
 		}
 	};
@@ -72,7 +72,7 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 			codec.pendingData = null;
 			return output;
 		} else {
-			return new Uint8Array(0);
+			return new Uint8Array();
 		}
 	}
 }

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

@@ -66,20 +66,21 @@ addEventListener(MESSAGE_EVENT_TYPE, async event => {
 
 async function init(message) {
 	try {
-		if (message.scripts && message.scripts.length) {
-			importScripts.apply(undefined, message.scripts);
+		const { options, scripts, config } = message;
+		const { codecType } = options;
+		if (scripts && scripts.length) {
+			importScripts.apply(undefined, scripts);
 		}
-		const options = message.options;
 		if (self.initCodec) {
 			self.initCodec();
 		}
 		let codecConstructor;
-		if (options.codecType.startsWith(CODEC_DEFLATE)) {
+		if (codecType.startsWith(CODEC_DEFLATE)) {
 			codecConstructor = self.Deflate;
-		} else if (options.codecType.startsWith(CODEC_INFLATE)) {
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
 			codecConstructor = self.Inflate;
 		}
-		const strategy = { highWaterMark: 1, size: () => message.config.chunkSize };
+		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
 		const readable = new ReadableStream({
 			async pull(controller) {
 				let result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
@@ -97,12 +98,13 @@ async function init(message) {
 				sendMessage({ type: MESSAGE_DATA, data });
 			}
 		}, strategy);
-		codec = createCodec(codecConstructor, readable, writable, options, message.config);
+		codec = createCodec(codecConstructor, readable, writable, options, config);
 		const result = await codec.run();
 		sendMessage({ type: MESSAGE_CLOSE, result });
 
 	} catch (error) {
-		postMessage({ error: { message: error.message, stack: error.stack } });
+		const { message, stack } = error;
+		postMessage({ error: { message, stack } });
 	}
 }
 

package/lib/core/zip-writer.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global BigInt, FileReader */
+/* global BigInt */
 
 import {
 	MAX_32_BITS,
@@ -125,7 +125,7 @@ class ZipWriter {
 		}
 	}
 
-	async close(comment = new Uint8Array(0), options = {}) {
+	async close(comment = new Uint8Array(), options = {}) {
 		while (this.pendingAddFileCalls.size) {
 			await Promise.all(Array.from(this.pendingAddFileCalls));
 		}
@@ -183,7 +183,7 @@ async function addFile(zipWriter, name, reader, options) {
 	if (password !== undefined && encryptionStrength !== undefined && (encryptionStrength < 1 || encryptionStrength > 3)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
-	let rawExtraField = new Uint8Array(0);
+	let rawExtraField = new Uint8Array();
 	const { extraField } = options;
 	if (extraField) {
 		let extraFieldSize = 0;
@@ -410,7 +410,7 @@ async function createFileEntry(reader, writable, config, options) {
 		arraySet(rawExtraFieldAES, EXTRAFIELD_DATA_AES, 2);
 		setUint8(extraFieldAESView, 8, encryptionStrength);
 	} else {
-		rawExtraFieldAES = new Uint8Array(0);
+		rawExtraFieldAES = new Uint8Array();
 	}
 	let rawExtraFieldNTFS;
 	let rawExtraFieldExtendedTimestamp;
@@ -440,10 +440,10 @@ async function createFileEntry(reader, writable, config, options) {
 			setBigUint64(extraFieldNTFSView, 20, getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
 			setBigUint64(extraFieldNTFSView, 28, getTimeNTFS(creationDate) || lastModTimeNTFS);
 		} catch (_error) {
-			rawExtraFieldNTFS = new Uint8Array(0);
+			rawExtraFieldNTFS = new Uint8Array();
 		}
 	} else {
-		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array(0);
+		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 	}
 	const fileEntry = {
 		version: version || VERSION_DEFLATE,
@@ -454,7 +454,7 @@ async function createFileEntry(reader, writable, config, options) {
 		rawFilename,
 		commentUTF8: true,
 		rawComment,
-		rawExtraFieldZip64: zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array(0),
+		rawExtraFieldZip64: zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array(),
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldAES,
@@ -550,7 +550,7 @@ async function createFileEntry(reader, writable, config, options) {
 		await writeUint8Array(writable, localHeaderArray);
 		fileEntry.dataWritten = true;
 	}
-	let dataDescriptorArray = new Uint8Array(0);
+	let dataDescriptorArray = new Uint8Array();
 	let dataDescriptorView, dataDescriptorOffset = 0;
 	if (dataDescriptor) {
 		dataDescriptorArray = new Uint8Array(zip64 ? (dataDescriptorSignature ? 24 : 20) : (dataDescriptorSignature ? 16 : 12));
@@ -657,7 +657,7 @@ async function closeFile(zipWriter, comment, options) {
 			setUint8(extraFieldExtendedTimestampView, 4, 0x1);
 			setUint32(extraFieldExtendedTimestampView, 5, Math.floor(fileEntry.lastModDate.getTime() / 1000));
 		} else {
-			rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array(0);
+			rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 		}
 		const extraFieldLength = rawExtraFieldZip64.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length + rawExtraField.length;
 		setUint32(directoryView, offset, CENTRAL_FILE_HEADER_SIGNATURE);
@@ -722,19 +722,10 @@ async function closeFile(zipWriter, comment, options) {
 }
 
 function sliceAsArrayBuffer(blob, start, end) {
-	if (blob.arrayBuffer) {
-		if (start || end) {
-			return blob.slice(start, end).arrayBuffer();
-		} else {
-			return blob.arrayBuffer();
-		}
+	if (start || end) {
+		return blob.slice(start, end).arrayBuffer();
 	} else {
-		const fileReader = new FileReader();
-		return new Promise((resolve, reject) => {
-			fileReader.onload = event => resolve(event.target.result);
-			fileReader.onerror = () => reject(fileReader.error);
-			fileReader.readAsArrayBuffer(start || end ? blob.slice(start, end) : blob);
-		});
+		return blob.arrayBuffer();
 	}
 }