@zip.js/zip.js 2.8.45 → 2.8.47

package/dist/zip-fs-core.js

@@ -46,6 +46,7 @@
 	const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
 	const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
 	const ARCHIVE_EXTRA_DATA_SIGNATURE = 0x08064b50;
+	const DIGITAL_SIGNATURE_RECORD_SIGNATURE = 0x05054b50;
 	const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 	const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 	const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
@@ -2815,7 +2816,7 @@
 
 	class DeflateStream extends TransformStream {
 
-		constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
+		constructor(options, { chunkSize, CompressionStreamFallback, CompressionStream }) {
 			super({});
 			const { compressed, encrypted, useCompressionStream, zipCrypto, computeCrc32, level, deflate64, format, compressionMethod } = options;
 			const stream = this;
@@ -2837,7 +2838,7 @@
 					readable = pipeThrough(readable, gzipCrc32Stream);
 				} else {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 					} catch (error) {
 						let gzipStream;
 						try {
@@ -2979,7 +2980,7 @@
 
 	class InflateStream extends TransformStream {
 
-		constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
+		constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream }) {
 			super({});
 			const { zipCrypto, encrypted, checkCrc32, crc32, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
 			let crc32Stream, decryptionStream;
@@ -2998,7 +2999,7 @@
 					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
 				} else {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
 					} catch (error) {
 						if (deflate64 || outputSize === UNDEFINED_VALUE) {
 							throw error;
@@ -3077,17 +3078,17 @@
 		return new CodecStreamClass(format, options);
 	}
 
-	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib) {
+	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
 		const Stream = useCompressionStream && CompressionStreamNative ?
 			CompressionStreamNative :
-			CompressionStreamZlib || CompressionStreamNative;
+			CompressionStreamFallback || CompressionStreamNative;
 		const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
 		let codecStream;
 		try {
 			codecStream = new Stream(format, options);
 		} catch (error) {
-			if (useCompressionStream && CompressionStreamZlib && Stream != CompressionStreamZlib) {
-				codecStream = new CompressionStreamZlib(format, options);
+			if (useCompressionStream && CompressionStreamFallback && Stream != CompressionStreamFallback) {
+				codecStream = new CompressionStreamFallback(format, options);
 			} else {
 				throw error;
 			}
@@ -3350,7 +3351,7 @@
 	const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
 	const ERR_WORKER_STARTUP_TIMEOUT = "Worker startup timeout";
 
-	let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions;
+	let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions, createWorkerFailed;
 	let transferStreamsSupported = true;
 	try {
 		transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
@@ -3360,14 +3361,14 @@
 	let initModule = () => { };
 
 	async function supportsDeflate(config) {
-		const { CompressionStream: NativeStream, CompressionStreamZlib: ZlibStream } = config;
-		if (ZlibStream && !ZlibStream.requiresModule) {
+		const { CompressionStream: NativeStream, CompressionStreamFallback: FallbackStream } = config;
+		if (FallbackStream && !FallbackStream.requiresModule) {
 			return true;
 		}
 		if (supportsDeflateRaw(NativeStream) || supportsGzip(NativeStream)) {
 			return true;
 		}
-		if (ZlibStream) {
+		if (FallbackStream) {
 			try {
 				await initModule(config);
 				return true;
@@ -3380,8 +3381,11 @@
 
 	class CodecWorker {
 
-		constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI }, onTaskFinished) {
+		constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI, createWorker }, onTaskFinished) {
 			const { signal } = streamOptions;
+			if (createWorkerFailed) {
+				createWorker = UNDEFINED_VALUE;
+			}
 			Object.assign(workerData, {
 				busy: true,
 				generation: (workerData.generation || 0) + 1,
@@ -3391,6 +3395,7 @@
 				writable,
 				options: Object.assign({}, options),
 				workerURI,
+				createWorker,
 				transferStreams,
 				terminate() {
 					return new Promise(resolve => {
@@ -3426,7 +3431,7 @@
 				// deno-lint-ignore valid-typeof
 				webWorkerSupported = typeof Worker != UNDEFINED_TYPE;
 			}
-			return (useWebWorkers && webWorkerSupported ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
+			return (useWebWorkers && ((webWorkerSupported && workerURI) || createWorker) ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
 		}
 	}
 
@@ -3483,7 +3488,11 @@
 			try {
 				worker = getWebWorker(workerData.workerURI, baseURI, workerData);
 			} catch {
-				webWorkerSupported = false;
+				if (workerData.createWorker) {
+					createWorkerFailed = true;
+				} else {
+					webWorkerSupported = false;
+				}
 				return createWorkerInterface(workerData, config);
 			}
 			Object.assign(workerData, {
@@ -3496,7 +3505,11 @@
 							return await runWebWorker(workerData, { chunkSize, wasmURI, baseURI, workerStartupTimeout });
 						} catch (error) {
 							if (error && error.workerStartupFailed) {
-								webWorkerSupported = false;
+								if (workerData.createWorker) {
+									createWorkerFailed = true;
+								} else {
+									webWorkerSupported = false;
+								}
 								const { reader } = workerData;
 								if (reader) {
 									reader.releaseLock();
@@ -3519,17 +3532,17 @@
 		try {
 			if (options.compressed && !options.format) {
 				const deflate = options.codecType.startsWith(CODEC_DEFLATE);
-				const ZlibStream = deflate ? config.CompressionStreamZlib : config.DecompressionStreamZlib;
+				const FallbackStream = deflate ? config.CompressionStreamFallback : config.DecompressionStreamFallback;
 				const NativeStream = deflate ? config.CompressionStream : config.DecompressionStream;
 				if (!options.useCompressionStream) {
 					try {
 						await initModule(config);
 					} catch {
-						if (!ZlibStream || ZlibStream.requiresModule) {
+						if (!FallbackStream || FallbackStream.requiresModule) {
 							options.useCompressionStream = true;
 						}
 					}
-				} else if (ZlibStream && ZlibStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
+				} else if (FallbackStream && FallbackStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
 					try {
 						await initModule(config);
 					} catch {
@@ -3654,8 +3667,11 @@
 	}
 
 	function getWebWorker(url, baseURI, workerData, isModuleType, useBlobURI = true) {
+		const { createWorker } = workerData;
 		let worker, resolvedURI, resolvedOptions;
-		if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
+		if (createWorker) {
+			worker = createWorker();
+		} else if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
 			// deno-lint-ignore valid-typeof
 			const isFunctionURI = typeof url == FUNCTION_TYPE;
 			if (isFunctionURI) {
@@ -3910,7 +3926,7 @@
 	async function runWorker(stream, workerOptions) {
 		const { options, config } = workerOptions;
 		const { transferStreams, useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
-		const { workerURI, maxWorkers } = config;
+		const { workerURI, createWorker, maxWorkers } = config;
 		if (format) {
 			if (codecURI) {
 				options.codecURI = resolveCodecURI(codecURI, config.baseURI);
@@ -3922,6 +3938,7 @@
 		const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
 		workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 		workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
+		workerOptions.createWorker = workerOptions.useWebWorkers && createWorker ? createWorker : UNDEFINED_VALUE;
 		options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 		return (await getWorker()).run();
 
@@ -3985,7 +4002,7 @@
 		starvationTimeout = null;
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
-			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE });
+			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
 			resolve(new CodecWorker({}, stream, inlineWorkerOptions, onInlineTaskFinished));
 			armStarvationTimeout();
 		}
@@ -4313,6 +4330,8 @@
 	const OPTION_LOCAL_EXTRA_FIELD = "localExtraField";
 	const OPTION_STRICTNESS = "strictness";
 	const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
+	const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
+	const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
 	const STRICTNESS_STRICT = "strict";
 	const STRICTNESS_BALANCED = "balanced";
 	const STRICTNESS_TOLERANT = "tolerant";
@@ -4438,6 +4457,7 @@
 			let startOffset;
 			let zip64EndOfDirectory;
 			let zip64EndOfDirectoryVersion2;
+			let directoryEncryptionInfo;
 			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);
@@ -4468,6 +4488,15 @@
 					}
 					zip64EndOfDirectory = true;
 					zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
+					if (zip64EndOfDirectoryVersion2) {
+						const extensibleDataLength = Math.min(
+							Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
+							reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+						if (extensibleDataLength > 0) {
+							const rawExtensibleData = await readUint8Array(reader, directoryDataOffset + ZIP64_END_OF_CENTRAL_DIR_LENGTH, extensibleDataLength);
+							directoryEncryptionInfo = getDirectoryEncryptionInfo(rawExtensibleData);
+						}
+					}
 					if (lastDiskNumber == MAX_16_BITS) {
 						lastDiskNumber = getUint32(endOfDirectoryView, 16);
 					} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
@@ -4491,7 +4520,7 @@
 					directoryDataOffset = getDiskOffset$1(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 				}
 			}
-			const declaredDirectoryDataLength = directoryDataLength;
+			let declaredDirectoryDataLength = directoryDataLength;
 			const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
 				(zip64EndOfDirectory ? ZIP64_END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
 			if (directoryDataOffset >= reader.size) {
@@ -4539,6 +4568,18 @@
 			if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 				throw new Error(ERR_BAD_FORMAT);
 			}
+			zipReader.directoryOffset = directoryDataOffset;
+			zipReader.directoryLength = declaredDirectoryDataLength;
+			const decryptCentralDirectory = getOptionValue$1(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
+			let decryptedDirectory;
+			if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
+				getUint32(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
+				(zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+				directoryArray = await decryptCentralDirectory(directoryArray, directoryEncryptionInfo);
+				directoryView = getDataView(directoryArray);
+				declaredDirectoryDataLength = directoryArray.length;
+				decryptedDirectory = true;
+			}
 			startOffset = directoryDataOffset;
 			const filenameEncoding = getOptionValue$1(zipReader, options, OPTION_FILENAME_ENCODING);
 			const commentEncoding = getOptionValue$1(zipReader, options, OPTION_COMMENT_ENCODING);
@@ -4547,7 +4588,7 @@
 			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))) {
+					if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 						throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
 					}
 					throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
@@ -4660,7 +4701,15 @@
 				}
 				yield entry;
 			}
-			if (checkAmbiguity && offset != declaredDirectoryDataLength) {
+			let offsetAfterSignature = offset;
+			if (offset + 6 <= directoryArray.length && getUint32(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+				const signatureDataLength = getUint16(directoryView, offset + 4);
+				if (offset + 6 + signatureDataLength <= directoryArray.length) {
+					zipReader.digitalSignature = directoryArray.subarray(offset + 6, offset + 6 + signatureDataLength);
+					offsetAfterSignature = offset + 6 + signatureDataLength;
+				}
+			}
+			if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
 				throwAmbiguousArchive("trailing central directory data");
 			}
 			if (duplicateFilename) {
@@ -4892,6 +4941,25 @@
 		return false;
 	}
 
+	function getDirectoryEncryptionInfo(rawExtensibleData) {
+		const directoryEncryptionInfo = { rawExtensibleData };
+		if (rawExtensibleData.length >= 28) {
+			const extensibleDataView = getDataView(rawExtensibleData);
+			const hashDataLength = getUint16(extensibleDataView, 26);
+			Object.assign(directoryEncryptionInfo, {
+				compressionMethod: getUint16(extensibleDataView, 0),
+				compressedSize: Number(getBigUint64(extensibleDataView, 2)),
+				uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
+				encryptionAlgorithm: getUint16(extensibleDataView, 18),
+				bitLength: getUint16(extensibleDataView, 20),
+				flags: getUint16(extensibleDataView, 22),
+				hashAlgorithm: getUint16(extensibleDataView, 24),
+				hashData: rawExtensibleData.subarray(28, 28 + hashDataLength)
+			});
+		}
+		return directoryEncryptionInfo;
+	}
+
 	function readCommonHeader(directory, dataView, offset) {
 		const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset + 2);
 		const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;
@@ -5443,6 +5511,7 @@
 		ERR_SPLIT_ZIP_FILE: ERR_SPLIT_ZIP_FILE,
 		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
 		ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
+		ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
 		ZipReader: ZipReader
 	});
 
@@ -5500,6 +5569,7 @@
 	const ERR_INVALID_UNIX_ID_SIZE = "uid/gid must be 0..65535 for unixExtraFieldType 'unix' (use 'infozip' for larger ids)";
 	const ERR_INVALID_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be integer 0..255)";
 	const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
+	const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
 
 	const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 	const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
@@ -6797,8 +6867,9 @@
 
 	async function closeFile(zipWriter, comment, options) {
 		const directoryDataLength = createDirectoryRecords(zipWriter.files);
-		const directoryStart = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
-		await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength });
+		const { directoryStart, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+		const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
+		await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength, signatureLength });
 	}
 
 	function createDirectoryRecords(files) {
@@ -6955,12 +7026,33 @@
 			}
 		}
 		await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
-		return { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset };
+		return {
+			directoryStart: { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset },
+			directoryArray
+		};
+	}
+
+	async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
+		const signCentralDirectory = getOptionValue(zipWriter, options, OPTION_SIGN_CENTRAL_DIRECTORY);
+		if (signCentralDirectory) {
+			const signatureData = await signCentralDirectory(directoryArray);
+			const signatureDataLength = getLength(signatureData);
+			if (signatureDataLength > MAX_16_BITS) {
+				throw new Error(ERR_INVALID_SIGNATURE_DATA);
+			}
+			const signatureRecord = createRecordWriter(6 + signatureDataLength);
+			signatureRecord.uint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
+			signatureRecord.uint16(signatureDataLength);
+			signatureRecord.bytes(signatureData);
+			await writeData(zipWriter.writer, signatureRecord.array);
+			return 6 + signatureDataLength;
+		}
+		return 0;
 	}
 
 	async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		const { writer } = zipWriter;
-		const { directoryStart } = cdInfo;
+		const { directoryStart, signatureLength } = cdInfo;
 		let { directoryDataLength } = cdInfo;
 		let filesLength = zipWriter.files.size;
 		let diskNumber = directoryStart.diskNumber;
@@ -6999,7 +7091,7 @@
 			endOfdirectoryRecord.uint64(directoryOffset);
 			endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
 			endOfdirectoryRecord.uint32(lastDiskNumber);
-			endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength));
+			endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength) + BigInt(signatureLength));
 			endOfdirectoryRecord.uint32(lastDiskNumber + 1);
 			const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 			if (supportZip64SplitFile) {
@@ -8272,6 +8364,8 @@
 		}
 	}
 
+	exports.ERR_ENTRY_EXISTS = ERR_ENTRY_EXISTS;
+	exports.ERR_READABLE_CONSUMED = ERR_READABLE_CONSUMED;
 	exports.fs = fs;
 
 }));