@zip.js/zip.js 2.8.52 → 2.8.53

package/dist/zip-fs.js

@@ -102,6 +102,9 @@
 	const VERSION_ZIP64 = 0x2D;
 	const VERSION_AES = 0x33;
 
+	const VERSION_MADE_BY_MSDOS = 0x0014;
+	const VERSION_MADE_BY_UNIX = 0x0300;
+
 	const DIRECTORY_SIGNATURE = "/";
 
 	const HEADER_SIZE = 30;
@@ -2762,6 +2765,7 @@
 				worker,
 				workerAlive: false,
 				terminated: false,
+				startupError: null,
 				interface: {
 					run: async () => {
 						try {
@@ -2789,6 +2793,13 @@
 	}
 
 	async function runWebWorker(workerData, config) {
+		if (!workerData.worker) {
+			const { startupError } = workerData;
+			workerData.startupError = null;
+			const error = startupError || new Error(ERR_WORKER_STARTUP_TIMEOUT);
+			error.workerStartupFailed = true;
+			throw error;
+		}
 		let resolveResult, rejectResult;
 		const result = new Promise((resolve, reject) => {
 			resolveResult = resolve;
@@ -3002,11 +3013,12 @@
 		if (!workerAlive) {
 			workerData.worker = null;
 		}
+		let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
+		if (!workerAlive) {
+			error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
+			workerData.startupError = error;
+		}
 		if (rejectResult) {
-			let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
-			if (!workerAlive) {
-				error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
-			}
 			rejectResult(error);
 			if (writer) {
 				writer.releaseLock();
@@ -4055,9 +4067,8 @@
 
 		async init() {
 			const reader = this;
-			const { readers } = reader;
 			reader.lastDiskNumber = 0;
-			await Promise.all(readers.map(diskReader => initStream(diskReader)));
+			const readers = reader.readers = await Promise.all(reader.readers.map(initDiskReader));
 			reader.diskOffsets = readers.map(diskReader => {
 				const diskOffset = reader.size;
 				reader.size += diskReader.size;
@@ -4252,6 +4263,16 @@
 		}
 	}
 
+	async function initDiskReader(diskReader) {
+		diskReader = new GenericReader(diskReader);
+		await initStream(diskReader);
+		if (diskReader.size === UNDEFINED_VALUE || !diskReader.readUint8Array) {
+			diskReader = new BlobReader(await streamToBlob(diskReader.readable));
+			await initStream(diskReader);
+		}
+		return diskReader;
+	}
+
 	function readUint8Array(reader, offset, size) {
 		return reader.readUint8Array(offset, size);
 	}
@@ -4410,6 +4431,10 @@
 	const PROPERTY_NAME_SETGID = "setgid";
 	const PROPERTY_NAME_STICKY = "sticky";
 	const PROPERTY_NAME_BITFLAG = "bitFlag";
+	const PROPERTY_NAME_RAW_BITFLAG = "rawBitFlag";
+	const PROPERTY_NAME_FILENAME_LENGTH = "filenameLength";
+	const PROPERTY_NAME_EXTRA_FIELD_LENGTH = "extraFieldLength";
+	const PROPERTY_NAME_UNIX_EXTERNAL_UPPER = "unixExternalUpper";
 	const PROPERTY_NAME_FILENAME_UTF8 = "filenameUTF8";
 	const PROPERTY_NAME_COMMENT_UTF8 = "commentUTF8";
 	const PROPERTY_NAME_RAW_EXTRA_FIELD = "rawExtraField";
@@ -4462,10 +4487,14 @@
 		PROPERTY_NAME_UID,
 		PROPERTY_NAME_GID,
 		PROPERTY_NAME_UNIX_MODE,
+		PROPERTY_NAME_UNIX_EXTERNAL_UPPER,
 		PROPERTY_NAME_SETUID,
 		PROPERTY_NAME_SETGID,
 		PROPERTY_NAME_STICKY,
 		PROPERTY_NAME_BITFLAG,
+		PROPERTY_NAME_RAW_BITFLAG,
+		PROPERTY_NAME_FILENAME_LENGTH,
+		PROPERTY_NAME_EXTRA_FIELD_LENGTH,
 		PROPERTY_NAME_FILENAME_UTF8,
 		PROPERTY_NAME_COMMENT_UTF8,
 		PROPERTY_NAME_RAW_EXTRA_FIELD,
@@ -4527,6 +4556,7 @@
 	const OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
 	const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
 	const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
+	const OPTION_CHECK_LOCAL_DIRECTORY = "checkLocalDirectory";
 	const OPTION_CHECK_SIGNATURE = "checkSignature";
 	const OPTION_CHECK_CRC32 = "checkCrc32";
 	const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
@@ -4658,7 +4688,7 @@
 			if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 				throw new Error(ERR_BAD_FORMAT);
 			}
-			const strictness = getStrictness(getOptionValue$1(zipReader, options, OPTION_STRICTNESS), getOptionValue$1(zipReader, options, OPTION_CHECK_AMBIGUITY));
+			const strictness = getStrictness(options, zipReader.options);
 			const checkAmbiguity = strictness == STRICTNESS_STRICT;
 			const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
 			const maxAppendedDataSize = getMaxAppendedDataSize(getOptionValue$1(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
@@ -4880,6 +4910,7 @@
 					index: indexFile,
 					versionMadeBy,
 					msDosCompatible,
+					zip64: false,
 					compressedSize: 0,
 					uncompressedSize: 0,
 					commentLength,
@@ -5090,9 +5121,12 @@
 				extraFieldLength,
 				filenameLength
 			} = localDirectory;
-			const checkAmbiguity = getStrictness(getOptionValue$1(zipEntry, options, OPTION_STRICTNESS), getOptionValue$1(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
+			const checkLocalDirectoryOption = getOptionValue$1(zipEntry, options, OPTION_CHECK_LOCAL_DIRECTORY);
+			const entryStrictness = getStrictness(options, zipEntry.options);
+			const checkLocalDirectory = getCheckLocalDirectory(checkLocalDirectoryOption, entryStrictness);
+			const checkLocalFilename = getCheckLocalFilename(checkLocalDirectoryOption, entryStrictness);
 			let rawLocalFilename = EMPTY_UINT8_ARRAY;
-			if (checkAmbiguity && (filenameLength || extraFieldLength)) {
+			if (checkLocalFilename && (filenameLength || extraFieldLength)) {
 				const trailingDataArray = await readUint8Array(reader, localHeaderOffset + HEADER_SIZE, filenameLength + extraFieldLength);
 				rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
 				localDirectory.rawExtraField = trailingDataArray.subarray(filenameLength);
@@ -5101,17 +5135,26 @@
 					await readUint8Array(reader, localHeaderOffset + HEADER_SIZE + filenameLength, extraFieldLength) :
 					EMPTY_UINT8_ARRAY;
 			}
+			if (checkLocalFilename) {
+				localDirectory.rawFilename = rawLocalFilename;
+			}
 			readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-			if (checkAmbiguity) {
-				checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename);
+			if (checkLocalDirectory) {
+				validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename);
 			}
-			const { lastAccessDate, creationDate } = localDirectory;
+			const { lastAccessDate, creationDate, uid, gid } = localDirectory;
 			if (lastAccessDate) {
 				fileEntry.lastAccessDate = lastAccessDate;
 			}
 			if (creationDate) {
 				fileEntry.creationDate = creationDate;
 			}
+			if (uid !== UNDEFINED_VALUE && fileEntry.uid === UNDEFINED_VALUE) {
+				fileEntry.uid = uid;
+			}
+			if (gid !== UNDEFINED_VALUE && fileEntry.gid === UNDEFINED_VALUE) {
+				fileEntry.gid = gid;
+			}
 			const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
 			const zipCrypto = encrypted && !extraFieldAES;
 			if (!passThrough) {
@@ -5347,10 +5390,12 @@
 			directory.extraFieldNTFS = extraFieldNTFS;
 		}
 		const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+		let unixIdsRead;
 		if (extraFieldUnix) {
-			readExtraFieldUnix(extraFieldUnix, directory, false);
+			unixIdsRead = readExtraFieldUnix(extraFieldUnix, directory, false);
 			directory.extraFieldUnix = extraFieldUnix;
-		} else {
+		}
+		if (!unixIdsRead) {
 			const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
 			if (extraFieldInfoZip) {
 				readExtraFieldUnix(extraFieldInfoZip, directory, true);
@@ -5453,7 +5498,7 @@
 			const creationDate = getDateNTFS(rawCreationDate);
 			const extraFieldData = { lastModDate, lastAccessDate, creationDate };
 			Object.assign(extraFieldNTFS, extraFieldData);
-			Object.assign(directory, extraFieldData);
+			Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
 		}
 	}
 
@@ -5497,6 +5542,7 @@
 			if (gid !== UNDEFINED_VALUE) {
 				directory.gid = gid;
 			}
+			return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
 		} catch {
 			// ignored
 		}
@@ -5569,26 +5615,25 @@
 		}
 		if (dataDescriptorLength) {
 			const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
-			const dataDescriptorSignature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
-				getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
-			if (dataDescriptorSignature) {
-				const readCrc32 = getUint32(getDataView(dataDescriptorArray), 4);
-				let readCompressedSize;
-				let readUncompressedSize;
-				if (extraFieldZip64) {
-					readCompressedSize = getBigUint64(getDataView(dataDescriptorArray), 8);
-					readUncompressedSize = getBigUint64(getDataView(dataDescriptorArray), 16);
-				} else {
-					readCompressedSize = getUint32(getDataView(dataDescriptorArray), 8);
-					readUncompressedSize = getUint32(getDataView(dataDescriptorArray), 12);
-				}
-				const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || readCrc32 == crc32;
+			const dataDescriptorView = getDataView(dataDescriptorArray);
+			let signature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
+				getUint32(dataDescriptorView, 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
+			if (signature) {
+				const signedDataDescriptor = readDataDescriptor(dataDescriptorView, DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, extraFieldZip64);
+				const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || signedDataDescriptor.crc32 == crc32;
 				if (matchCrc32 &&
-					readCompressedSize == compressedSize &&
-					readUncompressedSize == uncompressedSize) {
+					signedDataDescriptor.compressedSize == compressedSize &&
+					signedDataDescriptor.uncompressedSize == uncompressedSize) {
 					dataDescriptorLength += DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+				} else {
+					signature = false;
 				}
 			}
+			if (dataDescriptorArray.length >= dataDescriptorLength) {
+				const localDataDescriptor = readDataDescriptor(dataDescriptorView, signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0, extraFieldZip64);
+				localDataDescriptor.signature = signature;
+				fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
+			}
 		}
 		const range = {
 			start: offset,
@@ -5605,6 +5650,20 @@
 		readRanges.set(index, range);
 	}
 
+	function readDataDescriptor(dataDescriptorView, offset, extraFieldZip64) {
+		const crc32 = getUint32(dataDescriptorView, offset);
+		let compressedSize;
+		let uncompressedSize;
+		if (extraFieldZip64) {
+			compressedSize = getBigUint64(dataDescriptorView, offset + 4);
+			uncompressedSize = getBigUint64(dataDescriptorView, offset + 12);
+		} else {
+			compressedSize = getUint32(dataDescriptorView, offset + 4);
+			uncompressedSize = getUint32(dataDescriptorView, offset + 8);
+		}
+		return { crc32, compressedSize, uncompressedSize };
+	}
+
 	function getDiskOffset$1(reader, diskNumber) {
 		return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
 	}
@@ -5613,14 +5672,40 @@
 		return value === STRICTNESS_STRICT || value === STRICTNESS_BALANCED || value === STRICTNESS_TOLERANT;
 	}
 
-	function getStrictness(strictness, checkAmbiguity) {
-		if (strictness === UNDEFINED_VALUE) {
-			return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
+	function getStrictness(options, inheritedOptions) {
+		return resolveStrictness(options, resolveStrictness(inheritedOptions, STRICTNESS_BALANCED));
+	}
+
+	function resolveStrictness(options, inheritedStrictness) {
+		const strictness = options[OPTION_STRICTNESS];
+		if (strictness !== UNDEFINED_VALUE) {
+			if (!isStrictnessValue(strictness)) {
+				throw new Error(ERR_INVALID_STRICTNESS);
+			}
+			return strictness;
+		}
+		const checkAmbiguity = options[OPTION_CHECK_AMBIGUITY];
+		if (checkAmbiguity === UNDEFINED_VALUE) {
+			return inheritedStrictness;
+		}
+		if (checkAmbiguity) {
+			return STRICTNESS_STRICT;
+		}
+		return inheritedStrictness == STRICTNESS_TOLERANT ? STRICTNESS_TOLERANT : STRICTNESS_BALANCED;
+	}
+
+	function getCheckLocalDirectory(checkLocalDirectory, strictness) {
+		if (checkLocalDirectory === UNDEFINED_VALUE) {
+			return strictness != STRICTNESS_TOLERANT;
 		}
-		if (!isStrictnessValue(strictness)) {
-			throw new Error(ERR_INVALID_STRICTNESS);
+		return Boolean(checkLocalDirectory);
+	}
+
+	function getCheckLocalFilename(checkLocalFilename, strictness) {
+		if (checkLocalFilename === UNDEFINED_VALUE) {
+			return strictness == STRICTNESS_STRICT;
 		}
-		return strictness;
+		return Boolean(checkLocalFilename);
 	}
 
 	function getFilenameValidation(filenameValidation, strictness) {
@@ -5768,10 +5853,11 @@
 		return UNDEFINED_VALUE;
 	}
 
-	function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
+	function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
 		const { rawFilename } = zipEntry;
-		if (rawLocalFilename.length != rawFilename.length ||
-			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte])) {
+		if (checkLocalFilename &&
+			(rawLocalFilename.length != rawFilename.length ||
+				rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
 			throwAmbiguousArchive("mismatched local file header (filename)");
 		}
 		if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {
@@ -5889,6 +5975,7 @@
 
 	const ERR_DUPLICATED_NAME = "File already exists";
 	const ERR_INVALID_COMMENT = "Zip file comment exceeds 64KB";
+	const ERR_INVALID_COMMENT_TYPE = "Invalid zip file comment (must be a Uint8Array)";
 	const ERR_INVALID_ENTRY_COMMENT = "File entry comment exceeds 64KB";
 	const ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
 	const ERR_INVALID_VERSION = "Version exceeds 65535";
@@ -5957,6 +6044,10 @@
 			}
 			reader = new GenericReader(reader);
 			await initStream(reader);
+			if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+				reader = new BlobReader(await streamToBlob(reader.readable));
+				await initStream(reader);
+			}
 			const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
 			const zipReader$1 = new ZipReader(reader.readable);
 			const entries = await zipReader$1.getEntries();
@@ -6105,6 +6196,9 @@
 			const zipWriter = this;
 			const { pendingAddFileCalls, writer } = this;
 			const { writable } = writer;
+			if (!(comment instanceof Uint8Array)) {
+				throw new Error(ERR_INVALID_COMMENT_TYPE);
+			}
 			if (getLength(comment) > MAX_16_BITS) {
 				throw new Error(ERR_INVALID_COMMENT);
 			}
@@ -6201,8 +6295,6 @@
 			const diskOffset = getDiskOffset(zipWriter.writer);
 			const diskNumber = getDiskNumber(zipWriter.writer);
 			options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
-				internalFileAttribute: metadataInfo.resolvedOptions.internalFileAttributes,
-				externalFileAttribute: attributesInfo.resolvedOptions.externalFileAttributes,
 				signature: options[PROPERTY_NAME_SIGNATURE],
 				crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
 				offset: zipWriter.offset - diskOffset,
@@ -6216,14 +6308,20 @@
 			zipWriter.files.delete(name);
 			throw error;
 		}
-		Object.assign(fileEntry, { name, comment, extraField });
+		Object.assign(fileEntry, {
+			name,
+			comment,
+			extraField,
+			[PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES]: fileEntry.internalFileAttributes,
+			[PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES]: fileEntry.externalFileAttributes
+		});
 		return new Entry(fileEntry);
 	}
 
 	function resolveAttributes(zipWriter, name, options) {
 		name = name.trim();
 		let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
-		let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? 20 : 768);
+		let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
 		const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
 		const uid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_UID);
 		const gid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_GID);
@@ -6257,7 +6355,7 @@
 		const hasMsDosProvided = msdosAttributesRaw !== UNDEFINED_VALUE || msdosAttributes !== UNDEFINED_VALUE;
 		if (hasUnixMetadata) {
 			msDosCompatible = false;
-			versionMadeBy = (versionMadeBy & MAX_16_BITS) | (3 << 8);
+			versionMadeBy = (versionMadeBy & MAX_8_BITS) | VERSION_MADE_BY_UNIX;
 		} else if (hasMsDosProvided) {
 			msDosCompatible = true;
 			versionMadeBy = (versionMadeBy & MAX_8_BITS);
@@ -6297,11 +6395,10 @@
 				externalFileAttributes = FILE_ATTR_UNIX_DEFAULT_MASK << 16;
 			}
 		}
-		let unixExternalUpper;
 		if (!msDosCompatible) {
 			const unixModeProvided = unixMode !== UNDEFINED_VALUE || Boolean(setuid || setgid || sticky);
-			unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
-			unixMode = unixMode === UNDEFINED_VALUE ? unixExternalUpper : (unixMode & MAX_16_BITS);
+			const defaultUnixMode = (externalFileAttributes >> 16) & MAX_16_BITS;
+			unixMode = unixMode === UNDEFINED_VALUE ? defaultUnixMode : (unixMode & MAX_16_BITS);
 			if (setuid) {
 				unixMode |= FILE_ATTR_UNIX_SETUID_MASK;
 			} else {
@@ -6330,17 +6427,20 @@
 		if (hasMsDosProvided) {
 			externalFileAttributes = (externalFileAttributes & MAX_32_BITS) | (msdosAttributesRaw & MAX_8_BITS);
 		}
+		const unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
+		const symlink = unixMode !== UNDEFINED_VALUE && ((unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK);
 		return {
 			name,
 			resolvedOptions: {
 				versionMadeBy,
-				msDosCompatible,
+				msDosCompatible: Boolean(msDosCompatible),
 				externalFileAttributes,
 				unixExternalUpper,
 				uid,
 				gid,
 				unixMode,
 				unixExtraFieldType,
+				symlink,
 				setuid,
 				setgid,
 				sticky,
@@ -6573,6 +6673,9 @@
 		if (writerOptions[OPTION_SIGN_CENTRAL_DIRECTORY]) {
 			throw new Error(ERR_UNDETERMINED_SIZE);
 		}
+		if (comment !== UNDEFINED_VALUE && !(comment instanceof Uint8Array)) {
+			throw new Error(ERR_INVALID_COMMENT_TYPE);
+		}
 		const commentLength = getLength(comment);
 		if (commentLength > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_COMMENT);
@@ -6854,6 +6957,7 @@
 			uid,
 			gid,
 			unixMode,
+			symlink,
 			setuid,
 			setgid,
 			sticky,
@@ -6890,6 +6994,7 @@
 			uid,
 			gid,
 			unixMode,
+			symlink: Boolean(symlink),
 			setuid,
 			setgid,
 			sticky,
@@ -6970,8 +7075,8 @@
 			rawLastModDate,
 			creationDate,
 			lastAccessDate,
-			encrypted,
-			zipCrypto,
+			encrypted: Boolean(encrypted),
+			zipCrypto: Boolean(zipCrypto),
 			size: metadataSize + compressedSize,
 			compressionMethod,
 			version,
@@ -10113,6 +10218,7 @@
 	exports.ERR_INVALID_CODEC_DEFINITION = ERR_INVALID_CODEC_DEFINITION;
 	exports.ERR_INVALID_CODEC_MODULE = ERR_INVALID_CODEC_MODULE;
 	exports.ERR_INVALID_COMMENT = ERR_INVALID_COMMENT;
+	exports.ERR_INVALID_COMMENT_TYPE = ERR_INVALID_COMMENT_TYPE;
 	exports.ERR_INVALID_COMPRESSED_DATA = ERR_INVALID_COMPRESSED_DATA;
 	exports.ERR_INVALID_CRC32 = ERR_INVALID_CRC32;
 	exports.ERR_INVALID_ENCRYPTION_STRENGTH = ERR_INVALID_ENCRYPTION_STRENGTH;