@zip.js/zip.js 2.8.55 → 2.8.57

package/dist/zip-fs.js

@@ -235,6 +235,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;
 	}
@@ -4721,6 +4733,7 @@
 	const ERR_INVALID_STRICTNESS = "Invalid strictness (must be 'strict', 'balanced' or 'tolerant')";
 	const ERR_INVALID_FILENAME_VALIDATION = "Invalid filenameValidation (must be 'strict', 'balanced' or 'tolerant')";
 	const ERR_INVALID_MAX_APPENDED_DATA_SIZE = "Invalid maxAppendedDataSize (must be a number greater than or equal to 0)";
+	const ERR_UNSUPPORTED_UINT64 = "64-bit value exceeds Number.MAX_SAFE_INTEGER";
 	const DRIVE_LETTER_REGEXP = /^[a-zA-Z]:/;
 	const CHARSET_UTF8 = "utf-8";
 	const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
@@ -4743,6 +4756,7 @@
 			bytes: 8
 		}
 	};
+	const MAX_SAFE_UINT64 = BigInt(Number.MAX_SAFE_INTEGER);
 	const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
 	const MAX_DEFLATE_EXPANSION_RATIO = 1032;
 	const CENTRAL_DIRECTORY_UNREACHABLE = 0;
@@ -4838,7 +4852,7 @@
 					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),
+							getBigUint64(endOfDirectoryView, 4) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
 							reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 						if (extensibleDataLength > 0) {
 							zip64EndOfDirectoryLength += extensibleDataLength;
@@ -5071,8 +5085,15 @@
 				yield entry;
 			}
 			let offsetAfterSignature = offset;
-			const digitalSignature = readDigitalSignature(directoryArray.subarray(offset)) ||
+			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;
@@ -5412,8 +5433,8 @@
 			const hashDataLength = getUint16$1(extensibleDataView, 26);
 			Object.assign(directoryEncryptionInfo, {
 				compressionMethod: getUint16$1(extensibleDataView, 0),
-				compressedSize: Number(getBigUint64(extensibleDataView, 2)),
-				uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
+				compressedSize: getBigUint64(extensibleDataView, 2),
+				uncompressedSize: getBigUint64(extensibleDataView, 10),
 				encryptionAlgorithm: getUint16$1(extensibleDataView, 18),
 				bitLength: getUint16$1(extensibleDataView, 20),
 				flags: getUint16$1(extensibleDataView, 22),
@@ -6048,7 +6069,11 @@
 	}
 
 	function getBigUint64(view, offset) {
-		return Number(view.getBigUint64(offset, true));
+		const value = view.getBigUint64(offset, true);
+		if (value > MAX_SAFE_UINT64) {
+			throw new Error(ERR_UNSUPPORTED_UINT64);
+		}
+		return Number(value);
 	}
 
 	var zipReader = /*#__PURE__*/Object.freeze({
@@ -6077,6 +6102,7 @@
 		ERR_UNSAFE_FILENAME: ERR_UNSAFE_FILENAME,
 		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
 		ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
+		ERR_UNSUPPORTED_UINT64: ERR_UNSUPPORTED_UINT64,
 		ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
 		ZipReader: ZipReader,
 		ZipReaderStream: ZipReaderStream
@@ -6149,6 +6175,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";
@@ -6195,16 +6223,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 {
@@ -6217,7 +6243,7 @@
 					encrypted,
 					uncompressedSize,
 					compressedSize,
-					zip64
+					extraFieldZip64
 				} = entry;
 				let {
 					compressionMethod,
@@ -6234,13 +6260,13 @@
 				rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || EMPTY_UINT8_ARRAY;
 				rawExtraFieldNTFS = rawExtraFieldNTFS || EMPTY_UINT8_ARRAY;
 				rawExtraFieldUnix = rawExtraFieldUnix || EMPTY_UINT8_ARRAY;
-				rawExtraField = rawExtraField || EMPTY_UINT8_ARRAY;
+				rawExtraField = removeExtraFieldZip64(rawExtraField || EMPTY_UINT8_ARRAY);
 				if (entry.extraFieldAES) {
 					compressionMethod = COMPRESSION_METHOD_AES;
 				}
 				const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
-				const zip64UncompressedSize = zip64 && uncompressedSize >= MAX_32_BITS;
-				const zip64CompressedSize = zip64 && compressedSize >= MAX_32_BITS;
+				const zip64UncompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.uncompressedSize !== UNDEFINED_VALUE;
+				const zip64CompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.compressedSize !== UNDEFINED_VALUE;
 				const bitFlagValue = (getBitFlag(level, languageEncodingFlag, dataDescriptor, encrypted, compressionMethod) & ~BITFLAG_LEVEL) | (level << 1);
 				const {
 					headerArray,
@@ -6446,7 +6472,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);
@@ -6478,15 +6505,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);
 		}
@@ -6508,9 +6529,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);
 		}
@@ -6650,9 +6669,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);
@@ -6730,9 +6747,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);
 			}
@@ -6807,6 +6822,10 @@
 				maximumCompressedSize = contentSize === UNDEFINED_VALUE ? getMaximumCompressedSize(uncompressedSize) + encryptionOverhead : contentSize;
 			}
 		}
+		const emptyEntry = !encryptedEntry && (!hasContent || (contentSize === 0 && !passThrough)) && !isCompressed(compressionMethod, level);
+		if (emptyEntry && !zipCrypto && getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR) === UNDEFINED_VALUE) {
+			dataDescriptor = false;
+		}
 		const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
 		const zip64CompressedSize = zip64Enabled || maximumCompressedSize >= MAX_32_BITS;
 		if (zip64UncompressedSize || zip64CompressedSize) {
@@ -6821,6 +6840,7 @@
 			maximumCompressedSize,
 			resolvedOptions: {
 				dataDescriptor,
+				emptyEntry,
 				zip64,
 				zip64UncompressedSize,
 				zip64CompressedSize,
@@ -6847,7 +6867,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;
@@ -6871,7 +6893,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 = {
@@ -6882,15 +6904,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);
@@ -6904,7 +6928,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) {
@@ -6915,6 +6939,7 @@
 		const {
 			keepOrder,
 			dataDescriptor,
+			emptyEntry,
 			signal
 		} = options;
 		const {
@@ -6939,7 +6964,7 @@
 				lockPreviousFileEntry = previousFileEntry && previousFileEntry.lockFileEntry;
 				requestLockCurrentFileEntry();
 			}
-			if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || !dataDescriptor) {
+			if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || (!dataDescriptor && !emptyEntry)) {
 				bufferedWrite = true;
 				zipWriter.bufferedWrites++;
 				if (options.createTempStream) {
@@ -7361,8 +7386,8 @@
 		try {
 			const { uid, gid, unixExtraFieldType } = options;
 			if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE$1 && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
-				const uidBytes = packUnixId(uid);
-				const gidBytes = packUnixId(gid);
+				const uidBytes = packUnixId(uid === UNDEFINED_VALUE ? 0 : uid);
+				const gidBytes = packUnixId(gid === UNDEFINED_VALUE ? 0 : gid);
 				const payloadLength = 3 + uidBytes.length + gidBytes.length;
 				const extraFieldUnix = createRecordWriter(4 + payloadLength);
 				extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_INFOZIP);
@@ -7401,12 +7426,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);
@@ -7492,18 +7518,14 @@
 	}
 
 	function packUnixId(id) {
-		if (id === UNDEFINED_VALUE) {
-			return EMPTY_UINT8_ARRAY;
-		} else {
-			const dataArray = new Uint8Array(4);
-			const dataView = getDataView(dataArray);
-			dataView.setUint32(0, id, true);
-			let length = 4;
-			while (length > 1 && dataArray[length - 1] === 0) {
-				length--;
-			}
-			return dataArray.subarray(0, length);
+		const dataArray = new Uint8Array(4);
+		const dataView = getDataView(dataArray);
+		dataView.setUint32(0, id, true);
+		let length = 4;
+		while (length > 1 && dataArray[length - 1] === 0) {
+			length--;
 		}
+		return dataArray.subarray(0, length);
 	}
 
 	function normalizeMsdosAttributes(msdosAttributesRaw, msdosAttributes) {
@@ -7807,7 +7829,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;
@@ -7918,7 +7944,22 @@
 		return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
 	}
 
-	async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZipSignatureLength) {
+	function removeExtraFieldZip64(rawExtraField) {
+		const rawExtraFieldView = getDataView(rawExtraField);
+		let offsetExtraField = 0;
+		while (offsetExtraField + 4 <= getLength(rawExtraField)) {
+			const size = 4 + getUint16(rawExtraFieldView, offsetExtraField + 2);
+			if (getUint16(rawExtraFieldView, offsetExtraField) == EXTRAFIELD_TYPE_ZIP64) {
+				return removeExtraFieldZip64(concat(
+					rawExtraField.subarray(0, offsetExtraField),
+					rawExtraField.subarray(Math.min(offsetExtraField + size, getLength(rawExtraField)))));
+			}
+			offsetExtraField += size;
+		}
+		return rawExtraField;
+	}
+
+	async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 		const { writer } = zipWriter;
 		const entryPositions = new Map();
 		if (writer.closeDisk) {
@@ -7939,9 +7980,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
 			}));
 		}
@@ -9849,7 +9891,7 @@
 		} else if (writer.constructor == BlobWriter) {
 			return data.type == contentType;
 		} else if (writer.constructor == Data64URIWriter) {
-			return data.startsWith(writer.data);
+			return data.startsWith("data:" + (contentType || "") + ";base64,");
 		} else {
 			return true;
 		}
@@ -10522,6 +10564,7 @@
 	exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 	exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+	exports.ERR_UNSUPPORTED_UINT64 = ERR_UNSUPPORTED_UINT64;
 	exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;
 	exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;
 	exports.ERR_ZIP_NOT_EMPTY = ERR_ZIP_NOT_EMPTY;