@zip.js/zip.js 2.7.47 → 2.7.49

package/dist/zip-fs.js

@@ -3356,7 +3356,7 @@
 		PROPERTY_NAME_MS_DOS_COMPATIBLE, PROPERTY_NAME_ZIP64,
 		"directory", "bitFlag", "encrypted", "signature", "filenameUTF8", "commentUTF8", "compressionMethod", "version", "versionMadeBy",
 		"extraField", "rawExtraField", "extraFieldZip64", "extraFieldUnicodePath", "extraFieldUnicodeComment", "extraFieldAES", "extraFieldNTFS",
-		"extraFieldExtendedTimestamp"];
+		"extraFieldExtendedTimestamp", "zipCrypto"];
 
 	class Entry {
 
@@ -3591,6 +3591,7 @@
 				});
 				startOffset = Math.max(offsetFileEntry, startOffset);
 				await readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+				fileEntry.zipCrypto = fileEntry.encrypted && !fileEntry.extraFieldAES;
 				const entry = new Entry(fileEntry);
 				entry.getData = (writer, options) => fileEntry.getData(writer, entry, options);
 				offset = endOffset;
@@ -3708,8 +3709,12 @@
 				lastAccessDate: localDirectory.lastAccessDate,
 				creationDate: localDirectory.creationDate
 			});
-			const encrypted = zipEntry.encrypted && localDirectory.encrypted;
+			const passThrough = getOptionValue$1(zipEntry, options, "passThrough");
+			const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
 			const zipCrypto = encrypted && !extraFieldAES;
+			if (!passThrough) {
+				fileEntry.zipCrypto = zipCrypto;
+			}
 			if (encrypted) {
 				if (!zipCrypto && extraFieldAES.strength === UNDEFINED_VALUE) {
 					throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
@@ -3741,11 +3746,11 @@
 					rawPassword,
 					zipCrypto,
 					encryptionStrength: extraFieldAES && extraFieldAES.strength,
-					signed: getOptionValue$1(zipEntry, options, "checkSignature"),
+					signed: getOptionValue$1(zipEntry, options, "checkSignature") && !passThrough,
 					passwordVerification: zipCrypto && (bitFlag.dataDescriptor ? ((rawLastModDate >>> 8) & 0xFF) : ((signature >>> 24) & 0xFF)),
 					signature,
-					compressed: compressionMethod != 0,
-					encrypted,
+					compressed: compressionMethod != 0 && !passThrough,
+					encrypted: zipEntry.encrypted && !passThrough,
 					useWebWorkers: getOptionValue$1(zipEntry, options, "useWebWorkers"),
 					useCompressionStream: getOptionValue$1(zipEntry, options, "useCompressionStream"),
 					transferStreams: getOptionValue$1(zipEntry, options, "transferStreams"),
@@ -4074,6 +4079,7 @@
 	const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 	const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
 	const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (make sure 'keepOrder' is set to 'true')";
+	const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
 
 	const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 
@@ -4216,8 +4222,12 @@
 		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 rawPassword = getOptionValue(zipWriter, options, "rawPassword");
+		const passThrough = getOptionValue(zipWriter, options, "passThrough");
+		let password, rawPassword;
+		if (!passThrough) {
+			password = getOptionValue(zipWriter, options, "password");
+			rawPassword = getOptionValue(zipWriter, options, "rawPassword");
+		}
 		const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength", 3);
 		const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
 		const extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp", true);
@@ -4227,10 +4237,11 @@
 		const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
 		const dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature", false);
 		const signal = getOptionValue(zipWriter, options, "signal");
+		const useUnicodeFileNames = getOptionValue(zipWriter, options, "useUnicodeFileNames", true);
 		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)) {
+		if ((password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) && encryptionStrength !== UNDEFINED_VALUE && (encryptionStrength < 1 || encryptionStrength > 3)) {
 			throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 		}
 		let rawExtraField = new Uint8Array();
@@ -4256,18 +4267,28 @@
 		let maximumCompressedSize = 0;
 		let maximumEntrySize = 0;
 		let uncompressedSize = 0;
+		if (passThrough) {
+			({ uncompressedSize } = options);
+			if (uncompressedSize === UNDEFINED_VALUE) {
+				throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
+			}
+		}
 		const zip64Enabled = zip64 === true;
 		if (reader) {
 			reader = initReader(reader);
 			await initStream(reader);
-			if (reader.size === UNDEFINED_VALUE) {
-				dataDescriptor = true;
-				if (zip64 || zip64 === UNDEFINED_VALUE) {
-					zip64 = true;
-					uncompressedSize = maximumCompressedSize = MAX_32_BITS + 1;
+			if (!passThrough) {
+				if (reader.size === UNDEFINED_VALUE) {
+					dataDescriptor = true;
+					if (zip64 || zip64 === UNDEFINED_VALUE) {
+						zip64 = true;
+						uncompressedSize = maximumCompressedSize = MAX_32_BITS + 1;
+					}
+				} else {
+					uncompressedSize = reader.size;
+					maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 				}
 			} else {
-				uncompressedSize = reader.size;
 				maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 			}
 		}
@@ -4285,6 +4306,8 @@
 			}
 		}
 		zip64 = zip64 || false;
+		const encrypted = getOptionValue(zipWriter, options, "encrypted");
+		const { signature } = options;
 		options = Object.assign({}, options, {
 			rawFilename,
 			rawComment,
@@ -4308,13 +4331,17 @@
 			zipCrypto,
 			bufferedWrite,
 			keepOrder,
+			useUnicodeFileNames,
 			dataDescriptor,
 			dataDescriptorSignature,
 			signal,
 			msDosCompatible,
 			internalFileAttribute,
 			externalFileAttribute,
-			useCompressionStream
+			useCompressionStream,
+			passThrough,
+			encrypted: Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted),
+			signature
 		});
 		const headerInfo = getHeaderInfo(options);
 		const dataDescriptorInfo = getDataDescriptorInfo(options);
@@ -4525,7 +4552,8 @@
 			msDosCompatible,
 			internalFileAttribute,
 			externalFileAttribute,
-			useCompressionStream
+			useCompressionStream,
+			passThrough
 		} = options;
 		const fileEntry = {
 			lock,
@@ -4546,9 +4574,14 @@
 			externalFileAttribute,
 			diskNumberStart
 		};
+		let {
+			signature,
+			uncompressedSize
+		} = options;
 		let compressedSize = 0;
-		let uncompressedSize = 0;
-		let signature;
+		if (!passThrough) {
+			uncompressedSize = 0;
+		}
 		const { writable } = writer;
 		if (reader) {
 			reader.chunkSize = getChunkSize(config);
@@ -4564,9 +4597,9 @@
 					encryptionStrength,
 					zipCrypto: encrypted && zipCrypto,
 					passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
-					signed: true,
-					compressed,
-					encrypted,
+					signed: !passThrough,
+					compressed: compressed && !passThrough,
+					encrypted: encrypted && !passThrough,
 					useWebWorkers,
 					useCompressionStream,
 					transferStreams: false
@@ -4575,9 +4608,11 @@
 				streamOptions: { signal, size, onstart, onprogress, onend }
 			};
 			const result = await runWorker({ readable, writable }, workerOptions);
-			uncompressedSize = result.inputSize;
 			compressedSize = result.outputSize;
-			signature = result.signature;
+			if (!passThrough) {
+				uncompressedSize = result.inputSize;
+				signature = result.signature;
+			}
 			writable.size += uncompressedSize;
 		} else {
 			await writeData(writable, localHeaderArray);
@@ -4620,6 +4655,7 @@
 			creationDate,
 			lastAccessDate,
 			encrypted,
+			zipCrypto,
 			size: metadataSize + compressedSize,
 			compressionMethod,
 			version,
@@ -4641,19 +4677,18 @@
 			lastModDate,
 			lastAccessDate,
 			creationDate,
-			rawPassword,
-			password,
 			level,
 			zip64,
 			zipCrypto,
+			useUnicodeFileNames,
 			dataDescriptor,
 			directory,
 			rawExtraField,
 			encryptionStrength,
-			extendedTimestamp
+			extendedTimestamp,
+			encrypted
 		} = options;
 		const compressed = level !== 0 && !directory;
-		const encrypted = Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword)));
 		let version = options.version;
 		let rawExtraFieldAES;
 		if (encrypted && !zipCrypto) {
@@ -4702,13 +4737,25 @@
 		} else {
 			rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 		}
-		let bitFlag = BITFLAG_LANG_ENCODING_FLAG;
+		let bitFlag = 0;
+		if (useUnicodeFileNames) {
+			bitFlag = bitFlag | BITFLAG_LANG_ENCODING_FLAG;
+		}
 		if (dataDescriptor) {
 			bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
 		}
 		let compressionMethod = COMPRESSION_METHOD_STORE;
 		if (compressed) {
 			compressionMethod = COMPRESSION_METHOD_DEFLATE;
+			if (level >= 1 && level < 3) {
+				bitFlag = bitFlag | 0b110;
+			}
+			if (level >= 3 && level < 5) {
+				bitFlag = bitFlag | 0b01;
+			}
+			if (level === 9) {
+				bitFlag = bitFlag | 0b10;
+			}
 		}
 		if (zip64) {
 			version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
@@ -5194,7 +5241,8 @@
 				id: fs.entries.length,
 				parent,
 				children: [],
-				uncompressedSize: params.uncompressedSize || 0
+				uncompressedSize: params.uncompressedSize || 0,
+				passThrough: params.passThrough
 			});
 			fs.entries.push(zipEntry);
 			if (parent) {
@@ -5537,7 +5585,8 @@
 						importedEntries.push(addChild(parent, name, {
 							data: entry,
 							Reader: getZipBlobReader(Object.assign({}, options)),
-							uncompressedSize: entry.uncompressedSize
+							uncompressedSize: entry.uncompressedSize,
+							passThrough: options.passThrough
 						}));
 					}
 				} catch (error) {
@@ -5853,8 +5902,17 @@
 						comment,
 						lastModDate,
 						creationDate,
-						lastAccessDate
+						lastAccessDate,
+						uncompressedSize,
+						encrypted,
+						zipCrypto,
+						signature,
+						compressionMethod
 					} = child.data;
+					let level;
+					if (compressionMethod === 0) {
+						level = 0;
+					}
 					zipEntryOptions = {
 						externalFileAttribute,
 						versionMadeBy,
@@ -5863,6 +5921,16 @@
 						creationDate,
 						lastAccessDate
 					};
+					if (child.passThrough) {
+						zipEntryOptions = Object.assign(zipEntryOptions, {
+							passThrough: true,
+							encrypted,
+							zipCrypto,
+							signature,
+							uncompressedSize,
+							level
+						});
+					}
 				}
 				await zipWriter.add(name, child.reader, Object.assign({
 					directory: child.directory
@@ -6047,6 +6115,7 @@
 	exports.ERR_ITERATOR_COMPLETED_TOO_SOON = ERR_ITERATOR_COMPLETED_TOO_SOON;
 	exports.ERR_LOCAL_FILE_HEADER_NOT_FOUND = ERR_LOCAL_FILE_HEADER_NOT_FOUND;
 	exports.ERR_SPLIT_ZIP_FILE = ERR_SPLIT_ZIP_FILE;
+	exports.ERR_UNDEFINED_UNCOMPRESSED_SIZE = ERR_UNDEFINED_UNCOMPRESSED_SIZE;
 	exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION;
 	exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;