@zip.js/zip.js 2.7.48 → 2.7.50

package/index.cjs

@@ -9205,7 +9205,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 {
 
@@ -9440,6 +9440,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;
@@ -9557,8 +9558,12 @@ let ZipEntry$1 = class ZipEntry {
 			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);
@@ -9590,11 +9595,11 @@ let ZipEntry$1 = class ZipEntry {
 				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"),
@@ -9923,6 +9928,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]);
 
@@ -9943,7 +9949,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
@@ -10065,8 +10071,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);
@@ -10080,7 +10090,7 @@ async function addFile(zipWriter, name, reader, options) {
 	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();
@@ -10106,18 +10116,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);
 		}
 	}
@@ -10135,6 +10155,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,
@@ -10165,7 +10187,10 @@ async function addFile(zipWriter, name, reader, options) {
 		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);
@@ -10376,7 +10401,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		msDosCompatible,
 		internalFileAttribute,
 		externalFileAttribute,
-		useCompressionStream
+		useCompressionStream,
+		passThrough
 	} = options;
 	const fileEntry = {
 		lock,
@@ -10397,9 +10423,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);
@@ -10415,9 +10446,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
@@ -10426,9 +10457,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);
@@ -10471,6 +10504,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		creationDate,
 		lastAccessDate,
 		encrypted,
+		zipCrypto,
 		size: metadataSize + compressedSize,
 		compressionMethod,
 		version,
@@ -10492,8 +10526,6 @@ function getHeaderInfo(options) {
 		lastModDate,
 		lastAccessDate,
 		creationDate,
-		rawPassword,
-		password,
 		level,
 		zip64,
 		zipCrypto,
@@ -10502,10 +10534,10 @@ function getHeaderInfo(options) {
 		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) {
@@ -10564,6 +10596,15 @@ function getHeaderInfo(options) {
 	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;
@@ -11049,7 +11090,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) {
@@ -11392,7 +11434,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) {
@@ -11708,8 +11751,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,
@@ -11718,6 +11770,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
@@ -11907,6 +11969,7 @@ exports.ERR_INVALID_VERSION = ERR_INVALID_VERSION;
 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;

package/index.d.ts

@@ -800,19 +800,13 @@ export interface GetEntriesOptions {
 /**
  * Represents options passed to the constructor of {@link ZipReader} and {@link Entry#getData}.
  */
-export interface ZipReaderCheckPasswordOptions {
+export interface ZipReaderOptions {
   /**
    * `true` to check only if the password is valid.
    *
    * @defaultValue false
    */
   checkPasswordOnly: boolean;
-}
-
-/**
- * Represents options passed to the constructor of {@link ZipReader} and {@link Entry#getData}.
- */
-export interface ZipReaderOptions {
   /**
    * `true` to check the signature of the entry.
    *
@@ -823,6 +817,10 @@ export interface ZipReaderOptions {
    * The password used to decrypt the content of the entry.
    */
   password?: string;
+  /**
+   * `true` to read the data as-is without decompressing it and without decrypting it.
+   */
+  passThrough?: boolean;
   /**
    * The password used to encrypt the content of the entry (raw).
    */
@@ -873,6 +871,10 @@ export interface EntryMetaData {
    * `true` if the content of the entry is encrypted.
    */
   encrypted: boolean;
+  /**
+   * `true` if the content of the entry is encrypted with the ZipCrypto algorithm.
+   */
+  zipCrypto: boolean;
   /**
    * The size of the compressed data in bytes.
    */
@@ -979,19 +981,8 @@ export interface Entry extends EntryMetaData {
         Writer<unknown> | WritableWriter | WritableStream,
         boolean
       >,
-    options?: EntryGetDataOptions,
+    options?: EntryGetDataCheckPasswordOptions
   ): Promise<Type>;
-
-  /**
-   * Tests if the password is valid.
-   *
-   * @param writer `undefined` or `null`.
-   * @param options The options with `checkPasswordOnly` set to `true`.
-   */
-  getData?(
-    writer: undefined | null,
-    options: EntryGetDataCheckPasswordOptions,
-  ): Promise<void>;
 }
 
 /**
@@ -1004,7 +995,7 @@ export interface EntryGetDataOptions
  * Represents the options passed to {@link Entry#getData} and `{@link ZipFileEntry}.get*`.
  */
 export interface EntryGetDataCheckPasswordOptions
-  extends EntryGetDataOptions, ZipReaderCheckPasswordOptions { }
+  extends EntryGetDataOptions { }
 
 /**
  * Represents an instance used to create a zipped stream.
@@ -1184,6 +1175,14 @@ export interface ZipWriterAddDataOptions
    * The extra field of the entry.
    */
   extraField?: Map<number, Uint8Array>;
+  /**
+   * The uncompressed size of the entry. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option is not set to `true`.
+   */
+  uncompressedSize?: number;
+  /**
+   * The signature (CRC32 checksum) of the content. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option is not set to `true`.
+   */
+  signature?: number;
 }
 
 /**
@@ -1365,6 +1364,18 @@ export interface ZipWriterConstructorOptions {
    * @defaultValue false
    */
   usdz?: boolean;
+  /**
+   * `true` to write the data as-is without compressing it and without crypting it.
+   */
+  passThrough?: boolean;
+  /**
+   * `true` to write encrypted data when `passThrough` is set to `true`.
+   */
+  encrypted?: boolean;
+  /**
+   * The offset of the first entry in the zip file.
+   */
+  offset?: number;
   /**
    * Encode the filename and the comment of the entry.
    * 
@@ -2054,3 +2065,7 @@ export const ERR_SPLIT_ZIP_FILE: string;
  * Iteration completed too soon error
  */
 export const ERR_ITERATOR_COMPLETED_TOO_SOON: string;
+/**
+ * Undefined uncompressed size error
+ */
+export const ERR_UNDEFINED_UNCOMPRESSED_SIZE: string

package/index.js

@@ -81,6 +81,7 @@ export {
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
 	ERR_UNSUPPORTED_FORMAT,
+	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
 	ERR_SPLIT_ZIP_FILE,
 	ERR_ITERATOR_COMPLETED_TOO_SOON
 } from "./lib/zip-fs.js";