@zip.js/zip.js 2.8.55 → 2.8.56

package/deno.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zip-js/zip-js",
-	"version": "2.8.55",
+	"version": "2.8.56",
 	"exports": {
 		".": "./index.js",
 		"./external": "./lib/zip-fs-external.js",

package/dist/zip-core-external.js

@@ -226,6 +226,18 @@ function checkPasswordOption(password, rawPassword) {
 	}
 }
 
+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;
 }
@@ -5076,8 +5088,15 @@ class ZipReader {
 			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;
@@ -6154,6 +6173,8 @@ 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;
+const EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD = 9;
+const EXTRAFIELD_USDZ_MAX_LENGTH = 67;
 const VENDOR_VERSION_AE_1 = 1;
 const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 const UNIX_EXTRA_FIELD_TYPE = "unix";
@@ -6200,16 +6221,14 @@ class ZipWriter {
 		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 {
@@ -6451,7 +6470,8 @@ async function addFile(zipWriter, name, reader, options) {
 			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);
@@ -6483,15 +6503,9 @@ function resolveAttributes(zipWriter, name, options) {
 	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 && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
 		throw new Error(ERR_INVALID_UNIX_EXTRA_FIELD_TYPE);
 	}
@@ -6513,9 +6527,7 @@ function resolveAttributes(zipWriter, name, options) {
 		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);
 	}
@@ -6655,9 +6667,7 @@ function resolveMetadata(zipWriter, name, options) {
 		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);
@@ -6735,9 +6745,7 @@ function serializeExtraField(extraField) {
 	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);
 		}
@@ -7331,12 +7339,13 @@ function getHeaderInfo(options) {
 		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);
@@ -7737,7 +7746,11 @@ async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
 		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;
@@ -7848,7 +7861,7 @@ async function startsWithSplitZipSignature(reader) {
 	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) {
@@ -7869,9 +7882,10 @@ async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZip
 		}
 		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
 		}));
 	}