@zip.js/zip.js 2.18.1 → 2.19.0

package/dist/zip-fs-core-external.js

@@ -176,7 +176,6 @@ 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";
 const OPTION_PREVENT_CLOSE = "preventClose";
 const OPTION_ENCRYPTION_STRENGTH = "encryptionStrength";
 const OPTION_EXTENDED_TIMESTAMP = "extendedTimestamp";
@@ -294,7 +293,7 @@ function toNumber(value) {
  */
 
 
-const DEFAULT_CHUNK_SIZE$1 = 64 * 1024;
+const DEFAULT_CHUNK_SIZE$1 = 256 * 1024;
 const MINIMUM_CHUNK_SIZE = 64;
 const MINIMUM_PROPERTY_VALUE = 1;
 const ERR_INVALID_MAX_WORKERS = "Invalid maxWorkers (must be an integer greater than 0)";
@@ -2423,7 +2422,7 @@ function mapInflateStreamError(readable, sourceErrors) {
  */
 
 
-const DEFAULT_CHUNK_SIZE = 64 * 1024;
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
 const MESSAGE_EVENT_TYPE = "message";
 const MESSAGE_START = "start";
 const MESSAGE_PULL = "pull";
@@ -2633,7 +2632,7 @@ function disableWebWorker(workerData) {
 class CodecWorker {
 
 	constructor(workerData, { readable, writable }, workerOptions, onTaskFinished) {
-		const { options, config, streamOptions, useWebWorkers, transferStreams, workerURI } = workerOptions;
+		const { options, config, streamOptions, useWebWorkers, workerURI } = workerOptions;
 		let { createWorker } = workerOptions;
 		const { signal } = streamOptions;
 		if (createWorkerFailed) {
@@ -2650,7 +2649,6 @@ class CodecWorker {
 			workerOptions,
 			workerURI,
 			createWorker,
-			transferStreams,
 			terminate() {
 				return new Promise(resolve => {
 					const { worker, busy } = workerData;
@@ -2828,12 +2826,6 @@ const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
 const ABORT_EVENT_TYPE = "abort";
 
 let webWorkerSource, webWorkerURI, webWorkerOptions;
-let transferStreamsSupported = true;
-try {
-	transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
-} catch {
-	// ignored
-}
 
 setWebWorkerBackend(createWebWorkerInterface);
 
@@ -2920,14 +2912,11 @@ async function runWebWorker(workerData, config) {
 	});
 	const { readable, options } = workerData;
 	const { writable, closed, abortPipe } = watchClosedStream(workerData.writable, workerData);
-	let streamsTransferred;
 	try {
-		streamsTransferred = sendMessage({
+		sendMessage({
 			type: MESSAGE_START,
 			options,
-			config,
-			readable,
-			writable
+			config
 		}, workerData);
 	} catch (error) {
 		abortPipe();
@@ -2939,12 +2928,10 @@ async function runWebWorker(workerData, config) {
 		workerData.onTaskFinished();
 		throw error;
 	}
-	if (!streamsTransferred) {
-		Object.assign(workerData, {
-			reader: readable.getReader(),
-			writer: writable.getWriter()
-		});
-	}
+	Object.assign(workerData, {
+		reader: readable.getReader(),
+		writer: writable.getWriter()
+	});
 	const { workerStartupTimeout } = config;
 	if (!workerData.workerAlive && Number.isFinite(workerStartupTimeout) && workerStartupTimeout >= 0) {
 		workerData.startupTimeout = setTimeout(() => onStartupTimeout(workerData), workerStartupTimeout);
@@ -2977,7 +2964,7 @@ async function runWebWorker(workerData, config) {
 	}
 
 	async function closeWritable() {
-		if (!streamsTransferred && !writable.locked) {
+		if (!writable.locked) {
 			try {
 				await writable.getWriter().close();
 			} catch {
@@ -3168,31 +3155,14 @@ function onWorkerError(event, workerData) {
 	}
 }
 
-function sendMessage(message, { worker, writer, transferStreams, workerAlive }) {
+function sendMessage(message, { worker, writer }) {
 	try {
-		const { value, readable, writable } = message;
-		const transferables = [];
+		const { value } = message;
 		if (value) {
 			message.value = toExactUint8Array(value);
-			transferables.push(message.value.buffer);
-		}
-		if (transferStreams && transferStreamsSupported && workerAlive) {
-			if (readable) {
-				transferables.push(readable);
-			}
-			if (writable) {
-				transferables.push(writable);
-			}
-		} else {
-			message.readable = message.writable = null;
-		}
-		if (transferables.length) {
 			try {
-				worker.postMessage(message, transferables);
-				return true;
+				worker.postMessage(message, [message.value.buffer]);
 			} catch {
-				transferStreamsSupported = false;
-				message.readable = message.writable = null;
 				worker.postMessage(message);
 			}
 		} else {
@@ -3341,7 +3311,7 @@ let indexWorker = 0;
 
 async function runWorker(stream, workerOptions) {
 	const { options, config } = workerOptions;
-	const { transferStreams, useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
+	const { useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
 	const { workerURI, createWorker, maxWorkers } = config;
 	if (format) {
 		if (codecURI) {
@@ -3349,7 +3319,6 @@ async function runWorker(stream, workerOptions) {
 		}
 		await ensureCodecStreams(format, options.codecURI);
 	}
-	workerOptions.transferStreams = !format && (transferStreams || (transferStreams === UNDEFINED_VALUE && config.transferStreams));
 	const streamCopy = !compressed && !checkCrc32 && !computeCrc32 && !encrypted;
 	const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
 	workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
@@ -5151,17 +5120,6 @@ class ZipReader {
 			if (filename === UNDEFINED_VALUE) {
 				filename = decodeText(rawFilename, rawFilenameEncoding);
 			}
-			if (normalizeFilename) {
-				const normalizedFilename = normalizeFilename(filename);
-				if (normalizedFilename !== UNDEFINED_VALUE) {
-					filename = normalizedFilename;
-				}
-			}
-			if (isUnsafeFilename(filename, filenameValidation)) {
-				const error = new Error(ERR_UNSAFE_FILENAME);
-				error.filename = filename;
-				throw error;
-			}
 			let comment = decode(rawComment, rawCommentEncoding, TEXT_TYPE_COMMENT);
 			if (comment === UNDEFINED_VALUE) {
 				comment = decodeText(rawComment, rawCommentEncoding);
@@ -5189,7 +5147,20 @@ class ZipReader {
 				filename,
 				comment
 			});
-			if (readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6)) {
+			const malformedExtraField = readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+			filename = fileEntry.filename;
+			if (normalizeFilename) {
+				const normalizedFilename = normalizeFilename(filename);
+				if (normalizedFilename !== UNDEFINED_VALUE) {
+					filename = fileEntry.filename = normalizedFilename;
+				}
+			}
+			if (isUnsafeFilename(filename, filenameValidation)) {
+				const error = new Error(ERR_UNSAFE_FILENAME);
+				error.filename = filename;
+				throw error;
+			}
+			if (malformedExtraField) {
 				addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD, filename);
 			}
 			fileEntry.offset += prependedDataLength;
@@ -5593,7 +5564,6 @@ let ZipEntry$1 = class ZipEntry {
 				encrypted,
 				useWebWorkers: getOptionValue$1(zipEntry, options, OPTION_USE_WEB_WORKERS),
 				useCompressionStream,
-				transferStreams: getOptionValue$1(zipEntry, options, OPTION_TRANSFER_STREAMS),
 				deflate64,
 				format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
 				codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
@@ -5823,19 +5793,17 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		readExtraFieldNTFS(extraFieldNTFS, directory);
 		directory.extraFieldNTFS = extraFieldNTFS;
 	}
-	const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+	const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
 	let unixIdsRead;
+	if (extraFieldInfoZip) {
+		unixIdsRead = readExtraFieldUnix(extraFieldInfoZip, directory, true);
+		directory.extraFieldInfoZip = extraFieldInfoZip;
+	}
+	const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
 	if (extraFieldUnix) {
-		unixIdsRead = readExtraFieldUnix(extraFieldUnix, directory, false);
+		readExtraFieldUnix(extraFieldUnix, unixIdsRead ? {} : directory, false);
 		directory.extraFieldUnix = extraFieldUnix;
 	}
-	if (!unixIdsRead) {
-		const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
-		if (extraFieldInfoZip) {
-			readExtraFieldUnix(extraFieldInfoZip, directory, true);
-			directory.extraFieldInfoZip = extraFieldInfoZip;
-		}
-	}
 	const extraFieldExtendedTimestamp = extraField.get(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
 	if (extraFieldExtendedTimestamp) {
 		readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory, localDirectory);
@@ -6061,19 +6029,11 @@ async function detectOverlappingEntry({
 		const zip64 = Boolean(extraFieldZip64);
 		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
 		const dataDescriptorView = getDataView(dataDescriptorArray);
-		const ignoreCrc32 = fileEntry.encrypted && !fileEntry.zipCrypto;
-		let localDataDescriptor;
-		for (const [zip64Layout, signature] of [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]]) {
-			const candidate = readDataDescriptor(dataDescriptorView, zip64Layout, signature);
-			if (candidate && (ignoreCrc32 || candidate.crc32 == crc32) &&
-				candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize) {
-				localDataDescriptor = candidate;
-				break;
-			}
-		}
-		if (!localDataDescriptor) {
-			localDataDescriptor = readDataDescriptor(dataDescriptorView, zip64, false);
-		}
+		const candidates = [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]]
+			.map(([zip64Layout, signature]) => readDataDescriptor(dataDescriptorView, zip64Layout, signature))
+			.filter(candidate => candidate && candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize);
+		const localDataDescriptor = candidates.find(candidate => candidate.crc32 == crc32) || candidates[0] ||
+			readDataDescriptor(dataDescriptorView, zip64, true) || readDataDescriptor(dataDescriptorView, zip64, false);
 		if (localDataDescriptor) {
 			fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
 			dataDescriptorLength = getDataDescriptorLength(localDataDescriptor.zip64, localDataDescriptor.signature);
@@ -6730,6 +6690,7 @@ class ZipWriter {
 					rawExtraFieldExtendedTimestamp: EMPTY_UINT8_ARRAY,
 					rawExtraFieldNTFS: EMPTY_UINT8_ARRAY,
 					rawExtraFieldUnix: EMPTY_UINT8_ARRAY,
+					rawCentralExtraFieldUnix: EMPTY_UINT8_ARRAY,
 					rawExtraField,
 					rawCentralExtraField: EMPTY_UINT8_ARRAY,
 					headerArray,
@@ -7298,7 +7259,6 @@ function resolveMetadata(zipWriter, name, options) {
 	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);
 	const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
 	const createTempStream = getFunctionOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
@@ -7364,7 +7324,6 @@ function resolveMetadata(zipWriter, name, options) {
 			ntfsTimestamp,
 			keepOrder,
 			useWebWorkers,
-			transferStreams,
 			bufferedWrite,
 			createTempStream,
 			dataDescriptorSignature,
@@ -7423,7 +7382,7 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	if (reader) {
 		reader = new GenericReader(reader);
 		await initStream(reader);
-		if (!reader.readable && !reader.readUint8Array) {
+		if (!reader.readUint8Array && !reader.readable) {
 			throw new Error(ERR_INVALID_READER);
 		}
 		({ size: contentSize } = reader);
@@ -7784,6 +7743,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		extraFieldExtendedTimestampTime,
 		rawExtraFieldNTFS,
 		rawExtraFieldUnix,
+		rawCentralExtraFieldUnix,
 		rawExtraFieldAES,
 	} = headerInfo;
 	const { dataDescriptorArray } = dataDescriptorInfo;
@@ -7808,7 +7768,6 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		rawExtraField,
 		rawCentralExtraField,
 		useWebWorkers,
-		transferStreams,
 		onstart,
 		onprogress,
 		onend,
@@ -7850,6 +7809,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldUnix,
+		rawCentralExtraFieldUnix,
 		rawExtraFieldAES,
 		rawExtraField,
 		rawCentralExtraField,
@@ -7896,7 +7856,6 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 				encrypted: encrypted && !passThroughEncryption,
 				useWebWorkers,
 				useCompressionStream,
-				transferStreams,
 				format,
 				codecURI,
 				compressionMethod
@@ -8074,6 +8033,7 @@ function getHeaderInfo(options) {
 		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = EMPTY_UINT8_ARRAY;
 	}
 	let rawExtraFieldUnix;
+	let rawCentralExtraFieldUnix;
 	try {
 		const { uid, gid, unixExtraFieldType } = options;
 		if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
@@ -8088,7 +8048,7 @@ function getHeaderInfo(options) {
 			extraFieldUnix.writeBytes(uidBytes);
 			extraFieldUnix.writeUint8(gidBytes.length);
 			extraFieldUnix.writeBytes(gidBytes);
-			rawExtraFieldUnix = extraFieldUnix.array;
+			rawExtraFieldUnix = rawCentralExtraFieldUnix = extraFieldUnix.array;
 		} else if (unixExtraFieldType == UNIX_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
 			const extraFieldUnix = createRecordWriter(8);
 			extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_UNIX);
@@ -8096,11 +8056,15 @@ function getHeaderInfo(options) {
 			extraFieldUnix.writeUint16((uid === UNDEFINED_VALUE ? 0 : uid) & MAX_16_BITS);
 			extraFieldUnix.writeUint16((gid === UNDEFINED_VALUE ? 0 : gid) & MAX_16_BITS);
 			rawExtraFieldUnix = extraFieldUnix.array;
+			const centralExtraFieldUnix = createRecordWriter(4);
+			centralExtraFieldUnix.writeUint16(EXTRAFIELD_TYPE_UNIX);
+			centralExtraFieldUnix.writeUint16(0);
+			rawCentralExtraFieldUnix = centralExtraFieldUnix.array;
 		} else {
-			rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
+			rawExtraFieldUnix = rawCentralExtraFieldUnix = EMPTY_UINT8_ARRAY;
 		}
 	} catch {
-		rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
+		rawExtraFieldUnix = rawCentralExtraFieldUnix = EMPTY_UINT8_ARRAY;
 	}
 	if (compressionMethod === UNDEFINED_VALUE) {
 		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
@@ -8192,6 +8156,7 @@ function getHeaderInfo(options) {
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldUnix,
+		rawCentralExtraFieldUnix,
 		rawExtraFieldAES,
 		extraFieldLength
 	};
@@ -8367,7 +8332,7 @@ function createDirectoryRecords(files) {
 			rawExtraFieldAES,
 			rawComment,
 			rawExtraFieldNTFS,
-			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraField,
 			rawCentralExtraField,
 			extraFieldExtendedTimestampFlag,
@@ -8429,7 +8394,7 @@ function createDirectoryRecords(files) {
 			rawExtraFieldZip64,
 			rawExtraFieldAES,
 			rawExtraFieldNTFS,
-			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraFieldTimestamp,
 			rawExtraField,
 			rawCentralExtraField);
@@ -8458,7 +8423,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			rawExtraFieldAES,
 			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
-			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraField,
 			rawCentralExtraField,
 			rawComment,
@@ -8475,7 +8440,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
-		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField, rawCentralExtraField);
+		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawCentralExtraFieldUnix, rawExtraField, rawCentralExtraField);
 		const directoryRecordLength = CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
 		if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
@@ -8511,7 +8476,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		directoryRecord.writeBytes(rawExtraFieldAES);
 		directoryRecord.writeBytes(rawExtraFieldExtendedTimestamp);
 		directoryRecord.writeBytes(rawExtraFieldNTFS);
-		directoryRecord.writeBytes(rawExtraFieldUnix);
+		directoryRecord.writeBytes(rawCentralExtraFieldUnix);
 		directoryRecord.writeBytes(rawExtraField);
 		directoryRecord.writeBytes(rawCentralExtraField);
 		directoryRecord.writeBytes(rawComment);
@@ -9088,7 +9053,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.18.1";
+const VERSION = "2.19.0";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.