@zip.js/zip.js 2.9.0 → 2.11.0

package/dist/zip-fs-core.js

@@ -1461,8 +1461,7 @@
 	const GET_RANDOM_VALUES_SUPPORTED = typeof crypto != UNDEFINED_TYPE && typeof crypto.getRandomValues == FUNCTION_TYPE;
 
 	const ERR_INVALID_PASSWORD = "Invalid password";
-	const ERR_INVALID_SIGNATURE = "Invalid signature";
-	const ERR_INVALID_AUTHENTICATION_CODE = ERR_INVALID_SIGNATURE;
+	const ERR_INVALID_AUTHENTICATION_CODE = "Invalid authentication code";
 	const ERR_ABORT_CHECK_PASSWORD = "zipjs-abort-check-password";
 	const ERR_UNSUPPORTED_CRYPTO_API = "Crypto API not supported";
 
@@ -2036,6 +2035,7 @@
 	const ERR_INVALID_CODEC_DEFINITION = "Invalid codec definition";
 	const ERR_RESERVED_COMPRESSION_METHOD = "Reserved compression method";
 	const ERR_INVALID_CODEC_MODULE = "Invalid codec module";
+	const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 
 	const RESERVED_COMPRESSION_METHODS = [
 		COMPRESSION_METHOD_STORE,
@@ -2135,8 +2135,7 @@
 
 	const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
 	const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
-	const ERR_INVALID_CRC32 = ERR_INVALID_SIGNATURE;
-	const ERR_UNSUPPORTED_COMPRESSION$2 = "Compression method not supported";
+	const ERR_INVALID_CRC32 = "Invalid CRC32";
 	const FORMAT_DEFLATE_RAW = "deflate-raw";
 	const FORMAT_DEFLATE64_RAW = "deflate64-raw";
 	const FORMAT_GZIP = "gzip";
@@ -2404,7 +2403,7 @@
 
 	function createCodecStream(CodecStreamClass, format, options) {
 		if (!CodecStreamClass) {
-			throw new Error(ERR_UNSUPPORTED_COMPRESSION$2);
+			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
 		return new CodecStreamClass(format, options);
 	}
@@ -3475,21 +3474,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;
 	}
 
 	/*
@@ -4575,8 +4567,6 @@
 	const PROPERTY_NAME_RAW_CREATION_DATE = "rawCreationDate";
 	const PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES = "internalFileAttributes";
 	const PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES = "externalFileAttributes";
-	const PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES = "internalFileAttribute";
-	const PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES = "externalFileAttribute";
 	const PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW = "msdosAttributesRaw";
 	const PROPERTY_NAME_MSDOS_ATTRIBUTES = "msdosAttributes";
 	const PROPERTY_NAME_MS_DOS_COMPATIBLE = "msDosCompatible";
@@ -4635,8 +4625,6 @@
 		PROPERTY_NAME_DISK_NUMBER_START,
 		PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
 		PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES,
-		PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES,
-		PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES,
 		PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW,
 		PROPERTY_NAME_MSDOS_ATTRIBUTES,
 		PROPERTY_NAME_MS_DOS_COMPATIBLE,
@@ -4724,7 +4712,6 @@
 	const ERR_EXTRAFIELD_ZIP64_NOT_FOUND = "Zip64 extra field not found";
 	const ERR_ENCRYPTED = "File contains encrypted entry";
 	const ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
-	const ERR_UNSUPPORTED_COMPRESSION$1 = "Compression method not supported";
 	const ERR_SPLIT_ZIP_FILE = "Split zip file";
 	const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
 	const ERR_ENTRY_DATA_OUT_OF_BOUNDS = "Entry data out of bounds";
@@ -5105,8 +5092,6 @@
 					sticky,
 					symlink,
 					unixExternalUpper,
-					internalFileAttribute: fileEntry.internalFileAttributes,
-					externalFileAttribute: fileEntry.externalFileAttributes,
 					executable,
 					directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || fileEntry.filename.endsWith(DIRECTORY_SIGNATURE),
 					zipCrypto: fileEntry.encrypted && !fileEntry.extraFieldAES
@@ -5305,7 +5290,7 @@
 			rawPassword = rawPassword && rawPassword.length && rawPassword;
 			if (extraFieldAES) {
 				if (extraFieldAES.originalCompressionMethod != COMPRESSION_METHOD_AES) {
-					throw new Error(ERR_UNSUPPORTED_COMPRESSION$1);
+					throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 				}
 			}
 			if (dataArray.length < HEADER_SIZE || getUint32$1(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
@@ -5361,7 +5346,7 @@
 			}
 			const registeredCodec = passThrough ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
 			if (compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64 && !registeredCodec && !passThrough) {
-				throw new Error(ERR_UNSUPPORTED_COMPRESSION$1);
+				throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 			}
 			if (encrypted) {
 				if (!zipCrypto && (extraFieldAES.strength < 1 || extraFieldAES.strength > 3)) {
@@ -6213,14 +6198,13 @@
 		ERR_INVALID_FILENAME_VALIDATION: ERR_INVALID_FILENAME_VALIDATION,
 		ERR_INVALID_MAX_APPENDED_DATA_SIZE: ERR_INVALID_MAX_APPENDED_DATA_SIZE,
 		ERR_INVALID_PASSWORD: ERR_INVALID_PASSWORD,
-		ERR_INVALID_SIGNATURE: ERR_INVALID_SIGNATURE,
 		ERR_INVALID_STRICTNESS: ERR_INVALID_STRICTNESS,
 		ERR_INVALID_UNCOMPRESSED_SIZE: ERR_INVALID_UNCOMPRESSED_SIZE,
 		ERR_LOCAL_FILE_HEADER_NOT_FOUND: ERR_LOCAL_FILE_HEADER_NOT_FOUND,
 		ERR_OVERLAPPING_ENTRY: ERR_OVERLAPPING_ENTRY,
 		ERR_SPLIT_ZIP_FILE: ERR_SPLIT_ZIP_FILE,
 		ERR_UNSAFE_FILENAME: ERR_UNSAFE_FILENAME,
-		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
+		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION,
 		ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
 		ERR_UNSUPPORTED_UINT64: ERR_UNSUPPORTED_UINT64,
 		ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
@@ -6288,7 +6272,6 @@
 	const ERR_INVALID_EXTRAFIELD_TYPE = "Invalid extra field type (must be integer 0..65535)";
 	const ERR_INVALID_EXTRAFIELD_DATA_TYPE = "Invalid extra field data (must be a Uint8Array)";
 	const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
-	const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 	const MIN_UNIX_TIME = -2147483648;
 	const MAX_UNIX_TIME = 2147483647;
 	const MIN_NTFS_TIME = BigInt(0);
@@ -6728,9 +6711,7 @@
 		Object.assign(fileEntry, {
 			name,
 			comment,
-			extraField,
-			[PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES]: fileEntry.internalFileAttributes,
-			[PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES]: fileEntry.externalFileAttributes
+			extraField
 		});
 		return new Entry(fileEntry);
 	}
@@ -6777,7 +6758,7 @@
 		if (versionMadeBy > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_VERSION);
 		}
-		let externalFileAttributes = getAliasedOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES);
+		let externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES);
 		const externalFileAttributesProvided = externalFileAttributes !== UNDEFINED_VALUE;
 		if (!externalFileAttributesProvided) {
 			externalFileAttributes = 0;
@@ -6887,7 +6868,7 @@
 		const rawLastModDate = getOptionValue(zipWriter, options, PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE);
 		const lastAccessDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_LAST_ACCESS_DATE);
 		const creationDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_CREATION_DATE);
-		const internalFileAttributes = getAliasedOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES, 0);
+		const internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, 0);
 		const passThrough = getOptionValue(zipWriter, options, OPTION_PASS_THROUGH);
 		const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
 		const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
@@ -8356,16 +8337,6 @@
 		return checkFunctionOption(getOptionValue(zipWriter, options, name));
 	}
 
-	function getAliasedOptionValue(zipWriter, options, name, deprecatedName, defaultValue) {
-		const value = getAliasedValue(options, name, deprecatedName);
-		const result = value === UNDEFINED_VALUE ? getAliasedValue(zipWriter.options, name, deprecatedName) : value;
-		return result === UNDEFINED_VALUE ? defaultValue : result;
-	}
-
-	function getAliasedValue(options, name, deprecatedName) {
-		return options[name] === UNDEFINED_VALUE ? options[deprecatedName] : options[name];
-	}
-
 	function getNumberOptionValue(zipWriter, options, name, defaultValue) {
 		return toNumber(getOptionValue(zipWriter, options, name, defaultValue));
 	}
@@ -8624,7 +8595,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.9.0";
+	const VERSION = "2.11.0";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9103,7 +9074,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 +9158,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 +9270,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 +9360,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 +9473,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 +9481,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 +9527,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 +9547,7 @@
 						}
 					}
 				} catch (error) {
+					importedEntries.reverse().forEach(importedEntry => this.fs.remove(importedEntry));
 					try {
 						error.cause = {
 							entry
@@ -9648,7 +9666,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 +9678,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 +9740,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 +10080,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 +10388,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 +10425,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 +10482,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 +10500,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;
@@ -10438,7 +10522,6 @@
 	exports.ERR_INVALID_PASS_THROUGH = ERR_INVALID_PASS_THROUGH;
 	exports.ERR_INVALID_READER_OPTIONS = ERR_INVALID_READER_OPTIONS;
 	exports.ERR_INVALID_SIGNAL = ERR_INVALID_SIGNAL;
-	exports.ERR_INVALID_SIGNATURE = ERR_INVALID_SIGNATURE;
 	exports.ERR_INVALID_SIGNATURE_DATA = ERR_INVALID_SIGNATURE_DATA;
 	exports.ERR_INVALID_STRICTNESS = ERR_INVALID_STRICTNESS;
 	exports.ERR_INVALID_UID = ERR_INVALID_UID;
@@ -10458,7 +10541,7 @@
 	exports.ERR_UNDEFINED_UNCOMPRESSED_SIZE = ERR_UNDEFINED_UNCOMPRESSED_SIZE;
 	exports.ERR_UNDETERMINED_SIZE = ERR_UNDETERMINED_SIZE;
 	exports.ERR_UNSAFE_FILENAME = ERR_UNSAFE_FILENAME;
-	exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION$1;
+	exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION;
 	exports.ERR_UNSUPPORTED_CONTEXT = ERR_UNSUPPORTED_CONTEXT;
 	exports.ERR_UNSUPPORTED_CRYPTO_API = ERR_UNSUPPORTED_CRYPTO_API;
 	exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;