@zip.js/zip.js 2.6.42 → 2.6.44

package/dist/zip-full.js

@@ -7106,7 +7106,7 @@
 		}
 	}
 
-	class SplitZipReader extends Reader {
+	class SplitDataReader extends Reader {
 
 		constructor(readers) {
 			super();
@@ -7152,7 +7152,7 @@
 		}
 	}
 
-	class SplitZipWriter extends Stream {
+	class SplitDataWriter extends Stream {
 
 		constructor(writerGenerator, maxSize = 4294967296) {
 			super();
@@ -7173,6 +7173,7 @@
 						} else {
 							diskSourceWriter = value;
 							diskSourceWriter.size = 0;
+							await initStream(diskSourceWriter);
 							diskWritable = value.writable;
 							diskWriter = diskWritable.getWriter();
 						}
@@ -7233,6 +7234,9 @@
 		return reader.readUint8Array(offset, size, diskNumber);
 	}
 
+	const SplitZipReader = SplitDataReader;
+	const SplitZipWriter = SplitDataWriter;
+
 	/*
 	 Copyright (c) 2022 Gildas Lormeau. All rights reserved.
 
@@ -7459,7 +7463,7 @@
 			await initStream(reader);
 			if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
 				if (Array.isArray(reader)) {
-					reader = new SplitZipReader(reader);
+					reader = new SplitDataReader(reader);
 				} else {
 					reader = new BlobReader(await new Response(reader.readable).blob());
 				}
@@ -8037,7 +8041,7 @@
 
 		constructor(writer, options = {}) {
 			if (writer.writable === UNDEFINED_VALUE && typeof writer.next == FUNCTION_TYPE$1) {
-				writer = new SplitZipWriter(writer);
+				writer = new SplitDataWriter(writer);
 			}
 			if (writer instanceof WritableStream) {
 				writer = { writable: writer };
@@ -8045,7 +8049,7 @@
 			if (writer.writable.size === UNDEFINED_VALUE) {
 				writer.writable.size = 0;
 			}
-			const splitZipFile = writer instanceof SplitZipWriter;
+			const splitZipFile = writer instanceof SplitDataWriter;
 			if (!splitZipFile) {
 				Object.assign(writer, {
 					diskNumber: 0,
@@ -8102,13 +8106,15 @@
 		}
 
 		async close(comment = new Uint8Array(), options = {}) {
+			const zipWriter = this;
 			const { pendingAddFileCalls, writer } = this;
 			const { writable } = writer;
 			while (pendingAddFileCalls.size) {
 				await Promise.all(Array.from(pendingAddFileCalls));
 			}
 			await closeFile(this, comment, options);
-			if (!writer.preventClose && !options.preventClose) {
+			const preventClose = getOptionValue(zipWriter, options, "preventClose");
+			if (!preventClose) {
 				await writable.close();
 			}
 			return writer.getData ? writer.getData() : writable;
@@ -8131,20 +8137,33 @@
 		if (getLength(rawComment) > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_ENTRY_COMMENT);
 		}
-		const version = zipWriter.options.version || options.version || 0;
+		const version = getOptionValue(zipWriter, options, "version", VERSION_DEFLATE);
 		if (version > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_VERSION);
 		}
-		const versionMadeBy = zipWriter.options.versionMadeBy || options.versionMadeBy || 20;
+		const versionMadeBy = getOptionValue(zipWriter, options, "versionMadeBy", 20);
 		if (versionMadeBy > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_VERSION);
 		}
-		const lastModDate = getOptionValue(zipWriter, options, PROPERTY_NAME_LAST_MODIFICATION_DATE) || new Date();
+		const lastModDate = getOptionValue(zipWriter, options, PROPERTY_NAME_LAST_MODIFICATION_DATE, new Date());
 		const lastAccessDate = getOptionValue(zipWriter, options, PROPERTY_NAME_LAST_ACCESS_DATE);
 		const creationDate = getOptionValue(zipWriter, options, PROPERTY_NAME_CREATION_DATE);
+		const msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE, true);
+		const internalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE, 0);
+		const externalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE, 0);
 		const password = getOptionValue(zipWriter, options, "password");
-		const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength") || 3;
+		const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength", 3);
 		const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
+		const extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp", true);
+		const keepOrder = getOptionValue(zipWriter, options, "keepOrder", true);
+		const level = getOptionValue(zipWriter, options, "level");
+		const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
+		const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
+		const dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature", false);
+		const signal = getOptionValue(zipWriter, options, "signal");
+		const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
+		let dataDescriptor = getOptionValue(zipWriter, options, "dataDescriptor", true);
+		let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 		if (password !== UNDEFINED_VALUE && encryptionStrength !== UNDEFINED_VALUE && (encryptionStrength < 1 || encryptionStrength > 3)) {
 			throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 		}
@@ -8168,24 +8187,9 @@
 				offset += 4 + getLength(data);
 			});
 		}
-		let extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp");
-		if (extendedTimestamp === UNDEFINED_VALUE) {
-			extendedTimestamp = true;
-		}
 		let maximumCompressedSize = 0;
 		let maximumEntrySize = 0;
-		let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
-		if (keepOrder === UNDEFINED_VALUE) {
-			keepOrder = true;
-		}
 		let uncompressedSize = 0;
-		let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
-		if (msDosCompatible === UNDEFINED_VALUE) {
-			msDosCompatible = true;
-		}
-		const internalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE) || 0;
-		const externalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE) || 0;
-		let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 		if (reader) {
 			if (reader instanceof ReadableStream) {
 				reader = {
@@ -8194,7 +8198,7 @@
 			}
 			await initStream(reader);
 			if (reader.size === UNDEFINED_VALUE) {
-				options.dataDescriptor = true;
+				dataDescriptor = true;
 				if (zip64 || zip64 === UNDEFINED_VALUE) {
 					zip64 = true;
 					maximumCompressedSize = MAX_32_BITS;
@@ -8204,10 +8208,11 @@
 				maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 			}
 		}
-		const { diskOffset } = zipWriter.writer;
+		const { diskOffset, diskNumber } = zipWriter.writer;
 		if (zipWriter.offset + zipWriter.pendingEntriesSize - diskOffset >= MAX_32_BITS ||
 			uncompressedSize >= MAX_32_BITS ||
-			maximumCompressedSize >= MAX_32_BITS) {
+			maximumCompressedSize >= MAX_32_BITS ||
+			diskNumber >= MAX_16_BITS) {
 			if (zip64 === false || !keepOrder) {
 				throw new Error(ERR_UNSUPPORTED_FORMAT);
 			} else {
@@ -8215,19 +8220,6 @@
 			}
 		}
 		zip64 = zip64 || false;
-		const level = getOptionValue(zipWriter, options, "level");
-		const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
-		const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
-		let dataDescriptor = getOptionValue(zipWriter, options, "dataDescriptor");
-		let dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature");
-		const signal = getOptionValue(zipWriter, options, "signal");
-		const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
-		if (dataDescriptor === UNDEFINED_VALUE) {
-			dataDescriptor = true;
-		}
-		if (dataDescriptor && dataDescriptorSignature === UNDEFINED_VALUE) {
-			dataDescriptorSignature = false;
-		}
 		options = Object.assign({}, options, {
 			rawFilename,
 			rawComment,
@@ -8261,12 +8253,8 @@
 		let fileEntry;
 		try {
 			fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo }, options);
+		} finally {
 			zipWriter.pendingEntriesSize -= maximumEntrySize;
-		} catch (error) {
-			if (!error.corruptedEntry) {
-				zipWriter.pendingEntriesSize -= maximumEntrySize;
-			}
-			throw error;
 		}
 		Object.assign(fileEntry, { name, comment, extraField });
 		return new Entry(fileEntry);
@@ -8304,8 +8292,7 @@
 				await initStream(writer);
 			} else {
 				fileWriter = writer;
-				zipWriter.lockWriter = Promise.resolve();
-				releaseLockWriter = () => delete zipWriter.lockWriter;
+				initLockWriter();
 			}
 			await initStream(fileWriter);
 			const { writable, diskNumber } = writer;
@@ -8334,7 +8321,7 @@
 				await requestLockWriter();
 				writingBufferedEntryData = true;
 				if (!dataDescriptor) {
-					blob = await setMissingInfo(fileEntry, blob, writable, options);
+					blob = await writeMissingHeaderInfo(fileEntry, blob, writable, options);
 				}
 				fileEntry.diskNumberStart = writer.diskNumber;
 				diskOffset = writer.diskOffset;
@@ -8344,7 +8331,7 @@
 			}
 			fileEntry.offset = zipWriter.offset - diskOffset;
 			if (fileEntry.zip64) {
-				setZip64Info(fileEntry);
+				setZip64OffsetInfo(fileEntry);
 			} else if (fileEntry.offset >= MAX_32_BITS) {
 				throw new Error(ERR_UNSUPPORTED_FORMAT);
 			}
@@ -8377,6 +8364,11 @@
 			fileEntry.lock = new Promise(resolve => releaseLockCurrentFileEntry = resolve);
 		}
 
+		function initLockWriter() {
+			zipWriter.lockWriter = Promise.resolve();
+			releaseLockWriter = () => delete zipWriter.lockWriter;
+		}
+
 		async function requestLockWriter() {
 			const { lockWriter } = zipWriter;
 			if (lockWriter) {
@@ -8535,6 +8527,7 @@
 		} = options;
 		const compressed = level !== 0 && !directory;
 		const encrypted = Boolean(password && getLength(password));
+		let version = options.version;
 		let rawExtraFieldAES;
 		if (encrypted && !zipCrypto) {
 			rawExtraFieldAES = new Uint8Array(getLength(EXTRAFIELD_DATA_AES) + 2);
@@ -8586,7 +8579,6 @@
 		if (compressed) {
 			compressionMethod = COMPRESSION_METHOD_DEFLATE;
 		}
-		let version = options.version || VERSION_DEFLATE;
 		if (zip64) {
 			version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
 		}
@@ -8720,7 +8712,7 @@
 		}
 	}
 
-	async function setMissingInfo(fileEntry, entryData, writable, { zipCrypto }) {
+	async function writeMissingHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
 		const arrayBuffer = await sliceAsArrayBuffer(entryData, 0, 26);
 		const arrayBufferView = new DataView(arrayBuffer);
 		if (!fileEntry.encrypted || zipCrypto) {
@@ -8737,7 +8729,7 @@
 		return entryData.slice(arrayBuffer.byteLength);
 	}
 
-	function setZip64Info(fileEntry) {
+	function setZip64OffsetInfo(fileEntry) {
 		const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
 		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 		setBigUint64(rawExtraFieldZip64View, 20, BigInt(offset));
@@ -8746,10 +8738,10 @@
 
 	async function closeFile(zipWriter, comment, options) {
 		const { files, writer } = zipWriter;
-		let offset = 0;
-		let directoryDataLength = 0;
 		const { diskOffset, writable } = writer;
 		let { diskNumber } = writer;
+		let offset = 0;
+		let directoryDataLength = 0;
 		let directoryOffset = zipWriter.offset - diskOffset;
 		let filesLength = files.size;
 		for (const [, {
@@ -8771,14 +8763,6 @@
 					rawExtraFieldNTFS,
 					rawExtraField);
 		}
-		let zip64 = options.zip64 || zipWriter.options.zip64 || false;
-		if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || filesLength >= MAX_16_BITS) {
-			if (options.zip64 === false || zipWriter.options.zip64 === false) {
-				throw new Error(ERR_UNSUPPORTED_FORMAT);
-			} else {
-				zip64 = true;
-			}
-		}
 		const directoryArray = new Uint8Array(directoryDataLength);
 		const directoryView = getDataView(directoryArray);
 		for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
@@ -8844,13 +8828,21 @@
 		}
 		await initStream(writer);
 		await writeData(writable, directoryArray);
-		const endOfdirectoryArray = new Uint8Array(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
-		const endOfdirectoryView = getDataView(endOfdirectoryArray);
 		let lastDiskNumber = writer.diskNumber;
 		const { availableSize } = writer;
-		if (availableSize < getLength(endOfdirectoryArray)) {
+		if (availableSize < END_OF_CENTRAL_DIR_LENGTH) {
 			lastDiskNumber++;
 		}
+		let zip64 = getOptionValue(zipWriter, options, "zip64");
+		if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || filesLength >= MAX_16_BITS || lastDiskNumber >= MAX_16_BITS) {
+			if (zip64 === false) {
+				throw new Error(ERR_UNSUPPORTED_FORMAT);
+			} else {
+				zip64 = true;
+			}
+		}
+		const endOfdirectoryArray = new Uint8Array(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+		const endOfdirectoryView = getDataView(endOfdirectoryArray);
 		offset = 0;
 		if (zip64) {
 			setUint32(endOfdirectoryView, 0, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
@@ -8915,8 +8907,9 @@
 		}
 	}
 
-	function getOptionValue(zipWriter, options, name) {
-		return options[name] === UNDEFINED_VALUE ? zipWriter.options[name] : options[name];
+	function getOptionValue(zipWriter, options, name, defaultValue) {
+		const result = options[name] === UNDEFINED_VALUE ? zipWriter.options[name] : options[name];
+		return result === UNDEFINED_VALUE ? defaultValue : result;
 	}
 
 	function getMaximumCompressedSize(uncompressedSize) {
@@ -9021,6 +9014,8 @@
 	exports.HttpRangeReader = HttpRangeReader;
 	exports.HttpReader = HttpReader;
 	exports.Reader = Reader;
+	exports.SplitDataReader = SplitDataReader;
+	exports.SplitDataWriter = SplitDataWriter;
 	exports.SplitZipReader = SplitZipReader;
 	exports.SplitZipWriter = SplitZipWriter;
 	exports.TextReader = TextReader;