@zip.js/zip.js 2.7.33 → 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,26 +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) {
-				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);
-				}
-			}
+			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) {

package/lib/core/codec-worker.js

@@ -100,9 +100,9 @@ class ProgressWatcherStream extends TransformStream {
 	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) {
@@ -112,10 +112,10 @@ class ProgressWatcherStream extends TransformStream {
 				}
 				controller.enqueue(chunk);
 			},
-			flush() {
+			async flush() {
 				readableSource.size = chunkOffset;
 				if (onend) {
-					callHandler(onend, chunkOffset);
+					await callHandler(onend, chunkOffset);
 				}
 			}
 		});

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

package/lib/core/zip-writer.js

@@ -219,6 +219,7 @@ async function addFile(zipWriter, name, reader, options) {
 	const internalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE, 0);
 	const externalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE, 0);
 	const password = getOptionValue(zipWriter, options, "password");
+	const rawPassword = getOptionValue(zipWriter, options, "rawPassword");
 	const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength", 3);
 	const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
 	const extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp", true);
@@ -301,6 +302,7 @@ async function addFile(zipWriter, name, reader, options) {
 		zip64Offset,
 		zip64DiskNumberStart,
 		password,
+		rawPassword,
 		level,
 		useWebWorkers,
 		encryptionStrength,
@@ -467,7 +469,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	}
 
 	async function skipDiskIfNeeded(writable) {
-		if (headerInfo.localHeaderArray.length > writer.availableSize) {
+		if (getLength(headerInfo.localHeaderArray) > writer.availableSize) {
 			writer.availableSize = 0;
 			await writeData(writable, new Uint8Array());
 		}
@@ -500,6 +502,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		lastAccessDate,
 		creationDate,
 		password,
+		rawPassword,
 		level,
 		zip64,
 		zip64UncompressedSize,
@@ -556,6 +559,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 			options: {
 				codecType: CODEC_DEFLATE,
 				level,
+				rawPassword,
 				password,
 				encryptionStrength,
 				zipCrypto: encrypted && zipCrypto,
@@ -637,6 +641,7 @@ function getHeaderInfo(options) {
 		lastModDate,
 		lastAccessDate,
 		creationDate,
+		rawPassword,
 		password,
 		level,
 		zip64,
@@ -648,7 +653,7 @@ function getHeaderInfo(options) {
 		extendedTimestamp
 	} = options;
 	const compressed = level !== 0 && !directory;
-	const encrypted = Boolean(password && getLength(password));
+	const encrypted = Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword)));
 	let version = options.version;
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
@@ -771,7 +776,7 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	const { headerInfo } = entryInfo;
 	let { localHeaderArray, extraFieldLength } = headerInfo;
 	let localHeaderArrayView = getDataView(localHeaderArray);
-	let extraBytesLength = 64 - ((zipWriterOffset + localHeaderArray.length) % 64);
+	let extraBytesLength = 64 - ((zipWriterOffset + getLength(localHeaderArray)) % 64);
 	if (extraBytesLength < 4) {
 		extraBytesLength += 64;
 	}
@@ -780,9 +785,9 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	setUint16(extraFieldUSDZView, 0, EXTRAFIELD_TYPE_USDZ);
 	setUint16(extraFieldUSDZView, 2, extraBytesLength - 2);
 	const previousLocalHeaderArray = localHeaderArray;
-	headerInfo.localHeaderArray = localHeaderArray = new Uint8Array(previousLocalHeaderArray.length + extraBytesLength);
+	headerInfo.localHeaderArray = localHeaderArray = new Uint8Array(getLength(previousLocalHeaderArray) + extraBytesLength);
 	arraySet(localHeaderArray, previousLocalHeaderArray);
-	arraySet(localHeaderArray, rawExtraFieldUSDZ, previousLocalHeaderArray.length);
+	arraySet(localHeaderArray, rawExtraFieldUSDZ, getLength(previousLocalHeaderArray));
 	localHeaderArrayView = getDataView(localHeaderArray);
 	setUint16(localHeaderArrayView, 28, extraFieldLength + extraBytesLength);
 	entryInfo.metadataSize += extraBytesLength;
@@ -844,7 +849,7 @@ function setEntryInfo(entryInfo, options) {
 	if (zip64) {
 		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-		setUint16(rawExtraFieldZip64View, 2, rawExtraFieldZip64.length - 4);
+		setUint16(rawExtraFieldZip64View, 2, getLength(rawExtraFieldZip64) - 4);
 		let rawExtraFieldZip64Offset = 4;
 		if (zip64UncompressedSize) {
 			setUint32(headerView, 18, MAX_32_BITS);

package/lib/z-worker-bootstrap-fflate.js

@@ -31,9 +31,10 @@
 
 import "./core/z-worker-core.js";
 import { initShimAsyncCodec } from "./core/util/stream-codec-shim.js";
+import { UNDEFINED_VALUE } from "./core/constants.js";
 
 self.initCodec = () => {
-	const { Deflate, Inflate } = initShimAsyncCodec(fflate, undefined, (codec, onData) => codec.ondata = onData);
+	const { Deflate, Inflate } = initShimAsyncCodec(fflate, UNDEFINED_VALUE, (codec, onData) => codec.ondata = onData);
 	self.Deflate = Deflate;
 	self.Inflate = Inflate;
 };