@zip.js/zip.js 2.8.51 → 2.8.52

package/lib/core/zip-writer.js

@@ -120,6 +120,8 @@ import {
 	FILE_ATTR_MSDOS_SYSTEM_MASK,
 	FILE_ATTR_MSDOS_ARCHIVE_MASK,
 	FILE_ATTR_UNIX_TYPE_DIR,
+	FILE_ATTR_UNIX_TYPE_FILE,
+	FILE_ATTR_UNIX_TYPE_MASK,
 	FILE_ATTR_UNIX_EXECUTABLE_MASK,
 	FILE_ATTR_UNIX_DEFAULT_MASK,
 	FILE_ATTR_UNIX_SETUID_MASK,
@@ -154,7 +156,8 @@ import {
 import {
 	initStream,
 	GenericWriter,
-	GenericReader
+	GenericReader,
+	ownsWritable
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
 import { getDataView } from "./util/array.js";
@@ -165,6 +168,8 @@ import {
 	PROPERTY_NAME_CREATION_DATE,
 	PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
 	PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES,
+	PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES,
+	PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES,
 	PROPERTY_NAME_MS_DOS_COMPATIBLE,
 	PROPERTY_NAME_ZIP64,
 	PROPERTY_NAME_ENCRYPTED,
@@ -225,6 +230,7 @@ const ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
 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";
@@ -234,6 +240,7 @@ const MIN_NTFS_TIME = BigInt(0);
 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)";
@@ -441,7 +448,7 @@ class ZipWriter {
 			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();
 		}
@@ -514,6 +521,7 @@ function watchAddFileCall(zipWriterStream, promiseAddFile, onerror) {
 export {
 	ZipWriter,
 	ZipWriterStream,
+	getEntriesSize,
 	ERR_DUPLICATED_NAME,
 	ERR_INVALID_COMMENT,
 	ERR_INVALID_ENTRY_NAME,
@@ -523,8 +531,10 @@ export {
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
 	ERR_UNSUPPORTED_ENCRYPTION_USDZ,
+	ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH,
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
+	ERR_UNDETERMINED_SIZE,
 	ERR_UNDEFINED_READER,
 	ERR_ZIP_NOT_EMPTY,
 	ERR_INVALID_SIGNATURE_DATA,
@@ -629,7 +639,7 @@ function resolveAttributes(zipWriter, name, options) {
 	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;
@@ -677,7 +687,9 @@ function resolveAttributes(zipWriter, name, options) {
 		}
 		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);
 		}
@@ -730,15 +742,12 @@ function resolveMetadata(zipWriter, name, options) {
 	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);
@@ -851,14 +860,24 @@ function serializeExtraField(extraField) {
 }
 
 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);
@@ -866,29 +885,30 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	}
 	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;
@@ -902,7 +922,7 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	}
 	zip64 = zip64 || false;
 	return {
-		reader,
+		maximumCompressedSize,
 		resolvedOptions: {
 			dataDescriptor,
 			zip64,
@@ -916,6 +936,78 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	};
 }
 
+async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comment) {
+	const zipWriter = { options: writerOptions, config: getConfiguration() };
+	if (writerOptions[OPTION_SIGN_CENTRAL_DIRECTORY]) {
+		throw new Error(ERR_UNDETERMINED_SIZE);
+	}
+	const commentLength = getLength(comment);
+	if (commentLength > MAX_16_BITS) {
+		throw new Error(ERR_INVALID_COMMENT);
+	}
+	const usdz = writerOptions[OPTION_USDZ];
+	const files = new Map();
+	let layoutDependsOnWriteOrder = Boolean(usdz);
+	let offset = 0;
+	for (const entry of entries) {
+		let { name } = entry;
+		const { size } = entry;
+		const options = Object.assign({}, entry.options);
+		name = name.trim();
+		if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
+			name += DIRECTORY_SIGNATURE;
+		}
+		const attributesInfo = resolveAttributes(zipWriter, name, options);
+		({ name } = attributesInfo);
+		const { resolvedOptions: metadata } = resolveMetadata(zipWriter, name, options);
+		if (metadata.level != 0 && metadata.compressionMethod === UNDEFINED_VALUE &&
+			!metadata.passThrough && !(await supportsDeflate(zipWriter.config))) {
+			metadata.level = 0;
+		}
+		const hasContent = !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY);
+		if (hasContent && size === UNDEFINED_VALUE) {
+			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)) {
+			throw new Error(ERR_UNDETERMINED_SIZE);
+		}
+		const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes);
+		const headerInfo = getHeaderInfo(entryOptions);
+		const dataDescriptorInfo = getDataDescriptorInfo(entryOptions);
+		const entryInfo = {
+			headerInfo,
+			metadataSize: getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray)
+		};
+		if (usdz) {
+			appendExtraFieldUSDZ(entryInfo, offset);
+		}
+		const compressedSize = hasContent ? maximumCompressedSize : 0;
+		if (offset >= MAX_32_BITS) {
+			layoutDependsOnWriteOrder = true;
+		}
+		files.set(name, Object.assign({}, entryOptions, headerInfo, {
+			offset,
+			diskNumberStart: 0,
+			compressedSize
+		}));
+		offset += entryInfo.metadataSize + compressedSize;
+	}
+	if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
+		throw new Error(ERR_UNDETERMINED_SIZE);
+	}
+	const directoryDataLength = createDirectoryRecords(files);
+	let zip64 = getOptionValue(zipWriter, writerOptions, PROPERTY_NAME_ZIP64);
+	if (offset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || files.size >= MAX_16_BITS) {
+		if (zip64 === false) {
+			throw new Error(ERR_UNSUPPORTED_FORMAT);
+		} else {
+			zip64 = true;
+		}
+	}
+	return offset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+}
+
 async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		files,
@@ -1287,9 +1379,7 @@ function getHeaderInfo(options) {
 		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));
@@ -1976,6 +2066,16 @@ function getOptionValue(zipWriter, options, name, defaultValue) {
 	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));
 }
@@ -1988,6 +2088,12 @@ function getMaximumCompressedSize(uncompressedSize) {
 	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);
 }

package/lib/zip-core-writer.js

@@ -40,8 +40,10 @@ export {
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
 	ERR_UNSUPPORTED_ENCRYPTION_USDZ,
+	ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH,
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
+	ERR_UNDETERMINED_SIZE,
 	ERR_UNDEFINED_READER,
 	ERR_ZIP_NOT_EMPTY,
 	ERR_INVALID_SIGNATURE_DATA,

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.8.51",
+  "version": "2.8.52",
   "type": "module",
   "keywords": [
     "zip",
@@ -36,13 +36,13 @@
   "scripts": {
     "lint": "npx eslint . && deno lint",
     "test": "npm run test-node && npm run test-deno && npm run test-bun && npm run test-node-dist && npm run test-deno-dist && npm run test-bun-dist && npm run test-web-streams-polyfill && npm run test-types",
-    "test-browsers": "npm run test-chrome && npm run test-firefox && npm run test-webkit",
+    "test-browsers": "npm run test-chrome && npm run test-firefox && npm run test-safari",
     "serve-tests": "http-server -p 8888 -c-1 .",
     "test-all": "npm run lint && npm run test && npm run test-browsers",
     "build": "npx rollup -c",
     "build-dev": "npx rollup -c --environment DEV",
     "build-doc-api": "npx typedoc",
-    "build-doc-markdown": "npx typedoc --plugin typedoc-plugin-markdown --out ./docs",
+    "build-doc-markdown": "npx typedoc --plugin typedoc-plugin-markdown --disableSources --out ./docs",
     "test-deno": "cd ./tests && deno test --allow-read ./deno-runner.js",
     "test-web-streams-polyfill": "cd ./tests && deno run --allow-read ./web-streams-polyfill-runner.js",
     "test-node": "cd ./tests && node ./node-runner.js",
@@ -53,7 +53,7 @@
     "test-types": "tsc -p ./tests/types/tsconfig.json",
     "test-firefox": "node ./tests/browser-runner.js firefox",
     "test-chrome": "node ./tests/browser-runner.js chrome",
-    "test-webkit": "node ./tests/browser-runner.js webkit"
+    "test-safari": "node ./tests/browser-runner.js safari"
   },
   "main": "./index.cjs",
   "module": "./index.js",
@@ -260,8 +260,8 @@
     "@rollup/plugin-terser": "^1.0.0",
     "eslint": "^10.8.1",
     "http-server": "^14.1.1",
-    "playwright": "^1.62.1",
     "rollup": "^4.62.4",
+    "selenium-webdriver": "^4.47.0",
     "typedoc": "^0.28.20",
     "typedoc-plugin-markdown": "^4.12.0",
     "web-streams-polyfill": "^4.3.0",