@zip.js/zip.js 2.5.10 → 2.5.13

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,26 @@ 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] : [];
+	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;
 	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,8 +88,8 @@ 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) {
 			clearTerminateTimeout(workerData);
 			if (Number.isFinite(config.terminateWorkerTimeout) && config.terminateWorkerTimeout >= 0) {

package/lib/core/io.js

@@ -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) {
@@ -227,9 +227,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) {
@@ -283,7 +284,7 @@ class ReadableStreamReader {
 		this.initialized = true;
 	}
 
-	getStream() {
+	getReadable() {
 		return this.readableStream;
 	}
 }
@@ -292,8 +293,11 @@ class WritableStreamWriter extends Writer {
 
 	constructor(writable) {
 		super();
-		const writer = this;
-		writer.writable = writable;
+		Object.defineProperty(this, "writable", {
+			get() {
+				return writable;
+			}
+		});
 	}
 
 	async writeUint8Array(array) {
@@ -303,10 +307,6 @@ class WritableStreamWriter extends Writer {
 		writer.releaseLock();
 	}
 
-	getStream() {
-		return this.writable;
-	}
-
 	async getData() {
 		await this.writable.getWriter().close();
 		return this.writable;
@@ -322,11 +322,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 +494,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) {
@@ -590,4 +587,4 @@ export {
 	WritableStreamWriter,
 	ERR_HTTP_RANGE,
 	ERR_NOT_SEEKABLE_READER
-};
+};

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;
 

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);
 		}

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/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);

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();
@@ -79,26 +79,24 @@ async function init(message) {
 		} else if (options.codecType.startsWith(CODEC_INFLATE)) {
 			codecConstructor = self.Inflate;
 		}
+		const strategy = { highWaterMark: 1, size: () => message.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 });
 			}
-		});
+		}, strategy);
 		codec = createCodec(codecConstructor, readable, writable, options, message.config);
 		const result = await codec.run();
 		sendMessage({ type: MESSAGE_CLOSE, result });
@@ -110,10 +108,13 @@ async function init(message) {
 
 function sendMessage(message) {
 	if (message.data) {
-		const data = message.data;
+		let { data } = message;
 		if (data && data.length) {
 			try {
-				message.data = new Uint8Array(data).buffer;
+				if (data.length != data.buffer.byteLength) {
+					data = new Uint8Array(data);
+				}
+				message.data = data.buffer;
 				postMessage(message, [message.data]);
 			} catch (_error) {
 				postMessage(message);

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

@@ -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";
@@ -184,7 +184,7 @@ async function addFile(zipWriter, name, reader, options) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
 	let rawExtraField = new Uint8Array(0);
-	const extraField = options.extraField;
+	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,
@@ -524,20 +524,26 @@ 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 {
@@ -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;
@@ -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);