@zip.js/zip.js 2.6.20 → 2.6.23

package/lib/core/zip-writer.js

@@ -103,7 +103,7 @@ class ZipWriter {
 			files: new Map(),
 			filenames: new Set(),
 			offset: writer.writable.size,
-			pendingCompressedSize: 0,
+			pendingEntriesSize: 0,
 			pendingAddFileCalls: new Set()
 		});
 	}
@@ -228,6 +228,7 @@ async function addFile(zipWriter, name, reader, options) {
 		extendedTimestamp = true;
 	}
 	let maximumCompressedSize = 0;
+	let maximumEntrySize = 0;
 	let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
 	if (keepOrder === undefined) {
 		keepOrder = true;
@@ -249,7 +250,7 @@ async function addFile(zipWriter, name, reader, options) {
 		maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 	}
 	let zip64 = options.zip64 || zipWriter.options.zip64 || false;
-	if (zipWriter.offset + zipWriter.pendingCompressedSize >= MAX_32_BITS ||
+	if (zipWriter.offset + zipWriter.pendingEntriesSize >= MAX_32_BITS ||
 		uncompressedSize >= MAX_32_BITS ||
 		maximumCompressedSize >= MAX_32_BITS) {
 		if (options.zip64 === false || zipWriter.options.zip64 === false || !keepOrder) {
@@ -258,8 +259,6 @@ async function addFile(zipWriter, name, reader, options) {
 			zip64 = true;
 		}
 	}
-	zipWriter.pendingCompressedSize += maximumCompressedSize;
-	await Promise.resolve();
 	const level = getOptionValue(zipWriter, options, "level");
 	const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
 	const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
@@ -273,7 +272,7 @@ async function addFile(zipWriter, name, reader, options) {
 	if (dataDescriptor && dataDescriptorSignature === undefined) {
 		dataDescriptorSignature = false;
 	}
-	const fileEntry = await getFileEntry(zipWriter, name, reader, Object.assign({}, options, {
+	options = Object.assign({}, options, {
 		rawFilename,
 		rawComment,
 		version,
@@ -298,15 +297,20 @@ async function addFile(zipWriter, name, reader, options) {
 		internalFileAttribute,
 		externalFileAttribute,
 		useCompressionStream
-	}));
-	if (maximumCompressedSize) {
-		zipWriter.pendingCompressedSize -= maximumCompressedSize;
+	});
+	const headerInfo = getHeaderInfo(options);
+	const dataDescriptorInfo = getDataDescriptorInfo(options);
+	maximumEntrySize = headerInfo.localHeaderArray.length + maximumCompressedSize + dataDescriptorInfo.dataDescriptorArray.length;
+	zipWriter.pendingEntriesSize += maximumEntrySize;
+	const fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo }, options);
+	if (maximumEntrySize) {
+		zipWriter.pendingEntriesSize -= maximumEntrySize;
 	}
 	Object.assign(fileEntry, { name, comment, extraField });
 	return new Entry(fileEntry);
 }
 
-async function getFileEntry(zipWriter, name, reader, options) {
+async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		files,
 		writer
@@ -345,7 +349,8 @@ async function getFileEntry(zipWriter, name, reader, options) {
 		if (!bufferedWrite) {
 			await lockPreviousFileEntry;
 		}
-		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, zipWriter.config, options);
+		fileEntry.writingData = true;
+		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, zipWriter.config, options);
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
@@ -421,7 +426,25 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	}
 }
 
-async function createFileEntry(reader, writer, pendingFileEntry, config, options) {
+async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, config, options) {
+	const {
+		headerInfo,
+		dataDescriptorInfo
+	} = entryInfo;
+	const {
+		localHeaderArray,
+		headerArray,
+		lastModDate,
+		rawLastModDate,
+		encrypted,
+		compressed,
+		version,
+		compressionMethod,
+		rawExtraFieldExtendedTimestamp,
+		rawExtraFieldNTFS,
+		rawExtraFieldAES
+	} = headerInfo;
+	const { dataDescriptorArray } = dataDescriptorInfo;
 	const {
 		rawFilename,
 		lastAccessDate,
@@ -431,9 +454,7 @@ async function createFileEntry(reader, writer, pendingFileEntry, config, options
 		zip64,
 		zipCrypto,
 		dataDescriptor,
-		dataDescriptorSignature,
 		directory,
-		version,
 		versionMadeBy,
 		rawComment,
 		rawExtraField,
@@ -449,8 +470,108 @@ async function createFileEntry(reader, writer, pendingFileEntry, config, options
 		externalFileAttribute,
 		useCompressionStream
 	} = options;
-	const encrypted = Boolean(password && password.length);
+	const fileEntry = {
+		lock: pendingFileEntry.lock,
+		versionMadeBy,
+		zip64,
+		directory: Boolean(directory),
+		filenameUTF8: true,
+		rawFilename,
+		commentUTF8: true,
+		rawComment,
+		rawExtraFieldExtendedTimestamp,
+		rawExtraFieldNTFS,
+		rawExtraFieldAES,
+		rawExtraField,
+		extendedTimestamp,
+		msDosCompatible,
+		internalFileAttribute,
+		externalFileAttribute
+	};
+	let uncompressedSize = 0;
+	let signature;
+	let compressedSize = 0;
+	const { writable } = writer;
+	if (reader) {
+		reader.chunkSize = getChunkSize(config);
+		await writeData(writable, localHeaderArray);
+		const size = () => reader.size;
+		const readable = reader.readable;
+		readable.size = size;
+		const workerOptions = {
+			options: {
+				codecType: CODEC_DEFLATE,
+				level,
+				password,
+				encryptionStrength,
+				zipCrypto: encrypted && zipCrypto,
+				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
+				signed: true,
+				compressed,
+				encrypted,
+				useWebWorkers,
+				useCompressionStream
+			},
+			config,
+			streamOptions: { signal, size, onstart, onprogress, onend },
+			codecConstructor: config.Deflate
+		};
+		const previousSize = writable.size;
+		signature = (await runWorker({ readable, writable }, workerOptions)).signature;
+		uncompressedSize = reader.size = readable.size();
+		compressedSize = writable.size - previousSize;
+	} else {
+		await writeData(writable, localHeaderArray);
+	}
+	const rawExtraFieldZip64 = zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array();
+	if (reader) {
+		setEntryInfo({
+			signature,
+			rawExtraFieldZip64,
+			compressedSize,
+			uncompressedSize,
+			headerInfo,
+			dataDescriptorInfo
+		}, options);
+	}
+	if (dataDescriptor) {
+		await writeData(writable, dataDescriptorArray);
+	}
+	Object.assign(fileEntry, {
+		compressedSize,
+		lastModDate,
+		rawLastModDate,
+		creationDate,
+		lastAccessDate,
+		encrypted,
+		length: localHeaderArray.length + compressedSize + dataDescriptorArray.length,
+		compressionMethod,
+		version,
+		headerArray,
+		signature,
+		rawExtraFieldZip64
+	});
+	return fileEntry;
+}
+
+function getHeaderInfo(options) {
+	const {
+		rawFilename,
+		lastAccessDate,
+		creationDate,
+		password,
+		level,
+		zip64,
+		zipCrypto,
+		dataDescriptor,
+		directory,
+		rawExtraField,
+		encryptionStrength,
+		extendedTimestamp,
+	} = options;
+	let version = options.version || VERSION_DEFLATE;
 	const compressed = level !== 0 && !directory;
+	const encrypted = Boolean(password && password.length);
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
 		rawExtraFieldAES = new Uint8Array(EXTRAFIELD_DATA_AES.length + 2);
@@ -494,27 +615,6 @@ async function createFileEntry(reader, writer, pendingFileEntry, config, options
 	} else {
 		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 	}
-	const fileEntry = {
-		lock: pendingFileEntry.lock,
-		version: version || VERSION_DEFLATE,
-		versionMadeBy,
-		zip64,
-		directory: Boolean(directory),
-		filenameUTF8: true,
-		rawFilename,
-		commentUTF8: true,
-		rawComment,
-		rawExtraFieldZip64: zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array(),
-		rawExtraFieldExtendedTimestamp,
-		rawExtraFieldNTFS,
-		rawExtraFieldAES,
-		rawExtraField,
-		extendedTimestamp,
-		msDosCompatible,
-		internalFileAttribute,
-		externalFileAttribute
-	};
-	let uncompressedSize = 0;
 	let bitFlag = BITFLAG_LANG_ENCODING_FLAG;
 	if (dataDescriptor) {
 		bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
@@ -524,22 +624,21 @@ async function createFileEntry(reader, writer, pendingFileEntry, config, options
 		compressionMethod = COMPRESSION_METHOD_DEFLATE;
 	}
 	if (zip64) {
-		fileEntry.version = fileEntry.version > VERSION_ZIP64 ? fileEntry.version : VERSION_ZIP64;
+		version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
 	}
 	if (encrypted) {
 		bitFlag = bitFlag | BITFLAG_ENCRYPTED;
 		if (!zipCrypto) {
-			fileEntry.version = fileEntry.version > VERSION_AES ? fileEntry.version : VERSION_AES;
+			version = version > VERSION_AES ? version : VERSION_AES;
 			compressionMethod = COMPRESSION_METHOD_AES;
 			if (compressed) {
-				fileEntry.rawExtraFieldAES[9] = COMPRESSION_METHOD_DEFLATE;
+				rawExtraFieldAES[9] = COMPRESSION_METHOD_DEFLATE;
 			}
 		}
 	}
-	fileEntry.compressionMethod = compressionMethod;
-	const headerArray = fileEntry.headerArray = new Uint8Array(26);
+	const headerArray = new Uint8Array(26);
 	const headerView = getDataView(headerArray);
-	setUint16(headerView, 0, fileEntry.version);
+	setUint16(headerView, 0, version);
 	setUint16(headerView, 2, bitFlag);
 	setUint16(headerView, 4, compressionMethod);
 	const dateArray = new Uint32Array(1);
@@ -568,41 +667,28 @@ async function createFileEntry(reader, writer, pendingFileEntry, config, options
 	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, 30 + rawFilename.length + rawExtraFieldAES.length);
 	arraySet(localHeaderArray, rawExtraFieldNTFS, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length);
 	arraySet(localHeaderArray, rawExtraField, 30 + rawFilename.length + rawExtraFieldAES.length + rawExtraFieldExtendedTimestamp.length + rawExtraFieldNTFS.length);
-	let result;
-	let compressedSize = 0;
-	const { writable } = writer;
-	fileEntry.writingData = pendingFileEntry.writingData = true;
-	if (reader) {
-		reader.chunkSize = getChunkSize(config);
-		await writeData(writable, localHeaderArray);
-		const size = () => reader.size;
-		const readable = reader.readable;
-		readable.size = size;
-		const workerOptions = {
-			options: {
-				codecType: CODEC_DEFLATE,
-				level,
-				password,
-				encryptionStrength,
-				zipCrypto: encrypted && zipCrypto,
-				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
-				signed: true,
-				compressed,
-				encrypted,
-				useWebWorkers,
-				useCompressionStream
-			},
-			config,
-			streamOptions: { signal, size, onstart, onprogress, onend },
-			codecConstructor: config.Deflate
-		};
-		const previousSize = writable.size;
-		result = await runWorker({ readable, writable }, workerOptions);
-		uncompressedSize = reader.size = readable.size();
-		compressedSize = writable.size - previousSize;
-	} else {
-		await writeData(writable, localHeaderArray);
-	}
+	return {
+		localHeaderArray,
+		headerArray,
+		headerView,
+		lastModDate,
+		rawLastModDate,
+		encrypted,
+		compressed,
+		version,
+		compressionMethod,
+		rawExtraFieldExtendedTimestamp,
+		rawExtraFieldNTFS,
+		rawExtraFieldAES
+	};
+}
+
+function getDataDescriptorInfo(options) {
+	const {
+		zip64,
+		dataDescriptor,
+		dataDescriptorSignature
+	} = options;
 	let dataDescriptorArray = new Uint8Array();
 	let dataDescriptorView, dataDescriptorOffset = 0;
 	if (dataDescriptor) {
@@ -613,51 +699,61 @@ async function createFileEntry(reader, writer, pendingFileEntry, config, options
 			setUint32(dataDescriptorView, 0, DATA_DESCRIPTOR_RECORD_SIGNATURE);
 		}
 	}
-	if (reader) {
-		const { signature } = result;
-		if ((!encrypted || zipCrypto) && signature !== undefined) {
-			setUint32(headerView, 10, signature);
-			fileEntry.signature = signature;
-			if (dataDescriptor) {
-				setUint32(dataDescriptorView, dataDescriptorOffset, signature);
-			}
-		}
-		if (zip64) {
-			const rawExtraFieldZip64View = getDataView(fileEntry.rawExtraFieldZip64);
-			setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-			setUint16(rawExtraFieldZip64View, 2, EXTRAFIELD_LENGTH_ZIP64);
-			setUint32(headerView, 14, MAX_32_BITS);
-			setBigUint64(rawExtraFieldZip64View, 12, BigInt(compressedSize));
-			setUint32(headerView, 18, MAX_32_BITS);
-			setBigUint64(rawExtraFieldZip64View, 4, BigInt(uncompressedSize));
-			if (dataDescriptor) {
-				setBigUint64(dataDescriptorView, dataDescriptorOffset + 4, BigInt(compressedSize));
-				setBigUint64(dataDescriptorView, dataDescriptorOffset + 12, BigInt(uncompressedSize));
-			}
-		} else {
-			setUint32(headerView, 14, compressedSize);
-			setUint32(headerView, 18, uncompressedSize);
-			if (dataDescriptor) {
-				setUint32(dataDescriptorView, dataDescriptorOffset + 4, compressedSize);
-				setUint32(dataDescriptorView, dataDescriptorOffset + 8, uncompressedSize);
-			}
+	return {
+		dataDescriptorArray,
+		dataDescriptorView,
+		dataDescriptorOffset
+	};
+}
+
+function setEntryInfo(entryInfo, options) {
+	const {
+		signature,
+		rawExtraFieldZip64,
+		compressedSize,
+		uncompressedSize,
+		headerInfo,
+		dataDescriptorInfo
+	} = entryInfo;
+	const {
+		headerView,
+		encrypted
+	} = headerInfo;
+	const {
+		dataDescriptorView,
+		dataDescriptorOffset
+	} = dataDescriptorInfo;
+	const {
+		zip64,
+		zipCrypto,
+		dataDescriptor
+	} = options;
+	if ((!encrypted || zipCrypto) && signature !== undefined) {
+		setUint32(headerView, 10, signature);
+		if (dataDescriptor) {
+			setUint32(dataDescriptorView, dataDescriptorOffset, signature);
 		}
 	}
-	if (dataDescriptor) {
-		await writeData(writable, dataDescriptorArray);
+	if (zip64) {
+		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
+		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
+		setUint16(rawExtraFieldZip64View, 2, EXTRAFIELD_LENGTH_ZIP64);
+		setUint32(headerView, 14, MAX_32_BITS);
+		setBigUint64(rawExtraFieldZip64View, 12, BigInt(compressedSize));
+		setUint32(headerView, 18, MAX_32_BITS);
+		setBigUint64(rawExtraFieldZip64View, 4, BigInt(uncompressedSize));
+		if (dataDescriptor) {
+			setBigUint64(dataDescriptorView, dataDescriptorOffset + 4, BigInt(compressedSize));
+			setBigUint64(dataDescriptorView, dataDescriptorOffset + 12, BigInt(uncompressedSize));
+		}
+	} else {
+		setUint32(headerView, 14, compressedSize);
+		setUint32(headerView, 18, uncompressedSize);
+		if (dataDescriptor) {
+			setUint32(dataDescriptorView, dataDescriptorOffset + 4, compressedSize);
+			setUint32(dataDescriptorView, dataDescriptorOffset + 8, uncompressedSize);
+		}
 	}
-	const length = localHeaderArray.length + compressedSize + dataDescriptorArray.length;
-	Object.assign(fileEntry, {
-		compressedSize,
-		lastModDate,
-		rawLastModDate,
-		creationDate,
-		lastAccessDate,
-		encrypted,
-		length,
-		writingData: false
-	});
-	return fileEntry;
 }
 
 async function closeFile(zipWriter, comment, options) {

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.6.20",
+    "version": "2.6.23",
     "type": "module",
     "keywords": [
         "zip",

package/tests/all/test-zip64-auto.js

@@ -53,20 +53,26 @@ async function test() {
 	zip.configure({ chunkSize: 128, useWebWorkers: true });
 	const blobWriter = new CustomBlobWriter("application/zip");
 	blobWriter.writable.size = 0;
-	const array = new Uint8Array(64 * 1024 * 1024);
-	for (let index = 0; index < 64; index++) {
+	let array = new Uint8Array(64 * 1024 * 1024);
+	for (let index = 0; index < 63; index++) {
 		blobWriter.writeUint8Array(array);
 		blobWriter.writable.size += array.length;
 	}
+	array = new Uint8Array((64 * 1024 * 1024) - 1265);
+	blobWriter.writeUint8Array(array);
+	blobWriter.writable.size += array.length;
 	const zipWriter = new zip.ZipWriter(blobWriter, { keepOrder: true });
-	await zipWriter.add(FILENAME, new zip.BlobReader(BLOB));
+	await Promise.all([
+		zipWriter.add(FILENAME, new zip.BlobReader(BLOB)),
+		zipWriter.add(FILENAME + "1", new zip.BlobReader(BLOB)),
+		zipWriter.add(FILENAME + "2", new zip.BlobReader(BLOB))
+	]);
 	await zipWriter.close();
 	const zipReader = new zip.ZipReader(new zip.BlobReader(await blobWriter.getData()));
 	const entries = await zipReader.getEntries();
-	const data = await entries[0].getData(new zip.BlobWriter(zip.getMimeType(entries[0].filename)));
 	await zipReader.close();
 	zip.terminateWorkers();
-	if (TEXT_CONTENT != await data.text() && !entries[0].zip64) {
+	if (entries[0].zip64 || entries[1].zip64 || !entries[2].zip64) {
 		throw new Error();
 	}
 }