@zip.js/zip.js 2.8.52 → 2.8.54

package/lib/core/zip-reader.js

@@ -37,6 +37,8 @@ import {
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
 	SPLIT_ZIP_FILE_SIGNATURE,
+	TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE,
+	SPLIT_ZIP_FILE_SIGNATURE_LENGTH,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_LENGTH,
 	DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH,
@@ -90,7 +92,6 @@ import {
 	FILE_ATTR_UNIX_SETGID_MASK,
 	FILE_ATTR_UNIX_STICKY_MASK,
 	NUMBER_TYPE,
-	STRING_TYPE,
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
 import { getConfiguration } from "./configuration.js";
@@ -150,6 +151,7 @@ import {
 	OPTION_CHECK_OVERLAPPING_ENTRY_ONLY,
 	OPTION_CHECK_OVERLAPPING_ENTRY,
 	OPTION_CHECK_AMBIGUITY,
+	OPTION_CHECK_LOCAL_DIRECTORY,
 	OPTION_CHECK_SIGNATURE,
 	OPTION_CHECK_CRC32,
 	OPTION_CHECK_AUTHENTICATION_CODE,
@@ -166,7 +168,11 @@ import {
 	OPTION_USE_WEB_WORKERS,
 	OPTION_USE_COMPRESSION_STREAM,
 	OPTION_TRANSFER_STREAMS,
-	OPTION_PREVENT_CLOSE
+	OPTION_PREVENT_CLOSE,
+	checkFunctionOption,
+	checkSignalOption,
+	checkPasswordOption,
+	toNumber
 } from "./options.js";
 
 const ERR_BAD_FORMAT = "File format is not recognized";
@@ -180,6 +186,7 @@ const ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
 const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 const ERR_SPLIT_ZIP_FILE = "Split zip file";
 const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
+const ERR_ENTRY_DATA_OUT_OF_BOUNDS = "Entry data out of bounds";
 const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
 const ERR_ENCRYPTED_CENTRAL_DIRECTORY = "Encrypted central directory is not supported";
 const ERR_UNSAFE_FILENAME = "Unsafe filename";
@@ -209,6 +216,7 @@ const ZIP64_EXTRACTION = {
 	}
 };
 const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
+const MAX_DEFLATE_EXPANSION_RATIO = 1032;
 const CENTRAL_DIRECTORY_UNREACHABLE = 0;
 const CENTRAL_DIRECTORY_PLAUSIBLE = 1;
 const CENTRAL_DIRECTORY_REACHABLE = 2;
@@ -219,7 +227,6 @@ class ZipReader {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
 			options,
-			config: getConfiguration(),
 			readRanges: new Map()
 		});
 	}
@@ -227,7 +234,6 @@ class ZipReader {
 	async* getEntriesGenerator(options = {}) {
 		const zipReader = this;
 		let { reader } = zipReader;
-		const { config } = zipReader;
 		await initStream(reader);
 		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
 			reader = new BlobReader(await streamToBlob(reader.readable));
@@ -236,7 +242,7 @@ class ZipReader {
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
-		const strictness = getStrictness(getOptionValue(zipReader, options, OPTION_STRICTNESS), getOptionValue(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(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
@@ -244,9 +250,7 @@ class ZipReader {
 		const normalizeFilename = getOptionValue(zipReader, options, OPTION_NORMALIZE_FILENAME);
 		const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
 		if (!endOfDirectoryInfo) {
-			const signatureArray = await readUint8Array(reader, 0, 4);
-			const signatureView = getDataView(signatureArray);
-			if (getUint32(signatureView) == SPLIT_ZIP_FILE_SIGNATURE) {
+			if (await startsWithSplitZipSignature(reader)) {
 				throw new Error(ERR_SPLIT_ZIP_FILE);
 			} else {
 				throw new Error(ERR_EOCDR_NOT_FOUND);
@@ -385,7 +389,7 @@ class ZipReader {
 		}
 		zipReader.directoryOffset = directoryDataOffset;
 		zipReader.directoryLength = declaredDirectoryDataLength;
-		const decryptCentralDirectory = getOptionValue(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
+		const decryptCentralDirectory = getFunctionOptionValue(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
 		let decryptedDirectory;
 		if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
 			getUint32(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
@@ -401,7 +405,7 @@ class ZipReader {
 		const filenames = checkAmbiguity ? new Set() : UNDEFINED_VALUE;
 		let duplicateFilename;
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
-			const fileEntry = new ZipEntry(reader, config, zipReader.options);
+			const fileEntry = new ZipEntry(reader, zipReader.options);
 			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
 				if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 					throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
@@ -432,7 +436,7 @@ class ZipReader {
 				archive: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_ARCHIVE_MASK)
 			};
 			const offsetFileEntry = getUint32(directoryView, offset + 42);
-			const decode = getOptionValue(zipReader, options, OPTION_DECODE_TEXT) || decodeText;
+			const decode = getFunctionOptionValue(zipReader, options, OPTION_DECODE_TEXT) || decodeText;
 			const rawFilenameEncoding = filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437;
 			const rawCommentEncoding = commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437;
 			let filename = decode(rawFilename, rawFilenameEncoding, TEXT_TYPE_FILENAME);
@@ -458,6 +462,7 @@ class ZipReader {
 				index: indexFile,
 				versionMadeBy,
 				msDosCompatible,
+				zip64: false,
 				compressedSize: 0,
 				uncompressedSize: 0,
 				commentLength,
@@ -544,13 +549,17 @@ class ZipReader {
 		if (duplicateFilename) {
 			throwAmbiguousArchive("duplicate filename");
 		}
-		if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > 0))) {
-			throwAmbiguousArchive("prepended data");
-		}
 		const extractPrependedData = getOptionValue(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 		const extractAppendedData = getOptionValue(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
+		const splitZipSignatureLength = (checkAmbiguity || extractPrependedData) && filesLength &&
+			startOffset == SPLIT_ZIP_FILE_SIGNATURE_LENGTH && await startsWithSplitZipMarker(reader) ? SPLIT_ZIP_FILE_SIGNATURE_LENGTH : 0;
+		if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > splitZipSignatureLength))) {
+			throwAmbiguousArchive("prepended data");
+		}
 		if (extractPrependedData) {
-			zipReader.prependedData = startOffset > 0 ? await readUint8Array(reader, 0, startOffset) : EMPTY_UINT8_ARRAY;
+			zipReader.prependedData = startOffset > splitZipSignatureLength ?
+				await readUint8Array(reader, splitZipSignatureLength, startOffset - splitZipSignatureLength) :
+				EMPTY_UINT8_ARRAY;
 		}
 		zipReader.comment = commentLength ? await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength) : EMPTY_UINT8_ARRAY;
 		if (extractAppendedData) {
@@ -635,6 +644,7 @@ export {
 	ERR_INVALID_COMPRESSED_DATA,
 	ERR_SPLIT_ZIP_FILE,
 	ERR_OVERLAPPING_ENTRY,
+	ERR_ENTRY_DATA_OUT_OF_BOUNDS,
 	ERR_AMBIGUOUS_ARCHIVE,
 	ERR_ENCRYPTED_CENTRAL_DIRECTORY,
 	ERR_UNSAFE_FILENAME,
@@ -646,16 +656,16 @@ export {
 
 class ZipEntry {
 
-	constructor(reader, config, options) {
+	constructor(reader, options) {
 		Object.assign(this, {
 			reader,
-			config,
 			options
 		});
 	}
 
 	async getData(writer, fileEntry, readRanges, options = {}) {
 		const zipEntry = this;
+		const config = getConfiguration();
 		const {
 			reader,
 			index,
@@ -664,7 +674,6 @@ class ZipEntry {
 			extraFieldAES,
 			extraFieldZip64,
 			compressionMethod,
-			config,
 			bitFlag,
 			rawBitFlag,
 			crc32,
@@ -682,6 +691,7 @@ class ZipEntry {
 		let password = getOptionValue(zipEntry, options, OPTION_PASSWORD);
 		let rawPassword = getOptionValue(zipEntry, options, OPTION_RAW_PASSWORD);
 		const passThrough = getOptionValue(zipEntry, options, OPTION_PASS_THROUGH);
+		checkPasswordOption(password, rawPassword);
 		password = password && password.length && password;
 		rawPassword = rawPassword && rawPassword.length && rawPassword;
 		if (extraFieldAES) {
@@ -697,9 +707,12 @@ class ZipEntry {
 			extraFieldLength,
 			filenameLength
 		} = localDirectory;
-		const checkAmbiguity = getStrictness(getOptionValue(zipEntry, options, OPTION_STRICTNESS), getOptionValue(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
+		const checkLocalDirectoryOption = getOptionValue(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);
@@ -708,17 +721,26 @@ class ZipEntry {
 				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) {
@@ -739,9 +761,12 @@ class ZipEntry {
 			}
 		}
 		const dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
+		if (dataOffset + compressedSize > reader.size) {
+			throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS);
+		}
 		const size = compressedSize;
 		const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
-		const signal = getOptionValue(zipEntry, options, OPTION_SIGNAL);
+		const signal = checkSignalOption(getOptionValue(zipEntry, options, OPTION_SIGNAL));
 		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 		let checkOverlappingEntry = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
 		const checkOverlappingEntryOnly = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY_ONLY);
@@ -749,6 +774,8 @@ class ZipEntry {
 			checkOverlappingEntry = true;
 		}
 		const { onstart, onprogress, onend } = options;
+		const compressed = compressionMethod != COMPRESSION_METHOD_STORE && !passThrough;
+		const outputSize = passThrough ? compressedSize : uncompressedSize;
 		const deflate64 = compressionMethod == COMPRESSION_METHOD_DEFLATE_64;
 		let useCompressionStream = getOptionValue(zipEntry, options, OPTION_USE_COMPRESSION_STREAM);
 		if (deflate64) {
@@ -769,9 +796,9 @@ class ZipEntry {
 				checkCrc32,
 				checkAuthenticationCode: getOptionValue(zipEntry, options, OPTION_CHECK_AUTHENTICATION_CODE),
 				passwordVerification: zipCrypto && (dataDescriptor ? ((rawLastModDate >>> 8) & MAX_8_BITS) : ((crc32 >>> 24) & MAX_8_BITS)),
-				outputSize: passThrough ? compressedSize : uncompressedSize,
+				outputSize,
 				crc32,
-				compressed: compressionMethod != 0 && !passThrough,
+				compressed,
 				encrypted,
 				useWebWorkers: getOptionValue(zipEntry, options, OPTION_USE_WEB_WORKERS),
 				useCompressionStream,
@@ -808,11 +835,11 @@ class ZipEntry {
 					writer = new WritableStream();
 				}
 				writer = new GenericWriter(writer);
-				await initStream(writer, passThrough ? compressedSize : uncompressedSize);
+				await initStream(writer, getDecodableOutputSize(outputSize, compressedSize, compressed));
 				({ writable } = writer);
-				const { outputSize } = await runWorker({ readable, writable }, workerOptions);
-				writer.size += outputSize;
-				if (outputSize != (passThrough ? compressedSize : uncompressedSize)) {
+				const { outputSize: writtenSize } = await runWorker({ readable, writable }, workerOptions);
+				writer.size += writtenSize;
+				if (writtenSize != outputSize) {
 					throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
 				}
 			}
@@ -954,10 +981,12 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		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);
@@ -1060,7 +1089,7 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 		const creationDate = getDateNTFS(rawCreationDate);
 		const extraFieldData = { lastModDate, lastAccessDate, creationDate };
 		Object.assign(extraFieldNTFS, extraFieldData);
-		Object.assign(directory, extraFieldData);
+		Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
 	}
 }
 
@@ -1104,6 +1133,7 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 		if (gid !== UNDEFINED_VALUE) {
 			directory.gid = gid;
 		}
+		return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
 	} catch {
 		// ignored
 	}
@@ -1176,26 +1206,25 @@ async function detectOverlappingEntry({
 	}
 	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,
@@ -1212,22 +1241,80 @@ async function detectOverlappingEntry({
 	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(reader, diskNumber) {
 	return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
 }
 
+async function startsWithSplitZipSignature(reader) {
+	return await getFirstSignature(reader) == SPLIT_ZIP_FILE_SIGNATURE;
+}
+
+async function startsWithSplitZipMarker(reader) {
+	const signature = await getFirstSignature(reader);
+	return signature == SPLIT_ZIP_FILE_SIGNATURE || signature == TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE;
+}
+
+async function getFirstSignature(reader) {
+	const signatureArray = await readUint8Array(reader, 0, SPLIT_ZIP_FILE_SIGNATURE_LENGTH);
+	return getUint32(getDataView(signatureArray));
+}
+
 function isStrictnessValue(value) {
 	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 getDecodableOutputSize(outputSize, compressedSize, compressed) {
+	return Math.min(outputSize, compressed ? compressedSize * MAX_DEFLATE_EXPANSION_RATIO : compressedSize);
+}
+
+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) {
@@ -1375,10 +1462,11 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 	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)) {
@@ -1406,10 +1494,11 @@ function getOptionValue(zipReader, options, name) {
 	return options[name] === UNDEFINED_VALUE ? zipReader.options[name] : options[name];
 }
 
-function toNumber(value) {
-	return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
+function getFunctionOptionValue(zipReader, options, name) {
+	return checkFunctionOption(getOptionValue(zipReader, options, name));
 }
 
+
 function getDate(timeRaw) {
 	const date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & MAX_16_BITS;
 	return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);