@zip.js/zip.js 2.7.33 → 2.7.35

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,
@@ -584,8 +584,8 @@ class SplitDataWriter extends Stream {
 
 	constructor(writerGenerator, maxSize = 4294967295) {
 		super();
-		const zipWriter = this;
-		Object.assign(zipWriter, {
+		const writer = this;
+		Object.assign(writer, {
 			diskNumber: 0,
 			diskOffset: 0,
 			size: 0,
@@ -595,7 +595,7 @@ class SplitDataWriter extends Stream {
 		let diskSourceWriter, diskWritable, diskWriter;
 		const writable = new WritableStream({
 			async write(chunk) {
-				const { availableSize } = zipWriter;
+				const { availableSize } = writer;
 				if (!diskWriter) {
 					const { value, done } = await writerGenerator.next();
 					if (done && !value) {
@@ -604,9 +604,9 @@ class SplitDataWriter extends Stream {
 						diskSourceWriter = value;
 						diskSourceWriter.size = 0;
 						if (diskSourceWriter.maxSize) {
-							zipWriter.maxSize = diskSourceWriter.maxSize;
+							writer.maxSize = diskSourceWriter.maxSize;
 						}
-						zipWriter.availableSize = zipWriter.maxSize;
+						writer.availableSize = writer.maxSize;
 						await initStream(diskSourceWriter);
 						diskWritable = value.writable;
 						diskWriter = diskWritable.getWriter();
@@ -615,8 +615,8 @@ class SplitDataWriter extends Stream {
 				} else if (chunk.length >= availableSize) {
 					await writeChunk(chunk.slice(0, availableSize));
 					await closeDisk();
-					zipWriter.diskOffset += diskSourceWriter.size;
-					zipWriter.diskNumber++;
+					writer.diskOffset += diskSourceWriter.size;
+					writer.diskNumber++;
 					diskWriter = null;
 					await this.write(chunk.slice(availableSize));
 				} else {
@@ -628,7 +628,7 @@ class SplitDataWriter extends Stream {
 				await closeDisk();
 			}
 		});
-		Object.defineProperty(zipWriter, PROPERTY_NAME_WRITABLE, {
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
 			get() {
 				return writable;
 			}
@@ -640,8 +640,8 @@ class SplitDataWriter extends Stream {
 				await diskWriter.ready;
 				await diskWriter.write(chunk);
 				diskSourceWriter.size += chunkLength;
-				zipWriter.size += chunkLength;
-				zipWriter.availableSize -= chunkLength;
+				writer.size += chunkLength;
+				writer.availableSize -= chunkLength;
 			}
 		}
 
@@ -661,6 +661,8 @@ function isHttpFamily(url) {
 async function initStream(stream, initSize) {
 	if (stream.init && !stream.initialized) {
 		await stream.init(initSize);
+	} else {
+		return Promise.resolve();
 	}
 }
 
@@ -689,8 +691,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

@@ -7,8 +7,8 @@
  1. Redistributions of source code must retain the above copyright notice,
  this list of conditions and the following disclaimer.
 
- 2. Redistributions in binary form must reproduce the above copyright 
- notice, this list of conditions and the following disclaimer in 
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
  the documentation and/or other materials provided with the distribution.
 
  3. The names of the authors may not be used to endorse or promote products
@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global BigInt, Response, WritableStream */
+/* global BigInt, Response, WritableStream, ReadableStream, TransformStream */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -209,7 +209,7 @@ class ZipReader {
 		}
 		if (directoryDataOffset >= reader.size) {
 			prependedDataLength = reader.size - directoryDataOffset - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
-			directoryDataOffset = reader.size - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;	
+			directoryDataOffset = reader.size - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
 		}
 		if (expectedLastDiskNumber != lastDiskNumber) {
 			throw new Error(ERR_SPLIT_ZIP_FILE);
@@ -326,8 +326,37 @@ class ZipReader {
 	}
 }
 
+class ZipReaderStream {
+
+	constructor(options = {}) {
+		const { readable, writable } = new TransformStream();
+		const gen = new ZipReader(readable, options).getEntriesGenerator();
+		this.readable = new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await gen.next();
+				if (done)
+					return controller.close();
+				const chunk = {
+					...value,
+					readable: (function () {
+						const { readable, writable } = new TransformStream();
+						if (value.getData) {
+							value.getData(writable);
+							return readable;
+						}
+					})()
+				};
+				delete chunk.getData;
+				controller.enqueue(chunk);
+			}
+		});
+		this.writable = writable;
+	}
+}
+
 export {
 	ZipReader,
+	ZipReaderStream,
 	ERR_BAD_FORMAT,
 	ERR_EOCDR_NOT_FOUND,
 	ERR_EOCDR_ZIP64_NOT_FOUND,
@@ -372,7 +401,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 +429,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 +454,7 @@ class ZipEntry {
 			options: {
 				codecType: CODEC_INFLATE,
 				password,
+				rawPassword,
 				zipCrypto,
 				encryptionStrength: extraFieldAES && extraFieldAES.strength,
 				signed: getOptionValue(zipEntry, options, "checkSignature"),
@@ -452,7 +484,7 @@ class ZipEntry {
 				await writable.getWriter().close();
 			}
 		}
-		return checkPasswordOnly ? undefined : writer.getData ? writer.getData() : writable;
+		return checkPasswordOnly ? UNDEFINED_VALUE : writer.getData ? writer.getData() : writable;
 	}
 }
 
@@ -718,4 +750,4 @@ function setUint32(view, offset, value) {
 
 function getDataView(array) {
 	return new DataView(array.buffer);
-}
+}

package/lib/core/zip-writer.js

@@ -7,8 +7,8 @@
  1. Redistributions of source code must retain the above copyright notice,
  this list of conditions and the following disclaimer.
 
- 2. Redistributions in binary form must reproduce the above copyright 
- notice, this list of conditions and the following disclaimer in 
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
  the documentation and/or other materials provided with the distribution.
 
  3. The names of the authors may not be used to endorse or promote products
@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global BigInt */
+/* global BigInt, TransformStream, Response */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -75,9 +75,7 @@ import {
 import {
 	initStream,
 	initReader,
-	initWriter,
-	BlobWriter,
-	SplitDataWriter
+	initWriter
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
 import {
@@ -110,9 +108,12 @@ class ZipWriter {
 
 	constructor(writer, options = {}) {
 		writer = initWriter(writer);
+		const addSplitZipSignature =
+			writer.availableSize !== UNDEFINED_VALUE && writer.availableSize > 0 && writer.availableSize !== Infinity &&
+			writer.maxSize !== UNDEFINED_VALUE && writer.maxSize > 0 && writer.maxSize !== Infinity;
 		Object.assign(this, {
 			writer,
-			addSplitZipSignature: writer instanceof SplitDataWriter,
+			addSplitZipSignature,
 			options,
 			config: getConfiguration(),
 			files: new Map(),
@@ -175,8 +176,36 @@ class ZipWriter {
 	}
 }
 
+class ZipWriterStream {
+
+	constructor(options = {}) {
+		const { readable, writable } = new TransformStream();
+		this.readable = readable;
+		this.zipWriter = new ZipWriter(writable, options);
+	}
+
+	transform(path) {
+		const { readable, writable } = new TransformStream({
+			flush: () => { this.zipWriter.close(); }
+		});
+		this.zipWriter.add(path, readable);
+		return { readable: this.readable, writable };
+	}
+
+	writable(path) {
+		const { readable, writable } = new TransformStream();
+		this.zipWriter.add(path, readable);
+		return writable;
+	}
+
+	close(comment = undefined, options = {}) {
+		return this.zipWriter.close(comment, options);
+	}
+}
+
 export {
 	ZipWriter,
+	ZipWriterStream,
 	ERR_DUPLICATED_NAME,
 	ERR_INVALID_COMMENT,
 	ERR_INVALID_ENTRY_NAME,
@@ -219,6 +248,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 +331,7 @@ async function addFile(zipWriter, name, reader, options) {
 		zip64Offset,
 		zip64DiskNumberStart,
 		password,
+		rawPassword,
 		level,
 		useWebWorkers,
 		encryptionStrength,
@@ -356,6 +387,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	let writingBufferedEntryData;
 	let writingEntryData;
 	let fileWriter;
+	let blobPromise;
 	files.set(name, fileEntry);
 	try {
 		let lockPreviousFileEntry;
@@ -364,7 +396,8 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			requestLockCurrentFileEntry();
 		}
 		if ((options.bufferedWrite || zipWriter.writerLocked || (zipWriter.bufferedWrites && keepOrder) || !dataDescriptor) && !usdz) {
-			fileWriter = new BlobWriter();
+			fileWriter = new TransformStream();
+			blobPromise = new Response(fileWriter.readable).blob();
 			fileWriter.writable.size = 0;
 			bufferedWrite = true;
 			zipWriter.bufferedWrites++;
@@ -400,7 +433,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		fileEntry.filename = name;
 		if (bufferedWrite) {
 			await fileWriter.writable.getWriter().close();
-			let blob = await fileWriter.getData();
+			let blob = await blobPromise;
 			await lockPreviousFileEntry;
 			await requestLockWriter();
 			writingBufferedEntryData = true;
@@ -467,7 +500,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 +533,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		lastAccessDate,
 		creationDate,
 		password,
+		rawPassword,
 		level,
 		zip64,
 		zip64UncompressedSize,
@@ -556,6 +590,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 			options: {
 				codecType: CODEC_DEFLATE,
 				level,
+				rawPassword,
 				password,
 				encryptionStrength,
 				zipCrypto: encrypted && zipCrypto,
@@ -637,6 +672,7 @@ function getHeaderInfo(options) {
 		lastModDate,
 		lastAccessDate,
 		creationDate,
+		rawPassword,
 		password,
 		level,
 		zip64,
@@ -648,7 +684,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 +807,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 +816,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 +880,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);
@@ -1140,4 +1176,4 @@ function getLength(...arrayLikes) {
 	let result = 0;
 	arrayLikes.forEach(arrayLike => arrayLike && (result += arrayLike.length));
 	return result;
-}
+}

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