@zip.js/zip.js 2.8.35 → 2.8.37

package/dist/zip-fs-core.js

@@ -103,7 +103,7 @@
 	const HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
 	const LOCAL_HEADER_COMMON_OFFSET = 4;
 
-	const MAX_DATE = new Date(2107, 11, 31);
+	const MAX_DATE = new Date(2107, 11, 31, 23, 59, 58);
 	const MIN_DATE = new Date(1980, 0, 1);
 
 	const UNDEFINED_VALUE = undefined;
@@ -268,6 +268,7 @@
 	const HTTP_METHOD_GET = "GET";
 	const HTTP_RANGE_UNIT = "bytes";
 	const DEFAULT_BUFFER_SIZE = 256 * 1024;
+	const DEFAULT_MAXIMUM_RANGE_SIZE = 16 * 1024 * 1024;
 
 	const PROPERTY_NAME_WRITABLE = "writable";
 	const DISK_BOUNDARY = Symbol();
@@ -580,6 +581,7 @@
 			forceRangeRequests,
 			combineSizeEocd,
 			checkResourceChanges = true,
+			maximumRangeSize = DEFAULT_MAXIMUM_RANGE_SIZE,
 			fetch
 		} = options;
 		options = Object.assign({}, options);
@@ -588,6 +590,7 @@
 		delete options.forceRangeRequests;
 		delete options.combineSizeEocd;
 		delete options.checkResourceChanges;
+		delete options.maximumRangeSize;
 		delete options.useXHR;
 		delete options.fetch;
 		Object.assign(httpReader, {
@@ -598,6 +601,7 @@
 			forceRangeRequests,
 			combineSizeEocd,
 			checkResourceChanges,
+			maximumRangeSize,
 			fetch
 		});
 	}
@@ -683,40 +687,31 @@
 
 	function createRangeReadable(httpReader, offset, size) {
 		let bodyReader;
+		let windowOffset = offset;
+		let windowRemainingLength = 0;
 		let remainingLength = size;
 		return new ReadableStream({
-			async start() {
-				const response = await sendFetchRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, offset, size));
-				if (response.status != 206) {
-					throw new Error(ERR_HTTP_RANGE);
-				}
-				const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
-				if (contentRangeHeader) {
-					const rangeStart = Number(contentRangeHeader.trim().split(/[\s-]+/)[1]);
-					if (!Number.isNaN(rangeStart) && rangeStart != offset) {
-						throw new Error(ERR_HTTP_RANGE);
-					}
-				}
-				checkResourceValidators(httpReader, response);
-				setResourceValidators(httpReader, response);
-				bodyReader = response.body.getReader();
+			start() {
+				return openWindow();
 			},
 			async pull(controller) {
+				if (!bodyReader) {
+					await openWindow();
+				}
 				const { value, done } = await bodyReader.read();
 				if (done) {
-					if (remainingLength) {
-						throw new Error(ERR_HTTP_RANGE);
-					}
-					controller.close();
-				} else {
-					const chunk = value.length > remainingLength ? value.subarray(0, remainingLength) : value;
-					remainingLength -= chunk.length;
-					if (chunk.length) {
-						controller.enqueue(chunk);
-					}
+					throw new Error(ERR_HTTP_RANGE);
+				}
+				const chunk = value.length > windowRemainingLength ? value.subarray(0, windowRemainingLength) : value;
+				windowRemainingLength -= chunk.length;
+				remainingLength -= chunk.length;
+				if (chunk.length) {
+					controller.enqueue(chunk);
+				}
+				if (!windowRemainingLength) {
+					await closeWindow();
 					if (!remainingLength) {
 						controller.close();
-						await bodyReader.cancel();
 					}
 				}
 			},
@@ -724,6 +719,32 @@
 				return bodyReader && bodyReader.cancel(reason);
 			}
 		});
+
+		async function openWindow() {
+			const windowLength = Math.min(httpReader.maximumRangeSize, remainingLength);
+			const response = await sendFetchRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, windowOffset, windowLength));
+			if (response.status != 206) {
+				throw new Error(ERR_HTTP_RANGE);
+			}
+			const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
+			if (contentRangeHeader) {
+				const rangeStart = Number(contentRangeHeader.trim().split(/[\s-]+/)[1]);
+				if (!Number.isNaN(rangeStart) && rangeStart != windowOffset) {
+					throw new Error(ERR_HTTP_RANGE);
+				}
+			}
+			checkResourceValidators(httpReader, response);
+			setResourceValidators(httpReader, response);
+			windowOffset += windowLength;
+			windowRemainingLength = windowLength;
+			bodyReader = response.body.getReader();
+		}
+
+		async function closeWindow() {
+			const currentBodyReader = bodyReader;
+			bodyReader = UNDEFINED_VALUE;
+			await currentBodyReader.cancel();
+		}
 	}
 
 	function getContentRangeSize(response) {
@@ -1150,6 +1171,61 @@
 		return reader.readUint8Array(offset, size);
 	}
 
+	/*
+	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+	 Redistribution and use in source and binary forms, with or without
+	 modification, are permitted provided that the following conditions are met:
+
+	 1. Redistributions of source code must retain the above copyright notice,
+	 this list of conditions and the following disclaimer.
+
+	 2. Redistributions in binary form must reproduce the above copyright
+	 notice, this list of conditions and the following disclaimer in
+	 the documentation and/or other materials provided with the distribution.
+
+	 3. The names of the authors may not be used to endorse or promote products
+	 derived from this software without specific prior written permission.
+
+	 THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+	 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+	 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+	 INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+	 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+	 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	 */
+
+	const ERR_INVALID_CODEC_MODULE = "Invalid codec module";
+
+	const registeredCodecs = new Map();
+	const codecStreams = new Map();
+
+	function getRegisteredCodec(compressionMethod) {
+		return registeredCodecs.get(compressionMethod);
+	}
+
+	function getCodecStreams(format) {
+		return codecStreams.get(format);
+	}
+
+	function setCodecStreams(format, streams) {
+		const { CompressionStream, DecompressionStream } = streams;
+		if (typeof CompressionStream != FUNCTION_TYPE && typeof DecompressionStream != FUNCTION_TYPE) {
+			throw new Error(ERR_INVALID_CODEC_MODULE);
+		}
+		codecStreams.set(format, { CompressionStream, DecompressionStream });
+	}
+
+	async function ensureCodecStreams(format, codecURI) {
+		if (!codecStreams.has(format) && codecURI) {
+			setCodecStreams(format, await import(codecURI));
+		}
+	}
+
 	/*
 	 Copyright (c) 2022 Gildas Lormeau. All rights reserved.
 
@@ -2642,6 +2718,7 @@
 
 	const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
 	const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
+	const ERR_UNSUPPORTED_COMPRESSION$2 = "Compression method not supported";
 	const FORMAT_DEFLATE_RAW = "deflate-raw";
 	const FORMAT_DEFLATE64_RAW = "deflate64-raw";
 	const FORMAT_GZIP = "gzip";
@@ -2652,18 +2729,21 @@
 
 		constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
 			super({});
-			const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level, deflate64 } = options;
+			const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level, deflate64, format } = options;
 			const stream = this;
 			let crc32Stream, encryptionStream, gzipCrc32Stream;
 			let readable = super.readable;
-			const useGzipCrc32 = signed && compressed && !deflate64 && (!encrypted || zipCrypto) &&
+			const codecStreams = format && getCodecStreams(format);
+			const useGzipCrc32 = signed && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) &&
 				Boolean(useCompressionStream && CompressionStream);
 			if ((!encrypted || zipCrypto) && signed && !useGzipCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
 			}
 			if (compressed) {
-				if (useGzipCrc32) {
+				if (codecStreams) {
+					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.CompressionStream, format, { level, chunkSize }));
+				} else if (useGzipCrc32) {
 					gzipCrc32Stream = new GzipToRawDeflateStream();
 					readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP));
 					readable = pipeThrough(readable, gzipCrc32Stream);
@@ -2737,7 +2817,7 @@
 
 		constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
 			super({});
-			const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream, deflate64 } = options;
+			const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream, deflate64, format } = options;
 			let crc32Stream, decryptionStream;
 			let readable = super.readable;
 			if (encrypted) {
@@ -2749,7 +2829,12 @@
 				}
 			}
 			if (compressed) {
-				readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib, DecompressionStream);
+				const codecStreams = format && getCodecStreams(format);
+				if (codecStreams) {
+					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize }));
+				} else {
+					readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib, DecompressionStream);
+				}
 				readable = mapInflateStreamError(readable);
 			}
 			if ((!encrypted || zipCrypto) && signed) {
@@ -2776,6 +2861,13 @@
 		});
 	}
 
+	function createCodecStream(CodecStreamClass, format, options) {
+		if (!CodecStreamClass) {
+			throw new Error(ERR_UNSUPPORTED_COMPRESSION$2);
+		}
+		return new CodecStreamClass(format, options);
+	}
+
 	function pipeThroughCommpressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib, CompressionStream) {
 		const Stream = useCompressionStream && CompressionStreamNative ? CompressionStreamNative : CompressionStreamZlib || CompressionStream;
 		const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
@@ -2969,7 +3061,7 @@
 		constructor(chunkSize) {
 			const pendingChunks = [];
 			let pendingLength = 0;
-			if (!(chunkSize >= 1)) {
+			if (!Number.isFinite(chunkSize) || chunkSize < 1) {
 				chunkSize = DEFAULT_CHUNK_SIZE;
 			}
 			super({
@@ -3520,11 +3612,18 @@
 
 	async function runWorker(stream, workerOptions) {
 		const { options, config } = workerOptions;
-		const { transferStreams, useWebWorkers, useCompressionStream, compressed, signed, encrypted } = options;
+		const { transferStreams, useWebWorkers, useCompressionStream, compressed, signed, encrypted, format, codecURI } = options;
 		const { workerURI, maxWorkers } = config;
+		if (format) {
+			if (codecURI) {
+				options.codecURI = resolveCodecURI(codecURI, config.baseURI);
+			}
+			await ensureCodecStreams(format, options.codecURI);
+		}
 		workerOptions.transferStreams = transferStreams || (transferStreams === UNDEFINED_VALUE && config.transferStreams);
 		const streamCopy = !compressed && !signed && !encrypted;
-		workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
+		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;
 		options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 		return (await getWorker()).run();
@@ -3564,6 +3663,14 @@
 		}
 	}
 
+	function resolveCodecURI(codecURI, baseURI) {
+		try {
+			return new URL(codecURI, baseURI).toString();
+		} catch {
+			return codecURI;
+		}
+	}
+
 	function armStarvationTimeout() {
 		if (!starvationTimeout && pendingRequests.length && Number.isFinite(starvationDelay) && starvationDelay >= 0) {
 			starvationTimeout = setTimeout(onWorkerStarvation, starvationDelay);
@@ -3882,6 +3989,7 @@
 	const OPTION_PREVENT_CLOSE = "preventClose";
 	const OPTION_ENCRYPTION_STRENGTH = "encryptionStrength";
 	const OPTION_EXTENDED_TIMESTAMP = "extendedTimestamp";
+	const OPTION_NTFS_TIMESTAMP = "ntfsTimestamp";
 	const OPTION_KEEP_ORDER = "keepOrder";
 	const OPTION_LEVEL = "level";
 	const OPTION_BUFFERED_WRITE = "bufferedWrite";
@@ -4313,7 +4421,8 @@
 					throw new Error(ERR_UNSUPPORTED_COMPRESSION$1);
 				}
 			}
-			if ((compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64) && !passThrough) {
+			const registeredCodec = passThrough ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
+			if ((compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64 && !registeredCodec) && !passThrough) {
 				throw new Error(ERR_UNSUPPORTED_COMPRESSION$1);
 			}
 			if (dataArray.length < HEADER_SIZE || getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
@@ -4352,7 +4461,7 @@
 				fileEntry.zipCrypto = zipCrypto;
 			}
 			if (encrypted) {
-				if (!zipCrypto && extraFieldAES.strength === UNDEFINED_VALUE) {
+				if (!zipCrypto && (extraFieldAES.strength < 1 || extraFieldAES.strength > 3)) {
 					throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
 				} else if (!password && !rawPassword) {
 					throw new Error(ERR_ENCRYPTED);
@@ -4391,6 +4500,8 @@
 					useCompressionStream,
 					transferStreams: getOptionValue$1(zipEntry, options, OPTION_TRANSFER_STREAMS),
 					deflate64,
+					format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
+					codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
 					checkPasswordOnly
 				},
 				config,
@@ -5007,6 +5118,7 @@
 	const ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
 	const ERR_INVALID_VERSION = "Version exceeds 65535";
 	const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
+	const ERR_UNSUPPORTED_ENCRYPTION_USDZ = "Encryption is not supported in USDZ files";
 	const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 	const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
 	const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
@@ -5409,6 +5521,7 @@
 		const encryptionStrength = getOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 		const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
 		const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
+		const ntfsTimestamp = getOptionValue(zipWriter, options, OPTION_NTFS_TIMESTAMP);
 		const keepOrder = getOptionValue(zipWriter, options, OPTION_KEEP_ORDER, true);
 		const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
 		const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS);
@@ -5418,11 +5531,20 @@
 		const signal = getOptionValue(zipWriter, options, OPTION_SIGNAL);
 		const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
 		const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
+		const registeredCodec = passThrough || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
 		if (!passThrough && compressionMethod !== UNDEFINED_VALUE &&
-			compressionMethod !== COMPRESSION_METHOD_STORE && compressionMethod !== COMPRESSION_METHOD_DEFLATE) {
+			compressionMethod !== COMPRESSION_METHOD_STORE && compressionMethod !== COMPRESSION_METHOD_DEFLATE && !registeredCodec) {
 			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
 		let level = getOptionValue(zipWriter, options, OPTION_LEVEL);
+		if (zipWriter.options[OPTION_USDZ]) {
+			if (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) {
+				throw new Error(ERR_UNSUPPORTED_ENCRYPTION_USDZ);
+			}
+			if (level === UNDEFINED_VALUE && compressionMethod === UNDEFINED_VALUE) {
+				level = 0;
+			}
+		}
 		let useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
 		let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
 		if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
@@ -5434,7 +5556,7 @@
 		if (level !== UNDEFINED_VALUE && level != 6) {
 			useCompressionStream = false;
 		}
-		if (!useCompressionStream && (zipWriter.config.CompressionStream === UNDEFINED_VALUE && zipWriter.config.CompressionStreamZlib === UNDEFINED_VALUE)) {
+		if (!useCompressionStream && !registeredCodec && (zipWriter.config.CompressionStream === UNDEFINED_VALUE && zipWriter.config.CompressionStreamZlib === UNDEFINED_VALUE)) {
 			level = 0;
 		}
 		const zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
@@ -5478,6 +5600,7 @@
 				encryptionStrength,
 				zipCrypto,
 				extendedTimestamp,
+				ntfsTimestamp,
 				keepOrder,
 				useWebWorkers,
 				transferStreams,
@@ -5487,6 +5610,9 @@
 				signal,
 				useUnicodeFileNames,
 				compressionMethod,
+				format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
+				codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
+				codecVersionNeeded: registeredCodec ? registeredCodec.versionNeeded : UNDEFINED_VALUE,
 				level,
 				useCompressionStream,
 				dataDescriptor,
@@ -5783,7 +5909,9 @@
 			msdosAttributesRaw,
 			msdosAttributes,
 			useCompressionStream,
-			passThrough
+			passThrough,
+			format,
+			codecURI
 		} = options;
 		const fileEntry = {
 			lock,
@@ -5843,7 +5971,9 @@
 					encrypted: encrypted && !passThrough,
 					useWebWorkers,
 					useCompressionStream,
-					transferStreams
+					transferStreams,
+					format,
+					codecURI
 				},
 				config,
 				streamOptions: { signal, size, onstart, onprogress, onend }
@@ -5915,6 +6045,7 @@
 			rawExtraField,
 			encryptionStrength,
 			extendedTimestamp,
+			ntfsTimestamp,
 			passThrough,
 			encrypted,
 			zip64UncompressedSize,
@@ -5960,7 +6091,8 @@
 		let extraFieldExtendedTimestampFlag;
 		if (extendedTimestamp) {
 			const lastModTimeUnix = getTimeUnix(lastModDate);
-			if (inUnixTimeRange(lastModTimeUnix)) {
+			const lastModTimeUnixInRange = inUnixTimeRange(lastModTimeUnix);
+			if (lastModTimeUnixInRange) {
 				const extraFieldTimestampLength = 9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0);
 				const extraFieldTimestamp = createRecordWriter(extraFieldTimestampLength);
 				extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
@@ -5978,19 +6110,26 @@
 			} else {
 				rawExtraFieldExtendedTimestamp = EMPTY_UINT8_ARRAY;
 			}
-			try {
-				const lastModTimeNTFS = getTimeNTFS(lastModDate);
-				const extraFieldNTFS = createRecordWriter(36);
-				extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS);
-				extraFieldNTFS.uint16(32);
-				extraFieldNTFS.skip(4);
-				extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS_TAG1);
-				extraFieldNTFS.uint16(24);
-				extraFieldNTFS.uint64(lastModTimeNTFS);
-				extraFieldNTFS.uint64(getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
-				extraFieldNTFS.uint64(getTimeNTFS(creationDate) || lastModTimeNTFS);
-				rawExtraFieldNTFS = extraFieldNTFS.array;
-			} catch {
+			const writeExtraFieldNTFS = ntfsTimestamp === UNDEFINED_VALUE ?
+				!lastModTimeUnixInRange || Boolean(lastAccessDate || creationDate) :
+				ntfsTimestamp;
+			if (writeExtraFieldNTFS) {
+				try {
+					const lastModTimeNTFS = getTimeNTFS(lastModDate);
+					const extraFieldNTFS = createRecordWriter(36);
+					extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS);
+					extraFieldNTFS.uint16(32);
+					extraFieldNTFS.skip(4);
+					extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS_TAG1);
+					extraFieldNTFS.uint16(24);
+					extraFieldNTFS.uint64(lastModTimeNTFS);
+					extraFieldNTFS.uint64(getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
+					extraFieldNTFS.uint64(getTimeNTFS(creationDate) || lastModTimeNTFS);
+					rawExtraFieldNTFS = extraFieldNTFS.array;
+				} catch {
+					rawExtraFieldNTFS = EMPTY_UINT8_ARRAY;
+				}
+			} else {
 				rawExtraFieldNTFS = EMPTY_UINT8_ARRAY;
 			}
 		} else {
@@ -6028,6 +6167,10 @@
 		if (compressionMethod === UNDEFINED_VALUE) {
 			compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
 		}
+		const { codecVersionNeeded } = options;
+		if (compressed && codecVersionNeeded !== UNDEFINED_VALUE) {
+			version = version > codecVersionNeeded ? version : codecVersionNeeded;
+		}
 		if (zip64) {
 			version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
 		}