@zip.js/zip.js 2.7.32 → 2.7.34

package/lib/core/codec-pool.js

@@ -56,26 +56,28 @@ let indexWorker = 0;
 async function runWorker(stream, workerOptions) {
 	const { options, config } = workerOptions;
 	const { transferStreams, useWebWorkers, useCompressionStream, codecType, compressed, signed, encrypted } = options;
-	const { workerScripts, maxWorkers, terminateWorkerTimeout } = config;
+	const { workerScripts, maxWorkers } = config;
 	workerOptions.transferStreams = transferStreams || transferStreams === UNDEFINED_VALUE;
 	const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
 	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 	workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : [];
 	options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
-	let worker;
-	const workerData = pool.find(workerData => !workerData.busy);
-	if (workerData) {
-		clearTerminateTimeout(workerData);
-		worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
-	} else if (pool.length < maxWorkers) {
-		const workerData = { indexWorker };
-		indexWorker++;
-		pool.push(workerData);
-		worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
-	} else {
-		worker = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
+	return (await getWorker()).run();
+
+	async function getWorker() {
+		const workerData = pool.find(workerData => !workerData.busy);
+		if (workerData) {
+			clearTerminateTimeout(workerData);
+			return new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
+		} else if (pool.length < maxWorkers) {
+			const workerData = { indexWorker };
+			indexWorker++;
+			pool.push(workerData);
+			return new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
+		} else {
+			return new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
+		}
 	}
-	return worker.run();
 
 	function onTaskFinished(workerData) {
 		if (pendingRequests.length) {
@@ -83,18 +85,32 @@ async function runWorker(stream, workerOptions) {
 			resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
 		} else if (workerData.worker) {
 			clearTerminateTimeout(workerData);
-			if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
-				workerData.terminateTimeout = setTimeout(() => {
-					pool = pool.filter(data => data != workerData);
-					workerData.terminate();
-				}, terminateWorkerTimeout);
-			}
+			terminateWorker(workerData, workerOptions);
 		} else {
 			pool = pool.filter(data => data != workerData);
 		}
 	}
 }
 
+function terminateWorker(workerData, workerOptions) {
+	const { config } = workerOptions;
+	const { terminateWorkerTimeout } = config;
+	if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
+		if (workerData.terminated) {
+			workerData.terminated = false;
+		} else {
+			workerData.terminateTimeout = setTimeout(async () => {
+				pool = pool.filter(data => data != workerData);
+				try {
+					await workerData.terminate();
+				} catch (_error) {
+					// ignored
+				}
+			}, terminateWorkerTimeout);
+		}
+	}
+}
+
 function clearTerminateTimeout(workerData) {
 	const { terminateTimeout } = workerData;
 	if (terminateTimeout) {
@@ -103,9 +119,9 @@ function clearTerminateTimeout(workerData) {
 	}
 }
 
-function terminateWorkers() {
-	pool.forEach(workerData => {
+async function terminateWorkers() {
+	await Promise.allSettled(pool.map(workerData => {
 		clearTerminateTimeout(workerData);
-		workerData.terminate();
-	});
+		return workerData.terminate();
+	}));
 }

package/lib/core/codec-worker.js

@@ -34,6 +34,7 @@ import {
 } from "./constants.js";
 import {
 	CodecStream,
+	ChunkStream,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -43,7 +44,7 @@ import {
 } from "./streams/codec-stream.js";
 
 // deno-lint-ignore valid-typeof
-const WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
+let WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
 
 export {
 	CodecWorker
@@ -55,19 +56,37 @@ class CodecWorker {
 		const { signal } = streamOptions;
 		Object.assign(workerData, {
 			busy: true,
-			readable: readable.pipeThrough(new ProgressWatcherStream(readable, streamOptions, config), { signal }),
+			readable: readable
+				.pipeThrough(new ChunkStream(config.chunkSize))
+				.pipeThrough(new ProgressWatcherStream(readable, streamOptions), { signal }),
 			writable,
 			options: Object.assign({}, options),
 			scripts,
 			transferStreams,
 			terminate() {
-				const { worker, busy } = workerData;
-				if (worker && !busy) {
-					worker.terminate();
-					workerData.interface = null;
-				}
+				return new Promise(resolve => {
+					const { worker, busy } = workerData;
+					if (worker) {
+						if (busy) {
+							workerData.resolveTerminated = resolve;
+						} else {
+							worker.terminate();
+							resolve();
+						}
+						workerData.interface = null;
+					} else {
+						resolve();
+					}
+				});
 			},
 			onTaskFinished() {
+				const { resolveTerminated } = workerData;
+				if (resolveTerminated) {
+					workerData.resolveTerminated = null;
+					workerData.terminated = true;
+					workerData.worker.terminate();
+					resolveTerminated();
+				}
 				workerData.busy = false;
 				onTaskFinished(workerData);
 			}
@@ -78,12 +97,12 @@ class CodecWorker {
 
 class ProgressWatcherStream extends TransformStream {
 
-	constructor(readableSource, { onstart, onprogress, size, onend }, { chunkSize }) {
+	constructor(readableSource, { onstart, onprogress, size, onend }) {
 		let chunkOffset = 0;
 		super({
-			start() {
+			async start() {
 				if (onstart) {
-					callHandler(onstart, size);
+					await callHandler(onstart, size);
 				}
 			},
 			async transform(chunk, controller) {
@@ -93,13 +112,13 @@ class ProgressWatcherStream extends TransformStream {
 				}
 				controller.enqueue(chunk);
 			},
-			flush() {
+			async flush() {
 				readableSource.size = chunkOffset;
 				if (onend) {
-					callHandler(onend, chunkOffset);
+					await callHandler(onend, chunkOffset);
 				}
 			}
-		}, { highWaterMark: 1, size: () => chunkSize });
+		});
 	}
 }
 
@@ -117,10 +136,18 @@ function createWorkerInterface(workerData, config) {
 	};
 }
 
-function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
+function createWebWorkerInterface(workerData, config) {
+	const { baseURL, chunkSize } = config;
 	if (!workerData.interface) {
+		let worker;
+		try {
+			worker = getWebWorker(workerData.scripts[0], baseURL, workerData);
+		} catch (error) {
+			WEB_WORKERS_SUPPORTED = false;
+			return createWorkerInterface(workerData, config);
+		}
 		Object.assign(workerData, {
-			worker: getWebWorker(workerData.scripts[0], baseURL, workerData),
+			worker,
 			interface: {
 				run: () => runWebWorker(workerData, { chunkSize })
 			}
@@ -130,16 +157,18 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 }
 
 async function runWorker({ options, readable, writable, onTaskFinished }, config) {
-	const codecStream = new CodecStream(options, config);
 	try {
+		const codecStream = new CodecStream(options, config);
 		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
 		const {
 			signature,
-			size
+			inputSize,
+			outputSize
 		} = codecStream;
 		return {
 			signature,
-			size
+			inputSize,
+			outputSize
 		};
 	} finally {
 		onTaskFinished();
@@ -186,19 +215,20 @@ async function runWebWorker(workerData, config) {
 }
 
 function watchClosedStream(writableSource) {
-	const writer = writableSource.getWriter();
 	let resolveStreamClosed;
 	const closed = new Promise(resolve => resolveStreamClosed = resolve);
 	const writable = new WritableStream({
 		async write(chunk) {
+			const writer = writableSource.getWriter();
 			await writer.ready;
 			await writer.write(chunk);
+			writer.releaseLock();
 		},
 		close() {
-			writer.releaseLock();
 			resolveStreamClosed();
 		},
 		abort(reason) {
+			const writer = writableSource.getWriter();
 			return writer.abort(reason);
 		}
 	});
@@ -302,6 +332,7 @@ async function onMessage({ data }, workerData) {
 			}
 		}
 	} catch (error) {
+		sendMessage({ type: MESSAGE_CLOSE, messageId }, workerData);
 		close(error);
 	}
 

package/lib/core/io.js

@@ -262,7 +262,7 @@ class FetchReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		createHtpReader(this, url, options);
+		createHttpReader(this, url, options);
 	}
 
 	async init() {
@@ -279,7 +279,7 @@ class XHRReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		createHtpReader(this, url, options);
+		createHttpReader(this, url, options);
 	}
 
 	async init() {
@@ -292,7 +292,7 @@ class XHRReader extends Reader {
 	}
 }
 
-function createHtpReader(httpReader, url, options) {
+function createHttpReader(httpReader, url, options) {
 	const {
 		preventHeadRequest,
 		useRangeHeader,
@@ -689,8 +689,7 @@ function initWriter(writer) {
 	if (writable.size === UNDEFINED_VALUE) {
 		writable.size = 0;
 	}
-	const splitZipFile = writer instanceof SplitDataWriter;
-	if (!splitZipFile) {
+	if (!(writer instanceof SplitDataWriter)) {
 		Object.assign(writer, {
 			diskNumber: 0,
 			diskOffset: 0,

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

@@ -29,6 +29,7 @@
 /* global crypto, TransformStream */
 // deno-lint-ignore-file no-this-alias
 
+import { UNDEFINED_VALUE, UNDEFINED_TYPE, FUNCTION_TYPE } from "../constants.js";
 import { encodeText } from "./../util/encode-text.js";
 import {
 	cipher,
@@ -55,8 +56,6 @@ const SALT_LENGTH = [8, 12, 16];
 const KEY_LENGTH = [16, 24, 32];
 const SIGNATURE_LENGTH = 10;
 const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
-const UNDEFINED_TYPE = "undefined";
-const FUNCTION_TYPE = "function";
 // deno-lint-ignore valid-typeof
 const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
 const subtle = CRYPTO_API_SUPPORTED && crypto.subtle;
@@ -71,12 +70,12 @@ let DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && type
 
 class AESDecryptionStream extends TransformStream {
 
-	constructor({ password, signed, encryptionStrength, checkPasswordOnly }) {
+	constructor({ password, rawPassword, signed, encryptionStrength, checkPasswordOnly }) {
 		super({
 			start() {
 				Object.assign(this, {
 					ready: new Promise(resolve => this.resolveReady = resolve),
-					password,
+					password: encodePassword(password, rawPassword),
 					signed,
 					strength: encryptionStrength - 1,
 					pending: new Uint8Array()
@@ -140,14 +139,14 @@ class AESDecryptionStream extends TransformStream {
 
 class AESEncryptionStream extends TransformStream {
 
-	constructor({ password, encryptionStrength }) {
+	constructor({ password, rawPassword, encryptionStrength }) {
 		// deno-lint-ignore prefer-const
 		let stream;
 		super({
 			start() {
 				Object.assign(this, {
 					ready: new Promise(resolve => this.resolveReady = resolve),
-					password,
+					password: encodePassword(password, rawPassword),
 					strength: encryptionStrength - 1,
 					pending: new Uint8Array()
 				});
@@ -244,8 +243,7 @@ async function createEncryptionKeys(encrypt, strength, password) {
 
 async function createKeys(aesCrypto, strength, password, salt) {
 	aesCrypto.password = null;
-	const encodedPassword = encodeText(password);
-	const baseKey = await importKey(RAW_FORMAT, encodedPassword, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
+	const baseKey = await importKey(RAW_FORMAT, password, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
 	const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), baseKey, 8 * ((KEY_LENGTH[strength] * 2) + 2));
 	const compositeKey = new Uint8Array(derivedBits);
 	const key = toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[strength]));
@@ -289,6 +287,14 @@ async function deriveBits(algorithm, baseKey, length) {
 	}
 }
 
+function encodePassword(password, rawPassword) {
+	if (rawPassword === UNDEFINED_VALUE) {
+		return encodeText(password);
+	} else {
+		return rawPassword;
+	}
+}
+
 function concat(leftArray, rightArray) {
 	let array = leftArray;
 	if (leftArray.length + rightArray.length) {

package/lib/core/streams/codec-stream.js

@@ -65,7 +65,8 @@ export {
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_SIGNATURE,
 	ERR_ABORT_CHECK_PASSWORD,
-	CodecStream
+	CodecStream,
+	ChunkStream
 };
 
 class CodecStream extends TransformStream {
@@ -80,13 +81,27 @@ class CodecStream extends TransformStream {
 		} else if (codecType.startsWith(CODEC_INFLATE)) {
 			Stream = InflateStream;
 		}
-		let size = 0;
+		let outputSize = 0;
+		let inputSize = 0;
 		const stream = new Stream(options, config);
 		const readable = super.readable;
-		const transformStream = new TransformStream({
+		const inputSizeStream = new TransformStream({
 			transform(chunk, controller) {
 				if (chunk && chunk.length) {
-					size += chunk.length;
+					inputSize += chunk.length;
+					controller.enqueue(chunk);
+				}
+			},
+			flush() {
+				Object.assign(codec, {
+					inputSize
+				});
+			}
+		});
+		const outputSizeStream = new TransformStream({
+			transform(chunk, controller) {
+				if (chunk && chunk.length) {
+					outputSize += chunk.length;
 					controller.enqueue(chunk);
 				}
 			},
@@ -94,14 +109,46 @@ class CodecStream extends TransformStream {
 				const { signature } = stream;
 				Object.assign(codec, {
 					signature,
-					size
+					outputSize,
+					inputSize
 				});
 			}
 		});
 		Object.defineProperty(codec, "readable", {
 			get() {
-				return readable.pipeThrough(stream).pipeThrough(transformStream);
+				return readable.pipeThrough(inputSizeStream).pipeThrough(stream).pipeThrough(outputSizeStream);
 			}
 		});
 	}
+}
+
+class ChunkStream extends TransformStream {
+
+	constructor(chunkSize) {
+		let pendingChunk;
+		super({
+			transform,
+			flush(controller) {
+				if (pendingChunk && pendingChunk.length) {
+					controller.enqueue(pendingChunk);
+				}
+			}
+		});
+
+		function transform(chunk, controller) {
+			if (pendingChunk) {
+				const newChunk = new Uint8Array(pendingChunk.length + chunk.length);
+				newChunk.set(pendingChunk);
+				newChunk.set(chunk, pendingChunk.length);
+				chunk = newChunk;
+				pendingChunk = null;
+			}
+			if (chunk.length > chunkSize) {
+				controller.enqueue(chunk.slice(0, chunkSize));
+				transform(chunk.slice(chunkSize), controller);
+			} else {
+				pendingChunk = chunk;
+			}
+		}
+	}
 }

package/lib/core/streams/common-crypto.js

@@ -28,11 +28,12 @@
 
 /* global crypto */
 
+import { FUNCTION_TYPE, UNDEFINED_TYPE } from "../constants.js";
 import {
 	random
 } from "./codecs/sjcl.js";
 
-const GET_RANDOM_VALUES_SUPPORTED = typeof crypto != "undefined" && typeof crypto.getRandomValues == "function";
+const GET_RANDOM_VALUES_SUPPORTED = typeof crypto != UNDEFINED_TYPE && typeof crypto.getRandomValues == FUNCTION_TYPE;
 
 const ERR_INVALID_PASSWORD = "Invalid password";
 const ERR_INVALID_SIGNATURE = "Invalid signature";

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

@@ -148,9 +148,13 @@ function pipeThroughCommpressionStream(readable, useCompressionStream, options,
 		readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options));
 	} catch (error) {
 		if (useCompressionStream) {
-			readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
+			try {
+				readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
+			} catch (error) {
+				return readable;
+			}
 		} else {
-			throw error;
+			return readable;
 		}
 	}
 	return readable;

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

@@ -28,12 +28,14 @@
 
 /* global TextEncoder */
 
+import { UNDEFINED_TYPE } from "../constants.js";
+
 export {
 	encodeText
 };
 
 function encodeText(value) {
-	if (typeof TextEncoder == "undefined") {
+	if (typeof TextEncoder == UNDEFINED_TYPE) {
 		value = unescape(encodeURIComponent(value));
 		const result = new Uint8Array(value.length);
 		for (let i = 0; i < result.length; i++) {

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

@@ -29,6 +29,8 @@
 
 // deno-lint-ignore-file no-this-alias
 
+import { FUNCTION_TYPE, UNDEFINED_VALUE } from "../constants.js";
+
 export {
 	initShimAsyncCodec
 };
@@ -42,7 +44,7 @@ function initShimAsyncCodec(library, options = {}, registerDataHandler) {
 
 function objectHasOwn(object, propertyName) {
 	// eslint-disable-next-line no-prototype-builtins
-	return typeof Object.hasOwn === "function" ? Object.hasOwn(object, propertyName) : object.hasOwnProperty(propertyName);
+	return typeof Object.hasOwn === FUNCTION_TYPE ? Object.hasOwn(object, propertyName) : object.hasOwnProperty(propertyName);
 }
 
 function createCodecClass(constructor, constructorOptions, registerDataHandler) {
@@ -61,7 +63,7 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 					codecAdapter.pendingData = new Uint8Array(data);
 				}
 			};
-			if (objectHasOwn(options, "level") && options.level === undefined) {
+			if (objectHasOwn(options, "level") && options.level === UNDEFINED_VALUE) {
 				delete options.level;
 			}
 			codecAdapter.codec = new constructor(Object.assign({}, constructorOptions, options));

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

@@ -26,12 +26,13 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
+/* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream, AbortController */
 
 import { UNDEFINED_VALUE } from "./constants.js";
 import { StreamAdapter } from "./streams/stream-adapter.js";
 import {
 	CodecStream,
+	ChunkStream,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -43,7 +44,7 @@ import {
 const pendingPullMessages = new Map();
 const pendingDataMessages = new Map();
 
-let messageId = 0;
+let abortController, messageId = 0, importScriptSupported = true;
 
 addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
 	const { type, messageId, value, done } = data;
@@ -61,6 +62,9 @@ addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
 			pendingDataMessages.delete(messageId);
 			resolve();
 		}
+		if (type == MESSAGE_CLOSE) {
+			abortController.abort();
+		}
 	} catch (error) {
 		sendErrorMessage(error);
 	}
@@ -70,7 +74,16 @@ async function init(message) {
 	try {
 		const { options, scripts, config } = message;
 		if (scripts && scripts.length) {
-			importScripts.apply(UNDEFINED_VALUE, scripts);
+			try {
+				if (importScriptSupported) {
+					importScripts.apply(UNDEFINED_VALUE, scripts);
+				} else {
+					await imporModuleScripts(scripts);
+				}
+			} catch (error) {
+				importScriptSupported = false;
+				await imporModuleScripts(scripts);
+			}
 		}
 		if (self.initCodec) {
 			self.initCodec();
@@ -83,7 +96,7 @@ async function init(message) {
 		if (self.Inflate) {
 			config.DecompressionStream = new StreamAdapter(self.Inflate);
 		}
-		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
+		const strategy = { highWaterMark: 1 };
 		const readable = message.readable || new ReadableStream({
 			async pull(controller) {
 				const result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
@@ -107,7 +120,12 @@ async function init(message) {
 			}
 		}, strategy);
 		const codecStream = new CodecStream(options, config);
-		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
+		abortController = new AbortController();
+		const { signal } = abortController;
+		await readable
+			.pipeThrough(codecStream)
+			.pipeThrough(new ChunkStream(config.chunkSize))
+			.pipeTo(writable, { signal, preventClose: true, preventAbort: true });
 		try {
 			await writable.getWriter().close();
 		} catch (_error) {
@@ -115,13 +133,15 @@ async function init(message) {
 		}
 		const {
 			signature,
-			size
+			inputSize,
+			outputSize
 		} = codecStream;
 		sendMessage({
 			type: MESSAGE_CLOSE,
 			result: {
 				signature,
-				size
+				inputSize,
+				outputSize
 			}
 		});
 	} catch (error) {
@@ -129,6 +149,12 @@ async function init(message) {
 	}
 }
 
+async function imporModuleScripts(scripts) {
+	for (const script of scripts) {
+		await import(script);
+	}
+}
+
 function sendMessage(message) {
 	let { value } = message;
 	if (value) {

package/lib/core/zip-fs-core.js

@@ -52,6 +52,7 @@ import {
 import {
 	Entry
 } from "./zip-entry.js";
+import { UNDEFINED_VALUE } from "./constants.js";
 
 class ZipEntry {
 
@@ -433,7 +434,7 @@ class ZipDirectoryEntry extends ZipEntry {
 
 	async exportZip(writer, options) {
 		const zipEntry = this;
-		if (options.bufferedWrite === undefined) {
+		if (options.bufferedWrite === UNDEFINED_VALUE) {
 			options.bufferedWrite = true;
 		}
 		await Promise.all([initReaders(zipEntry, options.readerOptions), initStream(writer)]);

package/lib/core/zip-reader.js

@@ -372,7 +372,9 @@ class ZipEntry {
 		const dataArray = await readUint8Array(reader, offset, 30, diskNumberStart);
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, "password");
+		let rawPassword = getOptionValue(zipEntry, options, "rawPassword");
 		password = password && password.length && password;
+		rawPassword = rawPassword && rawPassword.length && rawPassword;
 		if (extraFieldAES) {
 			if (extraFieldAES.originalCompressionMethod != COMPRESSION_METHOD_AES) {
 				throw new Error(ERR_UNSUPPORTED_COMPRESSION);
@@ -398,7 +400,7 @@ class ZipEntry {
 		if (encrypted) {
 			if (!zipCrypto && extraFieldAES.strength === UNDEFINED_VALUE) {
 				throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
-			} else if (!password) {
+			} else if (!password && !rawPassword) {
 				throw new Error(ERR_ENCRYPTED);
 			}
 		}
@@ -423,6 +425,7 @@ class ZipEntry {
 			options: {
 				codecType: CODEC_INFLATE,
 				password,
+				rawPassword,
 				zipCrypto,
 				encryptionStrength: extraFieldAES && extraFieldAES.strength,
 				signed: getOptionValue(zipEntry, options, "checkSignature"),
@@ -452,7 +455,7 @@ class ZipEntry {
 				await writable.getWriter().close();
 			}
 		}
-		return checkPasswordOnly ? undefined : writer.getData ? writer.getData() : writable;
+		return checkPasswordOnly ? UNDEFINED_VALUE : writer.getData ? writer.getData() : writable;
 	}
 }