@zip.js/zip.js 2.8.54 → 2.8.56

package/dist/zip-fs-core.js

@@ -84,6 +84,7 @@
 	const BITFLAG_DATA_DESCRIPTOR = 0b1000;
 	const BITFLAG_STRONG_ENCRYPTION = 0b1000000;
 	const BITFLAG_LANG_ENCODING_FLAG = 0b100000000000;
+	const BITFLAG_MASKED_LOCAL_HEADERS = 0b10000000000000;
 	const FILE_ATTR_MSDOS_DIR_MASK = 0b10000;
 	const FILE_ATTR_MSDOS_READONLY_MASK = 0x01;
 	const FILE_ATTR_MSDOS_HIDDEN_MASK = 0x02;
@@ -233,6 +234,18 @@
 		}
 	}
 
+	function checkInteger(value, maxValue, errorMessage) {
+		if (!Number.isInteger(value) || value < 0 || value > maxValue) {
+			throw new Error(errorMessage);
+		}
+	}
+
+	function checkIntegerOption(value, maxValue, errorMessage) {
+		if (value !== UNDEFINED_VALUE) {
+			checkInteger(value, maxValue, errorMessage);
+		}
+	}
+
 	function toNumber(value) {
 		return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
 	}
@@ -4192,6 +4205,7 @@
 			let startOffset;
 			let zip64EndOfDirectory;
 			let zip64EndOfDirectoryVersion2;
+			let zip64EndOfDirectoryLength = ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 			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) {
@@ -4228,6 +4242,7 @@
 							Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
 							reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 						if (extensibleDataLength > 0) {
+							zip64EndOfDirectoryLength += extensibleDataLength;
 							const rawExtensibleData = await readUint8Array(reader, directoryDataOffset + ZIP64_END_OF_CENTRAL_DIR_LENGTH, extensibleDataLength);
 							directoryEncryptionInfo = getDirectoryEncryptionInfo(rawExtensibleData);
 						}
@@ -4257,7 +4272,7 @@
 			}
 			let declaredDirectoryDataLength = directoryDataLength;
 			const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
-				(zip64EndOfDirectory ? ZIP64_END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
+				(zip64EndOfDirectory ? zip64EndOfDirectoryLength + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
 			if (directoryDataOffset >= reader.size) {
 				prependedDataLength = reader.size - directoryDataOffset - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
 				directoryDataOffset = reader.size - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
@@ -4277,7 +4292,9 @@
 				}
 				const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 				if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
-					const storedPointsAtDirectory = getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
+					const storedPointsAtDirectory = getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE ||
+						Boolean(directoryEncryptionInfo && directoryEncryptionInfo.compressedSize) ||
+						detectEncryptedCentralDirectory(directoryView);
 					let reconcile = !storedPointsAtDirectory;
 					if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
 						const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4);
@@ -4306,11 +4323,13 @@
 			zipReader.directoryOffset = directoryDataOffset;
 			zipReader.directoryLength = declaredDirectoryDataLength;
 			const decryptCentralDirectory = getFunctionOptionValue$1(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
-			let decryptedDirectory;
+			let decryptedDirectory, dataAfterEncryptedDirectory;
 			if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
 				getUint32$1(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
 				(zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
-				directoryArray = await decryptCentralDirectory(directoryArray, directoryEncryptionInfo);
+				const encryptedDirectoryDataLength = getEncryptedDirectoryDataLength(directoryEncryptionInfo, declaredDirectoryDataLength, directoryArray.length);
+				dataAfterEncryptedDirectory = directoryArray.subarray(encryptedDirectoryDataLength);
+				directoryArray = await decryptCentralDirectory(directoryArray.subarray(0, encryptedDirectoryDataLength), directoryEncryptionInfo);
 				directoryView = getDataView(directoryArray);
 				declaredDirectoryDataLength = directoryArray.length;
 				decryptedDirectory = true;
@@ -4376,6 +4395,7 @@
 				}
 				Object.assign(fileEntry, {
 					index: indexFile,
+					decryptedDirectory,
 					versionMadeBy,
 					msDosCompatible,
 					zip64: false,
@@ -4452,13 +4472,19 @@
 				yield entry;
 			}
 			let offsetAfterSignature = offset;
-			if (offset + 6 <= directoryArray.length && getUint32$1(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
-				const signatureDataLength = getUint16$1(directoryView, offset + 4);
-				if (offset + 6 + signatureDataLength <= directoryArray.length) {
-					zipReader.digitalSignature = directoryArray.subarray(offset + 6, offset + 6 + signatureDataLength);
-					offsetAfterSignature = offset + 6 + signatureDataLength;
+			let digitalSignature = readDigitalSignature(directoryArray.subarray(offset)) ||
+				(decryptedDirectory ? readDigitalSignature(dataAfterEncryptedDirectory) : UNDEFINED_VALUE);
+			if (!digitalSignature && !decryptedDirectory) {
+				const signatureRecordOffset = directoryDataOffset + offset;
+				const signatureRecordLength = Math.min(centralDirectoryEndOffset - signatureRecordOffset, 6 + MAX_16_BITS);
+				if (signatureRecordLength >= 6) {
+					digitalSignature = readDigitalSignature(await readUint8Array(reader, signatureRecordOffset, signatureRecordLength));
 				}
 			}
+			if (digitalSignature) {
+				zipReader.digitalSignature = digitalSignature;
+				offsetAfterSignature = offset + 6 + digitalSignature.length;
+			}
 			if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
 				throwAmbiguousArchive("trailing central directory data");
 			}
@@ -4726,6 +4752,27 @@
 		return false;
 	}
 
+	function readDigitalSignature(signatureRecordArray) {
+		if (signatureRecordArray.length >= 6) {
+			const signatureRecordView = getDataView(signatureRecordArray);
+			if (getUint32$1(signatureRecordView, 0) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+				const signatureDataLength = getUint16$1(signatureRecordView, 4);
+				if (6 + signatureDataLength <= signatureRecordArray.length) {
+					return signatureRecordArray.subarray(6, 6 + signatureDataLength);
+				}
+			}
+		}
+	}
+
+	function getEncryptedDirectoryDataLength(directoryEncryptionInfo, declaredDirectoryDataLength, directoryDataLength) {
+		const encryptedDirectoryDataLength = directoryEncryptionInfo && directoryEncryptionInfo.compressedSize ?
+			directoryEncryptionInfo.compressedSize :
+			declaredDirectoryDataLength;
+		return encryptedDirectoryDataLength > 0 && encryptedDirectoryDataLength <= directoryDataLength ?
+			encryptedDirectoryDataLength :
+			directoryDataLength;
+	}
+
 	function getDirectoryEncryptionInfo(rawExtensibleData) {
 		const directoryEncryptionInfo = { rawExtensibleData };
 		if (rawExtensibleData.length >= 28) {
@@ -5310,7 +5357,9 @@
 
 	function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
 		const { rawFilename } = zipEntry;
-		if (checkLocalFilename &&
+		const maskedLocalDirectory = zipEntry.decryptedDirectory &&
+			(localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
+		if (checkLocalFilename && !maskedLocalDirectory &&
 			(rawLocalFilename.length != rawFilename.length ||
 				rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
 			throwAmbiguousArchive("mismatched local file header (filename)");
@@ -5321,7 +5370,7 @@
 		if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
 			throwAmbiguousArchive("mismatched local file header (compression method)");
 		}
-		if (!localDirectory.bitFlag.dataDescriptor &&
+		if (!localDirectory.bitFlag.dataDescriptor && !maskedLocalDirectory &&
 			(localDirectory.crc32 || localDirectory.compressedSize || localDirectory.uncompressedSize) &&
 			(localDirectory.crc32 != zipEntry.crc32 ||
 				localDirectory.compressedSize != zipEntry.compressedSize ||
@@ -5450,6 +5499,7 @@
 	const MAX_NTFS_TIME = BigInt("0x7fffffffffffffff");
 	const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 	const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
+	const ERR_UNDEFINED_COMPRESSION_METHOD = "Undefined compression method";
 	const ERR_UNDETERMINED_SIZE = "Undetermined size";
 	const ERR_UNDEFINED_READER = "Undefined reader";
 	const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
@@ -5465,6 +5515,8 @@
 
 	const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 	const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
+	const EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD = 9;
+	const EXTRAFIELD_USDZ_MAX_LENGTH = 67;
 	const VENDOR_VERSION_AE_1 = 1;
 	const INFOZIP_EXTRA_FIELD_TYPE$1 = "infozip";
 	const UNIX_EXTRA_FIELD_TYPE = "unix";
@@ -5511,16 +5563,14 @@
 			await zipReader$1.close();
 			await initStream(this.writer);
 			const { directoryOffset } = zipReader$1;
-			let splitZipSignatureLength = 0;
 			if (this.addSplitZipSignature) {
 				delete this.addSplitZipSignature;
 				if (!await startsWithSplitZipSignature(reader)) {
 					await writeData(this.writer, getSplitZipSignatureArray());
-					splitZipSignatureLength = SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
-					this.offset += splitZipSignatureLength;
+					this.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
 				}
 			}
-			const entryPositions = await copyZipData(this, reader, entries, directoryOffset, splitZipSignatureLength);
+			const entryPositions = await copyZipData(this, reader, entries, directoryOffset);
 			this.filenames = new Set(entries.map(entry => entry.filename));
 			this.fileEntries = new Map(entries.map(entry => {
 				const {
@@ -5700,7 +5750,8 @@
 				signature: options[PROPERTY_NAME_SIGNATURE],
 				crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
 				offset: zipWriter.offset - diskOffset,
-				diskNumberStart: diskNumber
+				diskNumberStart: diskNumber,
+				[OPTION_USDZ]: zipWriter.options[OPTION_USDZ]
 			});
 			const headerInfo = getHeaderInfo(options);
 			const dataDescriptorInfo = getDataDescriptorInfo(options);
@@ -5732,15 +5783,9 @@
 		let setuid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETUID);
 		let setgid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETGID);
 		let sticky = getOptionValue(zipWriter, options, PROPERTY_NAME_STICKY);
-		if (uid !== UNDEFINED_VALUE && (!Number.isInteger(uid) || uid < 0 || uid > MAX_32_BITS)) {
-			throw new Error(ERR_INVALID_UID);
-		}
-		if (gid !== UNDEFINED_VALUE && (!Number.isInteger(gid) || gid < 0 || gid > MAX_32_BITS)) {
-			throw new Error(ERR_INVALID_GID);
-		}
-		if (unixMode !== UNDEFINED_VALUE && (!Number.isInteger(unixMode) || unixMode < 0 || unixMode > MAX_16_BITS)) {
-			throw new Error(ERR_INVALID_UNIX_MODE);
-		}
+		checkIntegerOption(uid, MAX_32_BITS, ERR_INVALID_UID);
+		checkIntegerOption(gid, MAX_32_BITS, ERR_INVALID_GID);
+		checkIntegerOption(unixMode, MAX_16_BITS, ERR_INVALID_UNIX_MODE);
 		if (unixExtraFieldType !== UNDEFINED_VALUE && unixExtraFieldType !== INFOZIP_EXTRA_FIELD_TYPE$1 && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
 			throw new Error(ERR_INVALID_UNIX_EXTRA_FIELD_TYPE);
 		}
@@ -5762,9 +5807,7 @@
 			msDosCompatible = true;
 			versionMadeBy = (versionMadeBy & MAX_8_BITS);
 		}
-		if (msdosAttributesRaw !== UNDEFINED_VALUE && (!Number.isInteger(msdosAttributesRaw) || msdosAttributesRaw < 0 || msdosAttributesRaw > MAX_8_BITS)) {
-			throw new Error(ERR_INVALID_MSDOS_ATTRIBUTES);
-		}
+		checkIntegerOption(msdosAttributesRaw, MAX_8_BITS, ERR_INVALID_MSDOS_ATTRIBUTES);
 		if (msdosAttributes && (typeof msdosAttributes !== OBJECT_TYPE || Array.isArray(msdosAttributes))) {
 			throw new Error(ERR_INVALID_MSDOS_DATA);
 		}
@@ -5904,9 +5947,7 @@
 			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
 		let level = getNumberOptionValue(zipWriter, options, OPTION_LEVEL);
-		if (level !== UNDEFINED_VALUE && (!Number.isInteger(level) || level < 0 || level > MAX_LEVEL)) {
-			throw new Error(ERR_INVALID_LEVEL);
-		}
+		checkIntegerOption(level, MAX_LEVEL, ERR_INVALID_LEVEL);
 		if (zipWriter.options[OPTION_USDZ]) {
 			if (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) {
 				throw new Error(ERR_UNSUPPORTED_ENCRYPTION_USDZ);
@@ -5915,6 +5956,9 @@
 				level = 0;
 			}
 		}
+		if (passThrough) {
+			level = UNDEFINED_VALUE;
+		}
 		let useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
 		let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
 		if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
@@ -5981,9 +6025,7 @@
 		let extraFieldSize = 0;
 		let offset = 0;
 		extraField.forEach((data, type) => {
-			if (!Number.isInteger(type) || type < 0 || type > MAX_16_BITS) {
-				throw new Error(ERR_INVALID_EXTRAFIELD_TYPE);
-			}
+			checkInteger(type, MAX_16_BITS, ERR_INVALID_EXTRAFIELD_TYPE);
 			if (!(data instanceof Uint8Array)) {
 				throw new Error(ERR_INVALID_EXTRAFIELD_DATA_TYPE);
 			}
@@ -6026,6 +6068,9 @@
 			if (uncompressedSize === UNDEFINED_VALUE) {
 				throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
 			}
+			if (compressionMethod === UNDEFINED_VALUE) {
+				throw new Error(ERR_UNDEFINED_COMPRESSION_METHOD);
+			}
 		}
 		const zip64Enabled = zip64 === true;
 		const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
@@ -6095,7 +6140,9 @@
 		const usdz = writerOptions[OPTION_USDZ];
 		const files = new Map();
 		let layoutDependsOnWriteOrder = Boolean(usdz);
-		let offset = 0;
+		const initialOffset = writerOptions[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : writerOptions[OPTION_OFFSET];
+		let offset = initialOffset;
+		let minimumEntrySize = INFINITY_VALUE;
 		for (const entry of entries) {
 			let { name } = entry;
 			const { size } = entry;
@@ -6119,7 +6166,7 @@
 			if (hasContent && !metadata.passThrough && isCompressed(sizes.compressionMethod, sizes.level)) {
 				throw new Error(ERR_UNDETERMINED_SIZE);
 			}
-			const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes);
+			const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes, { [OPTION_USDZ]: usdz });
 			const headerInfo = getHeaderInfo(entryOptions);
 			const dataDescriptorInfo = getDataDescriptorInfo(entryOptions);
 			const entryInfo = {
@@ -6130,15 +6177,17 @@
 				appendExtraFieldUSDZ(entryInfo, offset);
 			}
 			const compressedSize = hasContent ? maximumCompressedSize : 0;
-			if (offset >= MAX_32_BITS) {
-				layoutDependsOnWriteOrder = true;
-			}
 			files.set(name, Object.assign({}, entryOptions, headerInfo, {
 				offset,
 				diskNumberStart: 0,
 				compressedSize
 			}));
-			offset += entryInfo.metadataSize + compressedSize;
+			const entrySize = entryInfo.metadataSize + compressedSize;
+			minimumEntrySize = Math.min(minimumEntrySize, entrySize);
+			offset += entrySize;
+		}
+		if (files.size && offset - minimumEntrySize >= MAX_32_BITS) {
+			layoutDependsOnWriteOrder = true;
 		}
 		if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 			throw new Error(ERR_UNDETERMINED_SIZE);
@@ -6152,7 +6201,7 @@
 				zip64 = true;
 			}
 		}
-		return offset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+		return offset - initialOffset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 	}
 
 	async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
@@ -6649,12 +6698,13 @@
 			if (passThrough && crc32 !== UNDEFINED_VALUE) {
 				rawExtraFieldAES[EXTRAFIELD_OFFSET_AES_VENDOR_VERSION] = VENDOR_VERSION_AE_1;
 			}
-			rawExtraFieldAES[9] = compressionMethod;
+			setUint16(getDataView(rawExtraFieldAES), EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD, compressionMethod);
 			compressionMethod = COMPRESSION_METHOD_AES;
 		}
 		const localExtraFieldZip64Length = writeLocalExtraFieldZip64 ? getLength(rawLocalExtraFieldZip64) : 0;
 		const extraFieldLength = localExtraFieldZip64Length + getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField, rawLocalExtraField);
-		if (extraFieldLength > MAX_16_BITS) {
+		const maximumUsdzExtraFieldLength = options[OPTION_USDZ] ? EXTRAFIELD_USDZ_MAX_LENGTH : 0;
+		if (extraFieldLength + maximumUsdzExtraFieldLength > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 		}
 		const dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
@@ -7055,7 +7105,11 @@
 			signatureRecord.writeUint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
 			signatureRecord.writeUint16(signatureDataLength);
 			signatureRecord.writeBytes(signatureData);
-			await writeData(zipWriter.writer, signatureRecord.array);
+			const { writer } = zipWriter;
+			if (exceedsAvailableSize(writer, getLength(signatureRecord.array))) {
+				await writer.closeDisk();
+			}
+			await writeData(writer, signatureRecord.array);
 			return 6 + signatureDataLength;
 		}
 		return 0;
@@ -7166,7 +7220,7 @@
 		return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
 	}
 
-	async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZipSignatureLength) {
+	async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 		const { writer } = zipWriter;
 		const entryPositions = new Map();
 		if (writer.closeDisk) {
@@ -7187,9 +7241,10 @@
 			}
 			await copyData(zipWriter, reader, copiedLength, directoryOffset - copiedLength);
 		} else {
+			const baseOffset = zipWriter.offset;
 			await copyData(zipWriter, reader, 0, directoryOffset);
 			entries.forEach(entry => entryPositions.set(entry, {
-				offset: splitZipSignatureLength + getSourceOffset(reader, entry),
+				offset: baseOffset + getSourceOffset(reader, entry),
 				diskNumberStart: 0
 			}));
 		}
@@ -8358,10 +8413,7 @@
 				});
 			}
 			if (isPassThrough(child, options)) {
-				let level, encryptionStrength;
-				if (compressionMethod === 0) {
-					level = 0;
-				}
+				let encryptionStrength;
 				if (extraFieldAES) {
 					encryptionStrength = extraFieldAES.strength;
 				}
@@ -8371,7 +8423,6 @@
 					zipCrypto,
 					crc32,
 					uncompressedSize,
-					level,
 					encryptionStrength,
 					compressionMethod
 				};