@zip.js/zip.js 2.9.0 → 2.10.0

package/lib/core/util/decode-cp437.js

@@ -26,23 +26,16 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TextDecoder */
-
 const CP437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\u00B6\u00A7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\u00C7\u00FC\u00E9\u00E2\u00E4\u00E0\u00E5\u00E7\u00EA\u00EB\u00E8\u00EF\u00EE\u00EC\u00C4\u00C5\u00C9\u00E6\u00C6\u00F4\u00F6\u00F2\u00FB\u00F9\u00FF\u00D6\u00DC\u00A2\u00A3\u00A5\u20A7\u0192\u00E1\u00ED\u00F3\u00FA\u00F1\u00D1\u00AA\u00BA\u00BF\u2310\u00AC\u00BD\u00BC\u00A1\u00AB\u00BB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\u00DF\u0393\u03C0\u03A3\u03C3\u00B5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\u00B1\u2265\u2264\u2320\u2321\u00F7\u2248\u00B0\u2219\u00B7\u221A\u207F\u00B2\u25A0\u00A0".split("");
-const VALID_CP437 = CP437.length == 256;
 
 export {
 	decodeCP437
 };
 
 function decodeCP437(stringValue) {
-	if (VALID_CP437) {
-		let result = "";
-		for (let indexCharacter = 0; indexCharacter < stringValue.length; indexCharacter++) {
-			result += CP437[stringValue[indexCharacter]];
-		}
-		return result;
-	} else {
-		return new TextDecoder().decode(stringValue);
+	let result = "";
+	for (let indexCharacter = 0; indexCharacter < stringValue.length; indexCharacter++) {
+		result += CP437[stringValue[indexCharacter]];
 	}
+	return result;
 }

package/lib/core/version.js

@@ -26,6 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.9.0";
+const VERSION = "2.10.0";
 
 export { VERSION };

package/lib/core/zip-fs.js

@@ -80,7 +80,14 @@ import { toExactUint8Array } from "./util/array.js";
 import { toCompatibleReadable, toCompatibleWritable } from "./util/compatible-streams.js";
 
 const ERR_ENTRY_EXISTS = "Entry filename already exists";
+const ERR_DUPLICATE_IMPORTED_ENTRY = "Duplicate entry filename in the imported zip file";
+const ERR_INVALID_DUPLICATES = "Invalid duplicates option (must be \"throw\", \"keep-first\" or \"keep-last\")";
+const ERR_ANCESTOR_ENTRY = "Entry is a ancestor of target entry";
 const ERR_READABLE_CONSUMED = "Readable stream already consumed";
+const DUPLICATES_THROW = "throw";
+const DUPLICATES_KEEP_FIRST = "keep-first";
+const DUPLICATES_KEEP_LAST = "keep-last";
+const DUPLICATES_VALUES = new Set([DUPLICATES_THROW, DUPLICATES_KEEP_FIRST, DUPLICATES_KEEP_LAST]);
 const ERR_INVALID_PASS_THROUGH = "Invalid passThrough option (use readerOptions.passThrough or set uncompressedSize for each entry)";
 const ERR_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
 const ERR_ZIP_CRYPTO_LAST_MOD_DATE = "The last modification date of an entry encrypted with ZipCrypto cannot be changed when passThrough is set";
@@ -157,12 +164,26 @@ class ZipEntry {
 	}
 
 	rename(name) {
-		const parent = this.parent;
-		if (parent && parent.getChildByName(name)) {
-			throw new Error(ERR_ENTRY_EXISTS);
-		} else {
-			this.name = name;
+		const zipEntry = this;
+		let parent = zipEntry.parent;
+		if (parent) {
+			const path = splitPath(name);
+			if (path) {
+				name = path.pop();
+				parent = getPathParent(parent, path, zipEntry);
+			}
+			const existingChild = parent.getChildByName(name);
+			if (existingChild && existingChild != zipEntry) {
+				throw new Error(ERR_ENTRY_EXISTS);
+			}
+			if (parent != zipEntry.parent) {
+				detach(zipEntry);
+				zipEntry.parent = parent;
+				parent.children.push(zipEntry);
+				registerEntries(zipEntry.fs, zipEntry);
+			}
 		}
+		zipEntry.name = name;
 	}
 
 	setOptions(options) {
@@ -255,47 +276,47 @@ class ZipFileEntry extends ZipEntry {
 	}
 
 	replaceBlob(blob) {
-		Object.assign(this, {
+		replaceContent(this, {
 			data: blob,
 			Reader: BlobReader,
 			Writer: BlobWriter,
-			reader: null
+			uncompressedSize: blob.size
 		});
 	}
 
 	replaceText(text) {
-		Object.assign(this, {
+		replaceContent(this, {
 			data: text,
 			Reader: TextReader,
 			Writer: TextWriter,
-			reader: null
+			uncompressedSize: getTextSize(text)
 		});
 	}
 
 	replaceData64URI(dataURI) {
-		Object.assign(this, {
+		replaceContent(this, {
 			data: dataURI,
 			Reader: Data64URIReader,
 			Writer: Data64URIWriter,
-			reader: null
+			uncompressedSize: getData64URISize(dataURI)
 		});
 	}
 
 	replaceUint8Array(array) {
-		Object.assign(this, {
+		replaceContent(this, {
 			data: array,
 			Reader: Uint8ArrayReader,
 			Writer: Uint8ArrayWriter,
-			reader: null
+			uncompressedSize: array.length
 		});
 	}
 
 	replaceReadable(readable) {
-		Object.assign(this, {
+		replaceContent(this, {
 			data: null,
 			Reader: getReadableReader(readable),
 			Writer: null,
-			reader: null
+			uncompressedSize: UNDEFINED_VALUE
 		});
 	}
 }
@@ -345,17 +366,12 @@ class ZipDirectoryEntry extends ZipEntry {
 	}
 
 	addData64URI(name, dataURI, options = {}) {
-		let dataEnd = dataURI.length;
-		while (dataURI.charAt(dataEnd - 1) == "=") {
-			dataEnd--;
-		}
-		const dataStart = dataURI.indexOf(",") + 1;
 		return addChild(this, name, {
 			data: dataURI,
 			Reader: Data64URIReader,
 			Writer: Data64URIWriter,
 			options,
-			uncompressedSize: Math.floor((dataEnd - dataStart) * 0.75)
+			uncompressedSize: getData64URISize(dataURI)
 		});
 	}
 
@@ -463,6 +479,7 @@ class ZipDirectoryEntry extends ZipEntry {
 			await initStream(reader);
 			zipReader = new ZipReader(reader, options);
 		}
+		const duplicates = checkDuplicatesOption(options.duplicates);
 		const importedEntries = [];
 		const entries = await zipReader.getEntries(options);
 		for (const entry of entries) {
@@ -470,19 +487,42 @@ class ZipDirectoryEntry extends ZipEntry {
 			try {
 				const path = entry.filename.split("/").filter(pathPart => pathPart != "" && pathPart != ".");
 				const name = path.pop();
-				path.forEach(pathPart => {
+				let skippedEntry = false;
+				for (const pathPart of path) {
 					const previousParent = parent;
 					parent = parent.getChildByName(pathPart);
 					if (parent) {
 						if (!parent.directory) {
-							throw new Error(ERR_ENTRY_EXISTS);
+							if (duplicates == DUPLICATES_KEEP_FIRST) {
+								skippedEntry = true;
+								break;
+							} else if (duplicates == DUPLICATES_KEEP_LAST) {
+								this.fs.remove(parent);
+								parent = new ZipDirectoryEntry(this.fs, pathPart, { data: null }, previousParent);
+								importedEntries.push(parent);
+							} else {
+								throw new Error(ERR_DUPLICATE_IMPORTED_ENTRY);
+							}
 						}
 					} else {
 						parent = new ZipDirectoryEntry(this.fs, pathPart, { data: null }, previousParent);
 						importedEntries.push(parent);
 					}
-				});
+				}
+				if (skippedEntry) {
+					continue;
+				}
 				if (!entry.directory) {
+					const existingChild = parent.getChildByName(name);
+					if (existingChild) {
+						if (duplicates == DUPLICATES_KEEP_FIRST) {
+							continue;
+						} else if (duplicates == DUPLICATES_KEEP_LAST) {
+							this.fs.remove(existingChild);
+						} else {
+							throw new Error(ERR_DUPLICATE_IMPORTED_ENTRY);
+						}
+					}
 					importedEntries.push(addChild(parent, name, {
 						data: entry,
 						Reader: getZipBlobReader(Object.assign({}, options)),
@@ -493,11 +533,17 @@ class ZipDirectoryEntry extends ZipEntry {
 					let directoryEntry = parent;
 					if (name) {
 						directoryEntry = parent.getChildByName(name);
-						if (directoryEntry) {
-							if (!directoryEntry.directory) {
-								throw new Error(ERR_ENTRY_EXISTS);
+						if (directoryEntry && !directoryEntry.directory) {
+							if (duplicates == DUPLICATES_KEEP_FIRST) {
+								continue;
+							} else if (duplicates == DUPLICATES_KEEP_LAST) {
+								this.fs.remove(directoryEntry);
+								directoryEntry = UNDEFINED_VALUE;
+							} else {
+								throw new Error(ERR_DUPLICATE_IMPORTED_ENTRY);
 							}
-						} else {
+						}
+						if (!directoryEntry) {
 							directoryEntry = new ZipDirectoryEntry(this.fs, name, { data: null }, parent);
 							importedEntries.push(directoryEntry);
 						}
@@ -507,6 +553,7 @@ class ZipDirectoryEntry extends ZipEntry {
 					}
 				}
 			} catch (error) {
+				importedEntries.reverse().forEach(importedEntry => this.fs.remove(importedEntry));
 				try {
 					error.cause = {
 						entry
@@ -625,7 +672,7 @@ class ZipFS {
 						}
 					}
 				} else {
-					throw new Error("Entry is a ancestor of target entry");
+					throw new Error(ERR_ANCESTOR_ENTRY);
 				}
 			} else {
 				throw new Error("Target entry is not a directory");
@@ -637,7 +684,7 @@ class ZipFS {
 		const path = fullname.split("/");
 		let node = this.root;
 		for (let index = 0; node && index < path.length; index++) {
-			node = node.getChildByName(path[index]);
+			node = node.directory ? node.getChildByName(path[index]) : UNDEFINED_VALUE;
 		}
 		if (!node) {
 			node = this.entries.find(entry => entry && (entry == this.root || entry.isDescendantOf(this.root)) &&
@@ -699,33 +746,27 @@ class ZipFS {
 	}
 
 	importBlob(blob, options) {
-		resetFS(this);
-		return this.root.importBlob(blob, options);
+		return resetAndImport(this, root => root.importBlob(blob, options));
 	}
 
 	importData64URI(dataURI, options) {
-		resetFS(this);
-		return this.root.importData64URI(dataURI, options);
+		return resetAndImport(this, root => root.importData64URI(dataURI, options));
 	}
 
 	importUint8Array(array, options) {
-		resetFS(this);
-		return this.root.importUint8Array(array, options);
+		return resetAndImport(this, root => root.importUint8Array(array, options));
 	}
 
 	importHttpContent(url, options) {
-		resetFS(this);
-		return this.root.importHttpContent(url, options);
+		return resetAndImport(this, root => root.importHttpContent(url, options));
 	}
 
 	importReadable(readable, options) {
-		resetFS(this);
-		return this.root.importReadable(readable, options);
+		return resetAndImport(this, root => root.importReadable(readable, options));
 	}
 
 	importZip(reader, options) {
-		resetFS(this);
-		return this.root.importZip(reader, options);
+		return resetAndImport(this, root => root.importZip(reader, options));
 	}
 
 	exportBlob(options) {
@@ -766,7 +807,7 @@ class ZipFS {
 }
 
 const fs = { FS: ZipFS, ZipDirectoryEntry, ZipFileEntry };
-export { ZipFS, ZipEntry, ZipFileEntry, ZipDirectoryEntry, fs, ERR_ENTRY_EXISTS, ERR_READABLE_CONSUMED, ERR_INVALID_PASS_THROUGH, ERR_INVALID_READER_OPTIONS, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ABORTED };
+export { ZipFS, ZipEntry, ZipFileEntry, ZipDirectoryEntry, fs, ERR_ENTRY_EXISTS, ERR_DUPLICATE_IMPORTED_ENTRY, ERR_INVALID_DUPLICATES, ERR_READABLE_CONSUMED, ERR_INVALID_PASS_THROUGH, ERR_INVALID_READER_OPTIONS, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ABORTED };
 
 function getTotalSize(entries, getEntrySize) {
 	let size = 0;
@@ -1046,6 +1087,25 @@ function checkReaderOptions(readerOptions) {
 	return readerOptions;
 }
 
+function replaceContent(zipEntry, params) {
+	const { uncompressedSize } = params;
+	Object.assign(zipEntry, params, {
+		reader: null,
+		passThrough: UNDEFINED_VALUE,
+		uncompressedSize: uncompressedSize === UNDEFINED_VALUE ? 0 : uncompressedSize,
+		undeterminedSize: uncompressedSize === UNDEFINED_VALUE
+	});
+}
+
+function getData64URISize(dataURI) {
+	let dataEnd = dataURI.length;
+	while (dataURI.charAt(dataEnd - 1) == "=") {
+		dataEnd--;
+	}
+	const dataStart = dataURI.indexOf(",") + 1;
+	return Math.floor((dataEnd - dataStart) * 0.75);
+}
+
 function isPassThrough(child, options) {
 	const { readerOptions } = options;
 	return Boolean(!child.directory && (child.passThrough || (readerOptions && readerOptions.passThrough)));
@@ -1335,6 +1395,15 @@ function resetFS(fs) {
 	fs.root = new ZipDirectoryEntry(fs);
 }
 
+function resetAndImport(fs, importFunction) {
+	const { entries, entryIdCounter, root } = fs;
+	resetFS(fs);
+	return importFunction(fs.root).catch(error => {
+		Object.assign(fs, { entries, entryIdCounter, root });
+		throw error;
+	});
+}
+
 function collectChildren(directory, recursive) {
 	const children = [];
 	const pendingDirectories = [directory];
@@ -1363,8 +1432,50 @@ function registerEntries(fs, entry) {
 
 function addChild(parent, name, params, directory) {
 	if (parent.directory) {
+		const path = splitPath(name);
+		if (path) {
+			name = path.pop();
+			parent = getPathParent(parent, path);
+		}
 		return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new ZipFileEntry(parent.fs, name, params, parent);
 	} else {
 		throw new Error("Parent entry is not a directory");
 	}
-}
+}
+
+function checkDuplicatesOption(duplicates) {
+	if (duplicates === UNDEFINED_VALUE) {
+		return DUPLICATES_THROW;
+	} else if (DUPLICATES_VALUES.has(duplicates)) {
+		return duplicates;
+	} else {
+		throw new Error(ERR_INVALID_DUPLICATES);
+	}
+}
+
+function splitPath(name) {
+	if (name.includes("/")) {
+		const path = name.split("/").filter(pathPart => pathPart != "" && pathPart != ".");
+		if (path.length) {
+			return path;
+		}
+	}
+}
+
+function getPathParent(parent, path, movedEntry) {
+	path.forEach(pathPart => {
+		const previousParent = parent;
+		parent = parent.getChildByName(pathPart);
+		if (parent) {
+			if (!parent.directory) {
+				throw new Error(ERR_ENTRY_EXISTS);
+			}
+			if (movedEntry && (parent == movedEntry || parent.isDescendantOf(movedEntry))) {
+				throw new Error(ERR_ANCESTOR_ENTRY);
+			}
+		} else {
+			parent = new ZipDirectoryEntry(previousParent.fs, pathPart, { data: null }, previousParent);
+		}
+	});
+	return parent;
+}

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