@zip.js/zip.js 2.6.41 → 2.6.43

package/README.md

@@ -1,9 +1,10 @@
 # Introduction
 
-zip.js is an open-source library (BSD-3-Clause license) implemented in
-JavaScript to compress and decompress zip files. It has been designed to handle
-large amounts of data and notably supports multi-core compression, compression
-streams, Zip64 and encryption.
+zip.js is a JavaScript open-source library (BSD-3-Clause license) for
+compressing and decompressing zip files. It was designed to handle large amounts
+of data. It supports notably multi-core compression, native compression with
+compression streams, files larger than 4GB with Zip64, split zip files and data
+encryption.
 
 # Documentation
 
@@ -92,7 +93,7 @@ const zipFileBlobPromise = new Response(zipFileStream.readable).blob();
 const helloWorldReadable = new Blob(["Hello world!"]).stream();
 
 // Creates a ZipWriter object writing data into `zipFileStream.writable`, adds
-// the entry "hello.txt" containing the text "Hello world!" retrieved from 
+// the entry "hello.txt" containing the text "Hello world!" retrieved from
 // `helloWorldReadable`, and closes the writer.
 const zipWriter = new ZipWriter(zipFileStream.writable);
 await zipWriter.add("hello.txt", helloWorldReadable);

package/cli-deno/mc-zip.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env -S deno run --allow-write --allow-read --allow-net
 
-/* global Deno, fetch, URL, TextEncoderStream */
+/* global Deno, URL, TextEncoderStream */
 
 import { parse as parseArgs } from "https://deno.land/std@0.147.0/flags/mod.ts";
 import { normalize as normalizePath, resolve as resolvePath, extname } from "https://deno.land/std@0.147.0/path/mod.ts";
-import { configure, ZipWriter, terminateWorkers } from "../index.js";
+import { configure, ZipWriter, terminateWorkers, HttpReader } from "../index.js";
 
 const args = parseArgs(Deno.args);
 const stdout = getTextWriter(Deno.stdout);
@@ -81,9 +81,9 @@ async function addFile(zipWriter, file) {
 		onstart: () => stdout.write("  adding: " + file.name + "\n")
 	};
 	try {
-		const readable = await getReadable(file);
-		if (readable) {
-			await zipWriter.add(file.name, { readable }, options);
+		const reader = await getReader(file);
+		if (reader) {
+			await zipWriter.add(file.name, reader, options);
 		}
 	} catch (error) {
 		await stdout.write("  error: " + error.message + ", file: " + file.url + "\n");
@@ -91,7 +91,7 @@ async function addFile(zipWriter, file) {
 }
 
 async function getFileInfo(file, options) {
-	let name, isFile, isDirectory, resolvedName;
+	let name, isFile, isDirectory, resolvedName, size;
 	const remote = isRemote(file);
 	if (remote) {
 		const url = new URL(file, import.meta.url);
@@ -111,9 +111,10 @@ async function getFileInfo(file, options) {
 		const stat = await Deno.stat(resolvedName);
 		isFile = stat.isFile;
 		isDirectory = stat.isDirectory;
+		size = stat.size;
 	}
 	return {
-		url: file, name, remote, isFile, isDirectory, resolvedName
+		url: file, name, remote, isFile, size, isDirectory, resolvedName
 	};
 }
 
@@ -134,12 +135,17 @@ async function addDirectories(file, options) {
 	}
 }
 
-async function getReadable(file) {
-	return file.remote ?
-		(await fetch(file.url)).body :
-		file.isFile ?
-			(await Deno.open(resolvePath(file.url), { read: true })).readable :
-			null;
+async function getReader(file) {
+	if (file.remote) {
+		return new HttpReader(file.url);
+	} else if (file.isFile) {
+		const { size } = file;
+		const { readable } = await Deno.open(resolvePath(file.url), { read: true });
+		return {
+			readable,
+			size
+		};
+	}
 }
 
 function isRemote(path) {

package/dist/zip-fs-full.js

@@ -8343,14 +8343,34 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
+	const PROPERTY_NAME_FILENAME = "filename";
+	const PROPERTY_NAME_RAW_FILENAME = "rawFilename";
+	const PROPERTY_NAME_COMMENT = "comment";
+	const PROPERTY_NAME_RAW_COMMENT = "rawComment";
+	const PROPERTY_NAME_UNCOMPPRESSED_SIZE = "uncompressedSize";
+	const PROPERTY_NAME_COMPPRESSED_SIZE = "compressedSize";
+	const PROPERTY_NAME_OFFSET = "offset";
+	const PROPERTY_NAME_DISK_NUMBER_START = "diskNumberStart";
+	const PROPERTY_NAME_LAST_MODIFICATION_DATE = "lastModDate";
+	const PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE = "rawLastModDate";
+	const PROPERTY_NAME_LAST_ACCESS_DATE = "lastAccessDate";
+	const PROPERTY_NAME_RAW_LAST_ACCESS_DATE = "rawLastAccessDate";
+	const PROPERTY_NAME_CREATION_DATE = "creationDate";
+	const PROPERTY_NAME_RAW_CREATION_DATE = "rawCreationDate";
+	const PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE = "internalFileAttribute";
+	const PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE = "externalFileAttribute";
+	const PROPERTY_NAME_MS_DOS_COMPATIBLE = "msDosCompatible";
+	const PROPERTY_NAME_ZIP64 = "zip64";
+
 	const PROPERTY_NAMES = [
-		"filename", "rawFilename", "directory", "encrypted", "compressedSize", "uncompressedSize",
-		"lastModDate", "rawLastModDate", "comment", "rawComment", "signature", "extraField",
-		"rawExtraField", "bitFlag", "extraFieldZip64", "extraFieldUnicodePath", "extraFieldUnicodeComment",
-		"extraFieldAES", "filenameUTF8", "commentUTF8", "offset", "zip64", "compressionMethod",
-		"extraFieldNTFS", "lastAccessDate", "creationDate", "extraFieldExtendedTimestamp",
-		"version", "versionMadeBy", "msDosCompatible", "internalFileAttribute", "externalFileAttribute",
-		"diskNumberStart"];
+		PROPERTY_NAME_FILENAME, PROPERTY_NAME_RAW_FILENAME, PROPERTY_NAME_COMPPRESSED_SIZE, PROPERTY_NAME_UNCOMPPRESSED_SIZE,
+		PROPERTY_NAME_LAST_MODIFICATION_DATE, PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE, PROPERTY_NAME_COMMENT, PROPERTY_NAME_RAW_COMMENT,
+		PROPERTY_NAME_LAST_ACCESS_DATE, PROPERTY_NAME_CREATION_DATE, PROPERTY_NAME_OFFSET, PROPERTY_NAME_DISK_NUMBER_START,
+		PROPERTY_NAME_DISK_NUMBER_START, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE,
+		PROPERTY_NAME_MS_DOS_COMPATIBLE, PROPERTY_NAME_ZIP64,
+		"directory", "bitFlag", "encrypted", "signature", "filenameUTF8", "commentUTF8", "compressionMethod", "version", "versionMadeBy",
+		"extraField", "rawExtraField", "extraFieldZip64", "extraFieldUnicodePath", "extraFieldUnicodeComment", "extraFieldAES", "extraFieldNTFS",
+		"extraFieldExtendedTimestamp"];
 
 	class Entry {
 
@@ -8402,10 +8422,10 @@
 	const CHARSET_UTF8 = "utf-8";
 	const CHARSET_CP437 = "cp437";
 	const ZIP64_PROPERTIES = [
-		["uncompressedSize", MAX_32_BITS],
-		["compressedSize", MAX_32_BITS],
-		["offset", MAX_32_BITS],
-		["diskNumberStart", MAX_16_BITS]
+		[PROPERTY_NAME_UNCOMPPRESSED_SIZE, MAX_32_BITS],
+		[PROPERTY_NAME_COMPPRESSED_SIZE, MAX_32_BITS],
+		[PROPERTY_NAME_OFFSET, MAX_32_BITS],
+		[PROPERTY_NAME_DISK_NUMBER_START, MAX_16_BITS]
 	];
 	const ZIP64_EXTRACTION = {
 		[MAX_16_BITS]: {
@@ -8765,12 +8785,12 @@
 		}
 		const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
 		if (extraFieldUnicodePath) {
-			await readExtraFieldUnicode(extraFieldUnicodePath, "filename", "rawFilename", directory, fileEntry);
+			await readExtraFieldUnicode(extraFieldUnicodePath, PROPERTY_NAME_FILENAME, PROPERTY_NAME_RAW_FILENAME, directory, fileEntry);
 			directory.extraFieldUnicodePath = extraFieldUnicodePath;
 		}
 		const extraFieldUnicodeComment = extraField.get(EXTRAFIELD_TYPE_UNICODE_COMMENT);
 		if (extraFieldUnicodeComment) {
-			await readExtraFieldUnicode(extraFieldUnicodeComment, "comment", "rawComment", directory, fileEntry);
+			await readExtraFieldUnicode(extraFieldUnicodeComment, PROPERTY_NAME_COMMENT, PROPERTY_NAME_RAW_COMMENT, directory, fileEntry);
 			directory.extraFieldUnicodeComment = extraFieldUnicodeComment;
 		}
 		const extraFieldAES = extraField.get(EXTRAFIELD_TYPE_AES);
@@ -8884,16 +8904,16 @@
 		const timeProperties = [];
 		const timeRawProperties = [];
 		if ((flags & 0x1) == 0x1) {
-			timeProperties.push("lastModDate");
-			timeRawProperties.push("rawLastModDate");
+			timeProperties.push(PROPERTY_NAME_LAST_MODIFICATION_DATE);
+			timeRawProperties.push(PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE);
 		}
 		if ((flags & 0x2) == 0x2) {
-			timeProperties.push("lastAccessDate");
-			timeRawProperties.push("rawLastAccessDate");
+			timeProperties.push(PROPERTY_NAME_LAST_ACCESS_DATE);
+			timeRawProperties.push(PROPERTY_NAME_RAW_LAST_ACCESS_DATE);
 		}
 		if ((flags & 0x4) == 0x4) {
-			timeProperties.push("creationDate");
-			timeRawProperties.push("rawCreationDate");
+			timeProperties.push(PROPERTY_NAME_CREATION_DATE);
+			timeRawProperties.push(PROPERTY_NAME_RAW_CREATION_DATE);
 		}
 		let offset = 1;
 		timeProperties.forEach((propertyName, indexProperty) => {
@@ -9120,9 +9140,9 @@
 		if (versionMadeBy > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_VERSION);
 		}
-		const lastModDate = getOptionValue(zipWriter, options, "lastModDate") || new Date();
-		const lastAccessDate = getOptionValue(zipWriter, options, "lastAccessDate");
-		const creationDate = getOptionValue(zipWriter, options, "creationDate");
+		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 password = getOptionValue(zipWriter, options, "password");
 		const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength") || 3;
 		const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
@@ -9160,13 +9180,13 @@
 			keepOrder = true;
 		}
 		let uncompressedSize = 0;
-		let msDosCompatible = getOptionValue(zipWriter, options, "msDosCompatible");
+		let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
 		if (msDosCompatible === UNDEFINED_VALUE) {
 			msDosCompatible = true;
 		}
-		const internalFileAttribute = getOptionValue(zipWriter, options, "internalFileAttribute") || 0;
-		const externalFileAttribute = getOptionValue(zipWriter, options, "externalFileAttribute") || 0;
-		let zip64 = getOptionValue(zipWriter, options, "zip64");
+		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 = {
@@ -9242,11 +9262,8 @@
 		let fileEntry;
 		try {
 			fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo }, options);
-		} catch (error) {
-			if (!error.corruptedEntry && maximumEntrySize) {
-				zipWriter.pendingEntriesSize -= maximumEntrySize;
-			}
-			throw error;
+		} finally {
+			zipWriter.pendingEntriesSize -= maximumEntrySize;
 		}
 		Object.assign(fileEntry, { name, comment, extraField });
 		return new Entry(fileEntry);
@@ -9293,7 +9310,7 @@
 			if (zipWriter.addSplitZipSignature) {
 				delete zipWriter.addSplitZipSignature;
 				const signatureArray = new Uint8Array(4);
-				const signatureArrayView = new DataView(signatureArray.buffer);
+				const signatureArrayView = getDataView(signatureArray);
 				setUint32(signatureArrayView, 0, SPLIT_ZIP_FILE_SIGNATURE);
 				await writeData(writable, signatureArray);
 				zipWriter.offset += 4;
@@ -9431,9 +9448,9 @@
 			externalFileAttribute,
 			diskNumberStart
 		};
+		let compressedSize = 0;
 		let uncompressedSize = 0;
 		let signature;
-		let compressedSize = 0;
 		const { writable } = writer;
 		if (reader) {
 			reader.chunkSize = getChunkSize(config);
@@ -9828,7 +9845,7 @@
 		const endOfdirectoryView = getDataView(endOfdirectoryArray);
 		let lastDiskNumber = writer.diskNumber;
 		const { availableSize } = writer;
-		if (availableSize < endOfdirectoryArray.length) {
+		if (availableSize < getLength(endOfdirectoryArray)) {
 			lastDiskNumber++;
 		}
 		offset = 0;
@@ -10582,7 +10599,7 @@
 	configure({ baseURL });
 	e(configure);
 
-	/// <reference types="./index.d.ts" />
+	/// <reference types="./index" />
 
 	configure({ Deflate: ZipDeflate, Inflate: ZipInflate });