@zip.js/zip.js 2.8.36 → 2.8.38

package/lib/core/zip-reader.js

@@ -42,6 +42,7 @@ import {
 	DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH,
 	LOCAL_FILE_HEADER_SIGNATURE,
+	ARCHIVE_EXTRA_DATA_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
 	CENTRAL_FILE_HEADER_LENGTH,
 	END_OF_CENTRAL_DIR_SIGNATURE,
@@ -61,6 +62,7 @@ import {
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
 	BITFLAG_ENCRYPTED,
+	BITFLAG_STRONG_ENCRYPTION,
 	BITFLAG_LEVEL,
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
@@ -86,6 +88,7 @@ import {
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
 import { getConfiguration } from "./configuration.js";
+import { getRegisteredCodec } from "./codec-registry.js";
 import {
 	runWorker,
 	CODEC_INFLATE,
@@ -160,6 +163,7 @@ const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 const ERR_SPLIT_ZIP_FILE = "Split zip file";
 const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
 const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
+const ERR_ENCRYPTED_CENTRAL_DIRECTORY = "Encrypted central directory is not supported";
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 const CHARSET_CP437 = "cp437";
@@ -237,6 +241,7 @@ class ZipReader {
 		let prependedDataLength = 0;
 		let startOffset;
 		let zip64EndOfDirectory;
+		let zip64EndOfDirectoryVersion2;
 		const requiresZip64 = directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS;
 		if (directoryDataOffset != MAX_32_BITS && diskNumber != MAX_16_BITS) {
 			directoryDataOffset += getDiskOffset(reader, diskNumber);
@@ -266,6 +271,7 @@ class ZipReader {
 					throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
 				}
 				zip64EndOfDirectory = true;
+				zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
 				if (lastDiskNumber == MAX_16_BITS) {
 					lastDiskNumber = getUint32(endOfDirectoryView, 16);
 				} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
@@ -345,6 +351,9 @@ class ZipReader {
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 			const fileEntry = new ZipEntry(reader, config, zipReader.options);
 			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
+				if (indexFile == 0 && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+					throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
+				}
 				throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
 			}
 			readCommonHeader(fileEntry, directoryView, offset + 6);
@@ -546,7 +555,8 @@ export {
 	ERR_INVALID_COMPRESSED_DATA,
 	ERR_SPLIT_ZIP_FILE,
 	ERR_OVERLAPPING_ENTRY,
-	ERR_AMBIGUOUS_ARCHIVE
+	ERR_AMBIGUOUS_ARCHIVE,
+	ERR_ENCRYPTED_CENTRAL_DIRECTORY
 };
 
 class ZipEntry {
@@ -593,7 +603,8 @@ class ZipEntry {
 				throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 			}
 		}
-		if ((compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64) && !passThrough) {
+		const registeredCodec = passThrough ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
+		if ((compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64 && !registeredCodec) && !passThrough) {
 			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
 		if (dataArray.length < HEADER_SIZE || getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
@@ -632,7 +643,10 @@ class ZipEntry {
 			fileEntry.zipCrypto = zipCrypto;
 		}
 		if (encrypted) {
-			if (!zipCrypto && extraFieldAES.strength === UNDEFINED_VALUE) {
+			if ((localDirectory.rawBitFlag & BITFLAG_STRONG_ENCRYPTION) == BITFLAG_STRONG_ENCRYPTION) {
+				throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
+			}
+			if (!zipCrypto && (extraFieldAES.strength < 1 || extraFieldAES.strength > 3)) {
 				throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
 			} else if (!password && !rawPassword) {
 				throw new Error(ERR_ENCRYPTED);
@@ -671,6 +685,8 @@ class ZipEntry {
 				useCompressionStream,
 				transferStreams: getOptionValue(zipEntry, options, OPTION_TRANSFER_STREAMS),
 				deflate64,
+				format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
+				codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
 				checkPasswordOnly
 			},
 			config,
@@ -723,6 +739,16 @@ class ZipEntry {
 	}
 }
 
+function detectEncryptedCentralDirectory(directoryView) {
+	const maxOffset = Math.min(directoryView.byteLength, 1024) - 3;
+	for (let offset = 0; offset < maxOffset; offset++) {
+		if (getUint32(directoryView, offset) == ARCHIVE_EXTRA_DATA_SIGNATURE) {
+			return true;
+		}
+	}
+	return false;
+}
+
 function readCommonHeader(directory, dataView, offset) {
 	const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset + 2);
 	const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;

package/lib/core/zip-writer.js

@@ -142,6 +142,7 @@ import {
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
 import { getConfiguration } from "./configuration.js";
+import { getRegisteredCodec } from "./codec-registry.js";
 import {
 	CODEC_DEFLATE,
 	runWorker
@@ -193,6 +194,7 @@ import {
 	OPTION_PREVENT_CLOSE,
 	OPTION_ENCRYPTION_STRENGTH,
 	OPTION_EXTENDED_TIMESTAMP,
+	OPTION_NTFS_TIMESTAMP,
 	OPTION_KEEP_ORDER,
 	OPTION_LEVEL,
 	OPTION_BUFFERED_WRITE,
@@ -213,6 +215,7 @@ const ERR_INVALID_ENTRY_COMMENT = "File entry comment exceeds 64KB";
 const ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
 const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
+const ERR_UNSUPPORTED_ENCRYPTION_USDZ = "Encryption is not supported in USDZ files";
 const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
 const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
@@ -501,6 +504,7 @@ export {
 	ERR_INVALID_EXTRAFIELD_TYPE,
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
+	ERR_UNSUPPORTED_ENCRYPTION_USDZ,
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
 	ERR_UNDEFINED_READER,
@@ -590,7 +594,11 @@ function resolveAttributes(zipWriter, name, options) {
 	if (versionMadeBy > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_VERSION);
 	}
-	let externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES, 0);
+	let externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES);
+	const externalFileAttributesProvided = externalFileAttributes !== UNDEFINED_VALUE;
+	if (!externalFileAttributesProvided) {
+		externalFileAttributes = 0;
+	}
 	if (!options[PROPERTY_NAME_DIRECTORY] && name.endsWith(DIRECTORY_SIGNATURE)) {
 		options[PROPERTY_NAME_DIRECTORY] = true;
 	}
@@ -599,13 +607,13 @@ function resolveAttributes(zipWriter, name, options) {
 		if (!name.endsWith(DIRECTORY_SIGNATURE)) {
 			name += DIRECTORY_SIGNATURE;
 		}
-		if (externalFileAttributes === 0) {
+		if (!externalFileAttributesProvided) {
 			externalFileAttributes = FILE_ATTR_MSDOS_DIR_MASK;
 			if (!msDosCompatible) {
 				externalFileAttributes |= (FILE_ATTR_UNIX_TYPE_DIR | FILE_ATTR_UNIX_EXECUTABLE_MASK | FILE_ATTR_UNIX_DEFAULT_MASK) << 16;
 			}
 		}
-	} else if (!msDosCompatible && externalFileAttributes === 0) {
+	} else if (!msDosCompatible && !externalFileAttributesProvided) {
 		if (executable) {
 			externalFileAttributes = (FILE_ATTR_UNIX_EXECUTABLE_MASK | FILE_ATTR_UNIX_DEFAULT_MASK) << 16;
 		} else {
@@ -614,6 +622,7 @@ function resolveAttributes(zipWriter, name, options) {
 	}
 	let unixExternalUpper;
 	if (!msDosCompatible) {
+		const unixModeProvided = unixMode !== UNDEFINED_VALUE || Boolean(setuid || setgid || sticky);
 		unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
 		unixMode = unixMode === UNDEFINED_VALUE ? unixExternalUpper : (unixMode & MAX_16_BITS);
 		if (setuid) {
@@ -631,10 +640,12 @@ function resolveAttributes(zipWriter, name, options) {
 		} else {
 			sticky = Boolean(unixMode & FILE_ATTR_UNIX_STICKY_MASK);
 		}
-		if (directory) {
-			unixMode |= FILE_ATTR_UNIX_TYPE_DIR;
+		if (!externalFileAttributesProvided || unixModeProvided) {
+			if (directory) {
+				unixMode |= FILE_ATTR_UNIX_TYPE_DIR;
+			}
+			externalFileAttributes = ((unixMode & MAX_16_BITS) << 16) | (externalFileAttributes & MAX_16_BITS);
 		}
-		externalFileAttributes = ((unixMode & MAX_16_BITS) << 16) | (externalFileAttributes & MAX_8_BITS);
 	}
 	({ msdosAttributesRaw, msdosAttributes } = normalizeMsdosAttributes(msdosAttributesRaw, msdosAttributes));
 	if (hasMsDosProvided) {
@@ -694,6 +705,7 @@ function resolveMetadata(zipWriter, name, options) {
 	const encryptionStrength = getOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 	const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
 	const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
+	const ntfsTimestamp = getOptionValue(zipWriter, options, OPTION_NTFS_TIMESTAMP);
 	const keepOrder = getOptionValue(zipWriter, options, OPTION_KEEP_ORDER, true);
 	const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
 	const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS);
@@ -703,11 +715,20 @@ function resolveMetadata(zipWriter, name, options) {
 	const signal = getOptionValue(zipWriter, options, OPTION_SIGNAL);
 	const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
 	const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
+	const registeredCodec = passThrough || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
 	if (!passThrough && compressionMethod !== UNDEFINED_VALUE &&
-		compressionMethod !== COMPRESSION_METHOD_STORE && compressionMethod !== COMPRESSION_METHOD_DEFLATE) {
+		compressionMethod !== COMPRESSION_METHOD_STORE && compressionMethod !== COMPRESSION_METHOD_DEFLATE && !registeredCodec) {
 		throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 	}
 	let level = getOptionValue(zipWriter, options, OPTION_LEVEL);
+	if (zipWriter.options[OPTION_USDZ]) {
+		if (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) {
+			throw new Error(ERR_UNSUPPORTED_ENCRYPTION_USDZ);
+		}
+		if (level === UNDEFINED_VALUE && compressionMethod === UNDEFINED_VALUE) {
+			level = 0;
+		}
+	}
 	let useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
 	let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
 	if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
@@ -719,7 +740,7 @@ function resolveMetadata(zipWriter, name, options) {
 	if (level !== UNDEFINED_VALUE && level != 6) {
 		useCompressionStream = false;
 	}
-	if (!useCompressionStream && (zipWriter.config.CompressionStream === UNDEFINED_VALUE && zipWriter.config.CompressionStreamZlib === UNDEFINED_VALUE)) {
+	if (!useCompressionStream && !registeredCodec && (zipWriter.config.CompressionStream === UNDEFINED_VALUE && zipWriter.config.CompressionStreamZlib === UNDEFINED_VALUE)) {
 		level = 0;
 	}
 	const zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
@@ -763,6 +784,7 @@ function resolveMetadata(zipWriter, name, options) {
 			encryptionStrength,
 			zipCrypto,
 			extendedTimestamp,
+			ntfsTimestamp,
 			keepOrder,
 			useWebWorkers,
 			transferStreams,
@@ -772,6 +794,9 @@ function resolveMetadata(zipWriter, name, options) {
 			signal,
 			useUnicodeFileNames,
 			compressionMethod,
+			format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
+			codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
+			codecVersionNeeded: registeredCodec ? registeredCodec.versionNeeded : UNDEFINED_VALUE,
 			level,
 			useCompressionStream,
 			dataDescriptor,
@@ -1068,7 +1093,9 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		msdosAttributesRaw,
 		msdosAttributes,
 		useCompressionStream,
-		passThrough
+		passThrough,
+		format,
+		codecURI
 	} = options;
 	const fileEntry = {
 		lock,
@@ -1128,7 +1155,9 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 				encrypted: encrypted && !passThrough,
 				useWebWorkers,
 				useCompressionStream,
-				transferStreams
+				transferStreams,
+				format,
+				codecURI
 			},
 			config,
 			streamOptions: { signal, size, onstart, onprogress, onend }
@@ -1200,6 +1229,7 @@ function getHeaderInfo(options) {
 		rawExtraField,
 		encryptionStrength,
 		extendedTimestamp,
+		ntfsTimestamp,
 		passThrough,
 		encrypted,
 		zip64UncompressedSize,
@@ -1245,7 +1275,8 @@ function getHeaderInfo(options) {
 	let extraFieldExtendedTimestampFlag;
 	if (extendedTimestamp) {
 		const lastModTimeUnix = getTimeUnix(lastModDate);
-		if (inUnixTimeRange(lastModTimeUnix)) {
+		const lastModTimeUnixInRange = inUnixTimeRange(lastModTimeUnix);
+		if (lastModTimeUnixInRange) {
 			const extraFieldTimestampLength = 9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0);
 			const extraFieldTimestamp = createRecordWriter(extraFieldTimestampLength);
 			extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
@@ -1263,19 +1294,26 @@ function getHeaderInfo(options) {
 		} else {
 			rawExtraFieldExtendedTimestamp = EMPTY_UINT8_ARRAY;
 		}
-		try {
-			const lastModTimeNTFS = getTimeNTFS(lastModDate);
-			const extraFieldNTFS = createRecordWriter(36);
-			extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS);
-			extraFieldNTFS.uint16(32);
-			extraFieldNTFS.skip(4);
-			extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS_TAG1);
-			extraFieldNTFS.uint16(24);
-			extraFieldNTFS.uint64(lastModTimeNTFS);
-			extraFieldNTFS.uint64(getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
-			extraFieldNTFS.uint64(getTimeNTFS(creationDate) || lastModTimeNTFS);
-			rawExtraFieldNTFS = extraFieldNTFS.array;
-		} catch {
+		const writeExtraFieldNTFS = ntfsTimestamp === UNDEFINED_VALUE ?
+			!lastModTimeUnixInRange || Boolean(lastAccessDate || creationDate) :
+			ntfsTimestamp;
+		if (writeExtraFieldNTFS) {
+			try {
+				const lastModTimeNTFS = getTimeNTFS(lastModDate);
+				const extraFieldNTFS = createRecordWriter(36);
+				extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS);
+				extraFieldNTFS.uint16(32);
+				extraFieldNTFS.skip(4);
+				extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS_TAG1);
+				extraFieldNTFS.uint16(24);
+				extraFieldNTFS.uint64(lastModTimeNTFS);
+				extraFieldNTFS.uint64(getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
+				extraFieldNTFS.uint64(getTimeNTFS(creationDate) || lastModTimeNTFS);
+				rawExtraFieldNTFS = extraFieldNTFS.array;
+			} catch {
+				rawExtraFieldNTFS = EMPTY_UINT8_ARRAY;
+			}
+		} else {
 			rawExtraFieldNTFS = EMPTY_UINT8_ARRAY;
 		}
 	} else {
@@ -1313,6 +1351,10 @@ function getHeaderInfo(options) {
 	if (compressionMethod === UNDEFINED_VALUE) {
 		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
 	}
+	const { codecVersionNeeded } = options;
+	if (compressed && codecVersionNeeded !== UNDEFINED_VALUE) {
+		version = version > codecVersionNeeded ? version : codecVersionNeeded;
+	}
 	if (zip64) {
 		version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
 	}
@@ -1326,6 +1368,7 @@ function getHeaderInfo(options) {
 	if (extraFieldLength > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 	}
+	const dosLastModDate = new Date(Math.ceil(lastModDate.getTime() / 2000) * 2000);
 	const {
 		headerArray,
 		headerView,
@@ -1335,7 +1378,7 @@ function getHeaderInfo(options) {
 		bitFlag: getBitFlag(level, useUnicodeFileNames, dataDescriptor, encrypted, compressionMethod),
 		compressionMethod,
 		uncompressedSize,
-		lastModDate: lastModDate < MIN_DATE ? MIN_DATE : lastModDate > MAX_DATE ? MAX_DATE : lastModDate,
+		lastModDate: dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate,
 		rawFilename,
 		zip64CompressedSize,
 		zip64UncompressedSize,

package/lib/zip-core-base.js

@@ -63,6 +63,13 @@ export {
 	configure,
 	resetConfiguration
 } from "./core/configuration.js";
+export {
+	registerCodec,
+	unregisterCodec,
+	ERR_INVALID_CODEC_DEFINITION,
+	ERR_RESERVED_COMPRESSION_METHOD,
+	ERR_INVALID_CODEC_MODULE
+} from "./core/codec-registry.js";
 export {
 	createOPFSTempStream
 } from "./core/util/opfs-temp-stream.js";

package/lib/zip-core-reader.js

@@ -44,5 +44,6 @@ export {
 	ERR_INVALID_COMPRESSED_DATA,
 	ERR_SPLIT_ZIP_FILE,
 	ERR_OVERLAPPING_ENTRY,
-	ERR_AMBIGUOUS_ARCHIVE
+	ERR_AMBIGUOUS_ARCHIVE,
+	ERR_ENCRYPTED_CENTRAL_DIRECTORY
 } from "./core/zip-reader.js";

package/lib/zip-core-writer.js

@@ -37,6 +37,7 @@ export {
 	ERR_INVALID_EXTRAFIELD_TYPE,
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
+	ERR_UNSUPPORTED_ENCRYPTION_USDZ,
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
 	ERR_UNDEFINED_READER,

package/package.json

@@ -3,7 +3,7 @@
   "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "2.8.36",
+  "version": "2.8.38",
   "type": "module",
   "keywords": [
     "zip",

package/worker-message-property-names.js

@@ -1,3 +1,3 @@
-const WORKER_MESSAGE_PROPERTY_NAMES = ["baseURI", "checkPasswordOnly", "chunkSize", "code", "codecType", "compressed", "config", "deflate64", "done", "encrypted", "encryptionStrength", "error", "inputSize", "level", "message", "messageId", "name", "options", "outputSize", "password", "passwordVerification", "rawPassword", "readable", "result", "signature", "signed", "stack", "transferStreams", "type", "useCompressionStream", "useWebWorkers", "value", "wasmURI", "writable", "zipCrypto"];
+const WORKER_MESSAGE_PROPERTY_NAMES = ["baseURI", "checkPasswordOnly", "chunkSize", "code", "codecType", "codecURI", "compressed", "config", "deflate64", "done", "encrypted", "encryptionStrength", "error", "format", "inputSize", "level", "message", "messageId", "name", "options", "outputSize", "password", "passwordVerification", "rawPassword", "readable", "result", "signature", "signed", "stack", "transferStreams", "type", "useCompressionStream", "useWebWorkers", "value", "wasmURI", "workerStartupTimeout", "writable", "zipCrypto"];
 
 export { WORKER_MESSAGE_PROPERTY_NAMES };