@zip.js/zip.js 2.11.2 → 2.11.4

package/dist/zip-fs-native.js

@@ -4,7 +4,7 @@
 	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.zip = {}));
 })(this, (function (exports) { 'use strict';
 
-	const { Array, Object, String, Number, BigInt, Math, Date, Map, Set, Response, URL, Error, Uint8Array, Uint16Array, Uint32Array, DataView, Blob, Promise, TextEncoder, TextDecoder, document, crypto, btoa, TransformStream, ReadableStream, WritableStream, CompressionStream, DecompressionStream, navigator, Worker, Symbol, setTimeout, clearTimeout, structuredClone } = typeof globalThis !== 'undefined' ? globalThis : this || self;
+	const { Array, Object, String, Number, BigInt, Math, Date, Map, Set, Response, URL, Error, Uint8Array, Uint16Array, Uint32Array, DataView, Blob, Promise, TextEncoder, TextDecoder, document, crypto, btoa, TransformStream, ReadableStream, WritableStream, CompressionStream, DecompressionStream, navigator, Worker, Symbol, setTimeout, clearTimeout, structuredClone } = typeof globalThis !== 'undefined' ? globalThis : self;
 
 	var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 	/*
@@ -217,6 +217,8 @@
 	const ERR_INVALID_FUNCTION_OPTION = "Invalid option (must be a function)";
 	const ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
 	const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
+	const ERR_ABORTED = "The operation was aborted";
+	const ABORT_ERROR_NAME = "AbortError";
 
 	function checkFunctionOption(value) {
 		if (value && typeof value != FUNCTION_TYPE) {
@@ -232,6 +234,12 @@
 		return signal || UNDEFINED_VALUE;
 	}
 
+	function throwIfAborted(signal) {
+		if (signal && signal.aborted) {
+			throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME) : signal.reason;
+		}
+	}
+
 	function checkPasswordOption(password, rawPassword) {
 		if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
 			throw new Error(ERR_INVALID_PASSWORD_TYPE);
@@ -3756,11 +3764,13 @@
 			const reader = this;
 			const { sourceBlob, size } = reader;
 			const { offset = 0, size: readSize = size - offset } = options || {};
-			if (!offset && readSize >= size) {
-				return toCompatibleReadable(sourceBlob.stream());
-			}
-			if (blobSliceReliable) {
-				return toCompatibleReadable(sourceBlob.slice(offset, offset + readSize).stream());
+			if (typeof sourceBlob.stream == FUNCTION_TYPE) {
+				if (!offset && readSize >= size) {
+					return toCompatibleReadable(sourceBlob.stream());
+				}
+				if (blobSliceReliable) {
+					return toCompatibleReadable(sourceBlob.slice(offset, offset + readSize).stream());
+				}
 			}
 			return super.createReadable(options);
 		}
@@ -5196,27 +5206,28 @@
 					const { done, value } = await gen.next();
 					if (done)
 						return controller.close();
-					const chunk = {
-						...value,
-						readable: (function () {
-							const { readable, writable } = new TransformStream();
-							if (value.getData) {
-								getData();
-								return readable;
-							}
+					const entryReadable = (function () {
+						const { readable, writable } = new TransformStream();
+						if (value.getData) {
+							getData();
+							return readable;
+						}
 
-							async function getData() {
+						async function getData() {
+							try {
+								await value.getData(writable);
+							} catch (error) {
 								try {
-									await value.getData(writable);
-								} catch (error) {
-									try {
-										await writable.abort(error);
-									} catch {
-										// ignored
-									}
+									await writable.abort(error);
+								} catch {
+									// ignored
 								}
 							}
-						})()
+						}
+					})();
+					const chunk = {
+						...value,
+						readable: entryReadable
 					};
 					delete chunk.getData;
 					controller.enqueue(chunk);
@@ -5362,6 +5373,7 @@
 			const size = compressedSize;
 			const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 			const signal = checkSignalOption(getOptionValue$1(zipEntry, options, OPTION_SIGNAL));
+			throwIfAborted(signal);
 			const checkPasswordOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 			let checkOverlappingEntry = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
 			const checkOverlappingEntryOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY_ONLY);
@@ -6268,6 +6280,7 @@
 	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_UNSUPPORTED_SPLIT_USDZ = "Split zip files are not supported in USDZ files";
 	const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set";
 	const ERR_INVALID_EXTRAFIELD = "Invalid extra field (must be a Map)";
 	const ERR_INVALID_EXTRAFIELD_TYPE = "Invalid extra field type (must be integer 0..65535)";
@@ -6282,6 +6295,7 @@
 	const ERR_UNDEFINED_COMPRESSION_METHOD = "Undefined compression method";
 	const ERR_UNDETERMINED_SIZE = "Undetermined size";
 	const ERR_UNDEFINED_READER = "Undefined reader";
+	const ERR_INVALID_READER = "Invalid reader (must be a Reader instance, a ReadableStream instance, or an object with a 'readable' property)";
 	const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
 	const ERR_INVALID_UID = "Invalid uid (must be integer 0..2^32-1)";
 	const ERR_INVALID_GID = "Invalid gid (must be integer 0..2^32-1)";
@@ -6313,6 +6327,9 @@
 			const addSplitZipSignature =
 				availableSize > 0 && availableSize !== INFINITY_VALUE &&
 				maxSize > 0 && maxSize !== INFINITY_VALUE;
+			if (addSplitZipSignature && options[OPTION_USDZ]) {
+				throw new Error(ERR_UNSUPPORTED_SPLIT_USDZ);
+			}
 			Object.assign(this, {
 				writer,
 				addSplitZipSignature,
@@ -6428,6 +6445,7 @@
 					}
 					const { offset, diskNumberStart } = entryPositions.get(entry);
 					Object.assign(entry, {
+						zip64Enabled: true,
 						zip64UncompressedSize,
 						zip64CompressedSize,
 						offset,
@@ -6886,6 +6904,7 @@
 		const createTempStream = getFunctionOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 		const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
 		const signal = checkSignalOption(getOptionValue(zipWriter, options, OPTION_SIGNAL));
+		throwIfAborted(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);
@@ -7003,6 +7022,9 @@
 		if (reader) {
 			reader = new GenericReader(reader);
 			await initStream(reader);
+			if (!reader.readable && !reader.readUint8Array) {
+				throw new Error(ERR_INVALID_READER);
+			}
 			({ size: contentSize } = reader);
 		}
 		return Object.assign({ reader }, resolveEntrySizes(zipWriter, Boolean(reader), contentSize, metadata, options));
@@ -7013,6 +7035,7 @@
 		let { dataDescriptor, zip64, level, compressionMethod } = metadata;
 		let maximumCompressedSize = 0;
 		let uncompressedSize = 0;
+		let unknownSize = false;
 		if (passThrough && hasContent) {
 			uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 			if (uncompressedSize === UNDEFINED_VALUE) {
@@ -7038,8 +7061,8 @@
 				if (contentSize === UNDEFINED_VALUE) {
 					dataDescriptor = true;
 					if (zip64 || zip64 === UNDEFINED_VALUE) {
-						zip64 = true;
-						uncompressedSize = maximumCompressedSize = MAX_32_BITS + 1;
+						zip64 = unknownSize = true;
+						maximumCompressedSize = MAX_32_BITS + 1;
 					}
 				} else {
 					options.uncompressedSize = uncompressedSize = contentSize;
@@ -7054,7 +7077,7 @@
 		if (emptyEntry && !zipCrypto && getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR) === UNDEFINED_VALUE) {
 			dataDescriptor = false;
 		}
-		const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
+		const zip64UncompressedSize = zip64Enabled || unknownSize || uncompressedSize >= MAX_32_BITS;
 		const zip64CompressedSize = zip64Enabled || maximumCompressedSize >= MAX_32_BITS;
 		if (zip64UncompressedSize || zip64CompressedSize) {
 			if (zip64 === false) {
@@ -7070,6 +7093,8 @@
 				dataDescriptor,
 				emptyEntry,
 				zip64,
+				zip64Enabled,
+				unknownSize,
 				zip64UncompressedSize,
 				zip64CompressedSize,
 				uncompressedSize,
@@ -7143,7 +7168,7 @@
 		if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 			throw new Error(ERR_UNDETERMINED_SIZE);
 		}
-		const directoryDataLength = createDirectoryRecords(files);
+		const { directoryDataLength, zip64Entries } = createDirectoryRecords(files);
 		let zip64 = getOptionValue(zipWriter, writerOptions, PROPERTY_NAME_ZIP64);
 		if (offset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || files.size >= MAX_16_BITS) {
 			if (zip64 === false) {
@@ -7151,6 +7176,8 @@
 			} else {
 				zip64 = true;
 			}
+		} else if (zip64 === UNDEFINED_VALUE && zip64Entries) {
+			zip64 = true;
 		}
 		return offset - initialOffset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 	}
@@ -7343,6 +7370,7 @@
 			rawPassword,
 			level,
 			zip64,
+			zip64Enabled,
 			zip64UncompressedSize,
 			zip64CompressedSize,
 			zipCrypto,
@@ -7383,6 +7411,7 @@
 			lockFileEntry,
 			versionMadeBy,
 			zip64,
+			zip64Enabled,
 			directory: Boolean(directory),
 			executable: Boolean(executable),
 			filenameUTF8: true,
@@ -7526,13 +7555,14 @@
 			zip64UncompressedSize,
 			zip64CompressedSize,
 			uncompressedSize,
+			unknownSize,
 			crc32
 		} = options;
 		let { version, compressionMethod } = options;
 		const compressed = !directory && isCompressed(compressionMethod, level);
 		let rawLocalExtraFieldZip64;
 		const uncompressedFile = passThrough || !compressed;
-		const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
+		const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || (uncompressedFile && !unknownSize)));
 		const writeLocalExtraFieldZip64 = zip64ExtraFieldComplete || (zip64 && dataDescriptor && (zip64UncompressedSize || zip64CompressedSize));
 		if (zip64 && (zip64UncompressedSize || zip64CompressedSize)) {
 			const length = 4 + 16;
@@ -7666,6 +7696,10 @@
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 		}
 		const dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
+		const clampedLastModDate = dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate;
+		const storedLastModDate = getLength(rawExtraFieldExtendedTimestamp) ?
+			new Date(getTimeUnix(lastModDate) * 1000) :
+			getLength(rawExtraFieldNTFS) ? lastModDate : clampedLastModDate;
 		const {
 			headerArray,
 			headerView,
@@ -7675,7 +7709,7 @@
 			bitFlag: getBitFlag(level, useUnicodeFileNames, dataDescriptor, encrypted, compressionMethod),
 			compressionMethod,
 			uncompressedSize,
-			lastModDate: dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate,
+			lastModDate: clampedLastModDate,
 			rawLastModDate: rawLastModDateOption,
 			rawFilename,
 			zip64CompressedSize,
@@ -7710,7 +7744,7 @@
 			localHeaderView,
 			headerArray,
 			headerView,
-			lastModDate,
+			lastModDate: storedLastModDate,
 			rawLastModDate,
 			encrypted,
 			compressed,
@@ -7882,14 +7916,15 @@
 
 
 	async function closeFile(zipWriter, comment, options) {
-		const directoryDataLength = createDirectoryRecords(zipWriter.fileEntries);
+		const { directoryDataLength, zip64Entries } = createDirectoryRecords(zipWriter.fileEntries);
 		const { directoryStart, directoryEnd, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
 		const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
-		await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryEnd, directoryDataLength, signatureLength });
+		await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryEnd, directoryDataLength, signatureLength, zip64Entries });
 	}
 
 	function createDirectoryRecords(files) {
 		let directoryDataLength = 0;
+		let zip64Entries = false;
 		for (const [, fileEntry] of files) {
 			const {
 				rawFilename,
@@ -7902,11 +7937,20 @@
 				extendedTimestamp,
 				extraFieldExtendedTimestampFlag,
 				lastModDate,
-				zip64UncompressedSize,
-				zip64CompressedSize,
+				zip64Enabled,
 				uncompressedSize,
 				compressedSize
 			} = fileEntry;
+			let { zip64UncompressedSize, zip64CompressedSize } = fileEntry;
+			if (!zip64Enabled) {
+				if (zip64UncompressedSize && uncompressedSize < MAX_32_BITS) {
+					zip64UncompressedSize = fileEntry.zip64UncompressedSize = false;
+				}
+				if (zip64CompressedSize && compressedSize < MAX_32_BITS) {
+					zip64CompressedSize = fileEntry.zip64CompressedSize = false;
+				}
+			}
+			zip64Entries = zip64Entries || zip64UncompressedSize || zip64CompressedSize;
 			const zip64Offset = fileEntry.offset >= MAX_32_BITS;
 			const zip64DiskNumberStart = fileEntry.diskNumberStart >= MAX_16_BITS;
 			let rawExtraFieldZip64;
@@ -7960,7 +8004,7 @@
 			}
 			directoryDataLength += CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
 		}
-		return directoryDataLength;
+		return { directoryDataLength, zip64Entries };
 	}
 
 	async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
@@ -8080,7 +8124,7 @@
 
 	async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		const { writer } = zipWriter;
-		const { directoryStart, directoryEnd, signatureLength } = cdInfo;
+		const { directoryStart, directoryEnd, signatureLength, zip64Entries } = cdInfo;
 		let { directoryDataLength } = cdInfo;
 		let fileEntriesLength = zipWriter.fileEntries.size;
 		let diskNumber = directoryStart.diskNumber;
@@ -8100,6 +8144,8 @@
 			} else {
 				zip64 = true;
 			}
+		} else if (zip64 === UNDEFINED_VALUE && zip64Entries) {
+			zip64 = true;
 		}
 		const endOfdirectoryRecord = createRecordWriter(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 		if (exceedsAvailableSize(writer, getLength(endOfdirectoryRecord.array) + commentLength)) {
@@ -8603,7 +8649,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.11.2";
+	const VERSION = "2.11.4";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9132,8 +9178,6 @@
 	const ERR_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
 	const ERR_ZIP_CRYPTO_LAST_MOD_DATE = "The last modification date of an entry encrypted with ZipCrypto cannot be changed when passThrough is set";
 	const ERR_ABORT_EXPORT = "zipjs-abort-export";
-	const ERR_ABORTED = "The operation was aborted";
-	const ABORT_ERROR_NAME = "AbortError";
 	const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 	const INTERPRETED_EXTRA_FIELD_TYPES = new Set([
 		EXTRAFIELD_TYPE_ZIP64,
@@ -9627,12 +9671,14 @@
 			if (options.bufferedWrite === UNDEFINED_VALUE) {
 				options.bufferedWrite = true;
 			}
-			const entries = zipEntry.getChildren({ recursive: true }).filter(child => !isImplicitDirectory(child)).map(child => {
+			const children = zipEntry.getChildren({ recursive: true });
+			const entries = children.filter(child => !isImplicitDirectory(child)).map(child => {
 				const { name, entryOptions } = getChildEntryOptions(child, zipEntry, options);
 				return { name, size: child.directory ? 0 : getDeterminedSize(child, isPassThrough(child, options)), options: entryOptions };
 			});
 			const writeOrderGuaranteed = !options.bufferedWrite ||
-				(entries.every(entry => entry.options.keepOrder !== false) && zipEntry.children.every(child => !child.children.length));
+				(entries.every(entry => entry.options.keepOrder !== false) &&
+					children.every(child => isImplicitDirectory(child) || !child.children.length));
 			return getEntriesSize(options, entries, writeOrderGuaranteed, options.globalComment);
 		}
 
@@ -10661,6 +10707,7 @@
 	exports.ERR_INVALID_PASSWORD = ERR_INVALID_PASSWORD;
 	exports.ERR_INVALID_PASSWORD_TYPE = ERR_INVALID_PASSWORD_TYPE;
 	exports.ERR_INVALID_PASS_THROUGH = ERR_INVALID_PASS_THROUGH;
+	exports.ERR_INVALID_READER = ERR_INVALID_READER;
 	exports.ERR_INVALID_READER_OPTIONS = ERR_INVALID_READER_OPTIONS;
 	exports.ERR_INVALID_SIGNAL = ERR_INVALID_SIGNAL;
 	exports.ERR_INVALID_SIGNATURE_DATA = ERR_INVALID_SIGNATURE_DATA;
@@ -10689,6 +10736,7 @@
 	exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 	exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+	exports.ERR_UNSUPPORTED_SPLIT_USDZ = ERR_UNSUPPORTED_SPLIT_USDZ;
 	exports.ERR_UNSUPPORTED_UINT64 = ERR_UNSUPPORTED_UINT64;
 	exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;
 	exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;