@zip.js/zip.js 2.5.11 → 2.5.14

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

@@ -2055,7 +2055,7 @@ const ZipInflate = (() => {
 	}
 
 	ZStream.prototype = {
-		inflateInit: function (bits) {
+		inflateInit(bits) {
 			const that = this;
 			that.istate = new Inflate();
 			if (!bits)
@@ -2063,14 +2063,14 @@ const ZipInflate = (() => {
 			return that.istate.inflateInit(that, bits);
 		},
 
-		inflate: function (f) {
+		inflate(f) {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
 			return that.istate.inflate(that, f);
 		},
 
-		inflateEnd: function () {
+		inflateEnd() {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
@@ -2079,23 +2079,23 @@ const ZipInflate = (() => {
 			return ret;
 		},
 
-		inflateSync: function () {
+		inflateSync() {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
 			return that.istate.inflateSync(that);
 		},
-		inflateSetDictionary: function (dictionary, dictLength) {
+		inflateSetDictionary(dictionary, dictLength) {
 			const that = this;
 			if (!that.istate)
 				return Z_STREAM_ERROR;
 			return that.istate.inflateSetDictionary(that, dictionary, dictLength);
 		},
-		read_byte: function (start) {
+		read_byte(start) {
 			const that = this;
 			return that.next_in[start];
 		},
-		read_buf: function (start, size) {
+		read_buf(start, size) {
 			const that = this;
 			return that.next_in.subarray(start, start + size);
 		}
@@ -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/streams/codecs/sjcl.js

@@ -232,7 +232,7 @@ hash.sha1.prototype = {
 	 * Reset the hash state.
 	 * @return this
 	 */
-	reset: function () {
+	reset() {
 		const sha1 = this;
 		sha1._h = this._init.slice(0);
 		sha1._buffer = [];
@@ -245,7 +245,7 @@ hash.sha1.prototype = {
 	 * @param {bitArray|String} data the data to hash.
 	 * @return this
 	 */
-	update: function (data) {
+	update(data) {
 		const sha1 = this;
 		if (typeof data === "string") {
 			data = codec.utf8String.toBits(data);
@@ -271,7 +271,7 @@ hash.sha1.prototype = {
 	 * Complete hashing and output the hash value.
 	 * @return {bitArray} The hash value, an array of 5 big-endian words. TODO
 	 */
-	finalize: function () {
+	finalize() {
 		const sha1 = this;
 		let b = sha1._buffer;
 		const h = sha1._h;
@@ -311,7 +311,7 @@ hash.sha1.prototype = {
 	 * The SHA-1 logical functions f(0), f(1), ..., f(79).
 	 * @private
 	 */
-	_f: function (t, b, c, d) {
+	_f(t, b, c, d) {
 		if (t <= 19) {
 			return (b & c) | (~b & d);
 		} else if (t <= 39) {
@@ -327,7 +327,7 @@ hash.sha1.prototype = {
 	 * Circular left-shift operator.
 	 * @private
 	 */
-	_S: function (n, x) {
+	_S(n, x) {
 		return (x << n) | (x >>> 32 - n);
 	},
 
@@ -336,7 +336,7 @@ hash.sha1.prototype = {
 	 * @param {Uint32Array|bitArray} words one block of words.
 	 * @private
 	 */
-	_block: function (words) {
+	_block(words) {
 		const sha1 = this;
 		const h = sha1._h;
 		// When words is passed to _block, it has 16 elements. SHA1 _block

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

@@ -66,8 +66,7 @@ class DeflateStream extends TransformStream {
 				readable = pipeCodecStream(codecConstructor, readable, chunkSize);
 			} else {
 				try {
-					const compressionStream = new CompressionStream(COMPRESSION_FORMAT);
-					readable = readable.pipeThrough(compressionStream);
+					readable = readable.pipeThrough(new CompressionStream(COMPRESSION_FORMAT));
 				} catch (_error) {
 					DEFLATE_RAW_SUPPORTED = false;
 					readable = pipeCodecStream(codecConstructor, readable, chunkSize);
@@ -153,8 +152,8 @@ export {
 	ERR_INVALID_SIGNATURE
 };
 
-function pipeCodecStream(codecConstructor, stream, chunkSize) {
-	return stream.pipeThrough(new CodecStream(codecConstructor, { chunkSize }));
+function pipeCodecStream(codecConstructor, readable, chunkSize) {
+	return readable.pipeThrough(new CodecStream(codecConstructor, { chunkSize }));
 }
 
 function filterEmptyChunks(readable) {

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

@@ -41,7 +41,7 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 			const codecAdapter = this;
 			const onData = data => {
 				if (codecAdapter.pendingData) {
-					const pendingData = codecAdapter.pendingData;
+					const { pendingData } = codecAdapter;
 					codecAdapter.pendingData = new Uint8Array(pendingData.length + data.length);
 					codecAdapter.pendingData.set(pendingData, 0);
 					codecAdapter.pendingData.set(data, pendingData.length);
@@ -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

@@ -46,15 +46,15 @@ let messageId = 0;
 
 addEventListener(MESSAGE_EVENT_TYPE, async event => {
 	const message = event.data;
-	const type = message.type;
+	const { type, messageId, data, done } = message;
 	try {
 		if (type == MESSAGE_START) {
 			init(message);
 		}
 		if (type == MESSAGE_DATA) {
-			const { resolve } = pendingMessages.get(message.messageId);
-			pendingMessages.delete(message.messageId);
-			resolve({ value: new Uint8Array(message.data), done: message.done });
+			const { resolve } = pendingMessages.get(messageId);
+			pendingMessages.delete(messageId);
+			resolve({ value: new Uint8Array(data), done });
 		}
 		if (type == MESSAGE_ABORT) {
 			codec.abort();
@@ -66,45 +66,45 @@ 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: () => config.chunkSize };
 		const readable = new ReadableStream({
 			async pull(controller) {
 				let result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
 				sendMessage({ type: MESSAGE_PULL, messageId });
-				messageId++;
+				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
 				const { value, done } = await result;
-				// debugger;
 				controller.enqueue(value);
 				if (done) {
 					controller.close();
 				}
 			}
-		}, {
-			highWaterMark: 1
-		});
+		}, strategy);
 		const writable = new WritableStream({
 			write(data) {
 				sendMessage({ type: MESSAGE_DATA, data });
 			}
-		});
-		codec = createCodec(codecConstructor, readable, writable, options, message.config);
+		}, strategy);
+		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-fs-core.js

@@ -503,11 +503,11 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 			await zipWriter.add(name, child.reader, Object.assign({
 				directory: child.directory
 			}, Object.assign({}, options, {
-				onprogress: indexProgress => {
+				onprogress: async indexProgress => {
 					if (options.onprogress) {
 						entryOffsets.set(name, indexProgress);
 						try {
-							options.onprogress(Array.from(entryOffsets.values()).reduce((previousValue, currentValue) => previousValue + currentValue), totalSize);
+							await options.onprogress(Array.from(entryOffsets.values()).reduce((previousValue, currentValue) => previousValue + currentValue), totalSize);
 						} catch (_error) {
 							// ignored
 						}

package/lib/core/zip-reader.js

@@ -61,7 +61,7 @@ import {
 	getChunkSize
 } from "./configuration.js";
 import {
-	runCodec,
+	runWorker,
 	CODEC_INFLATE,
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD
@@ -96,7 +96,7 @@ class ZipReader {
 
 	async* getEntriesGenerator(options = {}) {
 		const zipReader = this;
-		const reader = zipReader.reader;
+		const { reader, config } = zipReader;
 		if (!reader.initialized) {
 			await reader.init();
 		}
@@ -156,7 +156,7 @@ class ZipReader {
 			throw new Error(ERR_BAD_FORMAT);
 		}
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
-			const fileEntry = new ZipEntry(reader, zipReader.config, zipReader.options);
+			const fileEntry = new ZipEntry(reader, config, zipReader.options);
 			if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
 				throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
 			}
@@ -201,7 +201,7 @@ class ZipReader {
 			offset = endOffset;
 			if (options.onprogress) {
 				try {
-					options.onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
+					await options.onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
 				} catch (_error) {
 					// ignored
 				}
@@ -301,25 +301,32 @@ class ZipEntry {
 		}
 		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
 		const size = () => compressedSize;
-		const readable = reader.getStream({ offset: dataOffset, size, chunkSize: getChunkSize(config) });
-		const writable = writer.getStream();
+		const readable = reader.getReadable({ offset: dataOffset, size, chunkSize: getChunkSize(config) });
+		const { writable } = writer;
 		const signal = getOptionValue(zipEntry, options, "signal");
 		if (!writer.initialized) {
 			await writer.init();
 		}
-		await runCodec(config.Inflate, readable, writable, {
-			codecType: CODEC_INFLATE,
-			password,
-			zipCrypto,
-			encryptionStrength: extraFieldAES && extraFieldAES.strength,
-			signed: getOptionValue(zipEntry, options, "checkSignature"),
-			passwordVerification: zipCrypto && (bitFlag.dataDescriptor ? ((rawLastModDate >>> 8) & 0xFF) : ((signature >>> 24) & 0xFF)),
-			signature,
-			compressed: compressionMethod != 0,
-			encrypted,
-			useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
-			useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream")
-		}, config, { signal, onprogress: options.onprogress, size });
+		const { onstart, onprogress, onend } = options;
+		const workerOptions = {
+			options: {
+				codecType: CODEC_INFLATE,
+				password,
+				zipCrypto,
+				encryptionStrength: extraFieldAES && extraFieldAES.strength,
+				signed: getOptionValue(zipEntry, options, "checkSignature"),
+				passwordVerification: zipCrypto && (bitFlag.dataDescriptor ? ((rawLastModDate >>> 8) & 0xFF) : ((signature >>> 24) & 0xFF)),
+				signature,
+				compressed: compressionMethod != 0,
+				encrypted,
+				useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
+				useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream")
+			},
+			config,
+			streamOptions: { signal, size, onstart, onprogress, onend },
+			codecConstructor: config.Inflate
+		};
+		await runWorker({ readable, writable }, workerOptions);
 		return writer.getData();
 	}
 }
@@ -344,7 +351,7 @@ function readCommonHeader(directory, dataView, offset) {
 }
 
 async function readCommonFooter(fileEntry, directory, dataView, offset) {
-	const rawExtraField = directory.rawExtraField;
+	const { rawExtraField } = directory;
 	const extraField = directory.extraField = new Map();
 	const rawExtraFieldView = getDataView(new Uint8Array(rawExtraField));
 	let offsetExtraField = 0;

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,
@@ -65,7 +65,7 @@ import {
 } from "./configuration.js";
 import {
 	CODEC_DEFLATE,
-	runCodec
+	runWorker
 } from "./codec-pool.js";
 import encodeText from "./util/encode-text.js";
 import { BlobWriter } from "./io.js";
@@ -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,8 +183,8 @@ 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);
-	const extraField = options.extraField;
+	let rawExtraField = new Uint8Array();
+	const { extraField } = options;
 	if (extraField) {
 		let extraFieldSize = 0;
 		let offset = 0;
@@ -295,11 +295,10 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	try {
 		let lockPreviousFileEntry;
 		let fileWriter;
-		let lockCurrentFileEntry;
 		if (options.keepOrder) {
 			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lock;
 		}
-		fileEntry.lock = lockCurrentFileEntry = new Promise(resolve => resolveLockCurrentFileEntry = resolve);
+		fileEntry.lock = new Promise(resolve => resolveLockCurrentFileEntry = resolve);
 		if (options.bufferedWrite || zipWriter.lockWrite || !options.dataDescriptor) {
 			fileWriter = new BlobWriter();
 			fileWriter.init();
@@ -311,8 +310,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			}
 			fileWriter = writer;
 		}
-		fileEntry = await createFileEntry(reader, fileWriter.getStream(), zipWriter.config, options);
-		fileEntry.lock = lockCurrentFileEntry;
+		fileEntry = await createFileEntry(reader, fileWriter.writable, zipWriter.config, options);
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
@@ -327,7 +325,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 				}
 			} while (pendingFileEntry && pendingFileEntry.lock);
 			fileEntry.writingBufferedData = true;
-			const writable = writer.getStream();
+			const { writable } = writer;
 			if (!options.dataDescriptor) {
 				const headerLength = 26;
 				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, headerLength);
@@ -391,7 +389,9 @@ async function createFileEntry(reader, writable, config, options) {
 		rawComment,
 		rawExtraField,
 		useWebWorkers,
+		onstart,
 		onprogress,
+		onend,
 		signal,
 		encryptionStrength,
 		extendedTimestamp,
@@ -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,
@@ -524,27 +524,33 @@ async function createFileEntry(reader, writable, config, options) {
 		await writeUint8Array(writable, localHeaderArray);
 		fileEntry.dataWritten = true;
 		const size = () => reader.size;
-		const readable = reader.getStream({ offset: 0, size, chunkSize: getChunkSize(config) });
-		result = await runCodec(config.Deflate, readable, writable, {
-			codecType: CODEC_DEFLATE,
-			level,
-			password,
-			encryptionStrength,
-			zipCrypto: encrypted && zipCrypto,
-			passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
-			signed: true,
-			compressed,
-			encrypted,
-			useWebWorkers,
-			useCompressionStream
-		}, config, { signal, onprogress, size });
+		const readable = reader.getReadable({ offset: 0, size, chunkSize: getChunkSize(config) });
+		const workerOptions = {
+			options: {
+				codecType: CODEC_DEFLATE,
+				level,
+				password,
+				encryptionStrength,
+				zipCrypto: encrypted && zipCrypto,
+				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
+				signed: true,
+				compressed,
+				encrypted,
+				useWebWorkers,
+				useCompressionStream
+			},
+			config,
+			streamOptions: { signal, size, onstart, onprogress, onend },
+			codecConstructor: config.Deflate
+		};
+		result = await runWorker({ readable, writable }, workerOptions);
 		uncompressedSize = fileEntry.uncompressedSize = reader.size;
 		compressedSize = result.length;
 	} else {
 		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));
@@ -555,7 +561,7 @@ async function createFileEntry(reader, writable, config, options) {
 		}
 	}
 	if (reader) {
-		const signature = result.signature;
+		const { signature } = result;
 		if ((!encrypted || zipCrypto) && signature !== undefined) {
 			setUint32(headerView, 10, signature);
 			fileEntry.signature = signature;
@@ -651,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);
@@ -680,7 +686,7 @@ async function closeFile(zipWriter, comment, options) {
 		offset += 46 + rawFilename.length + extraFieldLength + rawComment.length;
 		if (options.onprogress) {
 			try {
-				options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
+				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
 			} catch (_error) {
 				// ignored
 			}
@@ -708,7 +714,7 @@ async function closeFile(zipWriter, comment, options) {
 	setUint16(directoryView, offset + 10, filesLength);
 	setUint32(directoryView, offset + 12, directoryDataLength);
 	setUint32(directoryView, offset + 16, directoryOffset);
-	const writable = zipWriter.writer.getStream();
+	const { writable } = zipWriter.writer;
 	await writeUint8Array(writable, directoryArray);
 	if (comment && comment.length) {
 		await writeUint8Array(writable, comment);
@@ -716,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();
 	}
 }