@zip.js/zip.js 2.8.37 → 2.8.39

package/dist/zip-fs-core.js

@@ -45,6 +45,7 @@
 	const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
 	const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
 	const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
+	const ARCHIVE_EXTRA_DATA_SIGNATURE = 0x08064b50;
 	const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 	const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 	const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
@@ -76,6 +77,7 @@
 	const BITFLAG_LEVEL_FAST_MASK = 0b100;
 	const BITFLAG_LEVEL_SUPER_FAST_MASK = 0b110;
 	const BITFLAG_DATA_DESCRIPTOR = 0b1000;
+	const BITFLAG_STRONG_ENCRYPTION = 0b1000000;
 	const BITFLAG_LANG_ENCODING_FLAG = 0b100000000000;
 	const FILE_ATTR_MSDOS_DIR_MASK = 0b10000;
 	const FILE_ATTR_MSDOS_READONLY_MASK = 0x01;
@@ -159,6 +161,7 @@
 		maxWorkers,
 		terminateWorkerTimeout: 5000,
 		workerStarvationTimeout: 5000,
+		workerStartupTimeout: 5000,
 		useWebWorkers: true,
 		useCompressionStream: true,
 		transferStreams: true,
@@ -987,7 +990,7 @@
 
 		getDiskOffset(diskNumber) {
 			const { diskOffsets, size } = this;
-			const diskOffset = diskOffsets.at(diskNumber);
+			const diskOffset = diskOffsets[diskNumber];
 			return diskOffset === UNDEFINED_VALUE ? size : diskOffset;
 		}
 
@@ -2575,7 +2578,7 @@
 					if (zipCrypto.password || zipCrypto.rawPassword) {
 						const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
 						zipCrypto.password = zipCrypto.rawPassword = null;
-						if ((decryptedHeader.at(-1) ^ zipCrypto.passwordVerification) != 0) {
+						if ((decryptedHeader[HEADER_LENGTH - 1] ^ zipCrypto.passwordVerification) != 0) {
 							throw new Error(ERR_INVALID_PASSWORD);
 						}
 						chunk = chunk.subarray(HEADER_LENGTH);
@@ -2748,7 +2751,7 @@
 					readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP));
 					readable = pipeThrough(readable, gzipCrc32Stream);
 				} else {
-					readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib, CompressionStream);
+					readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib);
 				}
 			}
 			if (encrypted) {
@@ -2833,7 +2836,7 @@
 				if (codecStreams) {
 					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize }));
 				} else {
-					readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib, DecompressionStream);
+					readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib);
 				}
 				readable = mapInflateStreamError(readable);
 			}
@@ -2852,6 +2855,25 @@
 		}
 	}
 
+	const deflateRawSupportByStream = new Map();
+
+	function supportsDeflateRaw(StreamClass) {
+		if (!StreamClass) {
+			return false;
+		}
+		let supported = deflateRawSupportByStream.get(StreamClass);
+		if (supported === UNDEFINED_VALUE) {
+			try {
+				new StreamClass(FORMAT_DEFLATE_RAW);
+				supported = true;
+			} catch {
+				supported = false;
+			}
+			deflateRawSupportByStream.set(StreamClass, supported);
+		}
+		return supported;
+	}
+
 	function setReadable(stream, readable, flush) {
 		readable = pipeThrough(readable, new TransformStream({ flush }));
 		Object.defineProperty(stream, "readable", {
@@ -2868,21 +2890,17 @@
 		return new CodecStreamClass(format, options);
 	}
 
-	function pipeThroughCommpressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib, CompressionStream) {
-		const Stream = useCompressionStream && CompressionStreamNative ? CompressionStreamNative : CompressionStreamZlib || CompressionStream;
+	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib) {
+		const Stream = useCompressionStream && CompressionStreamNative ?
+			CompressionStreamNative :
+			CompressionStreamZlib || CompressionStreamNative;
 		const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
 		let codecStream;
 		try {
 			codecStream = new Stream(format, options);
 		} catch (error) {
-			if (useCompressionStream) {
-				if (CompressionStreamZlib) {
-					codecStream = new CompressionStreamZlib(format, options);
-				} else if (CompressionStream) {
-					codecStream = new CompressionStream(format, options);
-				} else {
-					throw error;
-				}
+			if (useCompressionStream && CompressionStreamZlib && Stream != CompressionStreamZlib) {
+				codecStream = new CompressionStreamZlib(format, options);
 			} else {
 				throw error;
 			}
@@ -3143,6 +3161,7 @@
 	const MODULE_WORKER_OPTIONS = { type: "module" };
 	const ERROR_EVENT_TYPE = "error";
 	const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
+	const ERR_WORKER_STARTUP_TIMEOUT = "Worker startup timeout";
 
 	let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions;
 	let transferStreamsSupported = true;
@@ -3246,7 +3265,7 @@
 	}
 
 	function createWebWorkerInterface(workerData, config) {
-		const { baseURI, chunkSize } = config;
+		const { baseURI, chunkSize, workerStartupTimeout } = config;
 		let { wasmURI } = config;
 
 		if (!workerData.interface) {
@@ -3263,9 +3282,26 @@
 			}
 			Object.assign(workerData, {
 				worker,
+				workerAlive: false,
 				terminated: false,
 				interface: {
-					run: () => runWebWorker(workerData, { chunkSize, wasmURI, baseURI })
+					run: async () => {
+						try {
+							return await runWebWorker(workerData, { chunkSize, wasmURI, baseURI, workerStartupTimeout });
+						} catch (error) {
+							if (error && error.workerStartupFailed) {
+								webWorkerSupported = false;
+								const { reader } = workerData;
+								if (reader) {
+									reader.releaseLock();
+								}
+								workerData.reader = null;
+								workerData.writer = null;
+								return runWorker$1(workerData, config);
+							}
+							throw error;
+						}
+					}
 				}
 			});
 		}
@@ -3275,15 +3311,23 @@
 	async function runWorker$1({ options, readable, writable, onTaskFinished }, config) {
 		let codecStream;
 		try {
-			if (!options.useCompressionStream) {
-				try {
-					await initModule(config);
-				} catch {
-					const ZlibStream = options.codecType.startsWith(CODEC_DEFLATE) ?
-						config.CompressionStreamZlib :
-						config.DecompressionStreamZlib;
-					if (!ZlibStream || ZlibStream.requiresModule) {
-						options.useCompressionStream = true;
+			if (options.compressed && !options.format) {
+				const deflate = options.codecType.startsWith(CODEC_DEFLATE);
+				const ZlibStream = deflate ? config.CompressionStreamZlib : config.DecompressionStreamZlib;
+				const NativeStream = deflate ? config.CompressionStream : config.DecompressionStream;
+				if (!options.useCompressionStream) {
+					try {
+						await initModule(config);
+					} catch {
+						if (!ZlibStream || ZlibStream.requiresModule) {
+							options.useCompressionStream = true;
+						}
+					}
+				} else if (ZlibStream && ZlibStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
+					try {
+						await initModule(config);
+					} catch {
+						// ignored
 					}
 				}
 			}
@@ -3352,6 +3396,10 @@
 				writer: writable.getWriter()
 			});
 		}
+		const { workerStartupTimeout } = config;
+		if (!workerData.workerAlive && Number.isFinite(workerStartupTimeout) && workerStartupTimeout >= 0) {
+			workerData.startupTimeout = setTimeout(() => onStartupTimeout(workerData), workerStartupTimeout);
+		}
 		try {
 			const resultValue = await result;
 			await closeWritable();
@@ -3464,28 +3512,68 @@
 		} else {
 			worker = new Worker(webWorkerURI, webWorkerOptions);
 		}
-		worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData));
+		worker.addEventListener(MESSAGE_EVENT_TYPE, event => {
+			workerData.workerAlive = true;
+			clearStartupTimeout(workerData);
+			onMessage(event, workerData);
+		});
 		worker.addEventListener(ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
 		worker.addEventListener(MESSAGE_ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
 		return worker;
 	}
 
+	function onStartupTimeout(workerData) {
+		workerData.startupTimeout = null;
+		if (workerData.workerAlive) {
+			return;
+		}
+		const { rejectResult, writer } = workerData;
+		terminateWorker$1(workerData);
+		workerData.worker = null;
+		if (rejectResult) {
+			const error = new Error(ERR_WORKER_STARTUP_TIMEOUT);
+			error.workerStartupFailed = true;
+			rejectResult(error);
+			if (writer) {
+				writer.releaseLock();
+			}
+		}
+	}
+
+	function clearStartupTimeout(workerData) {
+		const { startupTimeout } = workerData;
+		if (startupTimeout) {
+			clearTimeout(startupTimeout);
+			workerData.startupTimeout = null;
+		}
+	}
+
 	function onWorkerError(event, workerData) {
 		if (event.preventDefault) {
 			event.preventDefault();
 		}
-		const { rejectResult, writer, onTaskFinished } = workerData;
+		clearStartupTimeout(workerData);
+		const { workerAlive, rejectResult, writer, onTaskFinished } = workerData;
 		terminateWorker$1(workerData);
+		if (!workerAlive) {
+			workerData.worker = null;
+		}
 		if (rejectResult) {
-			rejectResult(event.error || new Error(event.message || ERROR_EVENT_TYPE));
+			let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
+			if (!workerAlive) {
+				error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
+			}
+			rejectResult(error);
 			if (writer) {
 				writer.releaseLock();
 			}
-			onTaskFinished();
+			if (workerAlive) {
+				onTaskFinished();
+			}
 		}
 	}
 
-	function sendMessage(message, { worker, writer, transferStreams }) {
+	function sendMessage(message, { worker, writer, transferStreams, workerAlive }) {
 		try {
 			const { value, readable, writable } = message;
 			const transferables = [];
@@ -3493,7 +3581,7 @@
 				message.value = toExactUint8Array(value);
 				transferables.push(message.value.buffer);
 			}
-			if (transferStreams && transferStreamsSupported) {
+			if (transferStreams && transferStreamsSupported && workerAlive) {
 				if (readable) {
 					transferables.push(readable);
 				}
@@ -4049,6 +4137,7 @@
 	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";
@@ -4126,6 +4215,7 @@
 			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$1(reader, diskNumber);
@@ -4155,6 +4245,7 @@
 						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)) {
@@ -4234,6 +4325,9 @@
 			for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 				const fileEntry = new ZipEntry$1(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);
@@ -4461,6 +4555,9 @@
 				fileEntry.zipCrypto = zipCrypto;
 			}
 			if (encrypted) {
+				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) {
@@ -4554,6 +4651,16 @@
 		}
 	};
 
+	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;
@@ -5068,6 +5175,7 @@
 		ERR_BAD_FORMAT: ERR_BAD_FORMAT,
 		ERR_CENTRAL_DIRECTORY_NOT_FOUND: ERR_CENTRAL_DIRECTORY_NOT_FOUND,
 		ERR_ENCRYPTED: ERR_ENCRYPTED,
+		ERR_ENCRYPTED_CENTRAL_DIRECTORY: ERR_ENCRYPTED_CENTRAL_DIRECTORY,
 		ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND: ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND,
 		ERR_EOCDR_NOT_FOUND: ERR_EOCDR_NOT_FOUND,
 		ERR_EXTRAFIELD_ZIP64_NOT_FOUND: ERR_EXTRAFIELD_ZIP64_NOT_FOUND,
@@ -5417,7 +5525,11 @@
 		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;
 		}
@@ -5426,13 +5538,13 @@
 			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 {
@@ -5441,6 +5553,7 @@
 		}
 		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) {
@@ -5458,10 +5571,12 @@
 			} 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) {
@@ -6184,6 +6299,7 @@
 		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,
@@ -6193,7 +6309,7 @@
 			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,