@helloao/cli 0.0.10 → 0.0.11

package/node_modules/@zip.js/zip.js/lib/core/zip-reader.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global BigInt, Response, WritableStream, ReadableStream, TransformStream */
+/* global Response, WritableStream, ReadableStream, TransformStream */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -57,6 +57,9 @@ import {
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
 	FILE_ATTR_MSDOS_DIR_MASK,
+	FILE_ATTR_UNIX_TYPE_MASK,
+	FILE_ATTR_UNIX_TYPE_DIR,
+	FILE_ATTR_UNIX_EXECUTABLE_MASK,
 	DIRECTORY_SIGNATURE,
 	UNDEFINED_VALUE
 } from "./constants.js";
@@ -250,14 +253,20 @@ class ZipReader {
 			const extraFieldOffset = filenameOffset + fileEntry.filenameLength;
 			const commentOffset = extraFieldOffset + fileEntry.extraFieldLength;
 			const versionMadeBy = getUint16(directoryView, offset + 4);
-			const msDosCompatible = (versionMadeBy & 0) == 0;
+			const msDosCompatible = versionMadeBy >> 8 == 0;
+			const unixCompatible = versionMadeBy >> 8 == 3;
 			const rawFilename = directoryArray.subarray(filenameOffset, extraFieldOffset);
 			const commentLength = getUint16(directoryView, offset + 32);
 			const endOffset = commentOffset + commentLength;
 			const rawComment = directoryArray.subarray(commentOffset, endOffset);
 			const filenameUTF8 = languageEncodingFlag;
 			const commentUTF8 = languageEncodingFlag;
-			const directory = msDosCompatible && ((getUint8(directoryView, offset + 38) & FILE_ATTR_MSDOS_DIR_MASK) == FILE_ATTR_MSDOS_DIR_MASK);
+			const externalFileAttributes = getUint32(directoryView, offset + 38);
+			const directory =
+				(msDosCompatible && ((getUint8(directoryView, offset + 38) & FILE_ATTR_MSDOS_DIR_MASK) == FILE_ATTR_MSDOS_DIR_MASK)) ||
+				(unixCompatible && (((externalFileAttributes >> 16) & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR)) ||
+				(rawFilename.length && rawFilename[rawFilename.length - 1] == DIRECTORY_SIGNATURE.charCodeAt(0));
+			const executable = (unixCompatible && (((externalFileAttributes >> 16) & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0));
 			const offsetFileEntry = getUint32(directoryView, offset + 42) + prependedDataLength;
 			Object.assign(fileEntry, {
 				versionMadeBy,
@@ -268,13 +277,16 @@ class ZipReader {
 				directory,
 				offset: offsetFileEntry,
 				diskNumberStart: getUint16(directoryView, offset + 34),
-				internalFileAttribute: getUint16(directoryView, offset + 36),
-				externalFileAttribute: getUint32(directoryView, offset + 38),
+				internalFileAttributes: getUint16(directoryView, offset + 36),
+				externalFileAttributes,
 				rawFilename,
 				filenameUTF8,
 				commentUTF8,
-				rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset)
+				rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset),
+				executable
 			});
+			fileEntry.internalFileAttribute = fileEntry.internalFileAttributes;
+			fileEntry.externalFileAttribute = fileEntry.externalFileAttributes;
 			const decode = getOptionValue(zipReader, options, "decodeText") || decodeText;
 			const rawFilenameEncoding = filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437;
 			const rawCommentEncoding = commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437;
@@ -293,7 +305,8 @@ class ZipReader {
 				directory: directory || filename.endsWith(DIRECTORY_SIGNATURE)
 			});
 			startOffset = Math.max(offsetFileEntry, startOffset);
-			await readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+			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;
@@ -301,7 +314,8 @@ class ZipReader {
 			if (onprogress) {
 				try {
 					await onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
-				} catch (_error) {
+					// eslint-disable-next-line no-unused-vars
+				} catch (_) {
 					// ignored
 				}
 			}
@@ -406,6 +420,7 @@ class ZipEntry {
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, "password");
 		let rawPassword = getOptionValue(zipEntry, options, "rawPassword");
+		const passThrough = getOptionValue(zipEntry, options, "passThrough");
 		password = password && password.length && password;
 		rawPassword = rawPassword && rawPassword.length && rawPassword;
 		if (extraFieldAES) {
@@ -413,7 +428,7 @@ class ZipEntry {
 				throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 			}
 		}
-		if (compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE) {
+		if ((compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE) && !passThrough) {
 			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
 		if (getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
@@ -423,13 +438,16 @@ class ZipEntry {
 		localDirectory.rawExtraField = localDirectory.extraFieldLength ?
 			await readUint8Array(reader, offset + 30 + localDirectory.filenameLength, localDirectory.extraFieldLength, diskNumberStart) :
 			new Uint8Array();
-		await readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
+		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
 		Object.assign(fileEntry, {
 			lastAccessDate: localDirectory.lastAccessDate,
 			creationDate: localDirectory.creationDate
 		});
-		const encrypted = zipEntry.encrypted && localDirectory.encrypted;
+		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);
@@ -451,7 +469,7 @@ class ZipEntry {
 			writer = new WritableStream();
 		}
 		writer = initWriter(writer);
-		await initStream(writer, uncompressedSize);
+		await initStream(writer, passThrough ? compressedSize : uncompressedSize);
 		const { writable } = writer;
 		const { onstart, onprogress, onend } = options;
 		const workerOptions = {
@@ -461,11 +479,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"),
@@ -511,7 +529,7 @@ function readCommonHeader(directory, dataView, offset) {
 	});
 }
 
-async function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory) {
+function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory) {
 	const { rawExtraField } = directory;
 	const extraField = directory.extraField = new Map();
 	const rawExtraFieldView = getDataView(new Uint8Array(rawExtraField));
@@ -526,7 +544,8 @@ async function readCommonFooter(fileEntry, directory, dataView, offset, localDir
 			});
 			offsetExtraField += 4 + size;
 		}
-	} catch (_error) {
+		// eslint-disable-next-line no-unused-vars
+	} catch (_) {
 		// ignored
 	}
 	const compressionMethod = getUint16(dataView, offset + 4);
@@ -542,12 +561,12 @@ async function readCommonFooter(fileEntry, directory, dataView, offset, localDir
 	}
 	const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
 	if (extraFieldUnicodePath) {
-		await readExtraFieldUnicode(extraFieldUnicodePath, PROPERTY_NAME_FILENAME, PROPERTY_NAME_RAW_FILENAME, directory, fileEntry);
+		readExtraFieldUnicode(extraFieldUnicodePath, PROPERTY_NAME_FILENAME, PROPERTY_NAME_RAW_FILENAME, directory, fileEntry);
 		directory.extraFieldUnicodePath = extraFieldUnicodePath;
 	}
 	const extraFieldUnicodeComment = extraField.get(EXTRAFIELD_TYPE_UNICODE_COMMENT);
 	if (extraFieldUnicodeComment) {
-		await readExtraFieldUnicode(extraFieldUnicodeComment, PROPERTY_NAME_COMMENT, PROPERTY_NAME_RAW_COMMENT, directory, fileEntry);
+		readExtraFieldUnicode(extraFieldUnicodeComment, PROPERTY_NAME_COMMENT, PROPERTY_NAME_RAW_COMMENT, directory, fileEntry);
 		directory.extraFieldUnicodeComment = extraFieldUnicodeComment;
 	}
 	const extraFieldAES = extraField.get(EXTRAFIELD_TYPE_AES);
@@ -589,7 +608,7 @@ function readExtraFieldZip64(extraFieldZip64, directory) {
 	}
 }
 
-async function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
+function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
 	const extraFieldView = getDataView(extraFieldUnicode.data);
 	const crc32 = new Crc32();
 	crc32.append(fileEntry[rawPropertyName]);
@@ -633,7 +652,8 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 			}
 			offsetExtraField += 4 + attributeSize;
 		}
-	} catch (_error) {
+		// eslint-disable-next-line no-unused-vars
+	} catch (_) {
 		// ignored
 	}
 	try {
@@ -654,7 +674,8 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 			Object.assign(extraFieldNTFS, extraFieldData);
 			Object.assign(directory, extraFieldData);
 		}
-	} catch (_error) {
+		// eslint-disable-next-line no-unused-vars
+	} catch (_) {
 		// ignored
 	}
 }
@@ -723,7 +744,8 @@ function getDate(timeRaw) {
 	const date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & 0x0000ffff;
 	try {
 		return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
-	} catch (_error) {
+		// eslint-disable-next-line no-unused-vars
+	} catch (_) {
 		// ignored
 	}
 }

package/node_modules/@zip.js/zip.js/lib/core/zip-writer.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global BigInt, TransformStream, Response */
+/* global TransformStream, Response */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -56,6 +56,9 @@ import {
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
 	FILE_ATTR_MSDOS_DIR_MASK,
+	FILE_ATTR_UNIX_TYPE_DIR,
+	FILE_ATTR_UNIX_EXECUTABLE_MASK,
+	FILE_ATTR_UNIX_DEFAULT_MASK,
 	VERSION_DEFLATE,
 	VERSION_ZIP64,
 	VERSION_AES,
@@ -84,8 +87,16 @@ import {
 	PROPERTY_NAME_CREATION_DATE,
 	PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE,
 	PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE,
+	PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
+	PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES,
 	PROPERTY_NAME_MS_DOS_COMPATIBLE,
 	PROPERTY_NAME_ZIP64,
+	PROPERTY_NAME_ENCRYPTED,
+	PROPERTY_NAME_VERSION,
+	PROPERTY_NAME_VERSION_MADE_BY,
+	PROPERTY_NAME_ZIPCRYPTO,
+	PROPERTY_NAME_DIRECTORY,
+	PROPERTY_NAME_EXECUTABLE,
 	Entry
 } from "./zip-entry.js";
 
@@ -98,6 +109,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 +130,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,15 +226,42 @@ 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) {
 	name = name.trim();
-	if (options.directory && (!name.endsWith(DIRECTORY_SIGNATURE))) {
-		name += DIRECTORY_SIGNATURE;
-	} else {
-		options.directory = name.endsWith(DIRECTORY_SIGNATURE);
+	const msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
+	const versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? 20 : 768);
+	const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
+	if (versionMadeBy > MAX_16_BITS) {
+		throw new Error(ERR_INVALID_VERSION);
+	}
+	let externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES, 0);
+	if (externalFileAttributes === 0) {
+		externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE, 0);
+	}
+	if (!options.directory && name.endsWith(DIRECTORY_SIGNATURE)) {
+		options.directory = true;
+	}
+	const directory = getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY);
+	if (directory) {
+		if (!name.endsWith(DIRECTORY_SIGNATURE)) {
+			name += DIRECTORY_SIGNATURE;
+		}
+		if (externalFileAttributes === 0) {
+			externalFileAttributes = FILE_ATTR_MSDOS_DIR_MASK;
+			if (!msDosCompatible) {
+				externalFileAttributes |= (FILE_ATTR_UNIX_TYPE_DIR | FILE_ATTR_UNIX_EXECUTABLE_MASK | FILE_ATTR_UNIX_DEFAULT_MASK) << 16;
+			}
+		}
+	} else if (!msDosCompatible && externalFileAttributes === 0) {
+		if (executable) {
+			externalFileAttributes = (FILE_ATTR_UNIX_EXECUTABLE_MASK | FILE_ATTR_UNIX_DEFAULT_MASK) << 16;
+		} else {
+			externalFileAttributes = FILE_ATTR_UNIX_DEFAULT_MASK << 16;
+		}
 	}
 	const encode = getOptionValue(zipWriter, options, "encodeText", encodeText);
 	let rawFilename = encode(name);
@@ -240,24 +279,25 @@ async function addFile(zipWriter, name, reader, options) {
 	if (getLength(rawComment) > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_ENTRY_COMMENT);
 	}
-	const version = getOptionValue(zipWriter, options, "version", VERSION_DEFLATE);
+	const version = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION, VERSION_DEFLATE);
 	if (version > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_VERSION);
 	}
-	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 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 rawPassword = getOptionValue(zipWriter, options, "rawPassword");
+	let internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, 0);
+	if (internalFileAttributes === 0) {
+		internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE, 0);
+	}
+	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 zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
 	const extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp", true);
 	const keepOrder = getOptionValue(zipWriter, options, "keepOrder", true);
 	const level = getOptionValue(zipWriter, options, "level");
@@ -265,10 +305,12 @@ 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");
+	const compressionMethod = getOptionValue(zipWriter, options, "compressionMethod");
 	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 (!zipCrypto && (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) && !(encryptionStrength >= 1 && encryptionStrength <= 3)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
 	let rawExtraField = new Uint8Array();
@@ -294,18 +336,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 +375,8 @@ async function addFile(zipWriter, name, reader, options) {
 		}
 	}
 	zip64 = zip64 || false;
+	const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
+	const { signature } = options;
 	options = Object.assign({}, options, {
 		rawFilename,
 		rawComment,
@@ -346,13 +400,20 @@ async function addFile(zipWriter, name, reader, options) {
 		zipCrypto,
 		bufferedWrite,
 		keepOrder,
+		useUnicodeFileNames,
 		dataDescriptor,
 		dataDescriptorSignature,
 		signal,
 		msDosCompatible,
-		internalFileAttribute,
-		externalFileAttribute,
-		useCompressionStream
+		internalFileAttribute: internalFileAttributes,
+		internalFileAttributes,
+		externalFileAttribute: externalFileAttributes,
+		externalFileAttributes,
+		useCompressionStream,
+		passThrough,
+		encrypted: Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted),
+		signature,
+		compressionMethod
 	});
 	const headerInfo = getHeaderInfo(options);
 	const dataDescriptorInfo = getDataDescriptorInfo(options);
@@ -468,7 +529,8 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			if (error) {
 				try {
 					error.corruptedEntry = true;
-				} catch (_error) {
+					// eslint-disable-next-line no-unused-vars
+				} catch (_) {
 					// ignored
 				}
 			}
@@ -550,6 +612,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		zipCrypto,
 		dataDescriptor,
 		directory,
+		executable,
 		versionMadeBy,
 		rawComment,
 		rawExtraField,
@@ -561,15 +624,17 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		encryptionStrength,
 		extendedTimestamp,
 		msDosCompatible,
-		internalFileAttribute,
-		externalFileAttribute,
-		useCompressionStream
+		internalFileAttributes,
+		externalFileAttributes,
+		useCompressionStream,
+		passThrough
 	} = options;
 	const fileEntry = {
 		lock,
 		versionMadeBy,
 		zip64,
 		directory: Boolean(directory),
+		executable: Boolean(executable),
 		filenameUTF8: true,
 		rawFilename,
 		commentUTF8: true,
@@ -580,13 +645,18 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawExtraField,
 		extendedTimestamp,
 		msDosCompatible,
-		internalFileAttribute,
-		externalFileAttribute,
+		internalFileAttributes,
+		externalFileAttributes,
 		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 +672,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 +683,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 +730,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		creationDate,
 		lastAccessDate,
 		encrypted,
+		zipCrypto,
 		size: metadataSize + compressedSize,
 		compressionMethod,
 		version,
@@ -679,20 +752,19 @@ 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 { version, compressionMethod } = options;
+	const compressed = !directory && (level > 0 || (level === UNDEFINED_VALUE && compressionMethod !== 0));
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
 		rawExtraFieldAES = new Uint8Array(getLength(EXTRAFIELD_DATA_AES) + 2);
@@ -734,19 +806,33 @@ function getHeaderInfo(options) {
 			setBigUint64(extraFieldNTFSView, 12, lastModTimeNTFS);
 			setBigUint64(extraFieldNTFSView, 20, getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
 			setBigUint64(extraFieldNTFSView, 28, getTimeNTFS(creationDate) || lastModTimeNTFS);
-		} catch (_error) {
+			// eslint-disable-next-line no-unused-vars
+		} catch (_) {
 			rawExtraFieldNTFS = new Uint8Array();
 		}
 	} 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 (compressionMethod === UNDEFINED_VALUE) {
+		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
+	}
+	if (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;
@@ -755,10 +841,8 @@ function getHeaderInfo(options) {
 		bitFlag = bitFlag | BITFLAG_ENCRYPTED;
 		if (!zipCrypto) {
 			version = version > VERSION_AES ? version : VERSION_AES;
+			rawExtraFieldAES[9] = compressionMethod;
 			compressionMethod = COMPRESSION_METHOD_AES;
-			if (compressed) {
-				rawExtraFieldAES[9] = COMPRESSION_METHOD_DEFLATE;
-			}
 		}
 	}
 	const headerArray = new Uint8Array(26);
@@ -1011,15 +1095,13 @@ async function closeFile(zipWriter, comment, options) {
 			rawComment,
 			versionMadeBy,
 			headerArray,
-			directory,
 			zip64,
 			zip64UncompressedSize,
 			zip64CompressedSize,
 			zip64DiskNumberStart,
 			zip64Offset,
-			msDosCompatible,
-			internalFileAttribute,
-			externalFileAttribute,
+			internalFileAttributes,
+			externalFileAttributes,
 			diskNumberStart,
 			uncompressedSize,
 			compressedSize
@@ -1038,11 +1120,9 @@ async function closeFile(zipWriter, comment, options) {
 		setUint16(directoryView, offset + 30, extraFieldLength);
 		setUint16(directoryView, offset + 32, getLength(rawComment));
 		setUint16(directoryView, offset + 34, zip64 && zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
-		setUint16(directoryView, offset + 36, internalFileAttribute);
-		if (externalFileAttribute) {
-			setUint32(directoryView, offset + 38, externalFileAttribute);
-		} else if (directory && msDosCompatible) {
-			setUint8(directoryView, offset + 38, FILE_ATTR_MSDOS_DIR_MASK);
+		setUint16(directoryView, offset + 36, internalFileAttributes);
+		if (externalFileAttributes) {
+			setUint32(directoryView, offset + 38, externalFileAttributes);
 		}
 		setUint32(directoryView, offset + 42, zip64 && zip64Offset ? MAX_32_BITS : fileEntryOffset);
 		arraySet(directoryArray, rawFilename, offset + 46);
@@ -1062,7 +1142,8 @@ async function closeFile(zipWriter, comment, options) {
 		if (options.onprogress) {
 			try {
 				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
-			} catch (_error) {
+				// eslint-disable-next-line no-unused-vars
+			} catch (_) {
 				// ignored
 			}
 		}
@@ -1073,7 +1154,7 @@ async function closeFile(zipWriter, comment, options) {
 	if (availableSize < END_OF_CENTRAL_DIR_LENGTH) {
 		lastDiskNumber++;
 	}
-	let zip64 = getOptionValue(zipWriter, options, "zip64");
+	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_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);

package/node_modules/@zip.js/zip.js/lib/z-worker-inline-template.js

@@ -35,7 +35,7 @@ export {
 function configureWebWorker(configure, options = {}) {
 	// eslint-disable-next-line quotes
 	const code = `__workerCode__`;
-	const uri = options.useDataURI ?
+	const uri = () => options.useDataURI ?
 		`data:text/javascript,${encodeURIComponent(code)}` :
 		URL.createObjectURL(new Blob([code], { type: "text/javascript" }));
 	configure({ workerScripts: { inflate: [uri], deflate: [uri] } });