@zip.js/zip.js 2.8.42 → 2.8.44

package/dist/zip-core.js

@@ -1369,6 +1369,7 @@
 
 	const ERR_INVALID_PASSWORD = "Invalid password";
 	const ERR_INVALID_SIGNATURE = "Invalid signature";
+	const ERR_INVALID_AUTHENTICATION_CODE = ERR_INVALID_SIGNATURE;
 	const ERR_ABORT_CHECK_PASSWORD = "zipjs-abort-check-password";
 	const ERR_UNSUPPORTED_CRYPTO_API = "Crypto API not supported";
 
@@ -1435,7 +1436,7 @@
 
 	class AESDecryptionStream extends TransformStream {
 
-		constructor({ password, rawPassword, encryptionStrength, checkPasswordOnly }) {
+		constructor({ password, rawPassword, encryptionStrength, checkPasswordOnly, checkAuthenticationCode = true }) {
 			super({
 				start() {
 					initAesCrypto(this, password, rawPassword, encryptionStrength);
@@ -1485,8 +1486,8 @@
 						for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
 							invalidSignature |= signature[indexSignature] ^ originalSignature[indexSignature];
 						}
-						if (invalidSignature) {
-							throw new Error(ERR_INVALID_SIGNATURE);
+						if (invalidSignature && checkAuthenticationCode) {
+							throw new Error(ERR_INVALID_AUTHENTICATION_CODE);
 						}
 						controller.enqueue(decryptedChunkArray);
 					}
@@ -1924,6 +1925,7 @@
 
 	const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
 	const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
+	const ERR_INVALID_CRC32 = ERR_INVALID_SIGNATURE;
 	const ERR_UNSUPPORTED_COMPRESSION$2 = "Compression method not supported";
 	const FORMAT_DEFLATE_RAW = "deflate-raw";
 	const FORMAT_DEFLATE64_RAW = "deflate64-raw";
@@ -1931,19 +1933,20 @@
 	const GZIP_HEADER_LENGTH = 10;
 	const GZIP_TRAILER_LENGTH = 8;
 	const GZIP_HEADER_BYTES = [0x1f, 0x8b, 0x08];
+	const GZIP_OUTPUT_STALL_TIMEOUT = 5000;
 
 	class DeflateStream extends TransformStream {
 
 		constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
 			super({});
-			const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level, deflate64, format, compressionMethod } = options;
+			const { compressed, encrypted, useCompressionStream, zipCrypto, computeCrc32, level, deflate64, format, compressionMethod } = options;
 			const stream = this;
 			let crc32Stream, encryptionStream, gzipCrc32Stream;
 			let readable = super.readable;
 			const codecStreams = format && getCodecStreams(format);
-			const useGzipCrc32 = signed && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) &&
+			const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) &&
 				Boolean(useCompressionStream && CompressionStream);
-			if ((!encrypted || zipCrypto) && signed && !useGzipCrc32) {
+			if ((!encrypted || zipCrypto) && computeCrc32 && !useGzipCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
 			}
@@ -1982,7 +1985,7 @@
 				if (encrypted && !zipCrypto) {
 					signature = encryptionStream.signature;
 				}
-				if ((!encrypted || zipCrypto) && signed) {
+				if ((!encrypted || zipCrypto) && computeCrc32) {
 					signature = useGzipCrc32 ? gzipCrc32Stream.signature : new DataView(crc32Stream.value.buffer).getUint32(0);
 				}
 				stream.signature = signature;
@@ -2031,26 +2034,73 @@
 		}
 	}
 
-	class RawDeflateToGzipStream extends TransformStream {
+	function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize) {
+		const crc32 = new Crc32();
+		let outputLength = 0;
+		let inputDone = false;
+		let watchdogTimeout;
+		let resolveTrailerReady, rejectTrailerReady;
+		const trailerReady = new Promise((resolve, reject) => {
+			resolveTrailerReady = resolve;
+			rejectTrailerReady = reject;
+		});
+		trailerReady.catch(() => { });
+		if (!outputSize) {
+			resolveTrailerReady();
+		}
+		const gzipWrapStream = new TransformStream({
+			start(controller) {
+				const header = new Uint8Array(GZIP_HEADER_LENGTH);
+				header.set(GZIP_HEADER_BYTES);
+				controller.enqueue(header);
+			},
+			transform(chunk, controller) {
+				controller.enqueue(chunk);
+			},
+			async flush(controller) {
+				inputDone = true;
+				startWatchdog();
+				try {
+					await trailerReady;
+				} finally {
+					stopWatchdog();
+				}
+				const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
+				const dataView = getDataView(trailer);
+				dataView.setUint32(0, crc32.get(), true);
+				dataView.setUint32(4, outputSize, true);
+				controller.enqueue(trailer);
+			},
+			cancel(reason) {
+				rejectTrailerReady(reason);
+			}
+		});
+		const outputStream = new TransformStream({
+			transform(chunk, controller) {
+				crc32.append(chunk);
+				outputLength += chunk.length;
+				if (outputLength >= outputSize) {
+					resolveTrailerReady();
+				} else if (inputDone) {
+					startWatchdog();
+				}
+				controller.enqueue(chunk);
+			},
+			cancel(reason) {
+				rejectTrailerReady(reason);
+			}
+		});
+		readable = pipeThrough(readable, gzipWrapStream);
+		readable = pipeThroughBackpressured(readable, gzipStream);
+		return pipeThrough(readable, outputStream);
 
-		constructor(signature, uncompressedSize) {
-			super({
-				start(controller) {
-					const header = new Uint8Array(GZIP_HEADER_LENGTH);
-					header.set(GZIP_HEADER_BYTES);
-					controller.enqueue(header);
-				},
-				transform(chunk, controller) {
-					controller.enqueue(chunk);
-				},
-				flush(controller) {
-					const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
-					const dataView = getDataView(trailer);
-					dataView.setUint32(0, signature, true);
-					dataView.setUint32(4, uncompressedSize, true);
-					controller.enqueue(trailer);
-				}
-			});
+		function startWatchdog() {
+			stopWatchdog();
+			watchdogTimeout = setTimeout(() => rejectTrailerReady(new Error(ERR_INVALID_UNCOMPRESSED_SIZE)), GZIP_OUTPUT_STALL_TIMEOUT);
+		}
+
+		function stopWatchdog() {
+			clearTimeout(watchdogTimeout);
 		}
 	}
 
@@ -2058,7 +2108,7 @@
 
 		constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
 			super({});
-			const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
+			const { zipCrypto, encrypted, checkCrc32, signature, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
 			let crc32Stream, decryptionStream;
 			let readable = super.readable;
 			if (encrypted) {
@@ -2077,7 +2127,7 @@
 					try {
 						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib);
 					} catch (error) {
-						if (deflate64 || (encrypted && !zipCrypto) || signature === UNDEFINED_VALUE || outputSize === UNDEFINED_VALUE) {
+						if (deflate64 || outputSize === UNDEFINED_VALUE) {
 							throw error;
 						}
 						let gzipStream;
@@ -2086,46 +2136,58 @@
 						} catch {
 							throw error;
 						}
-						readable = pipeThrough(readable, new RawDeflateToGzipStream(signature, outputSize));
-						readable = pipeThroughBackpressured(readable, gzipStream);
+						readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize);
 					}
 				}
 				readable = mapInflateStreamError(readable);
 			}
-			if ((!encrypted || zipCrypto) && signed) {
+			if (checkCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
 			}
 			setReadable(this, readable, () => {
-				if ((!encrypted || zipCrypto) && signed) {
+				if (checkCrc32) {
 					const dataViewSignature = new DataView(crc32Stream.value.buffer);
 					if (signature != dataViewSignature.getUint32(0, false)) {
-						throw new Error(ERR_INVALID_SIGNATURE);
+						throw new Error(ERR_INVALID_CRC32);
 					}
 				}
 			});
 		}
 	}
 
-	const deflateRawSupportByStream = new Map();
+	const formatSupportByStream = new Map();
 
-	function supportsDeflateRaw(StreamClass) {
+	function supportsFormat(StreamClass, format) {
 		if (!StreamClass) {
 			return false;
 		}
-		let supported = deflateRawSupportByStream.get(StreamClass);
+		let supportByFormat = formatSupportByStream.get(StreamClass);
+		if (!supportByFormat) {
+			supportByFormat = new Map();
+			formatSupportByStream.set(StreamClass, supportByFormat);
+		}
+		let supported = supportByFormat.get(format);
 		if (supported === UNDEFINED_VALUE) {
 			try {
-				new StreamClass(FORMAT_DEFLATE_RAW);
+				new StreamClass(format);
 				supported = true;
 			} catch {
 				supported = false;
 			}
-			deflateRawSupportByStream.set(StreamClass, supported);
+			supportByFormat.set(format, supported);
 		}
 		return supported;
 	}
 
+	function supportsDeflateRaw(StreamClass) {
+		return supportsFormat(StreamClass, FORMAT_DEFLATE_RAW);
+	}
+
+	function supportsGzip(StreamClass) {
+		return supportsFormat(StreamClass, FORMAT_GZIP);
+	}
+
 	function setReadable(stream, readable, flush) {
 		readable = pipeThrough(readable, new TransformStream({ flush }));
 		Object.defineProperty(stream, "readable", {
@@ -2424,6 +2486,25 @@
 	}
 	let initModule = () => { };
 
+	async function supportsDeflate(config) {
+		const { CompressionStream: NativeStream, CompressionStreamZlib: ZlibStream } = config;
+		if (ZlibStream && !ZlibStream.requiresModule) {
+			return true;
+		}
+		if (supportsDeflateRaw(NativeStream) || supportsGzip(NativeStream)) {
+			return true;
+		}
+		if (ZlibStream) {
+			try {
+				await initModule(config);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		return false;
+	}
+
 	function resetWebWorkerSupport() {
 		webWorkerSupported = UNDEFINED_VALUE;
 	}
@@ -2959,7 +3040,7 @@
 
 	async function runWorker(stream, workerOptions) {
 		const { options, config } = workerOptions;
-		const { transferStreams, useWebWorkers, useCompressionStream, compressed, signed, encrypted, format, codecURI } = options;
+		const { transferStreams, useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
 		const { workerURI, maxWorkers } = config;
 		if (format) {
 			if (codecURI) {
@@ -2968,7 +3049,7 @@
 			await ensureCodecStreams(format, options.codecURI);
 		}
 		workerOptions.transferStreams = transferStreams || (transferStreams === UNDEFINED_VALUE && config.transferStreams);
-		const streamCopy = !compressed && !signed && !encrypted;
+		const streamCopy = !compressed && !checkCrc32 && !computeCrc32 && !encrypted;
 		const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
 		workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 		workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
@@ -4192,6 +4273,7 @@
 	const PROPERTY_NAME_EXECUTABLE = "executable";
 	const PROPERTY_NAME_COMPRESSION_METHOD = "compressionMethod";
 	const PROPERTY_NAME_SIGNATURE = "signature";
+	const PROPERTY_NAME_CRC32 = "crc32";
 	const PROPERTY_NAME_EXTRA_FIELD = "extraField";
 	const PROPERTY_NAME_EXTRA_FIELD_INFOZIP = "extraFieldInfoZip";
 	const PROPERTY_NAME_EXTRA_FIELD_UNIX = "extraFieldUnix";
@@ -4240,6 +4322,7 @@
 		PROPERTY_NAME_EXECUTABLE,
 		PROPERTY_NAME_COMPRESSION_METHOD,
 		PROPERTY_NAME_SIGNATURE,
+		PROPERTY_NAME_CRC32,
 		PROPERTY_NAME_EXTRA_FIELD,
 		PROPERTY_NAME_EXTRA_FIELD_UNIX,
 		PROPERTY_NAME_EXTRA_FIELD_INFOZIP,
@@ -4311,6 +4394,8 @@
 	const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
 	const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
 	const OPTION_CHECK_SIGNATURE = "checkSignature";
+	const OPTION_CHECK_CRC32 = "checkCrc32";
+	const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
 	const OPTION_USE_WEB_WORKERS = "useWebWorkers";
 	const OPTION_USE_COMPRESSION_STREAM = "useCompressionStream";
 	const OPTION_TRANSFER_STREAMS = "transferStreams";
@@ -4382,6 +4467,7 @@
 	const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 	const CHARSET_CP437 = "cp437";
 	const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_LANG_ENCODING_FLAG;
+	const VENDOR_VERSION_AE_1 = 1;
 	const ZIP64_PROPERTIES = [
 		[PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
 		[PROPERTY_NAME_COMPRESSED_SIZE, MAX_32_BITS],
@@ -4861,6 +4947,11 @@
 			if (deflate64) {
 				useCompressionStream = false;
 			}
+			const checkCrc32Option = getOptionValue$1(zipEntry, options, OPTION_CHECK_CRC32);
+			const checkCrc32 = (checkCrc32Option === UNDEFINED_VALUE ?
+				getOptionValue$1(zipEntry, options, OPTION_CHECK_SIGNATURE) :
+				checkCrc32Option) && !passThrough &&
+				(!encrypted || zipCrypto || (extraFieldAES && extraFieldAES.vendorVersion == VENDOR_VERSION_AE_1));
 			const workerOptions = {
 				options: {
 					codecType: CODEC_INFLATE,
@@ -4868,7 +4959,8 @@
 					rawPassword,
 					zipCrypto,
 					encryptionStrength: extraFieldAES && extraFieldAES.strength,
-					signed: getOptionValue$1(zipEntry, options, OPTION_CHECK_SIGNATURE) && !passThrough,
+					checkCrc32,
+					checkAuthenticationCode: getOptionValue$1(zipEntry, options, OPTION_CHECK_AUTHENTICATION_CODE),
 					passwordVerification: zipCrypto && (dataDescriptor ? ((rawLastModDate >>> 8) & MAX_8_BITS) : ((signature >>> 24) & MAX_8_BITS)),
 					outputSize: passThrough ? compressedSize : uncompressedSize,
 					signature,
@@ -4984,6 +5076,7 @@
 		const compressionMethod = getUint16(dataView, offset + 4);
 		Object.assign(directory, {
 			signature: getUint32(dataView, offset + HEADER_OFFSET_SIGNATURE),
+			crc32: getUint32(dataView, offset + HEADER_OFFSET_SIGNATURE),
 			compressedSize: getUint32(dataView, offset + HEADER_OFFSET_COMPRESSED_SIZE),
 			uncompressedSize: getUint32(dataView, offset + HEADER_OFFSET_UNCOMPRESSED_SIZE)
 		});
@@ -5085,6 +5178,9 @@
 			compressionMethod: getUint16(extraFieldView, 5)
 		});
 		directory.compressionMethod = extraFieldAES.compressionMethod;
+		if (extraFieldAES.vendorVersion != VENDOR_VERSION_AE_1) {
+			directory.crc32 = UNDEFINED_VALUE;
+		}
 	}
 
 	function readExtraFieldNTFS(extraFieldNTFS, directory) {
@@ -5103,26 +5199,22 @@
 		} catch {
 			// ignored
 		}
-		try {
-			if (tag1Data && tag1Data.length == 24) {
-				const tag1View = getDataView(tag1Data);
-				const rawLastModDate = tag1View.getBigUint64(0, true);
-				const rawLastAccessDate = tag1View.getBigUint64(8, true);
-				const rawCreationDate = tag1View.getBigUint64(16, true);
-				Object.assign(extraFieldNTFS, {
-					rawLastModDate,
-					rawLastAccessDate,
-					rawCreationDate
-				});
-				const lastModDate = getDateNTFS(rawLastModDate);
-				const lastAccessDate = getDateNTFS(rawLastAccessDate);
-				const creationDate = getDateNTFS(rawCreationDate);
-				const extraFieldData = { lastModDate, lastAccessDate, creationDate };
-				Object.assign(extraFieldNTFS, extraFieldData);
-				Object.assign(directory, extraFieldData);
-			}
-		} catch {
-			// ignored
+		if (tag1Data && tag1Data.length == 24) {
+			const tag1View = getDataView(tag1Data);
+			const rawLastModDate = tag1View.getBigUint64(0, true);
+			const rawLastAccessDate = tag1View.getBigUint64(8, true);
+			const rawCreationDate = tag1View.getBigUint64(16, true);
+			Object.assign(extraFieldNTFS, {
+				rawLastModDate,
+				rawLastAccessDate,
+				rawCreationDate
+			});
+			const lastModDate = getDateNTFS(rawLastModDate);
+			const lastAccessDate = getDateNTFS(rawLastAccessDate);
+			const creationDate = getDateNTFS(rawCreationDate);
+			const extraFieldData = { lastModDate, lastAccessDate, creationDate };
+			Object.assign(extraFieldNTFS, extraFieldData);
+			Object.assign(directory, extraFieldData);
 		}
 	}
 
@@ -5425,11 +5517,7 @@
 
 	function getDate(timeRaw) {
 		const date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & MAX_16_BITS;
-		try {
-			return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
-		} catch {
-			// ignored
-		}
+		return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
 	}
 
 	function getDateNTFS(timeRaw) {
@@ -5462,7 +5550,9 @@
 		ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND: ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND,
 		ERR_EOCDR_NOT_FOUND: ERR_EOCDR_NOT_FOUND,
 		ERR_EXTRAFIELD_ZIP64_NOT_FOUND: ERR_EXTRAFIELD_ZIP64_NOT_FOUND,
+		ERR_INVALID_AUTHENTICATION_CODE: ERR_INVALID_AUTHENTICATION_CODE,
 		ERR_INVALID_COMPRESSED_DATA: ERR_INVALID_COMPRESSED_DATA,
+		ERR_INVALID_CRC32: ERR_INVALID_CRC32,
 		ERR_INVALID_PASSWORD: ERR_INVALID_PASSWORD,
 		ERR_INVALID_SIGNATURE: ERR_INVALID_SIGNATURE,
 		ERR_INVALID_UNCOMPRESSED_SIZE: ERR_INVALID_UNCOMPRESSED_SIZE,
@@ -5516,6 +5606,8 @@
 	const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 	const MIN_UNIX_TIME = -2147483648;
 	const MAX_UNIX_TIME = 2147483647;
+	const MIN_NTFS_TIME = BigInt(0);
+	const MAX_NTFS_TIME = BigInt("0x7fffffffffffffff");
 	const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 	const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
 	const ERR_UNDEFINED_READER = "Undefined reader";
@@ -5797,6 +5889,11 @@
 		zipWriter.files.set(name, UNDEFINED_VALUE);
 		let fileEntry;
 		try {
+			const { resolvedOptions } = metadataInfo;
+			if (resolvedOptions.level != 0 && resolvedOptions.compressionMethod === UNDEFINED_VALUE &&
+				!resolvedOptions.passThrough && !(await supportsDeflate(zipWriter.config))) {
+				resolvedOptions.level = 0;
+			}
 			const sizesInfo = await resolveSizes(zipWriter, reader, metadataInfo, options);
 			({ reader } = sizesInfo);
 			const diskOffset = getDiskOffset(zipWriter.writer);
@@ -6017,9 +6114,6 @@
 		if (level !== UNDEFINED_VALUE && level != 6) {
 			useCompressionStream = false;
 		}
-		if (!useCompressionStream && !registeredCodec && (zipWriter.config.CompressionStream === UNDEFINED_VALUE && zipWriter.config.CompressionStreamZlib === UNDEFINED_VALUE)) {
-			level = 0;
-		}
 		const zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 		if (!zipCrypto && (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) && !(encryptionStrength >= 1 && encryptionStrength <= 3)) {
 			throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
@@ -6407,9 +6501,12 @@
 			msdosAttributes
 		};
 		let {
-			signature,
+			crc32: signature,
 			uncompressedSize
 		} = options;
+		if (signature === UNDEFINED_VALUE) {
+			({ signature } = options);
+		}
 		let compressedSize = 0;
 		if (!passThrough) {
 			uncompressedSize = 0;
@@ -6427,7 +6524,7 @@
 					encryptionStrength,
 					zipCrypto: encrypted && zipCrypto,
 					passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & MAX_8_BITS,
-					signed: !passThrough,
+					computeCrc32: !passThrough,
 					compressed: compressed && !passThrough,
 					encrypted: encrypted && !passThrough,
 					useWebWorkers,
@@ -6446,7 +6543,9 @@
 				writer.size += compressedSize;
 				if (!passThrough) {
 					uncompressedSize = result.inputSize;
-					signature = result.signature;
+					if (!encrypted || zipCrypto) {
+						signature = result.signature;
+					}
 				}
 				if ((!zip64CompressedSize && compressedSize >= MAX_32_BITS) ||
 					(!zip64UncompressedSize && uncompressedSize >= MAX_32_BITS)) {
@@ -6485,6 +6584,7 @@
 			headerArray,
 			headerView,
 			signature,
+			crc32: encrypted && !zipCrypto ? UNDEFINED_VALUE : signature,
 			extraFieldExtendedTimestampFlag,
 			zip64UncompressedSize,
 			zip64CompressedSize
@@ -6585,8 +6685,8 @@
 					extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS_TAG1);
 					extraFieldNTFS.uint16(24);
 					extraFieldNTFS.uint64(lastModTimeNTFS);
-					extraFieldNTFS.uint64(getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
-					extraFieldNTFS.uint64(getTimeNTFS(creationDate) || lastModTimeNTFS);
+					extraFieldNTFS.uint64(lastAccessDate ? getTimeNTFS(lastAccessDate) : lastModTimeNTFS);
+					extraFieldNTFS.uint64(creationDate ? getTimeNTFS(creationDate) : lastModTimeNTFS);
 					rawExtraFieldNTFS = extraFieldNTFS.array;
 				} catch {
 					rawExtraFieldNTFS = EMPTY_UINT8_ARRAY;
@@ -6646,7 +6746,7 @@
 		if (extraFieldLength > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 		}
-		const dosLastModDate = new Date(Math.ceil(lastModDate.getTime() / 2000) * 2000);
+		const dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
 		const {
 			headerArray,
 			headerView,
@@ -7155,7 +7255,8 @@
 
 	function getTimeNTFS(date) {
 		if (date) {
-			return ((BigInt(date.getTime()) + BigInt(11644473600000)) * BigInt(10000));
+			const timeNTFS = ((BigInt(date.getTime()) + BigInt(11644473600000)) * BigInt(10000));
+			return timeNTFS < MIN_NTFS_TIME ? MIN_NTFS_TIME : timeNTFS > MAX_NTFS_TIME ? MAX_NTFS_TIME : timeNTFS;
 		}
 	}
 
@@ -7760,10 +7861,12 @@
 	exports.ERR_EXTRAFIELD_ZIP64_NOT_FOUND = ERR_EXTRAFIELD_ZIP64_NOT_FOUND;
 	exports.ERR_HTTP_RANGE = ERR_HTTP_RANGE;
 	exports.ERR_HTTP_RESOURCE_CHANGED = ERR_HTTP_RESOURCE_CHANGED;
+	exports.ERR_INVALID_AUTHENTICATION_CODE = ERR_INVALID_AUTHENTICATION_CODE;
 	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_COMPRESSED_DATA = ERR_INVALID_COMPRESSED_DATA;
+	exports.ERR_INVALID_CRC32 = ERR_INVALID_CRC32;
 	exports.ERR_INVALID_ENCRYPTION_STRENGTH = ERR_INVALID_ENCRYPTION_STRENGTH;
 	exports.ERR_INVALID_ENTRY_COMMENT = ERR_INVALID_ENTRY_COMMENT;
 	exports.ERR_INVALID_ENTRY_NAME = ERR_INVALID_ENTRY_NAME;