@zip.js/zip.js 2.9.0 → 2.10.0

package/dist/zip-fs-core.js

@@ -3475,21 +3475,14 @@
 	 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;
 
 	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;
 	}
 
 	/*
@@ -8624,7 +8617,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.9.0";
+	const VERSION = "2.10.0";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9103,7 +9096,14 @@
 
 
 	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";
@@ -9180,12 +9180,26 @@
 		}
 
 		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) {
@@ -9278,47 +9292,47 @@
 		}
 
 		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
 			});
 		}
 	}
@@ -9368,17 +9382,12 @@
 		}
 
 		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)
 			});
 		}
 
@@ -9486,6 +9495,7 @@
 				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) {
@@ -9493,19 +9503,42 @@
 				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)),
@@ -9516,11 +9549,17 @@
 						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);
 							}
@@ -9530,6 +9569,7 @@
 						}
 					}
 				} catch (error) {
+					importedEntries.reverse().forEach(importedEntry => this.fs.remove(importedEntry));
 					try {
 						error.cause = {
 							entry
@@ -9648,7 +9688,7 @@
 							}
 						}
 					} 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");
@@ -9660,7 +9700,7 @@
 			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)) &&
@@ -9722,33 +9762,27 @@
 		}
 
 		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) {
@@ -10068,6 +10102,25 @@
 		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)));
@@ -10357,6 +10410,15 @@
 		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];
@@ -10385,12 +10447,54 @@
 
 	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;
+	}
+
 	exports.BlobReader = BlobReader;
 	exports.BlobWriter = BlobWriter;
 	exports.Data64URIReader = Data64URIReader;
@@ -10400,6 +10504,7 @@
 	exports.ERR_BAD_FORMAT = ERR_BAD_FORMAT;
 	exports.ERR_CENTRAL_DIRECTORY_NOT_FOUND = ERR_CENTRAL_DIRECTORY_NOT_FOUND;
 	exports.ERR_DUPLICATED_NAME = ERR_DUPLICATED_NAME;
+	exports.ERR_DUPLICATE_IMPORTED_ENTRY = ERR_DUPLICATE_IMPORTED_ENTRY;
 	exports.ERR_ENCRYPTED = ERR_ENCRYPTED;
 	exports.ERR_ENCRYPTED_CENTRAL_DIRECTORY = ERR_ENCRYPTED_CENTRAL_DIRECTORY;
 	exports.ERR_ENTRY_DATA_OUT_OF_BOUNDS = ERR_ENTRY_DATA_OUT_OF_BOUNDS;
@@ -10417,6 +10522,7 @@
 	exports.ERR_INVALID_COMPRESSED_DATA = ERR_INVALID_COMPRESSED_DATA;
 	exports.ERR_INVALID_CRC32 = ERR_INVALID_CRC32;
 	exports.ERR_INVALID_DATE = ERR_INVALID_DATE;
+	exports.ERR_INVALID_DUPLICATES = ERR_INVALID_DUPLICATES;
 	exports.ERR_INVALID_ENCRYPTION_STRENGTH = ERR_INVALID_ENCRYPTION_STRENGTH;
 	exports.ERR_INVALID_ENTRY_COMMENT = ERR_INVALID_ENTRY_COMMENT;
 	exports.ERR_INVALID_ENTRY_COMMENT_TYPE = ERR_INVALID_ENTRY_COMMENT_TYPE;