@zip.js/zip.js 2.8.56 → 2.8.57

package/index-native.cjs

@@ -4723,6 +4723,7 @@ const ERR_UNSAFE_FILENAME = "Unsafe filename";
 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";
@@ -4745,6 +4746,7 @@ const ZIP64_EXTRACTION = {
 		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;
@@ -4840,7 +4842,7 @@ class ZipReader {
 				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;
@@ -5421,8 +5423,8 @@ function getDirectoryEncryptionInfo(rawExtensibleData) {
 		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),
@@ -6057,7 +6059,11 @@ function getUint32$1(view, offset) {
 }
 
 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({
@@ -6086,6 +6092,7 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	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
@@ -6226,7 +6233,7 @@ class ZipWriter {
 				encrypted,
 				uncompressedSize,
 				compressedSize,
-				zip64
+				extraFieldZip64
 			} = entry;
 			let {
 				compressionMethod,
@@ -6243,13 +6250,13 @@ class ZipWriter {
 			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,
@@ -6805,6 +6812,10 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 			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) {
@@ -6819,6 +6830,7 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 		maximumCompressedSize,
 		resolvedOptions: {
 			dataDescriptor,
+			emptyEntry,
 			zip64,
 			zip64UncompressedSize,
 			zip64CompressedSize,
@@ -6917,6 +6929,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		keepOrder,
 		dataDescriptor,
+		emptyEntry,
 		signal
 	} = options;
 	const {
@@ -6941,7 +6954,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			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) {
@@ -7363,8 +7376,8 @@ function getHeaderInfo(options) {
 	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);
@@ -7495,18 +7508,14 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 }
 
 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) {
@@ -7925,6 +7934,21 @@ async function startsWithSplitZipSignature(reader) {
 	return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
 }
 
+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();
@@ -9492,7 +9516,7 @@ function keepsContentType(writer, data) {
 	} 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;
 	}
@@ -10165,6 +10189,7 @@ exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
 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;