@zip.js/zip.js 2.6.42 → 2.6.44

package/lib/core/zip-writer.js

@@ -75,7 +75,7 @@ import {
 import {
 	initStream,
 	BlobWriter,
-	SplitZipWriter
+	SplitDataWriter
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
 import {
@@ -109,7 +109,7 @@ class ZipWriter {
 
 	constructor(writer, options = {}) {
 		if (writer.writable === UNDEFINED_VALUE && typeof writer.next == FUNCTION_TYPE) {
-			writer = new SplitZipWriter(writer);
+			writer = new SplitDataWriter(writer);
 		}
 		if (writer instanceof WritableStream) {
 			writer = { writable: writer };
@@ -117,7 +117,7 @@ class ZipWriter {
 		if (writer.writable.size === UNDEFINED_VALUE) {
 			writer.writable.size = 0;
 		}
-		const splitZipFile = writer instanceof SplitZipWriter;
+		const splitZipFile = writer instanceof SplitDataWriter;
 		if (!splitZipFile) {
 			Object.assign(writer, {
 				diskNumber: 0,
@@ -174,13 +174,15 @@ class ZipWriter {
 	}
 
 	async close(comment = new Uint8Array(), options = {}) {
+		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
 		while (pendingAddFileCalls.size) {
 			await Promise.all(Array.from(pendingAddFileCalls));
 		}
 		await closeFile(this, comment, options);
-		if (!writer.preventClose && !options.preventClose) {
+		const preventClose = getOptionValue(zipWriter, options, "preventClose");
+		if (!preventClose) {
 			await writable.close();
 		}
 		return writer.getData ? writer.getData() : writable;
@@ -216,20 +218,33 @@ async function addFile(zipWriter, name, reader, options) {
 	if (getLength(rawComment) > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_ENTRY_COMMENT);
 	}
-	const version = zipWriter.options.version || options.version || 0;
+	const version = getOptionValue(zipWriter, options, "version", VERSION_DEFLATE);
 	if (version > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_VERSION);
 	}
-	const versionMadeBy = zipWriter.options.versionMadeBy || options.versionMadeBy || 20;
+	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 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 encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength") || 3;
+	const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength", 3);
 	const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
+	const extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp", true);
+	const keepOrder = getOptionValue(zipWriter, options, "keepOrder", true);
+	const level = getOptionValue(zipWriter, options, "level");
+	const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
+	const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
+	const dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature", false);
+	const signal = getOptionValue(zipWriter, options, "signal");
+	const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
+	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)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
@@ -253,24 +268,9 @@ async function addFile(zipWriter, name, reader, options) {
 			offset += 4 + getLength(data);
 		});
 	}
-	let extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp");
-	if (extendedTimestamp === UNDEFINED_VALUE) {
-		extendedTimestamp = true;
-	}
 	let maximumCompressedSize = 0;
 	let maximumEntrySize = 0;
-	let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
-	if (keepOrder === UNDEFINED_VALUE) {
-		keepOrder = true;
-	}
 	let uncompressedSize = 0;
-	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
-	if (msDosCompatible === UNDEFINED_VALUE) {
-		msDosCompatible = true;
-	}
-	const internalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE) || 0;
-	const externalFileAttribute = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE) || 0;
-	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 	if (reader) {
 		if (reader instanceof ReadableStream) {
 			reader = {
@@ -279,7 +279,7 @@ async function addFile(zipWriter, name, reader, options) {
 		}
 		await initStream(reader);
 		if (reader.size === UNDEFINED_VALUE) {
-			options.dataDescriptor = true;
+			dataDescriptor = true;
 			if (zip64 || zip64 === UNDEFINED_VALUE) {
 				zip64 = true;
 				maximumCompressedSize = MAX_32_BITS;
@@ -289,10 +289,11 @@ async function addFile(zipWriter, name, reader, options) {
 			maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 		}
 	}
-	const { diskOffset } = zipWriter.writer;
+	const { diskOffset, diskNumber } = zipWriter.writer;
 	if (zipWriter.offset + zipWriter.pendingEntriesSize - diskOffset >= MAX_32_BITS ||
 		uncompressedSize >= MAX_32_BITS ||
-		maximumCompressedSize >= MAX_32_BITS) {
+		maximumCompressedSize >= MAX_32_BITS ||
+		diskNumber >= MAX_16_BITS) {
 		if (zip64 === false || !keepOrder) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		} else {
@@ -300,19 +301,6 @@ async function addFile(zipWriter, name, reader, options) {
 		}
 	}
 	zip64 = zip64 || false;
-	const level = getOptionValue(zipWriter, options, "level");
-	const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
-	const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
-	let dataDescriptor = getOptionValue(zipWriter, options, "dataDescriptor");
-	let dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature");
-	const signal = getOptionValue(zipWriter, options, "signal");
-	const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
-	if (dataDescriptor === UNDEFINED_VALUE) {
-		dataDescriptor = true;
-	}
-	if (dataDescriptor && dataDescriptorSignature === UNDEFINED_VALUE) {
-		dataDescriptorSignature = false;
-	}
 	options = Object.assign({}, options, {
 		rawFilename,
 		rawComment,
@@ -346,12 +334,8 @@ async function addFile(zipWriter, name, reader, options) {
 	let fileEntry;
 	try {
 		fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo }, options);
+	} finally {
 		zipWriter.pendingEntriesSize -= maximumEntrySize;
-	} catch (error) {
-		if (!error.corruptedEntry) {
-			zipWriter.pendingEntriesSize -= maximumEntrySize;
-		}
-		throw error;
 	}
 	Object.assign(fileEntry, { name, comment, extraField });
 	return new Entry(fileEntry);
@@ -389,8 +373,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await initStream(writer);
 		} else {
 			fileWriter = writer;
-			zipWriter.lockWriter = Promise.resolve();
-			releaseLockWriter = () => delete zipWriter.lockWriter;
+			initLockWriter();
 		}
 		await initStream(fileWriter);
 		const { writable, diskNumber } = writer;
@@ -419,7 +402,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await requestLockWriter();
 			writingBufferedEntryData = true;
 			if (!dataDescriptor) {
-				blob = await setMissingInfo(fileEntry, blob, writable, options);
+				blob = await writeMissingHeaderInfo(fileEntry, blob, writable, options);
 			}
 			fileEntry.diskNumberStart = writer.diskNumber;
 			diskOffset = writer.diskOffset;
@@ -429,7 +412,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 		fileEntry.offset = zipWriter.offset - diskOffset;
 		if (fileEntry.zip64) {
-			setZip64Info(fileEntry);
+			setZip64OffsetInfo(fileEntry);
 		} else if (fileEntry.offset >= MAX_32_BITS) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
@@ -462,6 +445,11 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		fileEntry.lock = new Promise(resolve => releaseLockCurrentFileEntry = resolve);
 	}
 
+	function initLockWriter() {
+		zipWriter.lockWriter = Promise.resolve();
+		releaseLockWriter = () => delete zipWriter.lockWriter;
+	}
+
 	async function requestLockWriter() {
 		const { lockWriter } = zipWriter;
 		if (lockWriter) {
@@ -620,6 +608,7 @@ function getHeaderInfo(options) {
 	} = options;
 	const compressed = level !== 0 && !directory;
 	const encrypted = Boolean(password && getLength(password));
+	let version = options.version;
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
 		rawExtraFieldAES = new Uint8Array(getLength(EXTRAFIELD_DATA_AES) + 2);
@@ -671,7 +660,6 @@ function getHeaderInfo(options) {
 	if (compressed) {
 		compressionMethod = COMPRESSION_METHOD_DEFLATE;
 	}
-	let version = options.version || VERSION_DEFLATE;
 	if (zip64) {
 		version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
 	}
@@ -805,7 +793,7 @@ function setEntryInfo(entryInfo, options) {
 	}
 }
 
-async function setMissingInfo(fileEntry, entryData, writable, { zipCrypto }) {
+async function writeMissingHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
 	const arrayBuffer = await sliceAsArrayBuffer(entryData, 0, 26);
 	const arrayBufferView = new DataView(arrayBuffer);
 	if (!fileEntry.encrypted || zipCrypto) {
@@ -822,7 +810,7 @@ async function setMissingInfo(fileEntry, entryData, writable, { zipCrypto }) {
 	return entryData.slice(arrayBuffer.byteLength);
 }
 
-function setZip64Info(fileEntry) {
+function setZip64OffsetInfo(fileEntry) {
 	const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
 	const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 	setBigUint64(rawExtraFieldZip64View, 20, BigInt(offset));
@@ -831,10 +819,10 @@ function setZip64Info(fileEntry) {
 
 async function closeFile(zipWriter, comment, options) {
 	const { files, writer } = zipWriter;
-	let offset = 0;
-	let directoryDataLength = 0;
 	const { diskOffset, writable } = writer;
 	let { diskNumber } = writer;
+	let offset = 0;
+	let directoryDataLength = 0;
 	let directoryOffset = zipWriter.offset - diskOffset;
 	let filesLength = files.size;
 	for (const [, {
@@ -856,14 +844,6 @@ async function closeFile(zipWriter, comment, options) {
 				rawExtraFieldNTFS,
 				rawExtraField);
 	}
-	let zip64 = options.zip64 || zipWriter.options.zip64 || false;
-	if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || filesLength >= MAX_16_BITS) {
-		if (options.zip64 === false || zipWriter.options.zip64 === false) {
-			throw new Error(ERR_UNSUPPORTED_FORMAT);
-		} else {
-			zip64 = true;
-		}
-	}
 	const directoryArray = new Uint8Array(directoryDataLength);
 	const directoryView = getDataView(directoryArray);
 	for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
@@ -929,13 +909,21 @@ async function closeFile(zipWriter, comment, options) {
 	}
 	await initStream(writer);
 	await writeData(writable, directoryArray);
-	const endOfdirectoryArray = new Uint8Array(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
-	const endOfdirectoryView = getDataView(endOfdirectoryArray);
 	let lastDiskNumber = writer.diskNumber;
 	const { availableSize } = writer;
-	if (availableSize < getLength(endOfdirectoryArray)) {
+	if (availableSize < END_OF_CENTRAL_DIR_LENGTH) {
 		lastDiskNumber++;
 	}
+	let zip64 = getOptionValue(zipWriter, options, "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);
+		} else {
+			zip64 = true;
+		}
+	}
+	const endOfdirectoryArray = new Uint8Array(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+	const endOfdirectoryView = getDataView(endOfdirectoryArray);
 	offset = 0;
 	if (zip64) {
 		setUint32(endOfdirectoryView, 0, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
@@ -1000,8 +988,9 @@ function getTimeNTFS(date) {
 	}
 }
 
-function getOptionValue(zipWriter, options, name) {
-	return options[name] === UNDEFINED_VALUE ? zipWriter.options[name] : options[name];
+function getOptionValue(zipWriter, options, name, defaultValue) {
+	const result = options[name] === UNDEFINED_VALUE ? zipWriter.options[name] : options[name];
+	return result === UNDEFINED_VALUE ? defaultValue : result;
 }
 
 function getMaximumCompressedSize(uncompressedSize) {

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

package/tests/all/test-http-split-zip.js

@@ -24,7 +24,7 @@ export { test };
 async function test() {
 	zip.configure({ chunkSize: 16 * 1024, useWebWorkers: true });
 	const readers = PATHS.map(url => new zip.HttpReader(new URL(url, import.meta.url).href, { preventHeadRequest: true }));
-	const zipReader = new zip.ZipReader(new zip.SplitZipReader(readers));
+	const zipReader = new zip.ZipReader(new zip.SplitDataReader(readers));
 	const entries = await zipReader.getEntries();
 	const results = await Promise.all(UNCOMPRESSED_SIZES.map(async (uncompressedSize, indexEntry) =>
 		(await entries[indexEntry].getData(new zip.TextWriter())).length == uncompressedSize

package/tests/all/test-split-data.js

@@ -0,0 +1,37 @@
+/* global Blob, TextDecoder */
+
+import * as zip from "../../index.js";
+
+const TEXT_CONTENT = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Nam liber tempor cum soluta nobis eleifend option congue nihil imperdiet doming id quod mazim placerat facer possim assum. Typi non habent claritatem insitam; est usus legentis in iis qui facit eorum claritatem. Investigationes demonstraverunt lectores legere me lius quod ii legunt saepius. Claritas est etiam processus dynamicus, qui sequitur mutationem consuetudium lectorum. Mirum est notare quam littera gothica, quam nunc putamus parum claram, anteposuerit litterarum formas humanitatis per seacula quarta decima et quinta decima. Eodem modo typi, qui nunc nobis videntur parum clari, fiant sollemnes in futurum.";
+const BLOB_CONTENT = new Blob([TEXT_CONTENT]);
+
+export { test };
+
+const writers = [];
+
+function* arrayWriterGenerator() {
+	while (true) {
+		const writer = new zip.Uint8ArrayWriter();
+		writers.push(writer);
+		yield writer;
+	}
+}
+
+async function test() {
+	zip.configure({ chunkSize: 1024, useWebWorkers: true });
+	const zipWriter = new zip.ZipWriter(new zip.BlobWriter());
+	const readers = [
+		new zip.TextReader(TEXT_CONTENT),
+		new zip.BlobReader(BLOB_CONTENT)
+	];
+	await zipWriter.add("loremx2.txt", new zip.SplitDataReader(readers));
+	const blob = await zipWriter.close();
+	const zipReader = new zip.ZipReader(new zip.BlobReader(blob));
+	const firstEntry = (await zipReader.getEntries()).shift();
+	await firstEntry.getData(new zip.SplitDataWriter(arrayWriterGenerator(), 128));
+	const chunks = await Promise.all(writers.map(writer => writer.getData()));
+	const text = new TextDecoder().decode(new Uint8Array(chunks.map(data => Array.from(data)).flat()));
+	if (text != TEXT_CONTENT + TEXT_CONTENT) {
+		throw new Error();
+	}
+}

package/tests/all/test-split-zip.js

@@ -20,7 +20,7 @@ function* blobWriterGenerator() {
 
 async function test() {
 	zip.configure({ chunkSize: 1024, useWebWorkers: true });
-	const splitZipWriter = new zip.SplitZipWriter(blobWriterGenerator(), 8192);
+	const splitZipWriter = new zip.SplitDataWriter(blobWriterGenerator(), 8192);
 	const zipWriter = new zip.ZipWriter(splitZipWriter);
 	await Promise.all([
 		zipWriter.add("lorem1.txt", new zip.BlobReader(BLOB)),
@@ -29,7 +29,7 @@ async function test() {
 	]);
 	await zipWriter.close();
 	const readers = await Promise.all(writers.map(async writer => new zip.BlobReader(await writer.getData())));
-	const zipReader = new zip.ZipReader(new zip.SplitZipReader(readers));
+	const zipReader = new zip.ZipReader(new zip.SplitDataReader(readers));
 	const entries = await zipReader.getEntries();
 	const results = await Promise.all(entries.map(async entry => (await entry.getData(new zip.TextWriter())).length == TEXT_CONTENT.length * TEXT_CONTENT_REPEAT));
 	await zipReader.close();

package/tests/tests-data.js

@@ -41,7 +41,8 @@ export default ([
 	{ title: "Safe closing", script: "./test-safe-closing.js" },
 	{ title: "Service worker", script: "./test-sw.js", env: ["browser"] },
 	{ title: "Signature CRC32", script: "./test-crc.js" },
-	{ title: "Split file", script: "./test-split-zip.js" },
+	{ title: "Split data", script: "./test-split-data.js" },
+	{ title: "Split zip file", script: "./test-split-zip.js" },
 	{ title: "Store", script: "./test-store.js" },
 	{ title: "Streams", script: "./test-streams.js" },
 	{ title: "Worker timeout", script: "./test-worker-timeout.js" },