@zip.js/zip.js 2.8.51 → 2.8.52

package/dist/zip.js

@@ -90,6 +90,8 @@
 	const FILE_ATTR_MSDOS_ARCHIVE_MASK = 0x20;
 	const FILE_ATTR_UNIX_TYPE_MASK = 0o170000;
 	const FILE_ATTR_UNIX_TYPE_DIR = 0o040000;
+	const FILE_ATTR_UNIX_TYPE_SYMLINK = 0o120000;
+	const FILE_ATTR_UNIX_TYPE_FILE = 0o100000;
 	const FILE_ATTR_UNIX_EXECUTABLE_MASK = 0o111;
 	const FILE_ATTR_UNIX_DEFAULT_MASK = 0o644;
 	const FILE_ATTR_UNIX_SETUID_MASK = 0o4000;
@@ -1781,8 +1783,6 @@
 	 */
 
 
-	const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
-
 	function toCompatibleReadable(readable) {
 		if (readable instanceof ReadableStream) {
 			return readable;
@@ -1805,12 +1805,9 @@
 
 	function streamToBlob(readable, contentType) {
 		readable = toCompatibleReadable(readable);
+		const blobOptions = contentType ? { type: contentType } : {};
 		if (responseSupportsGlobalReadable()) {
-			const options = {};
-			if (contentType) {
-				options.headers = [[HTTP_HEADER_CONTENT_TYPE, contentType]];
-			}
-			return new Response(readable, options).blob();
+			return new Response(readable).blob().then(blob => contentType ? new Blob([blob], blobOptions) : blob);
 		}
 		const chunks = [];
 		return readable
@@ -1819,7 +1816,7 @@
 					chunks.push(chunk);
 				}
 			}))
-			.then(() => new Blob(chunks, contentType ? { type: contentType } : {}));
+			.then(() => new Blob(chunks, blobOptions));
 	}
 
 	function responseSupportsGlobalReadable() {
@@ -3354,8 +3351,10 @@
 				async pull(controller) {
 					const dataSize = size === UNDEFINED_VALUE ? chunkSize : Math.min(chunkSize, size - chunkOffset);
 					const data = await readUint8Array(reader, offset + chunkOffset, dataSize);
-					controller.enqueue(data);
-					if ((chunkOffset + chunkSize > size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
+					if (data.length) {
+						controller.enqueue(data);
+					}
+					if ((chunkOffset + chunkSize >= size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
 						controller.close();
 					} else {
 						chunkOffset += chunkSize;
@@ -3433,6 +3432,7 @@
 		constructor(contentType) {
 			super();
 			Object.assign(this, {
+				contentType,
 				data: "data:" + (contentType || "") + ";base64,",
 				pending: []
 			});
@@ -3534,6 +3534,7 @@
 					return transformStream.writable;
 				}
 			});
+			writer.contentType = contentType;
 			writer.blob = streamToBlob(transformStream.readable, contentType);
 			writer.blob.catch(() => { });
 		}
@@ -4213,6 +4214,10 @@
 		}
 	}
 
+	function ownsWritable(writer) {
+		return Boolean(writer && writer.getData);
+	}
+
 	function isHttpFamily(url) {
 		const { baseURI } = getConfiguration();
 		const { protocol } = new URL(url, baseURI);
@@ -4357,6 +4362,8 @@
 	const PROPERTY_NAME_RAW_CREATION_DATE = "rawCreationDate";
 	const PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES = "internalFileAttributes";
 	const PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES = "externalFileAttributes";
+	const PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES = "internalFileAttribute";
+	const PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES = "externalFileAttribute";
 	const PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW = "msdosAttributesRaw";
 	const PROPERTY_NAME_MSDOS_ATTRIBUTES = "msdosAttributes";
 	const PROPERTY_NAME_MS_DOS_COMPATIBLE = "msDosCompatible";
@@ -4367,6 +4374,7 @@
 	const PROPERTY_NAME_ZIPCRYPTO = "zipCrypto";
 	const PROPERTY_NAME_DIRECTORY = "directory";
 	const PROPERTY_NAME_EXECUTABLE = "executable";
+	const PROPERTY_NAME_SYMLINK = "symlink";
 	const PROPERTY_NAME_COMPRESSION_METHOD = "compressionMethod";
 	const PROPERTY_NAME_SIGNATURE = "signature";
 	const PROPERTY_NAME_CRC32 = "crc32";
@@ -4410,6 +4418,8 @@
 		PROPERTY_NAME_DISK_NUMBER_START,
 		PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
 		PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES,
+		PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES,
+		PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES,
 		PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW,
 		PROPERTY_NAME_MSDOS_ATTRIBUTES,
 		PROPERTY_NAME_MS_DOS_COMPATIBLE,
@@ -4420,6 +4430,7 @@
 		PROPERTY_NAME_ZIPCRYPTO,
 		PROPERTY_NAME_DIRECTORY,
 		PROPERTY_NAME_EXECUTABLE,
+		PROPERTY_NAME_SYMLINK,
 		PROPERTY_NAME_COMPRESSION_METHOD,
 		PROPERTY_NAME_SIGNATURE,
 		PROPERTY_NAME_CRC32,
@@ -4882,15 +4893,18 @@
 				const setuid = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_SETUID_MASK);
 				const setgid = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_SETGID_MASK);
 				const sticky = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_STICKY_MASK);
-				const executable = (fileEntry.unixMode !== UNDEFINED_VALUE)
+				const unixType = fileEntry.unixMode === UNDEFINED_VALUE ? unixExternalUpper : fileEntry.unixMode;
+				const symlink = (unixType & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK;
+				const executable = !symlink && ((fileEntry.unixMode !== UNDEFINED_VALUE)
 					? ((fileEntry.unixMode & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)
-					: (unixCompatible && ((unixExternalUpper & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0));
+					: (unixCompatible && ((unixExternalUpper & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)));
 				const modeIsDir = fileEntry.unixMode !== UNDEFINED_VALUE && ((fileEntry.unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR);
 				const upperIsDir = ((unixExternalUpper & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR);
 				Object.assign(fileEntry, {
 					setuid,
 					setgid,
 					sticky,
+					symlink,
 					unixExternalUpper,
 					internalFileAttribute: fileEntry.internalFileAttributes,
 					externalFileAttribute: fileEntry.externalFileAttributes,
@@ -4956,6 +4970,10 @@
 		}
 
 		async close() {
+			const { reader } = this;
+			if (!reader.readUint8Array && reader.readable && !reader.readable.locked) {
+				await reader.readable.cancel();
+			}
 		}
 	}
 
@@ -5180,7 +5198,7 @@
 					throw error;
 				}
 			} finally {
-				const preventClose = getOptionValue$1(zipEntry, options, OPTION_PREVENT_CLOSE);
+				const preventClose = !ownsWritable(writer) && getOptionValue$1(zipEntry, options, OPTION_PREVENT_CLOSE);
 				if (!preventClose && writable && !writable.locked) {
 					const writableWriter = writable.getWriter();
 					if (abortError) {
@@ -5424,8 +5442,8 @@
 			return;
 		}
 		const extraFieldView = getDataView(extraField.data);
-		const lastAccessDate = new Date(getUint32(extraFieldView, 0) * 1000);
-		const lastModDate = new Date(getUint32(extraFieldView, 4) * 1000);
+		const lastAccessDate = new Date((getUint32(extraFieldView, 0) | 0) * 1000);
+		const lastModDate = new Date((getUint32(extraFieldView, 4) | 0) * 1000);
 		const extraFieldData = { lastAccessDate, lastModDate };
 		if (extraField.data.length >= 12) {
 			extraFieldData.uid = getUint16(extraFieldView, 8);
@@ -5856,6 +5874,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_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set";
 	const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 	const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
 	const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
@@ -5865,6 +5884,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_UNDETERMINED_SIZE = "Undetermined size";
 	const ERR_UNDEFINED_READER = "Undefined reader";
 	const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
 	const ERR_INVALID_UID = "Invalid uid (must be integer 0..2^32-1)";
@@ -6072,7 +6092,7 @@
 				await Promise.allSettled(Array.from(pendingAddFileCalls));
 			}
 			await closeFile(zipWriter, comment, options);
-			const preventClose = getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
+			const preventClose = !ownsWritable(writer) && getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
 			if (!preventClose) {
 				await writable.getWriter().close();
 			}
@@ -6231,7 +6251,7 @@
 		if (versionMadeBy > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_VERSION);
 		}
-		let externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES);
+		let externalFileAttributes = getAliasedOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES);
 		const externalFileAttributesProvided = externalFileAttributes !== UNDEFINED_VALUE;
 		if (!externalFileAttributesProvided) {
 			externalFileAttributes = 0;
@@ -6279,7 +6299,9 @@
 			}
 			if (!externalFileAttributesProvided || unixModeProvided) {
 				if (directory) {
-					unixMode |= FILE_ATTR_UNIX_TYPE_DIR;
+					unixMode = (unixMode & ~FILE_ATTR_UNIX_TYPE_MASK) | FILE_ATTR_UNIX_TYPE_DIR;
+				} else if (!(unixMode & FILE_ATTR_UNIX_TYPE_MASK)) {
+					unixMode |= FILE_ATTR_UNIX_TYPE_FILE;
 				}
 				externalFileAttributes = ((unixMode & MAX_16_BITS) << 16) | (externalFileAttributes & MAX_16_BITS);
 			}
@@ -6332,15 +6354,12 @@
 		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 internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, 0);
+		const internalFileAttributes = getAliasedOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES, 0);
 		const passThrough = getOptionValue(zipWriter, options, OPTION_PASS_THROUGH);
-		let password, rawPassword;
-		if (!passThrough) {
-			password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
-			rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
-			if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
-				throw new Error(ERR_INVALID_PASSWORD_TYPE);
-			}
+		const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
+		const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
+		if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
+			throw new Error(ERR_INVALID_PASSWORD_TYPE);
 		}
 		const encryptionStrength = getNumberOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 		const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
@@ -6453,14 +6472,24 @@
 	}
 
 	async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, options) {
+		if (metadata.passThrough && !reader && !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY)) {
+			throw new Error(ERR_UNDEFINED_READER);
+		}
+		let contentSize;
+		if (reader) {
+			reader = new GenericReader(reader);
+			await initStream(reader);
+			({ size: contentSize } = reader);
+		}
+		return Object.assign({ reader }, resolveEntrySizes(zipWriter, Boolean(reader), contentSize, metadata, options));
+	}
+
+	function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options) {
 		const { passThrough, zipCrypto, password, rawPassword, encryptionStrength } = metadata;
 		let { dataDescriptor, zip64, level, compressionMethod } = metadata;
 		let maximumCompressedSize = 0;
 		let uncompressedSize = 0;
-		if (passThrough) {
-			if (!reader) {
-				throw new Error(ERR_UNDEFINED_READER);
-			}
+		if (passThrough && hasContent) {
 			uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 			if (uncompressedSize === UNDEFINED_VALUE) {
 				throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
@@ -6468,29 +6497,30 @@
 		}
 		const zip64Enabled = zip64 === true;
 		const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
-		const encryptedEntry = Boolean(reader) && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
-		if (!reader) {
+		if (hasContent && passThrough && !encrypted && getLength(password, rawPassword)) {
+			throw new Error(ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH);
+		}
+		const encryptedEntry = hasContent && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
+		if (!hasContent) {
 			level = 0;
 			compressionMethod = COMPRESSION_METHOD_STORE;
 		}
 		const encryptionOverhead = encryptedEntry ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
-		if (reader) {
-			reader = new GenericReader(reader);
-			await initStream(reader);
+		if (hasContent) {
 			if (!passThrough) {
-				if (reader.size === UNDEFINED_VALUE) {
+				if (contentSize === UNDEFINED_VALUE) {
 					dataDescriptor = true;
 					if (zip64 || zip64 === UNDEFINED_VALUE) {
 						zip64 = true;
 						uncompressedSize = maximumCompressedSize = MAX_32_BITS + 1;
 					}
 				} else {
-					options.uncompressedSize = uncompressedSize = reader.size;
-					maximumCompressedSize = getMaximumCompressedSize(uncompressedSize) + encryptionOverhead;
+					options.uncompressedSize = uncompressedSize = contentSize;
+					maximumCompressedSize = (isCompressed(compressionMethod, level) ? getMaximumCompressedSize(uncompressedSize) : uncompressedSize) + encryptionOverhead;
 				}
 			} else {
 				options.uncompressedSize = uncompressedSize;
-				maximumCompressedSize = getMaximumCompressedSize(uncompressedSize) + encryptionOverhead;
+				maximumCompressedSize = contentSize === UNDEFINED_VALUE ? getMaximumCompressedSize(uncompressedSize) + encryptionOverhead : contentSize;
 			}
 		}
 		const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
@@ -6504,7 +6534,7 @@
 		}
 		zip64 = zip64 || false;
 		return {
-			reader,
+			maximumCompressedSize,
 			resolvedOptions: {
 				dataDescriptor,
 				zip64,
@@ -6889,9 +6919,7 @@
 			crc32
 		} = options;
 		let { version, compressionMethod } = options;
-		const compressed = !directory && (compressionMethod === UNDEFINED_VALUE
-			? (level === UNDEFINED_VALUE || level > 0)
-			: compressionMethod !== COMPRESSION_METHOD_STORE);
+		const compressed = !directory && isCompressed(compressionMethod, level);
 		let rawLocalExtraFieldZip64;
 		const uncompressedFile = passThrough || !compressed;
 		const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
@@ -7578,6 +7606,16 @@
 		return result === UNDEFINED_VALUE ? defaultValue : result;
 	}
 
+	function getAliasedOptionValue(zipWriter, options, name, deprecatedName, defaultValue) {
+		const value = getAliasedValue(options, name, deprecatedName);
+		const result = value === UNDEFINED_VALUE ? getAliasedValue(zipWriter.options, name, deprecatedName) : value;
+		return result === UNDEFINED_VALUE ? defaultValue : result;
+	}
+
+	function getAliasedValue(options, name, deprecatedName) {
+		return options[name] === UNDEFINED_VALUE ? options[deprecatedName] : options[name];
+	}
+
 	function getNumberOptionValue(zipWriter, options, name, defaultValue) {
 		return toNumber(getOptionValue(zipWriter, options, name, defaultValue));
 	}
@@ -7590,6 +7628,12 @@
 		return uncompressedSize + (5 * (Math.floor(uncompressedSize / 16383) + 1));
 	}
 
+	function isCompressed(compressionMethod, level) {
+		return compressionMethod === UNDEFINED_VALUE
+			? (level === UNDEFINED_VALUE || level > 0)
+			: compressionMethod !== COMPRESSION_METHOD_STORE;
+	}
+
 	function setUint8(view, offset, value) {
 		view.setUint8(offset, value);
 	}
@@ -8653,11 +8697,13 @@
 	exports.ERR_SPLIT_ZIP_FILE = ERR_SPLIT_ZIP_FILE;
 	exports.ERR_UNDEFINED_READER = ERR_UNDEFINED_READER;
 	exports.ERR_UNDEFINED_UNCOMPRESSED_SIZE = ERR_UNDEFINED_UNCOMPRESSED_SIZE;
+	exports.ERR_UNDETERMINED_SIZE = ERR_UNDETERMINED_SIZE;
 	exports.ERR_UNSAFE_FILENAME = ERR_UNSAFE_FILENAME;
 	exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION$1;
 	exports.ERR_UNSUPPORTED_CONTEXT = ERR_UNSUPPORTED_CONTEXT;
 	exports.ERR_UNSUPPORTED_CRYPTO_API = ERR_UNSUPPORTED_CRYPTO_API;
 	exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
+	exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 	exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
 	exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;