@zip.js/zip.js 2.7.47 → 2.7.49

package/lib/core/zip-entry.js

@@ -53,7 +53,7 @@ const PROPERTY_NAMES = [
 	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 {
 

package/lib/core/zip-fs-core.js

@@ -72,7 +72,8 @@ class ZipEntry {
 			id: fs.entries.length,
 			parent,
 			children: [],
-			uncompressedSize: params.uncompressedSize || 0
+			uncompressedSize: params.uncompressedSize || 0,
+			passThrough: params.passThrough
 		});
 		fs.entries.push(zipEntry);
 		if (parent) {
@@ -415,7 +416,8 @@ class ZipDirectoryEntry extends ZipEntry {
 					importedEntries.push(addChild(parent, name, {
 						data: entry,
 						Reader: getZipBlobReader(Object.assign({}, options)),
-						uncompressedSize: entry.uncompressedSize
+						uncompressedSize: entry.uncompressedSize,
+						passThrough: options.passThrough
 					}));
 				}
 			} catch (error) {
@@ -732,8 +734,17 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 					comment,
 					lastModDate,
 					creationDate,
-					lastAccessDate
+					lastAccessDate,
+					uncompressedSize,
+					encrypted,
+					zipCrypto,
+					signature,
+					compressionMethod
 				} = child.data;
+				let level;
+				if (compressionMethod === 0) {
+					level = 0;
+				}
 				zipEntryOptions = {
 					externalFileAttribute,
 					versionMadeBy,
@@ -742,6 +753,16 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 					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

package/lib/core/zip-reader.js

@@ -294,6 +294,7 @@ class ZipReader {
 			});
 			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;
@@ -428,8 +429,12 @@ class ZipEntry {
 			lastAccessDate: localDirectory.lastAccessDate,
 			creationDate: localDirectory.creationDate
 		});
-		const encrypted = zipEntry.encrypted && localDirectory.encrypted;
+		const passThrough = getOptionValue(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);
@@ -461,11 +466,11 @@ class ZipEntry {
 				rawPassword,
 				zipCrypto,
 				encryptionStrength: extraFieldAES && extraFieldAES.strength,
-				signed: getOptionValue(zipEntry, options, "checkSignature"),
+				signed: getOptionValue(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(zipEntry, options, "useWebWorkers"),
 				useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream"),
 				transferStreams: getOptionValue(zipEntry, options, "transferStreams"),

package/lib/core/zip-writer.js

@@ -98,6 +98,7 @@ const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 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]);
 
@@ -118,7 +119,7 @@ class ZipWriter {
 			config: getConfiguration(),
 			files: new Map(),
 			filenames: new Set(),
-			offset: writer.writable.size,
+			offset: options.offset === UNDEFINED_VALUE ? writer.writable.size : options.offset,
 			pendingEntriesSize: 0,
 			pendingAddFileCalls: new Set(),
 			bufferedWrites: 0
@@ -214,7 +215,8 @@ export {
 	ERR_INVALID_EXTRAFIELD_TYPE,
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
-	ERR_UNSUPPORTED_FORMAT
+	ERR_UNSUPPORTED_FORMAT,
+	ERR_UNDEFINED_UNCOMPRESSED_SIZE
 };
 
 async function addFile(zipWriter, name, reader, options) {
@@ -254,8 +256,12 @@ async function addFile(zipWriter, name, reader, options) {
 	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);
@@ -265,10 +271,11 @@ async function addFile(zipWriter, name, reader, options) {
 	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();
@@ -294,18 +301,28 @@ async function addFile(zipWriter, name, reader, options) {
 	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);
 		}
 	}
@@ -323,6 +340,8 @@ async function addFile(zipWriter, name, reader, options) {
 		}
 	}
 	zip64 = zip64 || false;
+	const encrypted = getOptionValue(zipWriter, options, "encrypted");
+	const { signature } = options;
 	options = Object.assign({}, options, {
 		rawFilename,
 		rawComment,
@@ -346,13 +365,17 @@ async function addFile(zipWriter, name, reader, options) {
 		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);
@@ -563,7 +586,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		msDosCompatible,
 		internalFileAttribute,
 		externalFileAttribute,
-		useCompressionStream
+		useCompressionStream,
+		passThrough
 	} = options;
 	const fileEntry = {
 		lock,
@@ -584,9 +608,14 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		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);
@@ -602,9 +631,9 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 				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
@@ -613,9 +642,11 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 			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);
@@ -658,6 +689,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		creationDate,
 		lastAccessDate,
 		encrypted,
+		zipCrypto,
 		size: metadataSize + compressedSize,
 		compressionMethod,
 		version,
@@ -679,19 +711,18 @@ function getHeaderInfo(options) {
 		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) {
@@ -740,13 +771,25 @@ function getHeaderInfo(options) {
 	} 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;

package/package.json

@@ -3,7 +3,7 @@
     "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
     "author": "Gildas Lormeau",
     "license": "BSD-3-Clause",
-    "version": "2.7.47",
+    "version": "2.7.49",
     "type": "module",
     "keywords": [
         "zip",
@@ -80,7 +80,7 @@
         "@rollup/plugin-replace": "^5.0.7",
         "@rollup/plugin-terser": "^0.4.4",
         "http-server": "^14.1.1",
-        "rollup": "^4.18.1",
-        "typedoc": "^0.26.4"
+        "rollup": "^4.21.0",
+        "typedoc": "^0.26.6"
     }
 }