@zip.js/zip.js 2.11.3 → 2.12.0

package/lib/core/zip-writer.js

@@ -154,7 +154,8 @@ import {
 	OBJECT_TYPE,
 	STRING_TYPE,
 	FUNCTION_TYPE,
-	EMPTY_UINT8_ARRAY
+	EMPTY_UINT8_ARRAY,
+	SYMBOL_ASYNC_DISPOSE
 } from "./constants.js";
 import { getConfiguration } from "./configuration.js";
 import { getRegisteredCodec, ERR_UNSUPPORTED_COMPRESSION } from "./codec-registry.js";
@@ -175,6 +176,7 @@ import {
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
 import { concat, getDataView } from "./util/array.js";
+import { addWarning } from "./util/warnings.js";
 import { toCompatibleReadable, streamToBlob } from "./util/compatible-streams.js";
 import {
 	PROPERTY_NAME_LAST_MODIFICATION_DATE,
@@ -204,7 +206,9 @@ import {
 	PROPERTY_NAME_STICKY,
 	PROPERTY_NAME_MSDOS_ATTRIBUTES,
 	PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW,
-	Entry
+	Entry,
+	getEncryptionOverhead,
+	getUserExtraField
 } from "./zip-entry.js";
 import {
 	OPTION_PASSWORD,
@@ -238,10 +242,14 @@ import {
 	ERR_INVALID_PASSWORD_TYPE,
 	checkFunctionOption,
 	checkSignalOption,
+	throwIfAborted,
 	checkPasswordOption,
+	checkPassThroughOption,
 	checkInteger,
 	checkIntegerOption,
-	toNumber
+	toNumber,
+	OPTION_ENTRY,
+	PASS_THROUGH_COMPRESSED
 } from "./options.js";
 
 const ERR_DUPLICATED_NAME = "File already exists";
@@ -255,7 +263,7 @@ const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 const ERR_UNSUPPORTED_ENCRYPTION_USDZ = "Encryption is not supported in USDZ files";
 const ERR_UNSUPPORTED_SPLIT_USDZ = "Split zip files are not supported in USDZ files";
-const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set";
+const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set to true (use 'compressed' instead)";
 const ERR_INVALID_EXTRAFIELD = "Invalid extra field (must be a Map)";
 const ERR_INVALID_EXTRAFIELD_TYPE = "Invalid extra field type (must be integer 0..65535)";
 const ERR_INVALID_EXTRAFIELD_DATA_TYPE = "Invalid extra field data (must be a Uint8Array)";
@@ -267,6 +275,7 @@ const MAX_NTFS_TIME = BigInt("0x7fffffffffffffff");
 const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
 const ERR_UNDEFINED_COMPRESSION_METHOD = "Undefined compression method";
+const ERR_UNDEFINED_CRC32 = "Undefined CRC32";
 const ERR_UNDETERMINED_SIZE = "Undetermined size";
 const ERR_UNDEFINED_READER = "Undefined reader";
 const ERR_INVALID_READER = "Invalid reader (must be a Reader instance, a ReadableStream instance, or an object with a 'readable' property)";
@@ -280,14 +289,21 @@ const ERR_INVALID_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be intege
 const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
 const ERR_INVALID_LEVEL = "Invalid level (must be integer 0..9)";
 const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
+const ERR_INVALID_ENTRY = "Invalid entry option (must be an entry returned by ZipReader#getEntries())";
+const ERR_ZIP_CRYPTO_LAST_MOD_DATE = "The last modification date of an entry encrypted with ZipCrypto cannot be changed when passThrough is set";
+const WARNING_COMPRESSION_UNAVAILABLE = "compression unavailable";
+const WARNING_CLAMPED_LAST_MODIFICATION_DATE = "clamped last modification date";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
 const EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD = 9;
 const EXTRAFIELD_USDZ_MAX_LENGTH = 67;
+const MIN_PRINTABLE_ASCII_CHARACTER_CODE = 0x20;
+const MAX_PRINTABLE_ASCII_CHARACTER_CODE = 0x7e;
 const VENDOR_VERSION_AE_1 = 1;
 const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 const UNIX_EXTRA_FIELD_TYPE = "unix";
+const LEVEL_BY_BITFLAG_LEVEL = [8, 9, 5, 3];
 const MAX_LEVEL = 9;
 
 let workers = 0;
@@ -314,9 +330,11 @@ class ZipWriter {
 			initialOffset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : options[OPTION_OFFSET] - (writer.size || writer.writable.size || 0),
 			pendingAddFileCalls: new Set(),
 			pendingErrors: [],
+			warnings: [],
 			bufferedWrites: 0,
 			directWrites: 0,
-			lastFileEntry: UNDEFINED_VALUE
+			lastFileEntry: UNDEFINED_VALUE,
+			archiveClosed: false
 		});
 	}
 
@@ -481,6 +499,9 @@ class ZipWriter {
 		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
+		if (zipWriter.archiveClosed) {
+			return getWriterData(writer);
+		}
 		if (!(comment instanceof Uint8Array)) {
 			throw new Error(ERR_INVALID_COMMENT_TYPE);
 		}
@@ -504,11 +525,16 @@ class ZipWriter {
 			throw error;
 		}
 		await closeFile(zipWriter, comment, options);
+		zipWriter.archiveClosed = true;
 		const preventClose = !ownsWritable(writer) && getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
 		if (!preventClose) {
 			await writable.getWriter().close();
 		}
-		return writer.getData ? writer.getData() : writable;
+		return getWriterData(writer);
+	}
+
+	[SYMBOL_ASYNC_DISPOSE]() {
+		return this.close();
 	}
 }
 
@@ -587,6 +613,10 @@ class WatchedPromise extends Promise {
 	}
 }
 
+function getWriterData(writer) {
+	return writer.getData ? writer.getData() : writer.writable;
+}
+
 function watchPromiseError(zipWriter, promise) {
 	const watchedPromise = new WatchedPromise((resolve, reject) => Promise.prototype.then.call(promise, resolve, reject));
 	const watcher = {};
@@ -605,6 +635,14 @@ async function prependZipEntries(zipWriter, reader) {
 
 async function addFileEntry(zipWriter, name, reader, options) {
 	options = Object.assign({}, options);
+	const entry = options[OPTION_ENTRY];
+	if (entry !== UNDEFINED_VALUE) {
+		const { entryOptions, passThroughOptions } = getSourceEntryOptions(entry,
+			checkPassThroughOption(getOptionValue(zipWriter, options, OPTION_PASS_THROUGH)),
+			getOptionValue(zipWriter, options, PROPERTY_NAME_LAST_MODIFICATION_DATE));
+		delete options[OPTION_ENTRY];
+		options = Object.assign(entryOptions, passThroughOptions, options);
+	}
 	if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
 		name += DIRECTORY_SIGNATURE;
 	}
@@ -655,6 +693,7 @@ export {
 	ZipWriter,
 	ZipWriterStream,
 	getEntriesSize,
+	getSourceEntryOptions,
 	ERR_DUPLICATED_NAME,
 	ERR_INVALID_COMMENT,
 	ERR_INVALID_COMMENT_TYPE,
@@ -674,11 +713,14 @@ export {
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
 	ERR_UNDEFINED_COMPRESSION_METHOD,
+	ERR_UNDEFINED_CRC32,
 	ERR_UNDETERMINED_SIZE,
 	ERR_UNDEFINED_READER,
 	ERR_INVALID_READER,
 	ERR_ZIP_NOT_EMPTY,
 	ERR_INVALID_SIGNATURE_DATA,
+	ERR_INVALID_ENTRY,
+	ERR_ZIP_CRYPTO_LAST_MOD_DATE,
 	ERR_INVALID_UID,
 	ERR_INVALID_GID,
 	ERR_INVALID_UNIX_MODE,
@@ -688,7 +730,9 @@ export {
 	ERR_INVALID_MSDOS_DATA,
 	ERR_INVALID_LEVEL,
 	ERR_INVALID_PASSWORD_TYPE,
-	ERR_UNSUPPORTED_CRYPTO_API
+	ERR_UNSUPPORTED_CRYPTO_API,
+	WARNING_COMPRESSION_UNAVAILABLE,
+	WARNING_CLAMPED_LAST_MODIFICATION_DATE
 };
 
 async function addFile(zipWriter, name, reader, options) {
@@ -709,21 +753,33 @@ async function addFile(zipWriter, name, reader, options) {
 	try {
 		const { resolvedOptions } = metadataInfo;
 		if (resolvedOptions.level != 0 && resolvedOptions.compressionMethod === UNDEFINED_VALUE &&
-			!resolvedOptions.passThrough && !(await supportsDeflate(getConfiguration()))) {
+			!resolvedOptions.passThroughCompression && !(await supportsDeflate(getConfiguration()))) {
 			resolvedOptions.level = 0;
+			addWarning(zipWriter.warnings, WARNING_COMPRESSION_UNAVAILABLE, name);
 		}
 		const sizesInfo = await resolveSizes(zipWriter, reader, metadataInfo, options);
 		({ reader } = sizesInfo);
 		const diskOffset = getDiskOffset(zipWriter.writer);
 		const diskNumber = getDiskNumber(zipWriter.writer);
+		let crc32 = options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32;
+		const storesAE2 = sizesInfo.resolvedOptions.encrypted && !resolvedOptions.zipCrypto;
+		if (resolvedOptions.passThroughCompression && !resolvedOptions.passThroughEncryption && storesAE2) {
+			crc32 = UNDEFINED_VALUE;
+		}
+		if (resolvedOptions.passThroughCompression && reader && !storesAE2 && crc32 === UNDEFINED_VALUE) {
+			throw new Error(ERR_UNDEFINED_CRC32);
+		}
 		options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
 			signature: options[PROPERTY_NAME_SIGNATURE],
-			crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
+			crc32,
 			offset: zipWriter.offset - diskOffset,
 			diskNumberStart: diskNumber,
 			[OPTION_USDZ]: zipWriter.options[OPTION_USDZ]
 		});
 		const headerInfo = getHeaderInfo(options);
+		if (headerInfo.lastModDateClamped) {
+			addWarning(zipWriter.warnings, WARNING_CLAMPED_LAST_MODIFICATION_DATE, name);
+		}
 		const dataDescriptorInfo = getDataDescriptorInfo(options);
 		const metadataSize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray);
 		fileEntry = await getFileEntry(zipWriter, name, reader, {
@@ -750,6 +806,95 @@ async function addFile(zipWriter, name, reader, options) {
 	return new Entry(fileEntry);
 }
 
+function getSourceEntryOptions(entry, passThrough, lastModDateOverride) {
+	if (entry === null || typeof entry != OBJECT_TYPE || Array.isArray(entry)) {
+		throw new Error(ERR_INVALID_ENTRY);
+	}
+	const {
+		externalFileAttributes,
+		versionMadeBy,
+		comment,
+		lastModDate,
+		rawLastModDate,
+		creationDate,
+		lastAccessDate,
+		uncompressedSize,
+		encrypted,
+		zipCrypto,
+		crc32,
+		compressionMethod,
+		extraFieldAES,
+		extraFieldUnix,
+		internalFileAttributes,
+		extraField,
+		bitFlag,
+		directory,
+		uid,
+		gid
+	} = entry;
+	const entryOptions = {
+		externalFileAttributes,
+		versionMadeBy,
+		comment,
+		lastModDate,
+		creationDate,
+		lastAccessDate,
+		internalFileAttributes,
+		directory
+	};
+	if (bitFlag && bitFlag.languageEncodingFlag) {
+		entryOptions[OPTION_USE_UNICODE_FILE_NAMES] = true;
+	}
+	const userExtraField = getUserExtraField(extraField);
+	if (userExtraField) {
+		entryOptions[PROPERTY_NAME_EXTRA_FIELD] = userExtraField;
+	}
+	if (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE) {
+		Object.assign(entryOptions, {
+			uid,
+			gid,
+			unixExtraFieldType: extraFieldUnix ? UNIX_EXTRA_FIELD_TYPE : INFOZIP_EXTRA_FIELD_TYPE
+		});
+	}
+	const passThroughOptions = {};
+	if (passThrough && !directory) {
+		Object.assign(passThroughOptions, {
+			uncompressedSize,
+			crc32,
+			compressionMethod
+		});
+		if (passThrough !== PASS_THROUGH_COMPRESSED) {
+			Object.assign(passThroughOptions, {
+				encrypted,
+				zipCrypto,
+				encryptionStrength: extraFieldAES ? extraFieldAES.strength : UNDEFINED_VALUE
+			});
+		}
+		if (bitFlag) {
+			passThroughOptions.dataDescriptor = bitFlag.dataDescriptor;
+			passThroughOptions[OPTION_LEVEL] = LEVEL_BY_BITFLAG_LEVEL[bitFlag.level];
+		}
+		if (lastModDateOverride === UNDEFINED_VALUE) {
+			passThroughOptions.rawLastModDate = rawLastModDate;
+		} else if (passThrough !== PASS_THROUGH_COMPRESSED && zipCrypto && (!bitFlag || bitFlag.dataDescriptor) &&
+			lastModDateOverride instanceof Date &&
+			getDosTimeHighByte(lastModDateOverride) != ((rawLastModDate >>> 8) & MAX_8_BITS)) {
+			throw new Error(ERR_ZIP_CRYPTO_LAST_MOD_DATE);
+		}
+	}
+	return { entryOptions, passThroughOptions };
+}
+
+function getDosTimeHighByte(lastModDate) {
+	let dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
+	if (dosLastModDate < MIN_DATE) {
+		dosLastModDate = MIN_DATE;
+	} else if (dosLastModDate > MAX_DATE) {
+		dosLastModDate = MAX_DATE;
+	}
+	return ((dosLastModDate.getHours() << 3) | (dosLastModDate.getMinutes() >> 3)) & MAX_8_BITS;
+}
+
 function resolveAttributes(zipWriter, name, options) {
 	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
 	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
@@ -903,7 +1048,9 @@ function resolveMetadata(zipWriter, name, options) {
 	const lastAccessDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_LAST_ACCESS_DATE);
 	const creationDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_CREATION_DATE);
 	const internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, 0);
-	const passThrough = getOptionValue(zipWriter, options, OPTION_PASS_THROUGH);
+	const passThrough = checkPassThroughOption(getOptionValue(zipWriter, options, OPTION_PASS_THROUGH));
+	const passThroughCompression = Boolean(passThrough);
+	const passThroughEncryption = passThrough === true;
 	const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
 	const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
 	checkPasswordOption(password, rawPassword);
@@ -918,10 +1065,12 @@ function resolveMetadata(zipWriter, name, options) {
 	const createTempStream = getFunctionOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
 	const signal = checkSignalOption(getOptionValue(zipWriter, options, OPTION_SIGNAL));
-	const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
+	throwIfAborted(signal);
+	const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES,
+		!isPrintableASCIIText(rawFilename) || !isPrintableASCIIText(rawComment));
 	const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
-	const registeredCodec = passThrough || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
-	if (!passThrough && compressionMethod !== UNDEFINED_VALUE &&
+	const registeredCodec = passThroughCompression || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
+	if (!passThroughCompression && compressionMethod !== UNDEFINED_VALUE &&
 		compressionMethod !== COMPRESSION_METHOD_STORE && compressionMethod !== COMPRESSION_METHOD_DEFLATE && !registeredCodec) {
 		throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 	}
@@ -935,15 +1084,15 @@ function resolveMetadata(zipWriter, name, options) {
 			level = 0;
 		}
 	}
-	if (passThrough) {
-		level = UNDEFINED_VALUE;
+	if (passThroughCompression) {
+		level = toNumber(options[OPTION_LEVEL]);
 	}
 	let useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
 	let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
 	if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
 		dataDescriptor = false;
 	}
-	if (dataDescriptor === UNDEFINED_VALUE || (zipCrypto && !passThrough)) {
+	if (dataDescriptor === UNDEFINED_VALUE || (zipCrypto && !passThroughEncryption)) {
 		dataDescriptor = true;
 	}
 	if (level !== UNDEFINED_VALUE && level != 6) {
@@ -967,7 +1116,8 @@ function resolveMetadata(zipWriter, name, options) {
 			lastAccessDate,
 			creationDate,
 			internalFileAttributes,
-			passThrough,
+			passThroughCompression,
+			passThroughEncryption,
 			password,
 			rawPassword,
 			encryptionStrength,
@@ -1028,7 +1178,7 @@ function serializeExtraField(extraField) {
 }
 
 async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, options) {
-	if (metadata.passThrough && !reader && !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY)) {
+	if (metadata.passThroughCompression && !reader && !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY)) {
 		throw new Error(ERR_UNDEFINED_READER);
 	}
 	let contentSize;
@@ -1044,12 +1194,12 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 }
 
 function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options) {
-	const { passThrough, zipCrypto, password, rawPassword, encryptionStrength } = metadata;
+	const { passThroughCompression, passThroughEncryption, zipCrypto, password, rawPassword, encryptionStrength } = metadata;
 	let { dataDescriptor, zip64, level, compressionMethod } = metadata;
 	let maximumCompressedSize = 0;
 	let uncompressedSize = 0;
 	let unknownSize = false;
-	if (passThrough && hasContent) {
+	if (passThroughCompression && hasContent) {
 		uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 		if (uncompressedSize === UNDEFINED_VALUE) {
 			throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
@@ -1060,17 +1210,17 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 	}
 	const zip64Enabled = zip64 === true;
 	const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
-	if (hasContent && passThrough && !encrypted && getLength(password, rawPassword)) {
+	if (hasContent && passThroughEncryption && !encrypted && getLength(password, rawPassword)) {
 		throw new Error(ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH);
 	}
-	const encryptedEntry = hasContent && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
+	const encryptedEntry = hasContent && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThroughEncryption && encrypted));
 	if (!hasContent) {
 		level = 0;
 		compressionMethod = COMPRESSION_METHOD_STORE;
 	}
-	const encryptionOverhead = encryptedEntry ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
+	const encryptionOverhead = getEncryptionOverhead(encryptedEntry, zipCrypto, encryptionStrength);
 	if (hasContent) {
-		if (!passThrough) {
+		if (!passThroughCompression) {
 			if (contentSize === UNDEFINED_VALUE) {
 				dataDescriptor = true;
 				if (zip64 || zip64 === UNDEFINED_VALUE) {
@@ -1083,10 +1233,12 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 			}
 		} else {
 			options.uncompressedSize = uncompressedSize;
-			maximumCompressedSize = contentSize === UNDEFINED_VALUE ? getMaximumCompressedSize(uncompressedSize) + encryptionOverhead : contentSize;
+			maximumCompressedSize = contentSize === UNDEFINED_VALUE ?
+				getMaximumCompressedSize(uncompressedSize) + encryptionOverhead :
+				contentSize + (passThroughEncryption ? 0 : encryptionOverhead);
 		}
 	}
-	const emptyEntry = !encryptedEntry && (!hasContent || (contentSize === 0 && !passThrough)) && !isCompressed(compressionMethod, level);
+	const emptyEntry = !encryptedEntry && (!hasContent || (contentSize === 0 && !passThroughCompression)) && !isCompressed(compressionMethod, level);
 	if (emptyEntry && !zipCrypto && getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR) === UNDEFINED_VALUE) {
 		dataDescriptor = false;
 	}
@@ -1135,6 +1287,8 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 	const initialOffset = writerOptions[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : writerOptions[OPTION_OFFSET];
 	let offset = initialOffset;
 	let minimumEntrySize = INFINITY_VALUE;
+	const entrySizes = [];
+	const entriesAlreadyZip64 = new Set();
 	for (const entry of entries) {
 		let { name } = entry;
 		const { size } = entry;
@@ -1146,7 +1300,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		({ name } = attributesInfo);
 		const { resolvedOptions: metadata } = resolveMetadata(zipWriter, name, options);
 		if (metadata.level != 0 && metadata.compressionMethod === UNDEFINED_VALUE &&
-			!metadata.passThrough && !(await supportsDeflate(getConfiguration()))) {
+			!metadata.passThroughCompression && !(await supportsDeflate(getConfiguration()))) {
 			metadata.level = 0;
 		}
 		const hasContent = !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY);
@@ -1154,7 +1308,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 			throw new Error(ERR_UNDETERMINED_SIZE);
 		}
 		const { maximumCompressedSize, resolvedOptions: sizes } = resolveEntrySizes(zipWriter, hasContent, size, metadata, options);
-		if (hasContent && !metadata.passThrough && isCompressed(sizes.compressionMethod, sizes.level)) {
+		if (hasContent && !metadata.passThroughCompression && isCompressed(sizes.compressionMethod, sizes.level)) {
 			throw new Error(ERR_UNDETERMINED_SIZE);
 		}
 		const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes, { [OPTION_USDZ]: usdz });
@@ -1174,10 +1328,15 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 			compressedSize
 		}));
 		const entrySize = entryInfo.metadataSize + compressedSize;
+		entrySizes.push(entrySize);
+		entriesAlreadyZip64.add(Boolean(entryOptions.zip64Enabled ||
+			entryOptions.uncompressedSize >= MAX_32_BITS || compressedSize >= MAX_32_BITS));
 		minimumEntrySize = Math.min(minimumEntrySize, entrySize);
 		offset += entrySize;
 	}
-	const layoutDependsOnWriteOrder = files.size > 1 && (usdz || offset - minimumEntrySize >= MAX_32_BITS);
+	const layoutDependsOnWriteOrder = files.size > 1 && (usdz ||
+		(offset - minimumEntrySize >= MAX_32_BITS &&
+			(entriesAlreadyZip64.size > 1 || countEntriesBefore4GB(entrySizes, initialOffset, true) != countEntriesBefore4GB(entrySizes, initialOffset, false))));
 	if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 		throw new Error(ERR_UNDETERMINED_SIZE);
 	}
@@ -1195,6 +1354,20 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 	return offset - initialOffset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 }
 
+function countEntriesBefore4GB(entrySizes, initialOffset, largestFirst) {
+	const ordered = entrySizes.slice().sort((first, second) => largestFirst ? second - first : first - second);
+	let position = initialOffset;
+	let count = 0;
+	for (const entrySize of ordered) {
+		if (position >= MAX_32_BITS) {
+			break;
+		}
+		position += entrySize;
+		count++;
+	}
+	return count;
+}
+
 async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		fileEntries,
@@ -1370,6 +1543,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		extraFieldExtendedTimestampFlag,
+		extraFieldExtendedTimestampTime,
 		rawExtraFieldNTFS,
 		rawExtraFieldUnix,
 		rawExtraFieldAES,
@@ -1382,6 +1556,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		password,
 		rawPassword,
 		level,
+		useUnicodeFileNames,
 		zip64,
 		zip64Enabled,
 		zip64UncompressedSize,
@@ -1416,7 +1591,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		msdosAttributesRaw,
 		msdosAttributes,
 		useCompressionStream,
-		passThrough,
+		passThroughCompression,
+		passThroughEncryption,
 		format,
 		codecURI
 	} = options;
@@ -1427,9 +1603,9 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		zip64Enabled,
 		directory: Boolean(directory),
 		executable: Boolean(executable),
-		filenameUTF8: true,
+		filenameUTF8: Boolean(useUnicodeFileNames),
 		rawFilename,
-		commentUTF8: true,
+		commentUTF8: Boolean(useUnicodeFileNames),
 		rawComment,
 		rawExtraFieldZip64,
 		localExtraFieldZip64Length,
@@ -1460,7 +1636,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		uncompressedSize
 	} = options;
 	let compressedSize = 0;
-	if (!passThrough) {
+	if (!passThroughCompression) {
 		uncompressedSize = 0;
 	}
 	const { writable } = writer;
@@ -1477,9 +1653,9 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 				encryptionStrength,
 				zipCrypto: encrypted && zipCrypto,
 				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & MAX_8_BITS,
-				computeCrc32: !passThrough,
-				compressed: compressed && !passThrough,
-				encrypted: encrypted && !passThrough,
+				computeCrc32: !passThroughCompression,
+				compressed: compressed && !passThroughCompression,
+				encrypted: encrypted && !passThroughEncryption,
 				useWebWorkers,
 				useCompressionStream,
 				transferStreams,
@@ -1494,7 +1670,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 			const result = await runWorker({ readable, writable }, workerOptions);
 			compressedSize = result.outputSize;
 			writer.size += compressedSize;
-			if (!passThrough) {
+			if (!passThroughCompression) {
 				uncompressedSize = result.inputSize;
 				if (!encrypted || zipCrypto) {
 					crc32 = result.crc32;
@@ -1537,8 +1713,9 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		headerArray,
 		headerView,
 		signature: crc32,
-		crc32: encrypted && !zipCrypto && !passThrough ? UNDEFINED_VALUE : crc32,
+		crc32: encrypted && !zipCrypto && !passThroughCompression ? UNDEFINED_VALUE : crc32,
 		extraFieldExtendedTimestampFlag,
+		extraFieldExtendedTimestampTime,
 		zip64UncompressedSize,
 		zip64CompressedSize
 	});
@@ -1563,7 +1740,7 @@ function getHeaderInfo(options) {
 		encryptionStrength,
 		extendedTimestamp,
 		ntfsTimestamp,
-		passThrough,
+		passThroughCompression,
 		encrypted,
 		zip64UncompressedSize,
 		zip64CompressedSize,
@@ -1574,7 +1751,7 @@ function getHeaderInfo(options) {
 	let { version, compressionMethod } = options;
 	const compressed = !directory && isCompressed(compressionMethod, level);
 	let rawLocalExtraFieldZip64;
-	const uncompressedFile = passThrough || !compressed;
+	const uncompressedFile = passThroughCompression || !compressed;
 	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || (uncompressedFile && !unknownSize)));
 	const writeLocalExtraFieldZip64 = zip64ExtraFieldComplete || (zip64 && dataDescriptor && (zip64UncompressedSize || zip64CompressedSize));
 	if (zip64 && (zip64UncompressedSize || zip64CompressedSize)) {
@@ -1586,8 +1763,8 @@ function getHeaderInfo(options) {
 		if (zip64ExtraFieldComplete) {
 			extraFieldZip64.writeUint64(uncompressedSize);
 			if (uncompressedFile) {
-				const encryptionOverhead = encrypted ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
-				extraFieldZip64.writeUint64(passThrough ? 0 : uncompressedSize + encryptionOverhead);
+				const encryptionOverhead = getEncryptionOverhead(encrypted, zipCrypto, encryptionStrength);
+				extraFieldZip64.writeUint64(passThroughCompression ? 0 : uncompressedSize + encryptionOverhead);
 			}
 		}
 	} else {
@@ -1606,6 +1783,7 @@ function getHeaderInfo(options) {
 	let rawExtraFieldNTFS;
 	let rawExtraFieldExtendedTimestamp;
 	let extraFieldExtendedTimestampFlag;
+	let extraFieldExtendedTimestampTime;
 	if (extendedTimestamp) {
 		const lastModTimeUnix = getTimeUnix(lastModDate);
 		const lastModTimeUnixInRange = inUnixTimeRange(lastModTimeUnix);
@@ -1613,6 +1791,7 @@ function getHeaderInfo(options) {
 			const extraFieldTimestampLength = 9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0);
 			const extraFieldTimestamp = createRecordWriter(extraFieldTimestampLength);
 			extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
+			extraFieldExtendedTimestampTime = lastModTimeUnix;
 			extraFieldTimestamp.writeUint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
 			extraFieldTimestamp.writeUint16(extraFieldTimestampLength - 4);
 			extraFieldTimestamp.writeUint8(extraFieldExtendedTimestampFlag);
@@ -1696,7 +1875,7 @@ function getHeaderInfo(options) {
 	}
 	if (encrypted && !zipCrypto) {
 		version = version > VERSION_AES ? version : VERSION_AES;
-		if (passThrough && crc32 !== UNDEFINED_VALUE) {
+		if (passThroughCompression && crc32 !== UNDEFINED_VALUE) {
 			rawExtraFieldAES[EXTRAFIELD_OFFSET_AES_VENDOR_VERSION] = VENDOR_VERSION_AE_1;
 		}
 		setUint16(getDataView(rawExtraFieldAES), EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD, compressionMethod);
@@ -1758,12 +1937,14 @@ function getHeaderInfo(options) {
 		headerArray,
 		headerView,
 		lastModDate: storedLastModDate,
+		lastModDateClamped: storedLastModDate === clampedLastModDate && dosLastModDate.getTime() != clampedLastModDate.getTime(),
 		rawLastModDate,
 		encrypted,
 		compressed,
 		version,
 		compressionMethod,
 		extraFieldExtendedTimestampFlag,
+		extraFieldExtendedTimestampTime,
 		rawExtraFieldZip64: EMPTY_UINT8_ARRAY,
 		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
@@ -1866,7 +2047,7 @@ function setEntryInfo({
 }, {
 	zip64,
 	zipCrypto,
-	passThrough,
+	passThroughCompression,
 	dataDescriptor
 }) {
 	const {
@@ -1877,7 +2058,7 @@ function setEntryInfo({
 		dataDescriptorView,
 		dataDescriptorOffset
 	} = dataDescriptorInfo;
-	if ((!encrypted || zipCrypto || passThrough) && crc32 !== UNDEFINED_VALUE) {
+	if ((!encrypted || zipCrypto || passThroughCompression) && crc32 !== UNDEFINED_VALUE) {
 		setUint32(headerView, HEADER_OFFSET_SIGNATURE, crc32);
 		if (dataDescriptor) {
 			setUint32(dataDescriptorView, dataDescriptorOffset, crc32);
@@ -1908,9 +2089,9 @@ function updateLocalHeader({
 	uncompressedSize,
 	zip64UncompressedSize,
 	zip64CompressedSize
-}, localHeaderView, { dataDescriptor, passThrough }) {
+}, localHeaderView, { dataDescriptor, passThroughCompression }) {
 	if (!dataDescriptor) {
-		if (!encrypted || (passThrough && crc32 !== UNDEFINED_VALUE)) {
+		if (!encrypted || (passThroughCompression && crc32 !== UNDEFINED_VALUE)) {
 			setUint32(localHeaderView, HEADER_OFFSET_SIGNATURE + LOCAL_HEADER_COMMON_OFFSET, crc32);
 		}
 		if (!zip64CompressedSize) {
@@ -1947,9 +2128,8 @@ function createDirectoryRecords(files) {
 			rawExtraFieldUnix,
 			rawExtraField,
 			rawCentralExtraField,
-			extendedTimestamp,
 			extraFieldExtendedTimestampFlag,
-			lastModDate,
+			extraFieldExtendedTimestampTime,
 			zip64Enabled,
 			uncompressedSize,
 			compressedSize
@@ -1992,16 +2172,15 @@ function createDirectoryRecords(files) {
 		fileEntry.zip64Offset = zip64Offset;
 		fileEntry.zip64DiskNumberStart = zip64DiskNumberStart;
 		let rawExtraFieldTimestamp;
-		const lastModTimeUnix = getTimeUnix(lastModDate);
-		if (extendedTimestamp && inUnixTimeRange(lastModTimeUnix)) {
+		if (extraFieldExtendedTimestampTime === UNDEFINED_VALUE) {
+			rawExtraFieldTimestamp = EMPTY_UINT8_ARRAY;
+		} else {
 			const extraFieldTimestamp = createRecordWriter(9);
 			extraFieldTimestamp.writeUint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
 			extraFieldTimestamp.writeUint16(5);
 			extraFieldTimestamp.writeUint8(extraFieldExtendedTimestampFlag);
-			extraFieldTimestamp.writeUint32(lastModTimeUnix);
+			extraFieldTimestamp.writeUint32(extraFieldExtendedTimestampTime);
 			rawExtraFieldTimestamp = extraFieldTimestamp.array;
-		} else {
-			rawExtraFieldTimestamp = EMPTY_UINT8_ARRAY;
 		}
 		fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
 		const extraFieldLength = getLength(
@@ -2501,6 +2680,11 @@ function getHeaderArrayData({
 	};
 }
 
+function isPrintableASCIIText(rawText) {
+	return rawText.every(characterCode =>
+		characterCode >= MIN_PRINTABLE_ASCII_CHARACTER_CODE && characterCode <= MAX_PRINTABLE_ASCII_CHARACTER_CODE);
+}
+
 function getBitFlag(level, useUnicodeFileNames, dataDescriptor, encrypted, compressionMethod) {
 	let bitFlag = 0;
 	if (useUnicodeFileNames) {