@zip.js/zip.js 2.8.52 → 2.8.54

package/index-native.cjs

@@ -39,6 +39,7 @@ const COMPRESSION_METHOD_AES = 0x63;
 
 const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
 const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
+const TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE = 0x30304b50;
 const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
 const ARCHIVE_EXTRA_DATA_SIGNATURE = 0x08064b50;
 const DIGITAL_SIGNATURE_RECORD_SIGNATURE = 0x05054b50;
@@ -55,6 +56,7 @@ const ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_
 const DATA_DESCRIPTOR_RECORD_LENGTH = 12;
 const DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH = 20;
 const DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH = 4;
+const SPLIT_ZIP_FILE_SIGNATURE_LENGTH = 4;
 
 const EXTRAFIELD_TYPE_ZIP64 = 0x0001;
 const EXTRAFIELD_TYPE_AES = 0x9901;
@@ -96,6 +98,9 @@ const VERSION_DEFLATE = 0x14;
 const VERSION_ZIP64 = 0x2D;
 const VERSION_AES = 0x33;
 
+const VERSION_MADE_BY_MSDOS = 0x0014;
+const VERSION_MADE_BY_UNIX = 0x0300;
+
 const DIRECTORY_SIGNATURE = "/";
 
 const HEADER_SIZE = 30;
@@ -103,6 +108,8 @@ const HEADER_OFFSET_VERSION = 0;
 const HEADER_OFFSET_SIGNATURE = 10;
 const HEADER_OFFSET_COMPRESSED_SIZE = 14;
 const HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
+const HEADER_OFFSET_FILENAME_LENGTH = 22;
+const HEADER_OFFSET_EXTRAFIELD_LENGTH = 24;
 const LOCAL_HEADER_COMMON_OFFSET = 4;
 
 const MAX_DATE = new Date(2107, 11, 31, 23, 59, 58);
@@ -115,9 +122,116 @@ const FUNCTION_TYPE = "function";
 const OBJECT_TYPE = "object";
 const STRING_TYPE = "string";
 const NUMBER_TYPE = "number";
+const BOOLEAN_TYPE = "boolean";
 
 const EMPTY_UINT8_ARRAY = new Uint8Array();
 
+/*
+ Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+const OPTION_FILENAME_ENCODING = "filenameEncoding";
+const OPTION_COMMENT_ENCODING = "commentEncoding";
+const OPTION_DECODE_TEXT = "decodeText";
+const OPTION_EXTRACT_PREPENDED_DATA = "extractPrependedData";
+const OPTION_EXTRACT_APPENDED_DATA = "extractAppendedData";
+const OPTION_PASSWORD = "password";
+const OPTION_RAW_PASSWORD = "rawPassword";
+const OPTION_PASS_THROUGH = "passThrough";
+const OPTION_SIGNAL = "signal";
+const OPTION_CHECK_PASSWORD_ONLY = "checkPasswordOnly";
+const OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
+const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
+const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
+const OPTION_CHECK_LOCAL_DIRECTORY = "checkLocalDirectory";
+const OPTION_CHECK_SIGNATURE = "checkSignature";
+const OPTION_CHECK_CRC32 = "checkCrc32";
+const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
+const OPTION_USE_WEB_WORKERS = "useWebWorkers";
+const OPTION_USE_COMPRESSION_STREAM = "useCompressionStream";
+const OPTION_TRANSFER_STREAMS = "transferStreams";
+const OPTION_PREVENT_CLOSE = "preventClose";
+const OPTION_ENCRYPTION_STRENGTH = "encryptionStrength";
+const OPTION_EXTENDED_TIMESTAMP = "extendedTimestamp";
+const OPTION_NTFS_TIMESTAMP = "ntfsTimestamp";
+const OPTION_KEEP_ORDER = "keepOrder";
+const OPTION_LEVEL = "level";
+const OPTION_BUFFERED_WRITE = "bufferedWrite";
+const OPTION_CREATE_TEMP_STREAM = "createTempStream";
+const OPTION_DATA_DESCRIPTOR_SIGNATURE = "dataDescriptorSignature";
+const OPTION_USE_UNICODE_FILE_NAMES = "useUnicodeFileNames";
+const OPTION_DATA_DESCRIPTOR = "dataDescriptor";
+const OPTION_SUPPORT_ZIP64_SPLIT_FILE = "supportZip64SplitFile";
+const OPTION_ENCODE_TEXT = "encodeText";
+const OPTION_OFFSET = "offset";
+const OPTION_USDZ = "usdz";
+const OPTION_UNIX_EXTRA_FIELD_TYPE = "unixExtraFieldType";
+const OPTION_LOCAL_EXTRA_FIELD = "localExtraField";
+const OPTION_STRICTNESS = "strictness";
+const OPTION_FILENAME_VALIDATION = "filenameValidation";
+const OPTION_NORMALIZE_FILENAME = "normalizeFilename";
+const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
+const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
+const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
+const TEXT_TYPE_FILENAME = "filename";
+const TEXT_TYPE_COMMENT = "comment";
+const STRICTNESS_STRICT = "strict";
+const STRICTNESS_BALANCED = "balanced";
+const STRICTNESS_TOLERANT = "tolerant";
+
+const ERR_INVALID_FUNCTION_OPTION = "Invalid option (must be a function)";
+const ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
+const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
+
+function checkFunctionOption(value) {
+	if (value && typeof value != FUNCTION_TYPE) {
+		throw new Error(ERR_INVALID_FUNCTION_OPTION);
+	}
+	return value;
+}
+
+function checkSignalOption(signal) {
+	if (signal && (typeof signal.addEventListener != FUNCTION_TYPE || typeof signal.aborted != BOOLEAN_TYPE)) {
+		throw new Error(ERR_INVALID_SIGNAL);
+	}
+	return signal || UNDEFINED_VALUE;
+}
+
+function checkPasswordOption(password, rawPassword) {
+	if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
+		throw new Error(ERR_INVALID_PASSWORD_TYPE);
+	}
+}
+
+function toNumber(value) {
+	return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
+}
+
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -147,7 +261,10 @@ const EMPTY_UINT8_ARRAY = new Uint8Array();
  */
 
 
+const DEFAULT_CHUNK_SIZE$1 = 64 * 1024;
 const MINIMUM_CHUNK_SIZE = 64;
+const MINIMUM_PROPERTY_VALUE = 1;
+const ERR_INVALID_MAX_WORKERS = "Invalid maxWorkers (must be an integer greater than 0)";
 let maxWorkers = 2;
 try {
 	if (typeof navigator != UNDEFINED_TYPE && navigator.hardwareConcurrency) {
@@ -159,7 +276,7 @@ try {
 const DEFAULT_CONFIGURATION = {
 	workerURI: "./core/web-worker-wasm.js",
 	wasmURI: "./core/streams/zlib-wasm/zlib-streams.wasm",
-	chunkSize: 64 * 1024,
+	chunkSize: DEFAULT_CHUNK_SIZE$1,
 	maxWorkers,
 	terminateWorkerTimeout: 5000,
 	workerStarvationTimeout: 5000,
@@ -171,24 +288,38 @@ const DEFAULT_CONFIGURATION = {
 	DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 };
 
-const CONFIGURABLE_PROPERTY_NAMES = [
+const PROPERTY_NAME_MAX_WORKERS = "maxWorkers";
+
+const STRING_PROPERTY_NAMES = [
 	"baseURI",
 	"wasmURI",
-	"workerURI",
-	"createWorker",
+	"workerURI"
+];
+const BOOLEAN_PROPERTY_NAMES = [
+	"useCompressionStream",
+	"useWebWorkers",
+	"transferStreams"
+];
+const NUMBER_PROPERTY_NAMES = [
 	"chunkSize",
-	"maxWorkers",
+	PROPERTY_NAME_MAX_WORKERS,
 	"terminateWorkerTimeout",
 	"workerStarvationTimeout",
-	"workerStartupTimeout",
-	"useCompressionStream",
-	"useWebWorkers",
-	"transferStreams",
+	"workerStartupTimeout"
+];
+const FUNCTION_PROPERTY_NAMES = [
+	"createWorker",
 	"CompressionStream",
 	"DecompressionStream",
 	"CompressionStreamFallback",
 	"DecompressionStreamFallback"
 ];
+const CONFIGURABLE_PROPERTY_NAMES = [
+	...STRING_PROPERTY_NAMES,
+	...BOOLEAN_PROPERTY_NAMES,
+	...NUMBER_PROPERTY_NAMES,
+	...FUNCTION_PROPERTY_NAMES
+];
 
 const config = { ...DEFAULT_CONFIGURATION };
 
@@ -197,20 +328,43 @@ function getConfiguration() {
 }
 
 function getChunkSize(config) {
-	return Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
+	return normalizeChunkSize(config.chunkSize);
+}
+
+function normalizeChunkSize(chunkSize) {
+	chunkSize = toNumber(chunkSize);
+	return Number.isInteger(chunkSize) && chunkSize >= MINIMUM_PROPERTY_VALUE ? Math.max(chunkSize, MINIMUM_CHUNK_SIZE) : DEFAULT_CHUNK_SIZE$1;
 }
 
 function configure(configuration) {
-	configuration = normalizeConfiguration(configuration);
+	Object.assign(config, checkConfiguration(normalizeConfiguration(configuration)));
+}
+
+function checkConfiguration(configuration) {
+	const checkedConfiguration = {};
 	for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
 		const propertyValue = configuration[propertyName];
 		if (propertyValue !== UNDEFINED_VALUE) {
-			config[propertyName] = propertyValue;
+			checkedConfiguration[propertyName] = checkPropertyValue(propertyName, propertyValue);
+		}
+	}
+	return checkedConfiguration;
+}
+
+function checkPropertyValue(propertyName, propertyValue) {
+	if (NUMBER_PROPERTY_NAMES.includes(propertyName)) {
+		propertyValue = toNumber(propertyValue);
+		if (propertyName == PROPERTY_NAME_MAX_WORKERS && (!Number.isInteger(propertyValue) || propertyValue < MINIMUM_PROPERTY_VALUE)) {
+			throw new Error(ERR_INVALID_MAX_WORKERS);
 		}
+	} else if (FUNCTION_PROPERTY_NAMES.includes(propertyName)) {
+		checkFunctionOption(propertyValue);
 	}
+	return propertyValue;
 }
 
 function normalizeConfiguration(configuration) {
+	configuration = configuration || {};
 	const { CompressionStreamZlib, DecompressionStreamZlib } = configuration;
 	if (CompressionStreamZlib === UNDEFINED_VALUE && DecompressionStreamZlib === UNDEFINED_VALUE) {
 		return configuration;
@@ -226,14 +380,9 @@ function normalizeConfiguration(configuration) {
 }
 
 function setDefaultConfiguration(configuration) {
-	configuration = normalizeConfiguration(configuration);
-	for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
-		const propertyValue = configuration[propertyName];
-		if (propertyValue !== UNDEFINED_VALUE) {
-			DEFAULT_CONFIGURATION[propertyName] = propertyValue;
-		}
-	}
-	configure(configuration);
+	const checkedConfiguration = checkConfiguration(normalizeConfiguration(configuration));
+	Object.assign(DEFAULT_CONFIGURATION, checkedConfiguration);
+	Object.assign(config, checkedConfiguration);
 }
 
 function resetConfiguration() {
@@ -243,7 +392,7 @@ function resetConfiguration() {
 	Object.assign(config, DEFAULT_CONFIGURATION);
 }
 
-const r=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258],t=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],f=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],n=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],c=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],e=new Uint8Array(288);e.fill(8,0,144),e.fill(9,144,256),e.fill(7,256,280),e.fill(8,280,288);const j$1=new Uint8Array(30).fill(5);function z$1(r){const t=new Uint16Array(16);for(const f of r)t[f]++;t[0]=0;const f=new Uint16Array(17);for(let r=1;15>=r;r++)f[r+1]=f[r]+t[r];const n=new Uint16Array(r.length);for(let t=0;t<r.length;t++)r[t]&&(n[f[r[t]]++]=t);return {j:t,symbols:n}}const W$1="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",p$1=(s=()=>(W=>{let p=0,s=0,o=0,Y=new Uint8Array(1024),l=0,B=0;for(;!B;){B=u(1);const r=u(2);if(0==r)T();else if(1==r)w(z$1(e),z$1(j$1));else {if(2!=r)throw Error("invalid deflate block type");w(...K());}}return Y.subarray(0,l);function S(){if(p>=W.length)throw Error("unexpected end of deflate data");return W[p++]}function u(r){for(;r>o;)s|=S()<<o,o+=8;const t=s&(1<<r)-1;return s>>>=r,o-=r,t}function T(){s=0,o=0;const r=S()|S()<<8;p+=2,D(l+r);for(let t=0;r>t;t++)Y[l++]=S();}function w(c,e){let j=q(c);for(;256!=j;){if(256>j)D(l+1),Y[l++]=j;else {const c=j-257,z=r[c]+u(t[c]),W=q(e),p=f[W]+u(n[W]);D(l+z);const s=l-p;for(let r=0;z>r;r++)Y[l++]=Y[s+r];}j=q(c);}}function K(){const r=u(5)+257,t=u(5)+1,f=u(4)+4,n=new Uint8Array(19);for(let r=0;f>r;r++)n[c[r]]=u(3);const e=z$1(n),j=new Uint8Array(r+t);let W=0;for(;W<j.length;){const r=q(e);if(16>r)j[W++]=r;else if(16==r){const r=j[W-1];let t=u(2)+3;for(;t--;)j[W++]=r;}else W+=17==r?u(3)+3:u(7)+11;}return [z$1(j.subarray(0,r)),z$1(j.subarray(r))]}function q(r){const{j:t,symbols:f}=r;let n=0,c=0,e=0;for(let r=1;15>=r;r++){n|=u(1);const j=t[r];if(j>n-c)return f[e+(n-c)];e+=j,c=c+j<<1,n<<=1;}throw Error("invalid huffman code")}function D(r){if(Y.length<r){let t=2*Y.length;for(;r>t;)t*=2;const f=new Uint8Array(t);f.set(Y.subarray(0,l)),Y=f;}}})((r=>{const t=(r=(r+"").replace(/[^A-Za-z0-9+/=]/g,"")).length,f=[];for(let n=0;t>n;n+=4){const t=W$1.indexOf(r[n])<<18|W$1.indexOf(r[n+1])<<12|(63&W$1.indexOf(r[n+2]))<<6|63&W$1.indexOf(r[n+3]);f.push(t>>16&255),"="!==r[n+2]&&f.push(t>>8&255),"="!==r[n+3]&&f.push(255&t);}return new Uint8Array(f)})("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")),r=>r({workerURI:r=>{const t="text/javascript";let f=s();if("string"==typeof f&&(f=(new TextEncoder).encode(f)),r){const r=new Blob([f],{type:t});return URL.createObjectURL(r)}return "data:"+t+";base64,"+(r=>{let t="";const f=r.length;let n=0;for(;f>n+2;n+=3){const f=r[n]<<16|r[n+1]<<8|r[n+2];t+=W$1[f>>18&63]+W$1[f>>12&63]+W$1[f>>6&63]+W$1[63&f];}const c=f-n;if(1===c){const f=r[n]<<16;t+=W$1[f>>18&63]+W$1[f>>12&63]+"==";}else if(2===c){const f=r[n]<<16|r[n+1]<<8;t+=W$1[f>>18&63]+W$1[f>>12&63]+W$1[f>>6&63]+"=";}return t})(f)}}));var s;
+const t=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258],n=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],r=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],e=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],o=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],s=new Uint8Array(288);s.fill(8,0,144),s.fill(9,144,256),s.fill(7,256,280),s.fill(8,280,288);const Z$1=new Uint8Array(30).fill(5);function f(t){const n=new Uint16Array(16);for(const r of t)n[r]++;n[0]=0;const r=new Uint16Array(17);for(let t=1;15>=t;t++)r[t+1]=r[t]+n[t];const e=new Uint16Array(t.length);for(let n=0;n<t.length;n++)t[n]&&(e[r[t[n]]++]=n);return {o:n,symbols:e}}const P="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",a=(w=()=>(P=>{let a=0,w=0,b=0,l=new Uint8Array(1024),z=0,i=0;for(;!i;){i=c(1);const t=c(2);if(0==t)x();else if(1==t)h(f(s),f(Z$1));else {if(2!=t)throw Error("invalid deflate block type");h(...K());}}return l.subarray(0,z);function U(){if(a>=P.length)throw Error("unexpected end of deflate data");return P[a++]}function c(t){for(;t>b;)w|=U()<<b,b+=8;const n=w&(1<<t)-1;return w>>>=t,b-=t,n}function x(){w=0,b=0;const t=U()|U()<<8;a+=2,u(z+t);for(let n=0;t>n;n++)l[z++]=U();}function h(o,s){let Z=j(o);for(;256!=Z;){if(256>Z)u(z+1),l[z++]=Z;else {const o=Z-257,f=t[o]+c(n[o]),P=j(s),a=r[P]+c(e[P]);u(z+f);const w=z-a;for(let t=0;f>t;t++)l[z++]=l[w+t];}Z=j(o);}}function K(){const t=c(5)+257,n=c(5)+1,r=c(4)+4,e=new Uint8Array(19);for(let t=0;r>t;t++)e[o[t]]=c(3);const s=f(e),Z=new Uint8Array(t+n);let P=0;for(;P<Z.length;){const t=j(s);if(16>t)Z[P++]=t;else if(16==t){const t=Z[P-1];let n=c(2)+3;for(;n--;)Z[P++]=t;}else P+=17==t?c(3)+3:c(7)+11;}return [f(Z.subarray(0,t)),f(Z.subarray(t))]}function j(t){const{o:n,symbols:r}=t;let e=0,o=0,s=0;for(let t=1;15>=t;t++){e|=c(1);const Z=n[t];if(Z>e-o)return r[s+(e-o)];s+=Z,o=o+Z<<1,e<<=1;}throw Error("invalid huffman code")}function u(t){if(l.length<t){let n=2*l.length;for(;t>n;)n*=2;const r=new Uint8Array(n);r.set(l.subarray(0,z)),l=r;}}})((t=>{const n=(t=(t+"").replace(/[^A-Za-z0-9+/=]/g,"")).length,r=[];for(let e=0;n>e;e+=4){const n=P.indexOf(t[e])<<18|P.indexOf(t[e+1])<<12|(63&P.indexOf(t[e+2]))<<6|63&P.indexOf(t[e+3]);r.push(n>>16&255),"="!==t[e+2]&&r.push(n>>8&255),"="!==t[e+3]&&r.push(255&n);}return new Uint8Array(r)})("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")),t=>t({workerURI:t=>{const n="text/javascript";let r=w();if("string"==typeof r&&(r=(new TextEncoder).encode(r)),t){const t=new Blob([r],{type:n});return URL.createObjectURL(t)}return "data:"+n+";base64,"+(t=>{let n="";const r=t.length;let e=0;for(;r>e+2;e+=3){const r=t[e]<<16|t[e+1]<<8|t[e+2];n+=P[r>>18&63]+P[r>>12&63]+P[r>>6&63]+P[63&r];}const o=r-e;if(1===o){const r=t[e]<<16;n+=P[r>>18&63]+P[r>>12&63]+"==";}else if(2===o){const r=t[e]<<16|t[e+1]<<8;n+=P[r>>18&63]+P[r>>12&63]+P[r>>6&63]+"=";}return n})(r)}}));var w;
 
 /*
  Copyright (c) 2026 Gildas Lormeau. All rights reserved.
@@ -1391,13 +1540,13 @@ class AESDecryptionStream extends TransformStream {
 				const {
 					ctr,
 					hmac,
-					pending,
+					pendingInput,
 					ready
 				} = this;
 				if (hmac && ctr) {
 					await ready;
-					const chunkToDecrypt = subarray(pending, 0, pending.length - AUTHENTICATION_CODE_LENGTH);
-					const originalAuthenticationCode = subarray(pending, pending.length - AUTHENTICATION_CODE_LENGTH);
+					const chunkToDecrypt = subarray(pendingInput, 0, pendingInput.length - AUTHENTICATION_CODE_LENGTH);
+					const originalAuthenticationCode = subarray(pendingInput, pendingInput.length - AUTHENTICATION_CODE_LENGTH);
 					let decryptedChunkArray = EMPTY_UINT8_ARRAY;
 					if (chunkToDecrypt.length) {
 						const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
@@ -1406,7 +1555,7 @@ class AESDecryptionStream extends TransformStream {
 						decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
 					}
 					const authenticationCode = subarray(fromBits(codecBytes, hmac.digest()), 0, AUTHENTICATION_CODE_LENGTH);
-					let invalidAuthenticationCode = pending.length < AUTHENTICATION_CODE_LENGTH ? 1 : 0;
+					let invalidAuthenticationCode = pendingInput.length < AUTHENTICATION_CODE_LENGTH ? 1 : 0;
 					for (let indexByte = 0; indexByte < AUTHENTICATION_CODE_LENGTH; indexByte++) {
 						invalidAuthenticationCode |= authenticationCode[indexByte] ^ originalAuthenticationCode[indexByte];
 					}
@@ -1450,14 +1599,14 @@ class AESEncryptionStream extends TransformStream {
 				const {
 					ctr,
 					hmac,
-					pending,
+					pendingInput,
 					ready
 				} = this;
 				if (hmac && ctr) {
 					await ready;
 					let encryptedChunkArray = EMPTY_UINT8_ARRAY;
-					if (pending.length) {
-						const encryptedChunk = ctr.update(toBits(codecBytes, pending));
+					if (pendingInput.length) {
+						const encryptedChunk = ctr.update(toBits(codecBytes, pendingInput));
 						hmac.update(encryptedChunk);
 						encryptedChunkArray = fromBits(codecBytes, encryptedChunk);
 					}
@@ -1474,7 +1623,7 @@ function initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength) {
 		ready: new Promise(resolve => aesCrypto.resolveReady = resolve),
 		password: encodePassword(password, rawPassword),
 		strength: encryptionStrength - 1,
-		pending: EMPTY_UINT8_ARRAY
+		pendingInput: EMPTY_UINT8_ARRAY
 	});
 }
 
@@ -1482,10 +1631,10 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifyAuthen
 	const {
 		ctr,
 		hmac,
-		pending
+		pendingInput
 	} = aesCrypto;
-	if (pending.length) {
-		input = concat(pending, input);
+	if (pendingInput.length) {
+		input = concat(pendingInput, input);
 	}
 	const inputLength = input.length - paddingEnd;
 	output = expand(output, paddingStart + (inputLength - (inputLength % BLOCK_LENGTH)));
@@ -1501,7 +1650,7 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifyAuthen
 		}
 		output.set(fromBits(codecBytes, outputChunk), offset + paddingStart);
 	}
-	aesCrypto.pending = subarray(input, offset);
+	aesCrypto.pendingInput = subarray(input, offset);
 	return output;
 }
 
@@ -2752,6 +2901,7 @@ function createWebWorkerInterface(workerData, config) {
 			worker,
 			workerAlive: false,
 			terminated: false,
+			startupError: null,
 			interface: {
 				run: async () => {
 					try {
@@ -2779,6 +2929,13 @@ function createWebWorkerInterface(workerData, config) {
 }
 
 async function runWebWorker(workerData, config) {
+	if (!workerData.worker) {
+		const { startupError } = workerData;
+		workerData.startupError = null;
+		const error = startupError || new Error(ERR_WORKER_STARTUP_TIMEOUT);
+		error.workerStartupFailed = true;
+		throw error;
+	}
 	let resolveResult, rejectResult;
 	const result = new Promise((resolve, reject) => {
 		resolveResult = resolve;
@@ -2992,11 +3149,12 @@ function onWorkerError(event, workerData) {
 	if (!workerAlive) {
 		workerData.worker = null;
 	}
+	let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
+	if (!workerAlive) {
+		error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
+		workerData.startupError = error;
+	}
 	if (rejectResult) {
-		let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
-		if (!workerAlive) {
-			error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
-		}
 		rejectResult(error);
 		if (writer) {
 			writer.releaseLock();
@@ -3265,6 +3423,96 @@ async function terminateWorkers() {
 	resetWebWorkerSupport();
 }
 
+/*
+ Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* global TextDecoder */
+
+const CP437 = "\0☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ".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);
+	}
+}
+
+/*
+ Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+function decodeText(value, encoding) {
+	return decode(value, encoding, true);
+}
+
+function decodeTextRemovingBOM(value, encoding) {
+	return decode(value, encoding, false);
+}
+
+function decode(value, encoding, ignoreBOM) {
+	if (encoding && encoding.trim().toLowerCase() == "cp437") {
+		return decodeCP437(value);
+	} else {
+		return new TextDecoder(encoding, { ignoreBOM }).decode(value);
+	}
+}
+
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -3337,6 +3585,7 @@ class Reader extends Stream {
 	createReadable({ offset = 0, size, chunkSize = getChunkSize(getConfiguration()) } = {}) {
 		const reader = this;
 		let chunkOffset = 0;
+		chunkSize = normalizeChunkSize(chunkSize);
 		return new ReadableStream({
 			async pull(controller) {
 				const dataSize = size === UNDEFINED_VALUE ? chunkSize : Math.min(chunkSize, size - chunkOffset);
@@ -3344,7 +3593,7 @@ class Reader extends Stream {
 				if (data.length) {
 					controller.enqueue(data);
 				}
-				if ((chunkOffset + chunkSize >= size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
+				if ((chunkOffset + chunkSize >= size) || (!data.length && dataSize)) {
 					controller.close();
 				} else {
 					chunkOffset += chunkSize;
@@ -3424,31 +3673,31 @@ class Data64URIWriter extends Writer {
 		Object.assign(this, {
 			contentType,
 			data: "data:" + (contentType || "") + ";base64,",
-			pending: []
+			pendingCharacters: ""
 		});
 	}
 
 	writeUint8Array(array) {
 		const writer = this;
 		let indexArray;
-		let dataString = writer.pending;
-		const delta = writer.pending.length;
-		writer.pending = "";
+		let dataString = writer.pendingCharacters;
+		const delta = writer.pendingCharacters.length;
+		writer.pendingCharacters = "";
 		for (indexArray = 0; indexArray < (Math.floor((delta + array.length) / 3) * 3) - delta; indexArray++) {
 			dataString += String.fromCharCode(array[indexArray]);
 		}
 		for (; indexArray < array.length; indexArray++) {
-			writer.pending += String.fromCharCode(array[indexArray]);
+			writer.pendingCharacters += String.fromCharCode(array[indexArray]);
 		}
 		if (dataString.length > 2) {
 			writer.data += btoa(dataString);
 		} else {
-			writer.pending = dataString + writer.pending;
+			writer.pendingCharacters = dataString + writer.pendingCharacters;
 		}
 	}
 
 	getData() {
-		return this.data + btoa(this.pending);
+		return this.data + btoa(this.pendingCharacters);
 	}
 }
 
@@ -3478,7 +3727,7 @@ class BlobReader extends Reader {
 	constructor(blob) {
 		super();
 		Object.assign(this, {
-			blob,
+			sourceBlob: blob,
 			size: blob.size
 		});
 		if (!blobSliceProbe) {
@@ -3488,13 +3737,13 @@ class BlobReader extends Reader {
 
 	createReadable(options) {
 		const reader = this;
-		const { blob, size } = reader;
+		const { sourceBlob, size } = reader;
 		const { offset = 0, size: readSize = size - offset } = options || {};
 		if (!offset && readSize >= size) {
-			return toCompatibleReadable(blob.stream());
+			return toCompatibleReadable(sourceBlob.stream());
 		}
 		if (blobSliceReliable) {
-			return toCompatibleReadable(blob.slice(offset, offset + readSize).stream());
+			return toCompatibleReadable(sourceBlob.slice(offset, offset + readSize).stream());
 		}
 		return super.createReadable(options);
 	}
@@ -3503,7 +3752,7 @@ class BlobReader extends Reader {
 		const reader = this;
 		const offsetEnd = offset + length;
 		const readsWholeBlob = !offset && offsetEnd >= reader.size;
-		const blob = readsWholeBlob ? reader.blob : reader.blob.slice(offset, offsetEnd);
+		const blob = readsWholeBlob ? reader.sourceBlob : reader.sourceBlob.slice(offset, offsetEnd);
 		let arrayBuffer = await blob.arrayBuffer();
 		const sliceIgnoredByBuggyImplementation = arrayBuffer.byteLength > length;
 		if (sliceIgnoredByBuggyImplementation) {
@@ -3525,12 +3774,12 @@ class BlobWriter extends Stream {
 			}
 		});
 		writer.contentType = contentType;
-		writer.blob = streamToBlob(transformStream.readable, contentType);
-		writer.blob.catch(() => { });
+		writer.blobPromise = streamToBlob(transformStream.readable, contentType);
+		writer.blobPromise.catch(() => { });
 	}
 
 	getData() {
-		return this.blob;
+		return this.blobPromise;
 	}
 }
 
@@ -3564,7 +3813,7 @@ function getTextSize(text) {
 class TextWriter extends BlobWriter {
 
 	constructor(encoding) {
-		super(encoding);
+		super();
 		Object.assign(this, {
 			encoding,
 			utf8: !encoding || encoding.toLowerCase() == "utf-8"
@@ -3580,14 +3829,7 @@ class TextWriter extends BlobWriter {
 		if (blob.text && utf8) {
 			return blob.text();
 		} else {
-			const reader = new FileReader();
-			return new Promise((resolve, reject) => {
-				Object.assign(reader, {
-					onload: ({ target }) => resolve(target.result),
-					onerror: () => reject(reader.error)
-				});
-				reader.readAsText(blob, encoding);
-			});
+			return decodeTextRemovingBOM(new Uint8Array(await blob.arrayBuffer()), encoding);
 		}
 	}
 }
@@ -4045,9 +4287,8 @@ class SplitDataReader extends Reader {
 
 	async init() {
 		const reader = this;
-		const { readers } = reader;
 		reader.lastDiskNumber = 0;
-		await Promise.all(readers.map(diskReader => initStream(diskReader)));
+		const readers = reader.readers = await Promise.all(reader.readers.map(initDiskReader));
 		reader.diskOffsets = readers.map(diskReader => {
 			const diskOffset = reader.size;
 			reader.size += diskReader.size;
@@ -4242,89 +4483,27 @@ async function initStream(stream, initSize) {
 	}
 }
 
-function readUint8Array(reader, offset, size) {
-	return reader.readUint8Array(offset, size);
-}
-
-/*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright 
- notice, this list of conditions and the following disclaimer in 
- the documentation and/or other materials provided with the distribution.
-
- 3. The names of the authors may not be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
- INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
- OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* global TextDecoder */
-
-const CP437 = "\0☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ".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);
+async function initDiskReader(diskReader) {
+	diskReader = new GenericReader(diskReader);
+	await initStream(diskReader);
+	if (diskReader.size === UNDEFINED_VALUE || !diskReader.readUint8Array) {
+		diskReader = new BlobReader(await streamToBlob(diskReader.readable));
+		await initStream(diskReader);
 	}
+	return diskReader;
 }
 
-/*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright 
- notice, this list of conditions and the following disclaimer in 
- the documentation and/or other materials provided with the distribution.
-
- 3. The names of the authors may not be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
- INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
- OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
+function readUint8Array(reader, offset, size) {
+	return reader.readUint8Array(offset, size);
+}
 
-function decodeText(value, encoding) {
-	if (encoding && encoding.trim().toLowerCase() == "cp437") {
-		return decodeCP437(value);
+function createReadable(reader, options) {
+	if (reader.createReadable) {
+		return reader.createReadable(options);
+	} else if (reader.readUint8Array) {
+		return Reader.prototype.createReadable.call(reader, options);
 	} else {
-		return new TextDecoder(encoding, { ignoreBOM: true }).decode(value);
+		return reader.readable;
 	}
 }
 
@@ -4400,6 +4579,10 @@ const PROPERTY_NAME_SETUID = "setuid";
 const PROPERTY_NAME_SETGID = "setgid";
 const PROPERTY_NAME_STICKY = "sticky";
 const PROPERTY_NAME_BITFLAG = "bitFlag";
+const PROPERTY_NAME_RAW_BITFLAG = "rawBitFlag";
+const PROPERTY_NAME_FILENAME_LENGTH = "filenameLength";
+const PROPERTY_NAME_EXTRA_FIELD_LENGTH = "extraFieldLength";
+const PROPERTY_NAME_UNIX_EXTERNAL_UPPER = "unixExternalUpper";
 const PROPERTY_NAME_FILENAME_UTF8 = "filenameUTF8";
 const PROPERTY_NAME_COMMENT_UTF8 = "commentUTF8";
 const PROPERTY_NAME_RAW_EXTRA_FIELD = "rawExtraField";
@@ -4452,10 +4635,14 @@ const PROPERTY_NAMES = [
 	PROPERTY_NAME_UID,
 	PROPERTY_NAME_GID,
 	PROPERTY_NAME_UNIX_MODE,
+	PROPERTY_NAME_UNIX_EXTERNAL_UPPER,
 	PROPERTY_NAME_SETUID,
 	PROPERTY_NAME_SETGID,
 	PROPERTY_NAME_STICKY,
 	PROPERTY_NAME_BITFLAG,
+	PROPERTY_NAME_RAW_BITFLAG,
+	PROPERTY_NAME_FILENAME_LENGTH,
+	PROPERTY_NAME_EXTRA_FIELD_LENGTH,
 	PROPERTY_NAME_FILENAME_UTF8,
 	PROPERTY_NAME_COMMENT_UTF8,
 	PROPERTY_NAME_RAW_EXTRA_FIELD,
@@ -4476,82 +4663,6 @@ class Entry {
 
 }
 
-/*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright 
- notice, this list of conditions and the following disclaimer in 
- the documentation and/or other materials provided with the distribution.
-
- 3. The names of the authors may not be used to endorse or promote products
- derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
- INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
- OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-const OPTION_FILENAME_ENCODING = "filenameEncoding";
-const OPTION_COMMENT_ENCODING = "commentEncoding";
-const OPTION_DECODE_TEXT = "decodeText";
-const OPTION_EXTRACT_PREPENDED_DATA = "extractPrependedData";
-const OPTION_EXTRACT_APPENDED_DATA = "extractAppendedData";
-const OPTION_PASSWORD = "password";
-const OPTION_RAW_PASSWORD = "rawPassword";
-const OPTION_PASS_THROUGH = "passThrough";
-const OPTION_SIGNAL = "signal";
-const OPTION_CHECK_PASSWORD_ONLY = "checkPasswordOnly";
-const OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
-const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
-const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
-const OPTION_CHECK_SIGNATURE = "checkSignature";
-const OPTION_CHECK_CRC32 = "checkCrc32";
-const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
-const OPTION_USE_WEB_WORKERS = "useWebWorkers";
-const OPTION_USE_COMPRESSION_STREAM = "useCompressionStream";
-const OPTION_TRANSFER_STREAMS = "transferStreams";
-const OPTION_PREVENT_CLOSE = "preventClose";
-const OPTION_ENCRYPTION_STRENGTH = "encryptionStrength";
-const OPTION_EXTENDED_TIMESTAMP = "extendedTimestamp";
-const OPTION_NTFS_TIMESTAMP = "ntfsTimestamp";
-const OPTION_KEEP_ORDER = "keepOrder";
-const OPTION_LEVEL = "level";
-const OPTION_BUFFERED_WRITE = "bufferedWrite";
-const OPTION_CREATE_TEMP_STREAM = "createTempStream";
-const OPTION_DATA_DESCRIPTOR_SIGNATURE = "dataDescriptorSignature";
-const OPTION_USE_UNICODE_FILE_NAMES = "useUnicodeFileNames";
-const OPTION_DATA_DESCRIPTOR = "dataDescriptor";
-const OPTION_SUPPORT_ZIP64_SPLIT_FILE = "supportZip64SplitFile";
-const OPTION_ENCODE_TEXT = "encodeText";
-const OPTION_OFFSET = "offset";
-const OPTION_USDZ = "usdz";
-const OPTION_UNIX_EXTRA_FIELD_TYPE = "unixExtraFieldType";
-const OPTION_LOCAL_EXTRA_FIELD = "localExtraField";
-const OPTION_STRICTNESS = "strictness";
-const OPTION_FILENAME_VALIDATION = "filenameValidation";
-const OPTION_NORMALIZE_FILENAME = "normalizeFilename";
-const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
-const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
-const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
-const TEXT_TYPE_FILENAME = "filename";
-const TEXT_TYPE_COMMENT = "comment";
-const STRICTNESS_STRICT = "strict";
-const STRICTNESS_BALANCED = "balanced";
-const STRICTNESS_TOLERANT = "tolerant";
-
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -4592,6 +4703,7 @@ 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";
 const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
 const ERR_ENCRYPTED_CENTRAL_DIRECTORY = "Encrypted central directory is not supported";
 const ERR_UNSAFE_FILENAME = "Unsafe filename";
@@ -4612,7 +4724,7 @@ const ZIP64_PROPERTIES = [
 ];
 const ZIP64_EXTRACTION = {
 	[MAX_16_BITS]: {
-		getValue: getUint32,
+		getValue: getUint32$1,
 		bytes: 4
 	},
 	[MAX_32_BITS]: {
@@ -4621,6 +4733,7 @@ const ZIP64_EXTRACTION = {
 	}
 };
 const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
+const MAX_DEFLATE_EXPANSION_RATIO = 1032;
 const CENTRAL_DIRECTORY_UNREACHABLE = 0;
 const CENTRAL_DIRECTORY_PLAUSIBLE = 1;
 const CENTRAL_DIRECTORY_REACHABLE = 2;
@@ -4631,7 +4744,6 @@ class ZipReader {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
 			options,
-			config: getConfiguration(),
 			readRanges: new Map()
 		});
 	}
@@ -4639,7 +4751,6 @@ class ZipReader {
 	async* getEntriesGenerator(options = {}) {
 		const zipReader = this;
 		let { reader } = zipReader;
-		const { config } = zipReader;
 		await initStream(reader);
 		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
 			reader = new BlobReader(await streamToBlob(reader.readable));
@@ -4648,7 +4759,7 @@ class ZipReader {
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
-		const strictness = getStrictness(getOptionValue$1(zipReader, options, OPTION_STRICTNESS), getOptionValue$1(zipReader, options, OPTION_CHECK_AMBIGUITY));
+		const strictness = getStrictness(options, zipReader.options);
 		const checkAmbiguity = strictness == STRICTNESS_STRICT;
 		const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
 		const maxAppendedDataSize = getMaxAppendedDataSize(getOptionValue$1(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
@@ -4656,9 +4767,7 @@ class ZipReader {
 		const normalizeFilename = getOptionValue$1(zipReader, options, OPTION_NORMALIZE_FILENAME);
 		const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
 		if (!endOfDirectoryInfo) {
-			const signatureArray = await readUint8Array(reader, 0, 4);
-			const signatureView = getDataView(signatureArray);
-			if (getUint32(signatureView) == SPLIT_ZIP_FILE_SIGNATURE) {
+			if (await startsWithSplitZipSignature$1(reader)) {
 				throw new Error(ERR_SPLIT_ZIP_FILE);
 			} else {
 				throw new Error(ERR_EOCDR_NOT_FOUND);
@@ -4668,18 +4777,18 @@ class ZipReader {
 			throwAmbiguousArchive("multiple end of central directory records");
 		}
 		const endOfDirectoryView = getDataView(endOfDirectoryInfo);
-		let directoryDataLength = getUint32(endOfDirectoryView, 12);
-		let directoryDataOffset = getUint32(endOfDirectoryView, 16);
+		let directoryDataLength = getUint32$1(endOfDirectoryView, 12);
+		let directoryDataOffset = getUint32$1(endOfDirectoryView, 16);
 		const commentOffset = endOfDirectoryInfo.offset;
-		const commentLength = getUint16(endOfDirectoryView, 20);
+		const commentLength = getUint16$1(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
 		if (reader.size - appendedDataOffset > maxAppendedDataSize) {
 			throwAmbiguousArchive("appended data");
 		}
-		let lastDiskNumber = getUint16(endOfDirectoryView, 4);
+		let lastDiskNumber = getUint16$1(endOfDirectoryView, 4);
 		const expectedLastDiskNumber = reader.lastDiskNumber || 0;
-		let diskNumber = getUint16(endOfDirectoryView, 6);
-		let filesLength = getUint16(endOfDirectoryView, 10);
+		let diskNumber = getUint16$1(endOfDirectoryView, 6);
+		let filesLength = getUint16$1(endOfDirectoryView, 10);
 		let prependedDataLength = 0;
 		let startOffset;
 		let zip64EndOfDirectory;
@@ -4695,12 +4804,12 @@ class ZipReader {
 				EMPTY_UINT8_ARRAY;
 			const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
 			if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH &&
-				getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
-				directoryDataOffset = getDiskOffset$1(reader, getUint32(endOfDirectoryLocatorView, 4)) + getBigUint64(endOfDirectoryLocatorView, 8);
+				getUint32$1(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
+				directoryDataOffset = getDiskOffset$1(reader, getUint32$1(endOfDirectoryLocatorView, 4)) + getBigUint64(endOfDirectoryLocatorView, 8);
 				let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 				let endOfDirectoryView = getDataView(endOfDirectoryArray);
 				const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
-				if ((endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) &&
+				if ((endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32$1(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) &&
 					directoryDataOffset != expectedDirectoryDataOffset && expectedDirectoryDataOffset >= 0) {
 					const originalDirectoryDataOffset = directoryDataOffset;
 					directoryDataOffset = expectedDirectoryDataOffset;
@@ -4710,7 +4819,7 @@ class ZipReader {
 					endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 					endOfDirectoryView = getDataView(endOfDirectoryArray);
 				}
-				if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
+				if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32$1(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
 					throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
 				}
 				zip64EndOfDirectory = true;
@@ -4725,13 +4834,13 @@ class ZipReader {
 					}
 				}
 				if (lastDiskNumber == MAX_16_BITS) {
-					lastDiskNumber = getUint32(endOfDirectoryView, 16);
-				} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
+					lastDiskNumber = getUint32$1(endOfDirectoryView, 16);
+				} else if (checkAmbiguity && lastDiskNumber != getUint32$1(endOfDirectoryView, 16)) {
 					throwAmbiguousArchive("mismatched zip64 end of central directory record");
 				}
 				if (diskNumber == MAX_16_BITS) {
-					diskNumber = getUint32(endOfDirectoryView, 20);
-				} else if (checkAmbiguity && diskNumber != getUint32(endOfDirectoryView, 20)) {
+					diskNumber = getUint32$1(endOfDirectoryView, 20);
+				} else if (checkAmbiguity && diskNumber != getUint32$1(endOfDirectoryView, 20)) {
 					throwAmbiguousArchive("mismatched zip64 end of central directory record");
 				}
 				if (filesLength == MAX_16_BITS) {
@@ -4769,11 +4878,11 @@ class ZipReader {
 			}
 			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 			if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
-				const storedPointsAtDirectory = getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
+				const storedPointsAtDirectory = getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
 				let reconcile = !storedPointsAtDirectory;
 				if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
 					const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4);
-					reconcile = getUint32(getDataView(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
+					reconcile = getUint32$1(getDataView(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
 				}
 				if (reconcile) {
 					const originalDirectoryDataOffset = directoryDataOffset;
@@ -4797,10 +4906,10 @@ class ZipReader {
 		}
 		zipReader.directoryOffset = directoryDataOffset;
 		zipReader.directoryLength = declaredDirectoryDataLength;
-		const decryptCentralDirectory = getOptionValue$1(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
+		const decryptCentralDirectory = getFunctionOptionValue$1(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
 		let decryptedDirectory;
 		if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
-			getUint32(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
+			getUint32$1(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
 			(zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 			directoryArray = await decryptCentralDirectory(directoryArray, directoryEncryptionInfo);
 			directoryView = getDataView(directoryArray);
@@ -4813,8 +4922,8 @@ class ZipReader {
 		const filenames = checkAmbiguity ? new Set() : UNDEFINED_VALUE;
 		let duplicateFilename;
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
-			const fileEntry = new ZipEntry$1(reader, config, zipReader.options);
-			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
+			const fileEntry = new ZipEntry$1(reader, zipReader.options);
+			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32$1(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
 				if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 					throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
 				}
@@ -4825,16 +4934,16 @@ class ZipReader {
 			const filenameOffset = offset + CENTRAL_FILE_HEADER_LENGTH;
 			const extraFieldOffset = filenameOffset + fileEntry.filenameLength;
 			const commentOffset = extraFieldOffset + fileEntry.extraFieldLength;
-			const versionMadeBy = getUint16(directoryView, offset + 4);
+			const versionMadeBy = getUint16$1(directoryView, offset + 4);
 			const msDosCompatible = versionMadeBy >> 8 == 0;
 			const unixCompatible = versionMadeBy >> 8 == 3;
 			const rawFilename = directoryArray.subarray(filenameOffset, extraFieldOffset);
-			const commentLength = getUint16(directoryView, offset + 32);
+			const commentLength = getUint16$1(directoryView, offset + 32);
 			const endOffset = commentOffset + commentLength;
 			const rawComment = directoryArray.subarray(commentOffset, endOffset);
 			const filenameUTF8 = languageEncodingFlag;
 			const commentUTF8 = languageEncodingFlag;
-			const externalFileAttributes = getUint32(directoryView, offset + 38);
+			const externalFileAttributes = getUint32$1(directoryView, offset + 38);
 			const msdosAttributesRaw = externalFileAttributes & MAX_8_BITS;
 			const msdosAttributes = {
 				readOnly: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_READONLY_MASK),
@@ -4843,8 +4952,8 @@ class ZipReader {
 				directory: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_DIR_MASK),
 				archive: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_ARCHIVE_MASK)
 			};
-			const offsetFileEntry = getUint32(directoryView, offset + 42);
-			const decode = getOptionValue$1(zipReader, options, OPTION_DECODE_TEXT) || decodeText;
+			const offsetFileEntry = getUint32$1(directoryView, offset + 42);
+			const decode = getFunctionOptionValue$1(zipReader, options, OPTION_DECODE_TEXT) || decodeText;
 			const rawFilenameEncoding = filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437;
 			const rawCommentEncoding = commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437;
 			let filename = decode(rawFilename, rawFilenameEncoding, TEXT_TYPE_FILENAME);
@@ -4870,12 +4979,13 @@ class ZipReader {
 				index: indexFile,
 				versionMadeBy,
 				msDosCompatible,
+				zip64: false,
 				compressedSize: 0,
 				uncompressedSize: 0,
 				commentLength,
 				offset: offsetFileEntry,
-				diskNumberStart: getUint16(directoryView, offset + 34),
-				internalFileAttributes: getUint16(directoryView, offset + 36),
+				diskNumberStart: getUint16$1(directoryView, offset + 34),
+				internalFileAttributes: getUint16$1(directoryView, offset + 36),
 				externalFileAttributes,
 				msdosAttributesRaw,
 				msdosAttributes,
@@ -4943,8 +5053,8 @@ class ZipReader {
 			yield entry;
 		}
 		let offsetAfterSignature = offset;
-		if (offset + 6 <= directoryArray.length && getUint32(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
-			const signatureDataLength = getUint16(directoryView, offset + 4);
+		if (offset + 6 <= directoryArray.length && getUint32$1(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+			const signatureDataLength = getUint16$1(directoryView, offset + 4);
 			if (offset + 6 + signatureDataLength <= directoryArray.length) {
 				zipReader.digitalSignature = directoryArray.subarray(offset + 6, offset + 6 + signatureDataLength);
 				offsetAfterSignature = offset + 6 + signatureDataLength;
@@ -4956,13 +5066,17 @@ class ZipReader {
 		if (duplicateFilename) {
 			throwAmbiguousArchive("duplicate filename");
 		}
-		if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > 0))) {
-			throwAmbiguousArchive("prepended data");
-		}
 		const extractPrependedData = getOptionValue$1(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 		const extractAppendedData = getOptionValue$1(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
+		const splitZipSignatureLength = (checkAmbiguity || extractPrependedData) && filesLength &&
+			startOffset == SPLIT_ZIP_FILE_SIGNATURE_LENGTH && await startsWithSplitZipMarker(reader) ? SPLIT_ZIP_FILE_SIGNATURE_LENGTH : 0;
+		if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > splitZipSignatureLength))) {
+			throwAmbiguousArchive("prepended data");
+		}
 		if (extractPrependedData) {
-			zipReader.prependedData = startOffset > 0 ? await readUint8Array(reader, 0, startOffset) : EMPTY_UINT8_ARRAY;
+			zipReader.prependedData = startOffset > splitZipSignatureLength ?
+				await readUint8Array(reader, splitZipSignatureLength, startOffset - splitZipSignatureLength) :
+				EMPTY_UINT8_ARRAY;
 		}
 		zipReader.comment = commentLength ? await readUint8Array(reader, commentOffset + END_OF_CENTRAL_DIR_LENGTH, commentLength) : EMPTY_UINT8_ARRAY;
 		if (extractAppendedData) {
@@ -5029,16 +5143,16 @@ class ZipReaderStream {
 
 let ZipEntry$1 = class ZipEntry {
 
-	constructor(reader, config, options) {
+	constructor(reader, options) {
 		Object.assign(this, {
 			reader,
-			config,
 			options
 		});
 	}
 
 	async getData(writer, fileEntry, readRanges, options = {}) {
 		const zipEntry = this;
+		const config = getConfiguration();
 		const {
 			reader,
 			index,
@@ -5047,7 +5161,6 @@ let ZipEntry$1 = class ZipEntry {
 			extraFieldAES,
 			extraFieldZip64,
 			compressionMethod,
-			config,
 			bitFlag,
 			rawBitFlag,
 			crc32,
@@ -5065,6 +5178,7 @@ let ZipEntry$1 = class ZipEntry {
 		let password = getOptionValue$1(zipEntry, options, OPTION_PASSWORD);
 		let rawPassword = getOptionValue$1(zipEntry, options, OPTION_RAW_PASSWORD);
 		const passThrough = getOptionValue$1(zipEntry, options, OPTION_PASS_THROUGH);
+		checkPasswordOption(password, rawPassword);
 		password = password && password.length && password;
 		rawPassword = rawPassword && rawPassword.length && rawPassword;
 		if (extraFieldAES) {
@@ -5072,7 +5186,7 @@ let ZipEntry$1 = class ZipEntry {
 				throw new Error(ERR_UNSUPPORTED_COMPRESSION$1);
 			}
 		}
-		if (dataArray.length < HEADER_SIZE || getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
+		if (dataArray.length < HEADER_SIZE || getUint32$1(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
 			throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
 		}
 		readCommonHeader(localDirectory, dataView, 4);
@@ -5080,9 +5194,12 @@ let ZipEntry$1 = class ZipEntry {
 			extraFieldLength,
 			filenameLength
 		} = localDirectory;
-		const checkAmbiguity = getStrictness(getOptionValue$1(zipEntry, options, OPTION_STRICTNESS), getOptionValue$1(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
+		const checkLocalDirectoryOption = getOptionValue$1(zipEntry, options, OPTION_CHECK_LOCAL_DIRECTORY);
+		const entryStrictness = getStrictness(options, zipEntry.options);
+		const checkLocalDirectory = getCheckLocalDirectory(checkLocalDirectoryOption, entryStrictness);
+		const checkLocalFilename = getCheckLocalFilename(checkLocalDirectoryOption, entryStrictness);
 		let rawLocalFilename = EMPTY_UINT8_ARRAY;
-		if (checkAmbiguity && (filenameLength || extraFieldLength)) {
+		if (checkLocalFilename && (filenameLength || extraFieldLength)) {
 			const trailingDataArray = await readUint8Array(reader, localHeaderOffset + HEADER_SIZE, filenameLength + extraFieldLength);
 			rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
 			localDirectory.rawExtraField = trailingDataArray.subarray(filenameLength);
@@ -5091,17 +5208,26 @@ let ZipEntry$1 = class ZipEntry {
 				await readUint8Array(reader, localHeaderOffset + HEADER_SIZE + filenameLength, extraFieldLength) :
 				EMPTY_UINT8_ARRAY;
 		}
+		if (checkLocalFilename) {
+			localDirectory.rawFilename = rawLocalFilename;
+		}
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-		if (checkAmbiguity) {
-			checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename);
+		if (checkLocalDirectory) {
+			validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename);
 		}
-		const { lastAccessDate, creationDate } = localDirectory;
+		const { lastAccessDate, creationDate, uid, gid } = localDirectory;
 		if (lastAccessDate) {
 			fileEntry.lastAccessDate = lastAccessDate;
 		}
 		if (creationDate) {
 			fileEntry.creationDate = creationDate;
 		}
+		if (uid !== UNDEFINED_VALUE && fileEntry.uid === UNDEFINED_VALUE) {
+			fileEntry.uid = uid;
+		}
+		if (gid !== UNDEFINED_VALUE && fileEntry.gid === UNDEFINED_VALUE) {
+			fileEntry.gid = gid;
+		}
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (!passThrough) {
@@ -5122,9 +5248,12 @@ let ZipEntry$1 = class ZipEntry {
 			}
 		}
 		const dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
+		if (dataOffset + compressedSize > reader.size) {
+			throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS);
+		}
 		const size = compressedSize;
 		const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
-		const signal = getOptionValue$1(zipEntry, options, OPTION_SIGNAL);
+		const signal = checkSignalOption(getOptionValue$1(zipEntry, options, OPTION_SIGNAL));
 		const checkPasswordOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 		let checkOverlappingEntry = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
 		const checkOverlappingEntryOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY_ONLY);
@@ -5132,6 +5261,8 @@ let ZipEntry$1 = class ZipEntry {
 			checkOverlappingEntry = true;
 		}
 		const { onstart, onprogress, onend } = options;
+		const compressed = compressionMethod != COMPRESSION_METHOD_STORE && !passThrough;
+		const outputSize = passThrough ? compressedSize : uncompressedSize;
 		const deflate64 = compressionMethod == COMPRESSION_METHOD_DEFLATE_64;
 		let useCompressionStream = getOptionValue$1(zipEntry, options, OPTION_USE_COMPRESSION_STREAM);
 		if (deflate64) {
@@ -5152,9 +5283,9 @@ let ZipEntry$1 = class ZipEntry {
 				checkCrc32,
 				checkAuthenticationCode: getOptionValue$1(zipEntry, options, OPTION_CHECK_AUTHENTICATION_CODE),
 				passwordVerification: zipCrypto && (dataDescriptor ? ((rawLastModDate >>> 8) & MAX_8_BITS) : ((crc32 >>> 24) & MAX_8_BITS)),
-				outputSize: passThrough ? compressedSize : uncompressedSize,
+				outputSize,
 				crc32,
-				compressed: compressionMethod != 0 && !passThrough,
+				compressed,
 				encrypted,
 				useWebWorkers: getOptionValue$1(zipEntry, options, OPTION_USE_WEB_WORKERS),
 				useCompressionStream,
@@ -5191,11 +5322,11 @@ let ZipEntry$1 = class ZipEntry {
 					writer = new WritableStream();
 				}
 				writer = new GenericWriter(writer);
-				await initStream(writer, passThrough ? compressedSize : uncompressedSize);
+				await initStream(writer, getDecodableOutputSize(outputSize, compressedSize, compressed));
 				({ writable } = writer);
-				const { outputSize } = await runWorker({ readable, writable }, workerOptions);
-				writer.size += outputSize;
-				if (outputSize != (passThrough ? compressedSize : uncompressedSize)) {
+				const { outputSize: writtenSize } = await runWorker({ readable, writable }, workerOptions);
+				writer.size += writtenSize;
+				if (writtenSize != outputSize) {
 					throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
 				}
 			}
@@ -5229,7 +5360,7 @@ let ZipEntry$1 = class ZipEntry {
 function detectEncryptedCentralDirectory(directoryView) {
 	const maxOffset = Math.min(directoryView.byteLength, 1024) - 3;
 	for (let offset = 0; offset < maxOffset; offset++) {
-		if (getUint32(directoryView, offset) == ARCHIVE_EXTRA_DATA_SIGNATURE) {
+		if (getUint32$1(directoryView, offset) == ARCHIVE_EXTRA_DATA_SIGNATURE) {
 			return true;
 		}
 	}
@@ -5240,15 +5371,15 @@ function getDirectoryEncryptionInfo(rawExtensibleData) {
 	const directoryEncryptionInfo = { rawExtensibleData };
 	if (rawExtensibleData.length >= 28) {
 		const extensibleDataView = getDataView(rawExtensibleData);
-		const hashDataLength = getUint16(extensibleDataView, 26);
+		const hashDataLength = getUint16$1(extensibleDataView, 26);
 		Object.assign(directoryEncryptionInfo, {
-			compressionMethod: getUint16(extensibleDataView, 0),
+			compressionMethod: getUint16$1(extensibleDataView, 0),
 			compressedSize: Number(getBigUint64(extensibleDataView, 2)),
 			uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
-			encryptionAlgorithm: getUint16(extensibleDataView, 18),
-			bitLength: getUint16(extensibleDataView, 20),
-			flags: getUint16(extensibleDataView, 22),
-			hashAlgorithm: getUint16(extensibleDataView, 24),
+			encryptionAlgorithm: getUint16$1(extensibleDataView, 18),
+			bitLength: getUint16$1(extensibleDataView, 20),
+			flags: getUint16$1(extensibleDataView, 22),
+			hashAlgorithm: getUint16$1(extensibleDataView, 24),
 			hashData: rawExtensibleData.subarray(28, 28 + hashDataLength)
 		});
 	}
@@ -5256,12 +5387,12 @@ function getDirectoryEncryptionInfo(rawExtensibleData) {
 }
 
 function readCommonHeader(directory, dataView, offset) {
-	const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset + 2);
+	const rawBitFlag = directory.rawBitFlag = getUint16$1(dataView, offset + 2);
 	const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;
-	const rawLastModDate = getUint32(dataView, offset + 6);
+	const rawLastModDate = getUint32$1(dataView, offset + 6);
 	Object.assign(directory, {
 		encrypted,
-		version: getUint16(dataView, offset),
+		version: getUint16$1(dataView, offset),
 		bitFlag: {
 			level: (rawBitFlag & BITFLAG_LEVEL) >> 1,
 			dataDescriptor: (rawBitFlag & BITFLAG_DATA_DESCRIPTOR) == BITFLAG_DATA_DESCRIPTOR,
@@ -5269,8 +5400,8 @@ function readCommonHeader(directory, dataView, offset) {
 		},
 		rawLastModDate,
 		lastModDate: getDate(rawLastModDate),
-		filenameLength: getUint16(dataView, offset + 22),
-		extraFieldLength: getUint16(dataView, offset + 24)
+		filenameLength: getUint16$1(dataView, offset + 22),
+		extraFieldLength: getUint16$1(dataView, offset + 24)
 	});
 }
 
@@ -5281,8 +5412,8 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	let offsetExtraField = 0;
 	try {
 		while (offsetExtraField < rawExtraField.length) {
-			const type = getUint16(rawExtraFieldView, offsetExtraField);
-			const size = getUint16(rawExtraFieldView, offsetExtraField + 2);
+			const type = getUint16$1(rawExtraFieldView, offsetExtraField);
+			const size = getUint16$1(rawExtraFieldView, offsetExtraField + 2);
 			extraField.set(type, {
 				type,
 				data: rawExtraField.slice(offsetExtraField + 4, offsetExtraField + 4 + size)
@@ -5292,12 +5423,12 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	} catch {
 		// ignored
 	}
-	const compressionMethod = getUint16(dataView, offset + 4);
+	const compressionMethod = getUint16$1(dataView, offset + 4);
 	Object.assign(directory, {
-		signature: getUint32(dataView, offset + HEADER_OFFSET_SIGNATURE),
-		crc32: getUint32(dataView, offset + HEADER_OFFSET_SIGNATURE),
-		compressedSize: getUint32(dataView, offset + HEADER_OFFSET_COMPRESSED_SIZE),
-		uncompressedSize: getUint32(dataView, offset + HEADER_OFFSET_UNCOMPRESSED_SIZE)
+		signature: getUint32$1(dataView, offset + HEADER_OFFSET_SIGNATURE),
+		crc32: getUint32$1(dataView, offset + HEADER_OFFSET_SIGNATURE),
+		compressedSize: getUint32$1(dataView, offset + HEADER_OFFSET_COMPRESSED_SIZE),
+		uncompressedSize: getUint32$1(dataView, offset + HEADER_OFFSET_UNCOMPRESSED_SIZE)
 	});
 	const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
 	if (extraFieldZip64) {
@@ -5337,10 +5468,12 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		directory.extraFieldNTFS = extraFieldNTFS;
 	}
 	const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+	let unixIdsRead;
 	if (extraFieldUnix) {
-		readExtraFieldUnix(extraFieldUnix, directory, false);
+		unixIdsRead = readExtraFieldUnix(extraFieldUnix, directory, false);
 		directory.extraFieldUnix = extraFieldUnix;
-	} else {
+	}
+	if (!unixIdsRead) {
 		const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
 		if (extraFieldInfoZip) {
 			readExtraFieldUnix(extraFieldInfoZip, directory, true);
@@ -5384,11 +5517,11 @@ function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName,
 	computedCrc32.append(fileEntry[rawPropertyName]);
 	const computedCrc32View = getDataView(new Uint8Array(4));
 	computedCrc32View.setUint32(0, computedCrc32.get(), true);
-	const nameCrc32 = getUint32(extraFieldView, 1);
+	const nameCrc32 = getUint32$1(extraFieldView, 1);
 	Object.assign(extraFieldUnicode, {
 		version: getUint8(extraFieldView, 0),
 		[propertyName]: decodeText(extraFieldUnicode.data.subarray(5)),
-		valid: !fileEntry.bitFlag.languageEncodingFlag && nameCrc32 == getUint32(computedCrc32View, 0)
+		valid: !fileEntry.bitFlag.languageEncodingFlag && nameCrc32 == getUint32$1(computedCrc32View, 0)
 	});
 	if (extraFieldUnicode.valid) {
 		directory[propertyName] = extraFieldUnicode[propertyName];
@@ -5404,7 +5537,7 @@ function readExtraFieldAES(extraFieldAES, directory, compressionMethod) {
 		vendorId: getUint8(extraFieldView, 2),
 		strength,
 		originalCompressionMethod: compressionMethod,
-		compressionMethod: getUint16(extraFieldView, 5)
+		compressionMethod: getUint16$1(extraFieldView, 5)
 	});
 	directory.compressionMethod = extraFieldAES.compressionMethod;
 	if (extraFieldAES.vendorVersion != VENDOR_VERSION_AE_1$1) {
@@ -5418,8 +5551,8 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 	let tag1Data;
 	try {
 		while (offsetExtraField < extraFieldNTFS.data.length && !tag1Data) {
-			const tagValue = getUint16(extraFieldView, offsetExtraField);
-			const attributeSize = getUint16(extraFieldView, offsetExtraField + 2);
+			const tagValue = getUint16$1(extraFieldView, offsetExtraField);
+			const attributeSize = getUint16$1(extraFieldView, offsetExtraField + 2);
 			if (tagValue == EXTRAFIELD_TYPE_NTFS_TAG1) {
 				tag1Data = extraFieldNTFS.data.slice(offsetExtraField + 4, offsetExtraField + 4 + attributeSize);
 			}
@@ -5443,7 +5576,7 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 		const creationDate = getDateNTFS(rawCreationDate);
 		const extraFieldData = { lastModDate, lastAccessDate, creationDate };
 		Object.assign(extraFieldNTFS, extraFieldData);
-		Object.assign(directory, extraFieldData);
+		Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
 	}
 }
 
@@ -5452,12 +5585,12 @@ function readExtraFieldUnixDates(extraField, directory) {
 		return;
 	}
 	const extraFieldView = getDataView(extraField.data);
-	const lastAccessDate = new Date((getUint32(extraFieldView, 0) | 0) * 1000);
-	const lastModDate = new Date((getUint32(extraFieldView, 4) | 0) * 1000);
+	const lastAccessDate = new Date((getUint32$1(extraFieldView, 0) | 0) * 1000);
+	const lastModDate = new Date((getUint32$1(extraFieldView, 4) | 0) * 1000);
 	const extraFieldData = { lastAccessDate, lastModDate };
 	if (extraField.data.length >= 12) {
-		extraFieldData.uid = getUint16(extraFieldView, 8);
-		extraFieldData.gid = getUint16(extraFieldView, 10);
+		extraFieldData.uid = getUint16$1(extraFieldView, 8);
+		extraFieldData.gid = getUint16$1(extraFieldView, 10);
 	}
 	Object.assign(extraField, extraFieldData);
 	Object.assign(directory, extraFieldData);
@@ -5477,8 +5610,8 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 			gid = unpackUnixId(extraField.data.subarray(offset, offset + gidSize));
 			Object.assign(extraField, { version, uid, gid });
 		} else if (extraField.data.length >= 4) {
-			uid = getUint16(view, 0);
-			gid = getUint16(view, 2);
+			uid = getUint16$1(view, 0);
+			gid = getUint16$1(view, 2);
 			Object.assign(extraField, { uid, gid });
 		}
 		if (uid !== UNDEFINED_VALUE) {
@@ -5487,6 +5620,7 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 		if (gid !== UNDEFINED_VALUE) {
 			directory.gid = gid;
 		}
+		return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
 	} catch {
 		// ignored
 	}
@@ -5527,7 +5661,7 @@ function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory,
 	let offset = 1;
 	timeProperties.forEach((propertyName, indexProperty) => {
 		if (extraFieldExtendedTimestamp.data.length >= offset + 4) {
-			const time = getUint32(extraFieldView, offset);
+			const time = getUint32$1(extraFieldView, offset);
 			directory[propertyName] = extraFieldExtendedTimestamp[propertyName] = new Date((time | 0) * 1000);
 			const rawPropertyName = timeRawProperties[indexProperty];
 			extraFieldExtendedTimestamp[rawPropertyName] = time;
@@ -5559,26 +5693,25 @@ async function detectOverlappingEntry({
 	}
 	if (dataDescriptorLength) {
 		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
-		const dataDescriptorSignature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
-			getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
-		if (dataDescriptorSignature) {
-			const readCrc32 = getUint32(getDataView(dataDescriptorArray), 4);
-			let readCompressedSize;
-			let readUncompressedSize;
-			if (extraFieldZip64) {
-				readCompressedSize = getBigUint64(getDataView(dataDescriptorArray), 8);
-				readUncompressedSize = getBigUint64(getDataView(dataDescriptorArray), 16);
-			} else {
-				readCompressedSize = getUint32(getDataView(dataDescriptorArray), 8);
-				readUncompressedSize = getUint32(getDataView(dataDescriptorArray), 12);
-			}
-			const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || readCrc32 == crc32;
+		const dataDescriptorView = getDataView(dataDescriptorArray);
+		let signature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
+			getUint32$1(dataDescriptorView, 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
+		if (signature) {
+			const signedDataDescriptor = readDataDescriptor(dataDescriptorView, DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, extraFieldZip64);
+			const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || signedDataDescriptor.crc32 == crc32;
 			if (matchCrc32 &&
-				readCompressedSize == compressedSize &&
-				readUncompressedSize == uncompressedSize) {
+				signedDataDescriptor.compressedSize == compressedSize &&
+				signedDataDescriptor.uncompressedSize == uncompressedSize) {
 				dataDescriptorLength += DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+			} else {
+				signature = false;
 			}
 		}
+		if (dataDescriptorArray.length >= dataDescriptorLength) {
+			const localDataDescriptor = readDataDescriptor(dataDescriptorView, signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0, extraFieldZip64);
+			localDataDescriptor.signature = signature;
+			fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
+		}
 	}
 	const range = {
 		start: offset,
@@ -5595,22 +5728,80 @@ async function detectOverlappingEntry({
 	readRanges.set(index, range);
 }
 
+function readDataDescriptor(dataDescriptorView, offset, extraFieldZip64) {
+	const crc32 = getUint32$1(dataDescriptorView, offset);
+	let compressedSize;
+	let uncompressedSize;
+	if (extraFieldZip64) {
+		compressedSize = getBigUint64(dataDescriptorView, offset + 4);
+		uncompressedSize = getBigUint64(dataDescriptorView, offset + 12);
+	} else {
+		compressedSize = getUint32$1(dataDescriptorView, offset + 4);
+		uncompressedSize = getUint32$1(dataDescriptorView, offset + 8);
+	}
+	return { crc32, compressedSize, uncompressedSize };
+}
+
 function getDiskOffset$1(reader, diskNumber) {
 	return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
 }
 
+async function startsWithSplitZipSignature$1(reader) {
+	return await getFirstSignature(reader) == SPLIT_ZIP_FILE_SIGNATURE;
+}
+
+async function startsWithSplitZipMarker(reader) {
+	const signature = await getFirstSignature(reader);
+	return signature == SPLIT_ZIP_FILE_SIGNATURE || signature == TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE;
+}
+
+async function getFirstSignature(reader) {
+	const signatureArray = await readUint8Array(reader, 0, SPLIT_ZIP_FILE_SIGNATURE_LENGTH);
+	return getUint32$1(getDataView(signatureArray));
+}
+
 function isStrictnessValue(value) {
 	return value === STRICTNESS_STRICT || value === STRICTNESS_BALANCED || value === STRICTNESS_TOLERANT;
 }
 
-function getStrictness(strictness, checkAmbiguity) {
-	if (strictness === UNDEFINED_VALUE) {
-		return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
+function getDecodableOutputSize(outputSize, compressedSize, compressed) {
+	return Math.min(outputSize, compressed ? compressedSize * MAX_DEFLATE_EXPANSION_RATIO : compressedSize);
+}
+
+function getStrictness(options, inheritedOptions) {
+	return resolveStrictness(options, resolveStrictness(inheritedOptions, STRICTNESS_BALANCED));
+}
+
+function resolveStrictness(options, inheritedStrictness) {
+	const strictness = options[OPTION_STRICTNESS];
+	if (strictness !== UNDEFINED_VALUE) {
+		if (!isStrictnessValue(strictness)) {
+			throw new Error(ERR_INVALID_STRICTNESS);
+		}
+		return strictness;
+	}
+	const checkAmbiguity = options[OPTION_CHECK_AMBIGUITY];
+	if (checkAmbiguity === UNDEFINED_VALUE) {
+		return inheritedStrictness;
 	}
-	if (!isStrictnessValue(strictness)) {
-		throw new Error(ERR_INVALID_STRICTNESS);
+	if (checkAmbiguity) {
+		return STRICTNESS_STRICT;
 	}
-	return strictness;
+	return inheritedStrictness == STRICTNESS_TOLERANT ? STRICTNESS_TOLERANT : STRICTNESS_BALANCED;
+}
+
+function getCheckLocalDirectory(checkLocalDirectory, strictness) {
+	if (checkLocalDirectory === UNDEFINED_VALUE) {
+		return strictness != STRICTNESS_TOLERANT;
+	}
+	return Boolean(checkLocalDirectory);
+}
+
+function getCheckLocalFilename(checkLocalFilename, strictness) {
+	if (checkLocalFilename === UNDEFINED_VALUE) {
+		return strictness == STRICTNESS_STRICT;
+	}
+	return Boolean(checkLocalFilename);
 }
 
 function getFilenameValidation(filenameValidation, strictness) {
@@ -5639,7 +5830,7 @@ function isUnsafeFilename(filename, filenameValidation) {
 
 function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
 	if (maxAppendedDataSize !== UNDEFINED_VALUE) {
-		const size = toNumber$1(maxAppendedDataSize);
+		const size = toNumber(maxAppendedDataSize);
 		if (typeof size != NUMBER_TYPE || Number.isNaN(size) || size < 0) {
 			throw new Error(ERR_INVALID_MAX_APPENDED_DATA_SIZE);
 		}
@@ -5662,7 +5853,7 @@ async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDat
 	let plausibleEndOfDirectoryInfo;
 	let endOfDirectoryReachingEndCount = 0;
 	for await (const [anchoredView, anchoredOffset, anchoredArray, indexByte, offset] of scanEndOfCentralDirectory(reader, anchoredLength)) {
-		const commentLength = getUint16(anchoredView, indexByte + 20);
+		const commentLength = getUint16$1(anchoredView, indexByte + 20);
 		if (offset + END_OF_CENTRAL_DIR_LENGTH + commentLength == size) {
 			const reachability = await getCentralDirectoryReachability(reader, anchoredView, anchoredOffset, indexByte, offset, size, remoteProbeBudget);
 			if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
@@ -5713,7 +5904,7 @@ async function* scanEndOfCentralDirectory(reader, scanLength) {
 	const scanArray = await readUint8Array(reader, scanOffset, scanLength);
 	const scanView = getDataView(scanArray);
 	for (let indexByte = scanArray.length - END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
-		if (getUint32(scanView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
+		if (getUint32$1(scanView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
 			yield [scanView, scanOffset, scanArray, indexByte, scanOffset + indexByte];
 		}
 	}
@@ -5724,9 +5915,9 @@ function getEndOfCentralDirectoryInfo(scanArray, indexByte, offset) {
 }
 
 async function getCentralDirectoryReachability(reader, view, anchoredOffset, indexByte, offset, size, remoteProbeBudget) {
-	const filesLength = getUint16(view, indexByte + 10);
-	const directoryDataLength = getUint32(view, indexByte + 12);
-	const directoryDataOffset = getUint32(view, indexByte + 16);
+	const filesLength = getUint16$1(view, indexByte + 10);
+	const directoryDataLength = getUint32$1(view, indexByte + 12);
+	const directoryDataOffset = getUint32$1(view, indexByte + 16);
 	if (filesLength == MAX_16_BITS || directoryDataLength == MAX_32_BITS || directoryDataOffset == MAX_32_BITS) {
 		const locatorSignature = await readSignature(reader, view, anchoredOffset, offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, size, remoteProbeBudget);
 		return locatorSignature == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE ? CENTRAL_DIRECTORY_REACHABLE : CENTRAL_DIRECTORY_UNREACHABLE;
@@ -5734,7 +5925,7 @@ async function getCentralDirectoryReachability(reader, view, anchoredOffset, ind
 	if (!filesLength && !directoryDataLength) {
 		return CENTRAL_DIRECTORY_PLAUSIBLE;
 	}
-	const directoryDiskNumber = getUint16(view, indexByte + 6);
+	const directoryDiskNumber = getUint16$1(view, indexByte + 6);
 	for (const centralDirectoryOffset of [offset - directoryDataLength, getDiskOffset$1(reader, directoryDiskNumber) + directoryDataOffset]) {
 		if (await readSignature(reader, view, anchoredOffset, centralDirectoryOffset, size, remoteProbeBudget) == CENTRAL_FILE_HEADER_SIGNATURE) {
 			return CENTRAL_DIRECTORY_REACHABLE;
@@ -5748,20 +5939,21 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 		return UNDEFINED_VALUE;
 	}
 	if (signatureOffset >= anchoredOffset) {
-		return getUint32(view, signatureOffset - anchoredOffset);
+		return getUint32$1(view, signatureOffset - anchoredOffset);
 	}
 	if (remoteProbeBudget.count > 0) {
 		remoteProbeBudget.count--;
 		const signatureArray = await readUint8Array(reader, signatureOffset, 4);
-		return getUint32(getDataView(signatureArray), 0);
+		return getUint32$1(getDataView(signatureArray), 0);
 	}
 	return UNDEFINED_VALUE;
 }
 
-function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
+function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
 	const { rawFilename } = zipEntry;
-	if (rawLocalFilename.length != rawFilename.length ||
-		rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte])) {
+	if (checkLocalFilename &&
+		(rawLocalFilename.length != rawFilename.length ||
+			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
 		throwAmbiguousArchive("mismatched local file header (filename)");
 	}
 	if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {
@@ -5789,10 +5981,11 @@ function getOptionValue$1(zipReader, options, name) {
 	return options[name] === UNDEFINED_VALUE ? zipReader.options[name] : options[name];
 }
 
-function toNumber$1(value) {
-	return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
+function getFunctionOptionValue$1(zipReader, options, name) {
+	return checkFunctionOption(getOptionValue$1(zipReader, options, name));
 }
 
+
 function getDate(timeRaw) {
 	const date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & MAX_16_BITS;
 	return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
@@ -5806,11 +5999,11 @@ function getUint8(view, offset) {
 	return view.getUint8(offset);
 }
 
-function getUint16(view, offset) {
+function getUint16$1(view, offset) {
 	return view.getUint16(offset, true);
 }
 
-function getUint32(view, offset) {
+function getUint32$1(view, offset) {
 	return view.getUint32(offset, true);
 }
 
@@ -5825,6 +6018,7 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	ERR_CENTRAL_DIRECTORY_NOT_FOUND: ERR_CENTRAL_DIRECTORY_NOT_FOUND,
 	ERR_ENCRYPTED: ERR_ENCRYPTED,
 	ERR_ENCRYPTED_CENTRAL_DIRECTORY: ERR_ENCRYPTED_CENTRAL_DIRECTORY,
+	ERR_ENTRY_DATA_OUT_OF_BOUNDS: ERR_ENTRY_DATA_OUT_OF_BOUNDS,
 	ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND: ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND,
 	ERR_EOCDR_NOT_FOUND: ERR_EOCDR_NOT_FOUND,
 	ERR_EXTRAFIELD_ZIP64_NOT_FOUND: ERR_EXTRAFIELD_ZIP64_NOT_FOUND,
@@ -5879,13 +6073,18 @@ var zipReader = /*#__PURE__*/Object.freeze({
 
 const ERR_DUPLICATED_NAME = "File already exists";
 const ERR_INVALID_COMMENT = "Zip file comment exceeds 64KB";
+const ERR_INVALID_COMMENT_TYPE = "Invalid zip file comment (must be a Uint8Array)";
 const ERR_INVALID_ENTRY_COMMENT = "File entry comment exceeds 64KB";
+const ERR_INVALID_ENTRY_COMMENT_TYPE = "Invalid file entry comment (must be a string)";
+const ERR_INVALID_DATE = "Invalid date (must be a valid Date instance)";
 const ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
 const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 const ERR_UNSUPPORTED_ENCRYPTION_USDZ = "Encryption is not supported in USDZ files";
 const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set";
-const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
+const ERR_INVALID_EXTRAFIELD = "Invalid extra field (must be a Map)";
+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;
@@ -5905,7 +6104,6 @@ const ERR_INVALID_UNIX_ID_SIZE = "uid/gid must be 0..65535 for unixExtraFieldTyp
 const ERR_INVALID_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be integer 0..255)";
 const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
 const ERR_INVALID_LEVEL = "Invalid level (must be integer 0..9)";
-const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
 const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
@@ -5930,8 +6128,7 @@ class ZipWriter {
 			writer,
 			addSplitZipSignature,
 			options,
-			config: getConfiguration(),
-			files: new Map(),
+			fileEntries: new Map(),
 			filenames: new Set(),
 			offset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? writer.size || writer.writable.size || 0 : options[OPTION_OFFSET],
 			initialOffset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : options[OPTION_OFFSET] - (writer.size || writer.writable.size || 0),
@@ -5947,15 +6144,28 @@ class ZipWriter {
 		}
 		reader = new GenericReader(reader);
 		await initStream(reader);
+		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+			reader = new BlobReader(await streamToBlob(reader.readable));
+			await initStream(reader);
+		}
 		const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
-		const zipReader$1 = new ZipReader(reader.readable);
+		const zipReader$1 = new ZipReader(reader);
 		const entries = await zipReader$1.getEntries();
 		await zipReader$1.close();
 		await initStream(this.writer);
-		await reader.readable.pipeTo(this.writer.writable, { preventClose: true, preventAbort: true });
-		this.writer.size = this.offset = reader.size;
+		const { directoryOffset } = zipReader$1;
+		let splitZipSignatureLength = 0;
+		if (this.addSplitZipSignature) {
+			delete this.addSplitZipSignature;
+			if (!await startsWithSplitZipSignature(reader)) {
+				await writeData(this.writer, getSplitZipSignatureArray());
+				splitZipSignatureLength = SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
+				this.offset += splitZipSignatureLength;
+			}
+		}
+		const entryPositions = await copyZipData(this, reader, entries, directoryOffset, splitZipSignatureLength);
 		this.filenames = new Set(entries.map(entry => entry.filename));
-		this.files = new Map(entries.map(entry => {
+		this.fileEntries = new Map(entries.map(entry => {
 			const {
 				version,
 				rawLastModDate,
@@ -6010,11 +6220,12 @@ class ZipWriter {
 			if (crc32 !== UNDEFINED_VALUE) {
 				setUint32(headerView, HEADER_OFFSET_SIGNATURE, crc32);
 			}
+			const { offset, diskNumberStart } = entryPositions.get(entry);
 			Object.assign(entry, {
 				zip64UncompressedSize,
 				zip64CompressedSize,
-				zip64Offset: zip64 && entry.offset >= MAX_32_BITS,
-				diskNumberStart: 0,
+				offset,
+				diskNumberStart,
 				zip64DiskNumberStart: false,
 				rawExtraFieldZip64,
 				rawExtraFieldAES,
@@ -6034,11 +6245,8 @@ class ZipWriter {
 	async add(name = "", reader, options = {}) {
 		const zipWriter = this;
 		options = Object.assign({}, options);
-		const {
-			pendingAddFileCalls,
-			config
-		} = zipWriter;
-		if (workers < config.maxWorkers) {
+		const { pendingAddFileCalls } = zipWriter;
+		if (workers < getConfiguration().maxWorkers) {
 			workers++;
 		} else {
 			await new Promise(resolve => pendingEntries.push(resolve));
@@ -6075,16 +6283,16 @@ class ZipWriter {
 	}
 
 	remove(entry) {
-		const { filenames, files } = this;
+		const { filenames, fileEntries } = this;
 		// deno-lint-ignore valid-typeof
 		if (typeof entry == STRING_TYPE) {
-			entry = files.get(entry);
+			entry = fileEntries.get(entry);
 		}
 		if (entry && entry.filename !== UNDEFINED_VALUE) {
 			const { filename } = entry;
-			if (filenames.has(filename) && files.has(filename)) {
+			if (filenames.has(filename) && fileEntries.has(filename)) {
 				filenames.delete(filename);
-				files.delete(filename);
+				fileEntries.delete(filename);
 				return true;
 			}
 		}
@@ -6095,6 +6303,9 @@ class ZipWriter {
 		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
+		if (!(comment instanceof Uint8Array)) {
+			throw new Error(ERR_INVALID_COMMENT_TYPE);
+		}
 		if (getLength(comment) > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_COMMENT);
 		}
@@ -6178,12 +6389,12 @@ async function addFile(zipWriter, name, reader, options) {
 	const metadataInfo = resolveMetadata(zipWriter, name, options);
 	const { comment } = metadataInfo;
 	const extraField = options[PROPERTY_NAME_EXTRA_FIELD];
-	zipWriter.files.set(name, UNDEFINED_VALUE);
+	zipWriter.fileEntries.set(name, UNDEFINED_VALUE);
 	let fileEntry;
 	try {
 		const { resolvedOptions } = metadataInfo;
 		if (resolvedOptions.level != 0 && resolvedOptions.compressionMethod === UNDEFINED_VALUE &&
-			!resolvedOptions.passThrough && !(await supportsDeflate(zipWriter.config))) {
+			!resolvedOptions.passThrough && !(await supportsDeflate(getConfiguration()))) {
 			resolvedOptions.level = 0;
 		}
 		const sizesInfo = await resolveSizes(zipWriter, reader, metadataInfo, options);
@@ -6191,8 +6402,6 @@ async function addFile(zipWriter, name, reader, options) {
 		const diskOffset = getDiskOffset(zipWriter.writer);
 		const diskNumber = getDiskNumber(zipWriter.writer);
 		options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
-			internalFileAttribute: metadataInfo.resolvedOptions.internalFileAttributes,
-			externalFileAttribute: attributesInfo.resolvedOptions.externalFileAttributes,
 			signature: options[PROPERTY_NAME_SIGNATURE],
 			crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
 			offset: zipWriter.offset - diskOffset,
@@ -6203,17 +6412,23 @@ async function addFile(zipWriter, name, reader, options) {
 		const metadataSize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray);
 		fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo, metadataSize }, options);
 	} catch (error) {
-		zipWriter.files.delete(name);
+		zipWriter.fileEntries.delete(name);
 		throw error;
 	}
-	Object.assign(fileEntry, { name, comment, extraField });
+	Object.assign(fileEntry, {
+		name,
+		comment,
+		extraField,
+		[PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES]: fileEntry.internalFileAttributes,
+		[PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES]: fileEntry.externalFileAttributes
+	});
 	return new Entry(fileEntry);
 }
 
 function resolveAttributes(zipWriter, name, options) {
 	name = name.trim();
 	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
-	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? 20 : 768);
+	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
 	const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
 	const uid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_UID);
 	const gid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_GID);
@@ -6241,21 +6456,21 @@ function resolveAttributes(zipWriter, name, options) {
 	if (unixExtraFieldType === UNDEFINED_VALUE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
 		unixExtraFieldType = INFOZIP_EXTRA_FIELD_TYPE$1;
 	}
-	let msdosAttributesRaw = getOptionValue(zipWriter, options, PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW);
+	let msdosAttributesRaw = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW);
 	let msdosAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_MSDOS_ATTRIBUTES);
-	const hasUnixMetadata = uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE || unixMode !== UNDEFINED_VALUE || unixExtraFieldType;
+	const hasUnixMetadata = uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE || unixMode !== UNDEFINED_VALUE || unixExtraFieldType || executable;
 	const hasMsDosProvided = msdosAttributesRaw !== UNDEFINED_VALUE || msdosAttributes !== UNDEFINED_VALUE;
 	if (hasUnixMetadata) {
 		msDosCompatible = false;
-		versionMadeBy = (versionMadeBy & MAX_16_BITS) | (3 << 8);
+		versionMadeBy = (versionMadeBy & MAX_8_BITS) | VERSION_MADE_BY_UNIX;
 	} else if (hasMsDosProvided) {
 		msDosCompatible = true;
 		versionMadeBy = (versionMadeBy & MAX_8_BITS);
 	}
-	if (msdosAttributesRaw !== UNDEFINED_VALUE && (msdosAttributesRaw < 0 || msdosAttributesRaw > MAX_8_BITS)) {
+	if (msdosAttributesRaw !== UNDEFINED_VALUE && (!Number.isInteger(msdosAttributesRaw) || msdosAttributesRaw < 0 || msdosAttributesRaw > MAX_8_BITS)) {
 		throw new Error(ERR_INVALID_MSDOS_ATTRIBUTES);
 	}
-	if (msdosAttributes && typeof msdosAttributes !== OBJECT_TYPE) {
+	if (msdosAttributes && (typeof msdosAttributes !== OBJECT_TYPE || Array.isArray(msdosAttributes))) {
 		throw new Error(ERR_INVALID_MSDOS_DATA);
 	}
 	if (versionMadeBy > MAX_16_BITS) {
@@ -6287,11 +6502,10 @@ function resolveAttributes(zipWriter, name, options) {
 			externalFileAttributes = FILE_ATTR_UNIX_DEFAULT_MASK << 16;
 		}
 	}
-	let unixExternalUpper;
 	if (!msDosCompatible) {
 		const unixModeProvided = unixMode !== UNDEFINED_VALUE || Boolean(setuid || setgid || sticky);
-		unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
-		unixMode = unixMode === UNDEFINED_VALUE ? unixExternalUpper : (unixMode & MAX_16_BITS);
+		const defaultUnixMode = (externalFileAttributes >> 16) & MAX_16_BITS;
+		unixMode = unixMode === UNDEFINED_VALUE ? defaultUnixMode : (unixMode & MAX_16_BITS);
 		if (setuid) {
 			unixMode |= FILE_ATTR_UNIX_SETUID_MASK;
 		} else {
@@ -6320,17 +6534,20 @@ function resolveAttributes(zipWriter, name, options) {
 	if (hasMsDosProvided) {
 		externalFileAttributes = (externalFileAttributes & MAX_32_BITS) | (msdosAttributesRaw & MAX_8_BITS);
 	}
+	const unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
+	const symlink = unixMode !== UNDEFINED_VALUE && ((unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK);
 	return {
 		name,
 		resolvedOptions: {
 			versionMadeBy,
-			msDosCompatible,
+			msDosCompatible: Boolean(msDosCompatible),
 			externalFileAttributes,
 			unixExternalUpper,
 			uid,
 			gid,
 			unixMode,
 			unixExtraFieldType,
+			symlink,
 			setuid,
 			setgid,
 			sticky,
@@ -6341,7 +6558,7 @@ function resolveAttributes(zipWriter, name, options) {
 }
 
 function resolveMetadata(zipWriter, name, options) {
-	const encode = getOptionValue(zipWriter, options, OPTION_ENCODE_TEXT, encodeText);
+	const encode = getFunctionOptionValue(zipWriter, options, OPTION_ENCODE_TEXT) || encodeText;
 	let rawFilename = encode(name, TEXT_TYPE_FILENAME);
 	if (rawFilename === UNDEFINED_VALUE) {
 		rawFilename = encodeText(name);
@@ -6350,6 +6567,10 @@ function resolveMetadata(zipWriter, name, options) {
 		throw new Error(ERR_INVALID_ENTRY_NAME);
 	}
 	const comment = options[PROPERTY_NAME_COMMENT] || "";
+	// deno-lint-ignore valid-typeof
+	if (typeof comment != STRING_TYPE) {
+		throw new Error(ERR_INVALID_ENTRY_COMMENT_TYPE);
+	}
 	let rawComment = encode(comment, TEXT_TYPE_COMMENT);
 	if (rawComment === UNDEFINED_VALUE) {
 		rawComment = encodeText(comment);
@@ -6361,16 +6582,14 @@ function resolveMetadata(zipWriter, name, options) {
 	if (version > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_VERSION);
 	}
-	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 lastModDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_LAST_MODIFICATION_DATE, new 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 passThrough = getOptionValue(zipWriter, options, OPTION_PASS_THROUGH);
 	const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
 	const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
-	if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
-		throw new Error(ERR_INVALID_PASSWORD_TYPE);
-	}
+	checkPasswordOption(password, rawPassword);
 	const encryptionStrength = getNumberOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 	const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
 	const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
@@ -6379,9 +6598,9 @@ function resolveMetadata(zipWriter, name, options) {
 	const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
 	const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS);
 	const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
-	const createTempStream = getOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
+	const createTempStream = getFunctionOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
-	const signal = getOptionValue(zipWriter, options, OPTION_SIGNAL);
+	const signal = checkSignalOption(getOptionValue(zipWriter, options, OPTION_SIGNAL));
 	const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
 	const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
 	const registeredCodec = passThrough || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
@@ -6461,18 +6680,26 @@ function serializeExtraField(extraField) {
 	if (!extraField) {
 		return EMPTY_UINT8_ARRAY;
 	}
+	if (!(extraField instanceof Map)) {
+		throw new Error(ERR_INVALID_EXTRAFIELD);
+	}
 	let extraFieldSize = 0;
 	let offset = 0;
-	extraField.forEach(data => extraFieldSize += 4 + getLength(data));
-	const rawExtraField = new Uint8Array(extraFieldSize);
-	const rawExtraFieldView = getDataView(rawExtraField);
 	extraField.forEach((data, type) => {
-		if (type > MAX_16_BITS) {
+		if (!Number.isInteger(type) || type < 0 || type > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_TYPE);
 		}
+		if (!(data instanceof Uint8Array)) {
+			throw new Error(ERR_INVALID_EXTRAFIELD_DATA_TYPE);
+		}
 		if (getLength(data) > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 		}
+		extraFieldSize += 4 + getLength(data);
+	});
+	const rawExtraField = new Uint8Array(extraFieldSize);
+	const rawExtraFieldView = getDataView(rawExtraField);
+	extraField.forEach((data, type) => {
 		setUint16(rawExtraFieldView, offset, type);
 		setUint16(rawExtraFieldView, offset + 2, getLength(data));
 		arraySet(rawExtraField, data, offset + 4);
@@ -6559,10 +6786,13 @@ function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options
 }
 
 async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comment) {
-	const zipWriter = { options: writerOptions, config: getConfiguration() };
-	if (writerOptions[OPTION_SIGN_CENTRAL_DIRECTORY]) {
+	const zipWriter = { options: writerOptions };
+	if (checkFunctionOption(writerOptions[OPTION_SIGN_CENTRAL_DIRECTORY])) {
 		throw new Error(ERR_UNDETERMINED_SIZE);
 	}
+	if (comment !== UNDEFINED_VALUE && !(comment instanceof Uint8Array)) {
+		throw new Error(ERR_INVALID_COMMENT_TYPE);
+	}
 	const commentLength = getLength(comment);
 	if (commentLength > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_COMMENT);
@@ -6583,7 +6813,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		({ name } = attributesInfo);
 		const { resolvedOptions: metadata } = resolveMetadata(zipWriter, name, options);
 		if (metadata.level != 0 && metadata.compressionMethod === UNDEFINED_VALUE &&
-			!metadata.passThrough && !(await supportsDeflate(zipWriter.config))) {
+			!metadata.passThrough && !(await supportsDeflate(getConfiguration()))) {
 			metadata.level = 0;
 		}
 		const hasContent = !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY);
@@ -6632,7 +6862,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 
 async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
-		files,
+		fileEntries,
 		writer
 	} = zipWriter;
 	const {
@@ -6654,12 +6884,12 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	let writerSizeBeforeEntry;
 	let flushedBufferedSize = 0;
 	let fileWriter;
-	files.set(name, fileEntry);
+	fileEntries.set(name, fileEntry);
 	zipWriter.lastFileEntry = fileEntry;
 	try {
 		let lockPreviousFileEntry;
 		if (keepOrder) {
-			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lock;
+			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lockFileEntry;
 			requestLockCurrentFileEntry();
 		}
 		if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || !dataDescriptor) {
@@ -6680,11 +6910,8 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		const diskOffset = getDiskOffset(writer);
 		if (zipWriter.addSplitZipSignature) {
 			delete zipWriter.addSplitZipSignature;
-			const signatureArray = new Uint8Array(4);
-			const signatureArrayView = getDataView(signatureArray);
-			setUint32(signatureArrayView, 0, SPLIT_ZIP_FILE_SIGNATURE);
-			await writeData(writer, signatureArray);
-			zipWriter.offset += 4;
+			await writeData(writer, getSplitZipSignatureArray());
+			zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
 		}
 		if (usdz && !bufferedWrite) {
 			appendExtraFieldUSDZ(entryInfo, zipWriter.offset - diskOffset);
@@ -6702,11 +6929,11 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			writerSizeBeforeEntry = writer.size;
 			await writeData(fileWriter, localHeaderArray);
 		}
-		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, zipWriter.config, options);
+		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, getConfiguration(), options);
 		if (!bufferedWrite) {
 			writingEntryData = false;
 		}
-		files.set(name, fileEntry);
+		fileEntries.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
 			await Promise.all([fileWriter.writable.getWriter().close(), lockPreviousFileEntry]);
@@ -6747,7 +6974,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 				zipWriter.offset += flushedBufferedSize;
 			}
 		}
-		files.delete(name);
+		fileEntries.delete(name);
 		throw error;
 	} finally {
 		if (bufferedWrite) {
@@ -6769,7 +6996,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	}
 
 	function requestLockCurrentFileEntry() {
-		fileEntry.lock = new Promise(resolve => releaseLockCurrentFileEntry = resolve);
+		fileEntry.lockFileEntry = new Promise(resolve => releaseLockCurrentFileEntry = resolve);
 	}
 
 	async function requestLockWriter() {
@@ -6789,7 +7016,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	}
 }
 
-async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryInfo, config, options) {
+async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry }, entryInfo, config, options) {
 	const {
 		headerInfo,
 		dataDescriptorInfo,
@@ -6844,6 +7071,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		uid,
 		gid,
 		unixMode,
+		symlink,
 		setuid,
 		setgid,
 		sticky,
@@ -6856,7 +7084,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		codecURI
 	} = options;
 	const fileEntry = {
-		lock,
+		lockFileEntry,
 		versionMadeBy,
 		zip64,
 		directory: Boolean(directory),
@@ -6880,6 +7108,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		uid,
 		gid,
 		unixMode,
+		symlink: Boolean(symlink),
 		setuid,
 		setgid,
 		sticky,
@@ -6897,7 +7126,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	}
 	const { writable } = writer;
 	if (reader) {
-		const readable = toCompatibleReadable(reader.createReadable ? reader.createReadable() : reader.readable);
+		const readable = toCompatibleReadable(createReadable(reader));
 		const size = reader.size;
 		const workerOptions = {
 			options: {
@@ -6960,8 +7189,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawLastModDate,
 		creationDate,
 		lastAccessDate,
-		encrypted,
-		zipCrypto,
+		encrypted: Boolean(encrypted),
+		zipCrypto: Boolean(zipCrypto),
 		size: metadataSize + compressedSize,
 		compressionMethod,
 		version,
@@ -7009,14 +7238,14 @@ function getHeaderInfo(options) {
 	if (zip64 && (zip64UncompressedSize || zip64CompressedSize)) {
 		const length = 4 + 16;
 		const extraFieldZip64 = createRecordWriter(length);
-		extraFieldZip64.uint16(EXTRAFIELD_TYPE_ZIP64);
-		extraFieldZip64.uint16(length - 4);
+		extraFieldZip64.writeUint16(EXTRAFIELD_TYPE_ZIP64);
+		extraFieldZip64.writeUint16(length - 4);
 		rawLocalExtraFieldZip64 = extraFieldZip64.array;
 		if (zip64ExtraFieldComplete) {
-			extraFieldZip64.uint64(uncompressedSize);
+			extraFieldZip64.writeUint64(uncompressedSize);
 			if (uncompressedFile) {
 				const encryptionOverhead = encrypted ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
-				extraFieldZip64.uint64(passThrough ? 0 : uncompressedSize + encryptionOverhead);
+				extraFieldZip64.writeUint64(passThrough ? 0 : uncompressedSize + encryptionOverhead);
 			}
 		}
 	} else {
@@ -7025,8 +7254,8 @@ function getHeaderInfo(options) {
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
 		const extraFieldAES = createRecordWriter(getLength(EXTRAFIELD_DATA_AES) + 2);
-		extraFieldAES.uint16(EXTRAFIELD_TYPE_AES);
-		extraFieldAES.bytes(EXTRAFIELD_DATA_AES);
+		extraFieldAES.writeUint16(EXTRAFIELD_TYPE_AES);
+		extraFieldAES.writeBytes(EXTRAFIELD_DATA_AES);
 		rawExtraFieldAES = extraFieldAES.array;
 		rawExtraFieldAES[8] = encryptionStrength;
 	} else {
@@ -7042,15 +7271,15 @@ function getHeaderInfo(options) {
 			const extraFieldTimestampLength = 9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0);
 			const extraFieldTimestamp = createRecordWriter(extraFieldTimestampLength);
 			extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
-			extraFieldTimestamp.uint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-			extraFieldTimestamp.uint16(extraFieldTimestampLength - 4);
-			extraFieldTimestamp.uint8(extraFieldExtendedTimestampFlag);
-			extraFieldTimestamp.uint32(lastModTimeUnix);
+			extraFieldTimestamp.writeUint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
+			extraFieldTimestamp.writeUint16(extraFieldTimestampLength - 4);
+			extraFieldTimestamp.writeUint8(extraFieldExtendedTimestampFlag);
+			extraFieldTimestamp.writeUint32(lastModTimeUnix);
 			if (lastAccessDate) {
-				extraFieldTimestamp.uint32(clampUnixTime(getTimeUnix(lastAccessDate)));
+				extraFieldTimestamp.writeUint32(clampUnixTime(getTimeUnix(lastAccessDate)));
 			}
 			if (creationDate) {
-				extraFieldTimestamp.uint32(clampUnixTime(getTimeUnix(creationDate)));
+				extraFieldTimestamp.writeUint32(clampUnixTime(getTimeUnix(creationDate)));
 			}
 			rawExtraFieldExtendedTimestamp = extraFieldTimestamp.array;
 		} else {
@@ -7063,14 +7292,14 @@ function getHeaderInfo(options) {
 			try {
 				const lastModTimeNTFS = getTimeNTFS(lastModDate);
 				const extraFieldNTFS = createRecordWriter(36);
-				extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS);
-				extraFieldNTFS.uint16(32);
+				extraFieldNTFS.writeUint16(EXTRAFIELD_TYPE_NTFS);
+				extraFieldNTFS.writeUint16(32);
 				extraFieldNTFS.skip(4);
-				extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS_TAG1);
-				extraFieldNTFS.uint16(24);
-				extraFieldNTFS.uint64(lastModTimeNTFS);
-				extraFieldNTFS.uint64(lastAccessDate ? getTimeNTFS(lastAccessDate) : lastModTimeNTFS);
-				extraFieldNTFS.uint64(creationDate ? getTimeNTFS(creationDate) : lastModTimeNTFS);
+				extraFieldNTFS.writeUint16(EXTRAFIELD_TYPE_NTFS_TAG1);
+				extraFieldNTFS.writeUint16(24);
+				extraFieldNTFS.writeUint64(lastModTimeNTFS);
+				extraFieldNTFS.writeUint64(lastAccessDate ? getTimeNTFS(lastAccessDate) : lastModTimeNTFS);
+				extraFieldNTFS.writeUint64(creationDate ? getTimeNTFS(creationDate) : lastModTimeNTFS);
 				rawExtraFieldNTFS = extraFieldNTFS.array;
 			} catch {
 				rawExtraFieldNTFS = EMPTY_UINT8_ARRAY;
@@ -7089,20 +7318,20 @@ function getHeaderInfo(options) {
 			const gidBytes = packUnixId(gid);
 			const payloadLength = 3 + uidBytes.length + gidBytes.length;
 			const extraFieldUnix = createRecordWriter(4 + payloadLength);
-			extraFieldUnix.uint16(EXTRAFIELD_TYPE_INFOZIP);
-			extraFieldUnix.uint16(payloadLength);
-			extraFieldUnix.uint8(1);
-			extraFieldUnix.uint8(uidBytes.length);
-			extraFieldUnix.bytes(uidBytes);
-			extraFieldUnix.uint8(gidBytes.length);
-			extraFieldUnix.bytes(gidBytes);
+			extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_INFOZIP);
+			extraFieldUnix.writeUint16(payloadLength);
+			extraFieldUnix.writeUint8(1);
+			extraFieldUnix.writeUint8(uidBytes.length);
+			extraFieldUnix.writeBytes(uidBytes);
+			extraFieldUnix.writeUint8(gidBytes.length);
+			extraFieldUnix.writeBytes(gidBytes);
 			rawExtraFieldUnix = extraFieldUnix.array;
 		} else if (unixExtraFieldType == UNIX_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
 			const extraFieldUnix = createRecordWriter(8);
-			extraFieldUnix.uint16(EXTRAFIELD_TYPE_UNIX);
-			extraFieldUnix.uint16(4);
-			extraFieldUnix.uint16((uid === UNDEFINED_VALUE ? 0 : uid) & MAX_16_BITS);
-			extraFieldUnix.uint16((gid === UNDEFINED_VALUE ? 0 : gid) & MAX_16_BITS);
+			extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_UNIX);
+			extraFieldUnix.writeUint16(4);
+			extraFieldUnix.writeUint16((uid === UNDEFINED_VALUE ? 0 : uid) & MAX_16_BITS);
+			extraFieldUnix.writeUint16((gid === UNDEFINED_VALUE ? 0 : gid) & MAX_16_BITS);
 			rawExtraFieldUnix = extraFieldUnix.array;
 		} else {
 			rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
@@ -7152,18 +7381,18 @@ function getHeaderInfo(options) {
 	const localHeader = createRecordWriter(HEADER_SIZE + getLength(rawFilename) + extraFieldLength);
 	const localHeaderArray = localHeader.array;
 	const localHeaderView = getDataView(localHeaderArray);
-	localHeader.uint32(LOCAL_FILE_HEADER_SIGNATURE);
-	localHeader.bytes(headerArray);
-	localHeader.bytes(rawFilename);
+	localHeader.writeUint32(LOCAL_FILE_HEADER_SIGNATURE);
+	localHeader.writeBytes(headerArray);
+	localHeader.writeBytes(rawFilename);
 	if (writeLocalExtraFieldZip64) {
-		localHeader.bytes(rawLocalExtraFieldZip64);
-	}
-	localHeader.bytes(rawExtraFieldAES);
-	localHeader.bytes(rawExtraFieldExtendedTimestamp);
-	localHeader.bytes(rawExtraFieldNTFS);
-	localHeader.bytes(rawExtraFieldUnix);
-	localHeader.bytes(rawExtraField);
-	localHeader.bytes(rawLocalExtraField);
+		localHeader.writeBytes(rawLocalExtraFieldZip64);
+	}
+	localHeader.writeBytes(rawExtraFieldAES);
+	localHeader.writeBytes(rawExtraFieldExtendedTimestamp);
+	localHeader.writeBytes(rawExtraFieldNTFS);
+	localHeader.writeBytes(rawExtraFieldUnix);
+	localHeader.writeBytes(rawExtraField);
+	localHeader.writeBytes(rawLocalExtraField);
 	if (dataDescriptor) {
 		if (!zip64CompressedSize) {
 			setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + LOCAL_HEADER_COMMON_OFFSET, 0);
@@ -7353,7 +7582,7 @@ function updateLocalHeader({
 
 
 async function closeFile(zipWriter, comment, options) {
-	const directoryDataLength = createDirectoryRecords(zipWriter.files);
+	const directoryDataLength = createDirectoryRecords(zipWriter.fileEntries);
 	const { directoryStart, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
 	const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
 	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength, signatureLength });
@@ -7383,19 +7612,19 @@ function createDirectoryRecords(files) {
 		if (zip64Offset || zip64DiskNumberStart || zip64UncompressedSize || zip64CompressedSize) {
 			const length = 4 + (zip64UncompressedSize ? 8 : 0) + (zip64CompressedSize ? 8 : 0) + (zip64Offset ? 8 : 0) + (zip64DiskNumberStart ? 4 : 0);
 			const extraFieldZip64 = createRecordWriter(length);
-			extraFieldZip64.uint16(EXTRAFIELD_TYPE_ZIP64);
-			extraFieldZip64.uint16(length - 4);
+			extraFieldZip64.writeUint16(EXTRAFIELD_TYPE_ZIP64);
+			extraFieldZip64.writeUint16(length - 4);
 			if (zip64UncompressedSize) {
-				extraFieldZip64.uint64(uncompressedSize);
+				extraFieldZip64.writeUint64(uncompressedSize);
 			}
 			if (zip64CompressedSize) {
-				extraFieldZip64.uint64(compressedSize);
+				extraFieldZip64.writeUint64(compressedSize);
 			}
 			if (zip64Offset) {
-				extraFieldZip64.uint64(fileEntry.offset);
+				extraFieldZip64.writeUint64(fileEntry.offset);
 			}
 			if (zip64DiskNumberStart) {
-				extraFieldZip64.uint32(fileEntry.diskNumberStart);
+				extraFieldZip64.writeUint32(fileEntry.diskNumberStart);
 			}
 			rawExtraFieldZip64 = extraFieldZip64.array;
 		} else {
@@ -7408,10 +7637,10 @@ function createDirectoryRecords(files) {
 		const lastModTimeUnix = getTimeUnix(lastModDate);
 		if (extendedTimestamp && inUnixTimeRange(lastModTimeUnix)) {
 			const extraFieldTimestamp = createRecordWriter(9);
-			extraFieldTimestamp.uint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-			extraFieldTimestamp.uint16(5);
-			extraFieldTimestamp.uint8(extraFieldExtendedTimestampFlag);
-			extraFieldTimestamp.uint32(lastModTimeUnix);
+			extraFieldTimestamp.writeUint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
+			extraFieldTimestamp.writeUint16(5);
+			extraFieldTimestamp.writeUint8(extraFieldExtendedTimestampFlag);
+			extraFieldTimestamp.writeUint32(lastModTimeUnix);
 			rawExtraFieldTimestamp = extraFieldTimestamp.array;
 		} else {
 			rawExtraFieldTimestamp = EMPTY_UINT8_ARRAY;
@@ -7433,14 +7662,14 @@ function createDirectoryRecords(files) {
 }
 
 async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
-	const { files, writer } = zipWriter;
+	const { fileEntries, writer } = zipWriter;
 	const directoryArray = new Uint8Array(directoryDataLength);
 	await initStream(writer);
 	let offset = 0;
 	let directoryDiskOffset = 0;
 	let directoryStartDiskNumber = getDiskNumber(writer);
 	let directoryStartDiskOffset = getDiskOffset(writer);
-	for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
+	for (const [indexFileEntry, fileEntry] of Array.from(fileEntries.values()).entries()) {
 		const {
 			offset: fileEntryOffset,
 			rawFilename,
@@ -7485,28 +7714,28 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			setUint16(headerView, HEADER_OFFSET_VERSION, VERSION_ZIP64);
 		}
 		const directoryRecord = createRecordWriter(directoryRecordLength);
-		directoryRecord.uint32(CENTRAL_FILE_HEADER_SIGNATURE);
-		directoryRecord.uint16(versionMadeBy);
-		directoryRecord.bytes(headerArray.subarray(0, HEADER_SIZE - 4 - 2));
-		directoryRecord.uint16(extraFieldLength);
-		directoryRecord.uint16(getLength(rawComment));
-		directoryRecord.uint16(zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
-		directoryRecord.uint16(internalFileAttributes);
-		directoryRecord.uint32(externalFileAttributes);
-		directoryRecord.uint32(zip64Offset ? MAX_32_BITS : fileEntryOffset);
-		directoryRecord.bytes(rawFilename);
-		directoryRecord.bytes(rawExtraFieldZip64);
-		directoryRecord.bytes(rawExtraFieldAES);
-		directoryRecord.bytes(rawExtraFieldExtendedTimestamp);
-		directoryRecord.bytes(rawExtraFieldNTFS);
-		directoryRecord.bytes(rawExtraFieldUnix);
-		directoryRecord.bytes(rawExtraField);
-		directoryRecord.bytes(rawComment);
+		directoryRecord.writeUint32(CENTRAL_FILE_HEADER_SIGNATURE);
+		directoryRecord.writeUint16(versionMadeBy);
+		directoryRecord.writeBytes(headerArray.subarray(0, HEADER_SIZE - 4 - 2));
+		directoryRecord.writeUint16(extraFieldLength);
+		directoryRecord.writeUint16(getLength(rawComment));
+		directoryRecord.writeUint16(zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
+		directoryRecord.writeUint16(internalFileAttributes);
+		directoryRecord.writeUint32(externalFileAttributes);
+		directoryRecord.writeUint32(zip64Offset ? MAX_32_BITS : fileEntryOffset);
+		directoryRecord.writeBytes(rawFilename);
+		directoryRecord.writeBytes(rawExtraFieldZip64);
+		directoryRecord.writeBytes(rawExtraFieldAES);
+		directoryRecord.writeBytes(rawExtraFieldExtendedTimestamp);
+		directoryRecord.writeBytes(rawExtraFieldNTFS);
+		directoryRecord.writeBytes(rawExtraFieldUnix);
+		directoryRecord.writeBytes(rawExtraField);
+		directoryRecord.writeBytes(rawComment);
 		arraySet(directoryArray, directoryRecord.array, offset);
 		offset += directoryRecordLength;
 		if (options.onprogress) {
 			try {
-				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
+				await options.onprogress(indexFileEntry + 1, fileEntries.size, new Entry(fileEntry));
 			} catch {
 				// ignored
 			}
@@ -7520,7 +7749,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 }
 
 async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
-	const signCentralDirectory = getOptionValue(zipWriter, options, OPTION_SIGN_CENTRAL_DIRECTORY);
+	const signCentralDirectory = getFunctionOptionValue(zipWriter, options, OPTION_SIGN_CENTRAL_DIRECTORY);
 	if (signCentralDirectory) {
 		const signatureData = await signCentralDirectory(directoryArray);
 		const signatureDataLength = getLength(signatureData);
@@ -7528,9 +7757,9 @@ async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
 			throw new Error(ERR_INVALID_SIGNATURE_DATA);
 		}
 		const signatureRecord = createRecordWriter(6 + signatureDataLength);
-		signatureRecord.uint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
-		signatureRecord.uint16(signatureDataLength);
-		signatureRecord.bytes(signatureData);
+		signatureRecord.writeUint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
+		signatureRecord.writeUint16(signatureDataLength);
+		signatureRecord.writeBytes(signatureData);
 		await writeData(zipWriter.writer, signatureRecord.array);
 		return 6 + signatureDataLength;
 	}
@@ -7541,7 +7770,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	const { writer } = zipWriter;
 	const { directoryStart, signatureLength } = cdInfo;
 	let { directoryDataLength } = cdInfo;
-	let filesLength = zipWriter.files.size;
+	let fileEntriesLength = zipWriter.fileEntries.size;
 	let diskNumber = directoryStart.diskNumber;
 	let directoryOffset = getSegmentOffset(zipWriter, directoryStart);
 	let lastDiskNumber = getDiskNumber(writer);
@@ -7549,7 +7778,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		lastDiskNumber++;
 	}
 	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
-	if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || filesLength >= MAX_16_BITS || lastDiskNumber >= MAX_16_BITS) {
+	if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || fileEntriesLength >= MAX_16_BITS || lastDiskNumber >= MAX_16_BITS) {
 		if (zip64 === false) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		} else {
@@ -7566,37 +7795,37 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	}
 	lastDiskNumber = getDiskNumber(writer);
 	if (zip64) {
-		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
-		endOfdirectoryRecord.uint64(44);
-		endOfdirectoryRecord.uint16(45);
-		endOfdirectoryRecord.uint16(45);
-		endOfdirectoryRecord.uint32(lastDiskNumber);
-		endOfdirectoryRecord.uint32(diskNumber);
-		endOfdirectoryRecord.uint64(filesLength);
-		endOfdirectoryRecord.uint64(filesLength);
-		endOfdirectoryRecord.uint64(directoryDataLength);
-		endOfdirectoryRecord.uint64(directoryOffset);
-		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
-		endOfdirectoryRecord.uint32(lastDiskNumber);
-		endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength) + BigInt(signatureLength));
-		endOfdirectoryRecord.uint32(lastDiskNumber + 1);
+		endOfdirectoryRecord.writeUint32(ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
+		endOfdirectoryRecord.writeUint64(44);
+		endOfdirectoryRecord.writeUint16(45);
+		endOfdirectoryRecord.writeUint16(45);
+		endOfdirectoryRecord.writeUint32(lastDiskNumber);
+		endOfdirectoryRecord.writeUint32(diskNumber);
+		endOfdirectoryRecord.writeUint64(fileEntriesLength);
+		endOfdirectoryRecord.writeUint64(fileEntriesLength);
+		endOfdirectoryRecord.writeUint64(directoryDataLength);
+		endOfdirectoryRecord.writeUint64(directoryOffset);
+		endOfdirectoryRecord.writeUint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
+		endOfdirectoryRecord.writeUint32(lastDiskNumber);
+		endOfdirectoryRecord.writeUint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength) + BigInt(signatureLength));
+		endOfdirectoryRecord.writeUint32(lastDiskNumber + 1);
 		const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 		if (supportZip64SplitFile) {
 			lastDiskNumber = MAX_16_BITS;
 			diskNumber = MAX_16_BITS;
 		}
-		filesLength = MAX_16_BITS;
+		fileEntriesLength = MAX_16_BITS;
 		directoryOffset = MAX_32_BITS;
 		directoryDataLength = MAX_32_BITS;
 	}
-	endOfdirectoryRecord.uint32(END_OF_CENTRAL_DIR_SIGNATURE);
-	endOfdirectoryRecord.uint16(lastDiskNumber);
-	endOfdirectoryRecord.uint16(diskNumber);
-	endOfdirectoryRecord.uint16(filesLength);
-	endOfdirectoryRecord.uint16(filesLength);
-	endOfdirectoryRecord.uint32(directoryDataLength);
-	endOfdirectoryRecord.uint32(directoryOffset);
-	endOfdirectoryRecord.uint16(commentLength);
+	endOfdirectoryRecord.writeUint32(END_OF_CENTRAL_DIR_SIGNATURE);
+	endOfdirectoryRecord.writeUint16(lastDiskNumber);
+	endOfdirectoryRecord.writeUint16(diskNumber);
+	endOfdirectoryRecord.writeUint16(fileEntriesLength);
+	endOfdirectoryRecord.writeUint16(fileEntriesLength);
+	endOfdirectoryRecord.writeUint32(directoryDataLength);
+	endOfdirectoryRecord.writeUint32(directoryOffset);
+	endOfdirectoryRecord.writeUint16(commentLength);
 	await writeData(writer, endOfdirectoryRecord.array);
 	if (commentLength) {
 		await writeData(writer, comment);
@@ -7609,11 +7838,11 @@ function createRecordWriter(length) {
 	let offset = 0;
 	return {
 		array,
-		uint8: value => { setUint8(view, offset, value); offset += 1; },
-		uint16: value => { setUint16(view, offset, value); offset += 2; },
-		uint32: value => { setUint32(view, offset, value); offset += 4; },
-		uint64: value => { setBigUint64(view, offset, BigInt(value)); offset += 8; },
-		bytes: value => { arraySet(array, value, offset); offset += getLength(value); },
+		writeUint8: value => { setUint8(view, offset, value); offset += 1; },
+		writeUint16: value => { setUint16(view, offset, value); offset += 2; },
+		writeUint32: value => { setUint32(view, offset, value); offset += 4; },
+		writeUint64: value => { setBigUint64(view, offset, BigInt(value)); offset += 8; },
+		writeBytes: value => { arraySet(array, value, offset); offset += getLength(value); },
 		skip: count => offset += count
 	};
 }
@@ -7637,6 +7866,71 @@ function getSegmentOffset(zipWriter, { diskNumber = 0, diskOffset = 0 }) {
 	return zipWriter.offset - diskOffset - (diskNumber ? zipWriter.initialOffset : 0);
 }
 
+async function startsWithSplitZipSignature(reader) {
+	const signatureArray = await readUint8Array(reader, 0, SPLIT_ZIP_FILE_SIGNATURE_LENGTH);
+	return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
+}
+
+async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZipSignatureLength) {
+	const { writer } = zipWriter;
+	const entryPositions = new Map();
+	if (writer.closeDisk) {
+		const sortedEntries = Array.from(entries).sort((firstEntry, secondEntry) =>
+			getSourceOffset(reader, firstEntry) - getSourceOffset(reader, secondEntry));
+		let copiedLength = 0;
+		for (const entry of sortedEntries) {
+			const sourceOffset = getSourceOffset(reader, entry);
+			await copyData(zipWriter, reader, copiedLength, sourceOffset - copiedLength);
+			if (exceedsAvailableSize(writer, await getLocalHeaderLength(reader, sourceOffset))) {
+				await writer.closeDisk();
+			}
+			entryPositions.set(entry, {
+				offset: getSegmentOffset(zipWriter, writer),
+				diskNumberStart: getDiskNumber(writer)
+			});
+			copiedLength = sourceOffset;
+		}
+		await copyData(zipWriter, reader, copiedLength, directoryOffset - copiedLength);
+	} else {
+		await copyData(zipWriter, reader, 0, directoryOffset);
+		entries.forEach(entry => entryPositions.set(entry, {
+			offset: splitZipSignatureLength + getSourceOffset(reader, entry),
+			diskNumberStart: 0
+		}));
+	}
+	return entryPositions;
+}
+
+async function copyData(zipWriter, reader, offset, size) {
+	if (size > 0) {
+		const { writer } = zipWriter;
+		await createReadable(reader, { offset, size }).pipeTo(writer.writable, { preventClose: true, preventAbort: true });
+		writer.size += size;
+		zipWriter.offset += size;
+	}
+}
+
+async function getLocalHeaderLength(reader, offset) {
+	const headerArray = await readUint8Array(reader, offset, HEADER_SIZE);
+	if (getLength(headerArray) < HEADER_SIZE) {
+		return HEADER_SIZE;
+	}
+	const headerView = getDataView(headerArray);
+	return HEADER_SIZE +
+		getUint16(headerView, HEADER_OFFSET_FILENAME_LENGTH + LOCAL_HEADER_COMMON_OFFSET) +
+		getUint16(headerView, HEADER_OFFSET_EXTRAFIELD_LENGTH + LOCAL_HEADER_COMMON_OFFSET);
+}
+
+function getSourceOffset(reader, { offset, diskNumberStart }) {
+	return offset + (reader.getDiskOffset ? reader.getDiskOffset(diskNumberStart) : 0);
+}
+
+function getSplitZipSignatureArray() {
+	const signatureArray = new Uint8Array(SPLIT_ZIP_FILE_SIGNATURE_LENGTH);
+	setUint32(getDataView(signatureArray), 0, SPLIT_ZIP_FILE_SIGNATURE);
+	return signatureArray;
+}
+
 async function writeData(writer, array) {
 	const { writable } = writer;
 	const streamWriter = writable.getWriter();
@@ -7688,6 +7982,21 @@ function getOptionValue(zipWriter, options, name, defaultValue) {
 	return result === UNDEFINED_VALUE ? defaultValue : result;
 }
 
+function getDateOptionValue(zipWriter, options, name, defaultValue) {
+	const date = getOptionValue(zipWriter, options, name, defaultValue);
+	if (date === null) {
+		return defaultValue;
+	}
+	if (date !== UNDEFINED_VALUE && (typeof date.getTime != FUNCTION_TYPE || Number.isNaN(date.getTime()))) {
+		throw new Error(ERR_INVALID_DATE);
+	}
+	return date;
+}
+
+function getFunctionOptionValue(zipWriter, options, name) {
+	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;
@@ -7702,9 +8011,6 @@ function getNumberOptionValue(zipWriter, options, name, defaultValue) {
 	return toNumber(getOptionValue(zipWriter, options, name, defaultValue));
 }
 
-function toNumber(value) {
-	return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
-}
 
 function getMaximumCompressedSize(uncompressedSize) {
 	return uncompressedSize + (5 * (Math.floor(uncompressedSize / 16383) + 1));
@@ -7716,6 +8022,14 @@ function isCompressed(compressionMethod, level) {
 		: compressionMethod !== COMPRESSION_METHOD_STORE;
 }
 
+function getUint16(view, offset) {
+	return view.getUint16(offset, true);
+}
+
+function getUint32(view, offset) {
+	return view.getUint32(offset, true);
+}
+
 function setUint8(view, offset, value) {
 	view.setUint8(offset, value);
 }
@@ -7759,9 +8073,9 @@ function getHeaderArrayData({
 	const headerRecord = createRecordWriter(HEADER_SIZE - 4);
 	const headerArray = headerRecord.array;
 	const headerView = getDataView(headerArray);
-	headerRecord.uint16(version);
-	headerRecord.uint16(bitFlag);
-	headerRecord.uint16(compressionMethod);
+	headerRecord.writeUint16(version);
+	headerRecord.writeUint16(bitFlag);
+	headerRecord.writeUint16(compressionMethod);
 	if (rawLastModDate === UNDEFINED_VALUE) {
 		const dateArray = new Uint32Array(1);
 		const dateView = getDataView(dateArray);
@@ -7769,20 +8083,20 @@ function getHeaderArrayData({
 		setUint16(dateView, 2, ((((lastModDate.getFullYear() - 1980) << 4) | (lastModDate.getMonth() + 1)) << 5) | lastModDate.getDate());
 		rawLastModDate = dateArray[0];
 	}
-	headerRecord.uint32(rawLastModDate);
+	headerRecord.writeUint32(rawLastModDate);
 	headerRecord.skip(4);
 	if (zip64CompressedSize || compressedSize !== UNDEFINED_VALUE) {
-		headerRecord.uint32(zip64CompressedSize ? MAX_32_BITS : compressedSize);
+		headerRecord.writeUint32(zip64CompressedSize ? MAX_32_BITS : compressedSize);
 	} else {
 		headerRecord.skip(4);
 	}
 	if (zip64UncompressedSize || uncompressedSize !== UNDEFINED_VALUE) {
-		headerRecord.uint32(zip64UncompressedSize ? MAX_32_BITS : uncompressedSize);
+		headerRecord.writeUint32(zip64UncompressedSize ? MAX_32_BITS : uncompressedSize);
 	} else {
 		headerRecord.skip(4);
 	}
-	headerRecord.uint16(getLength(rawFilename));
-	headerRecord.uint16(extraFieldLength);
+	headerRecord.writeUint16(getLength(rawFilename));
+	headerRecord.writeUint16(extraFieldLength);
 	return {
 		headerArray,
 		headerView,
@@ -8365,6 +8679,7 @@ setDefaultConfiguration({
 const ERR_ENTRY_EXISTS = "Entry filename already exists";
 const ERR_READABLE_CONSUMED = "Readable stream already consumed";
 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_ABORT_EXPORT = "zipjs-abort-export";
 const ERR_ABORTED = "The operation was aborted";
 const ABORT_ERROR_NAME = "AbortError";
@@ -8397,13 +8712,14 @@ class ZipEntry {
 			fs,
 			name,
 			data: params.data,
-			options: params.options,
+			options: params.options && Object.assign({}, params.options),
 			id: fs.entryIdCounter++,
 			parent,
 			children: [],
 			uncompressedSize: params.uncompressedSize || 0,
 			undeterminedSize: params.undeterminedSize || params.uncompressedSize === UNDEFINED_VALUE,
-			passThrough: params.passThrough
+			passThrough: params.passThrough,
+			defaultLastModDate: params.defaultLastModDate || new Date()
 		});
 		if (parent || !fs.root) {
 			fs.entries[zipEntry.id] = zipEntry;
@@ -8413,12 +8729,6 @@ class ZipEntry {
 		}
 	}
 
-	moveTo(target) {
-		// deprecated
-		const zipEntry = this;
-		zipEntry.fs.move(zipEntry, target);
-	}
-
 	getFullname() {
 		return this.getRelativeName();
 	}
@@ -8450,6 +8760,11 @@ class ZipEntry {
 			this.name = name;
 		}
 	}
+
+	setOptions(options) {
+		const entryOptions = Object.assign({}, this.options, options);
+		this.options = Object.fromEntries(Object.entries(entryOptions).filter(([, value]) => value !== UNDEFINED_VALUE));
+	}
 }
 
 class ZipFileEntry extends ZipEntry {
@@ -8476,7 +8791,7 @@ class ZipFileEntry extends ZipEntry {
 			const reader = zipEntry.reader = createReader(zipEntry.Reader, zipEntry.data, options);
 			const dataSize = zipEntry.uncompressedSize || reader.size;
 			await Promise.all([initStream(reader), initStream(writer, dataSize)]);
-			const { signal } = options;
+			const signal = checkSignalOption(options.signal);
 			const readable = createProgressReadable(zipEntry, reader, options, signal);
 			const preventClose = !ownsWritable(writer) && Boolean(options.preventClose);
 			zipEntry.uncompressedSize = reader.size;
@@ -8694,10 +9009,6 @@ class ZipDirectoryEntry extends ZipEntry {
 		});
 	}
 
-	addData(name, params) {
-		return addChild(this, name, params);
-	}
-
 	importBlob(blob, options) {
 		return this.importZip(new BlobReader(blob), options);
 	}
@@ -8811,7 +9122,7 @@ class ZipDirectoryEntry extends ZipEntry {
 		if (options.bufferedWrite === UNDEFINED_VALUE) {
 			options.bufferedWrite = true;
 		}
-		const [readers] = await Promise.all([initReaders(zipEntry, options.readerOptions), initStream(writer)]);
+		const [readers] = await Promise.all([initReaders(zipEntry, checkReaderOptions(options.readerOptions)), initStream(writer)]);
 		const zipWriter = new ZipWriter(writer, options);
 		await exportZip(zipWriter, zipEntry, getTotalSize([zipEntry], getUncompressedSize), options, readers);
 		await zipWriter.close(options.globalComment);
@@ -8821,12 +9132,13 @@ class ZipDirectoryEntry extends ZipEntry {
 	getExportedSize(options = {}) {
 		const zipEntry = this;
 		options = Object.assign({}, options);
+		checkReaderOptions(options.readerOptions);
 		if (options.bufferedWrite === UNDEFINED_VALUE) {
 			options.bufferedWrite = true;
 		}
 		const writeOrderGuaranteed = !options.bufferedWrite ||
 			(options.keepOrder !== false && zipEntry.children.every(child => !child.children.length));
-		return getEntriesSize(options, Array.from(zipEntry.getChildren({ recursive: true }), child => {
+		return getEntriesSize(options, zipEntry.getChildren({ recursive: true }).filter(child => !isImplicitDirectory(child)).map(child => {
 			const { name, entryOptions } = getChildEntryOptions(child, zipEntry, options);
 			return { name, size: child.directory ? 0 : getDeterminedSize(child, isPassThrough(child, options)), options: entryOptions };
 		}), writeOrderGuaranteed, options.globalComment);
@@ -8865,7 +9177,7 @@ class ZipDirectoryEntry extends ZipEntry {
 }
 
 
-class FS {
+class ZipFS {
 
 	constructor() {
 		resetFS(this);
@@ -8981,10 +9293,6 @@ class FS {
 		return this.root.addFile(file, options);
 	}
 
-	addData(name, params) {
-		return this.root.addData(name, params);
-	}
-
 	importBlob(blob, options) {
 		resetFS(this);
 		return this.root.importBlob(blob, options);
@@ -9052,7 +9360,7 @@ class FS {
 	}
 }
 
-const fs = { FS, ZipDirectoryEntry, ZipFileEntry };
+const fs = { FS: ZipFS, ZipDirectoryEntry, ZipFileEntry };
 
 function getTotalSize(entries, getEntrySize) {
 	let size = 0;
@@ -9196,7 +9504,7 @@ function detach(entry) {
 }
 
 function forwardAbort(signal, abortController) {
-	if (!signal) {
+	if (!checkSignalOption(signal)) {
 		return () => { };
 	}
 	if (signal.aborted) {
@@ -9292,7 +9600,7 @@ function getChildEntryOptions(child, selectedEntry, options) {
 			};
 		}
 	}
-	const entryOptions = Object.assign({}, zipEntryMetadata, options, passThroughOptions, childOptions, { directory: child.directory });
+	const entryOptions = Object.assign({ lastModDate: child.defaultLastModDate }, zipEntryMetadata, options, childOptions, passThroughOptions, { directory: child.directory });
 	if (!child.directory && entryOptions.passThrough && entryOptions.uncompressedSize === UNDEFINED_VALUE) {
 		throw new Error(ERR_INVALID_PASS_THROUGH);
 	}
@@ -9307,11 +9615,22 @@ function getDeterminedSize(child, passThrough) {
 	return child.undeterminedSize ? UNDEFINED_VALUE : getExtractedSize(child, passThrough);
 }
 
+function checkReaderOptions(readerOptions) {
+	if (readerOptions && (typeof readerOptions != OBJECT_TYPE || Array.isArray(readerOptions))) {
+		throw new Error(ERR_INVALID_READER_OPTIONS);
+	}
+	return readerOptions;
+}
+
 function isPassThrough(child, options) {
 	const { readerOptions } = options;
 	return Boolean(!child.directory && (child.passThrough || (readerOptions && readerOptions.passThrough)));
 }
 
+function isImplicitDirectory(child) {
+	return child.directory && child.data === null;
+}
+
 function getUserExtraField(extraField) {
 	if (extraField) {
 		const userExtraField = new Map();
@@ -9329,7 +9648,7 @@ function getUserExtraField(extraField) {
 async function exportZip(zipWriter, entry, totalSize, options, readers) {
 	const { onstart, onprogress, onend, onentryprogress } = options;
 	const selectedEntry = entry;
-	const totalEntries = getTotalSize(entry.children, () => 1);
+	const totalEntries = getTotalSize(entry.children, child => isImplicitDirectory(child) ? 0 : 1);
 	let writtenSize = 0;
 	let writtenEntries = 0;
 	if (onstart) {
@@ -9358,6 +9677,9 @@ async function exportZip(zipWriter, entry, totalSize, options, readers) {
 	}
 
 	async function addChild(child) {
+		if (isImplicitDirectory(child)) {
+			return;
+		}
 		const { name, entryOptions } = getChildEntryOptions(child, selectedEntry, options);
 		let entryWrittenSize = 0;
 		const entryMetadata = await zipWriter.add(name, readers.get(child), Object.assign(entryOptions, {
@@ -9391,7 +9713,7 @@ function addFileSystemHandle(zipEntry, handle, options) {
 				if (handle.kind == "file") {
 					const file = await handle.getFile();
 					addedEntries.push(
-						parentEntry.addData(file.name, {
+						addChild(parentEntry, file.name, {
 							Reader: function () {
 								const readable = file.stream();
 								const size = file.size;
@@ -9425,10 +9747,11 @@ function addFileSystemHandle(zipEntry, handle, options) {
 
 async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 	const { onstart, onprogress, onend } = options;
+	const readerOptions = checkReaderOptions(options.readerOptions);
 	const abortController = new AbortController();
 	const { signal } = abortController;
 	const releaseSignal = forwardAbort(options.signal, abortController);
-	const getDataOptions = Object.assign({}, options, options.readerOptions, {
+	const getDataOptions = Object.assign({}, options, readerOptions, {
 		signal,
 		onstart: UNDEFINED_VALUE,
 		onprogress: UNDEFINED_VALUE,
@@ -9715,7 +10038,7 @@ function decodeMimeTypes(data) {
  */
 
 
-p$1(setDefaultConfiguration);
+a(setDefaultConfiguration);
 
 exports.BlobReader = BlobReader;
 exports.BlobWriter = BlobWriter;
@@ -9728,6 +10051,7 @@ exports.ERR_CENTRAL_DIRECTORY_NOT_FOUND = ERR_CENTRAL_DIRECTORY_NOT_FOUND;
 exports.ERR_DUPLICATED_NAME = ERR_DUPLICATED_NAME;
 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;
 exports.ERR_ENTRY_EXISTS = ERR_ENTRY_EXISTS;
 exports.ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND = ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND;
 exports.ERR_EOCDR_NOT_FOUND = ERR_EOCDR_NOT_FOUND;
@@ -9738,22 +10062,31 @@ exports.ERR_INVALID_AUTHENTICATION_CODE = ERR_INVALID_AUTHENTICATION_CODE;
 exports.ERR_INVALID_CODEC_DEFINITION = ERR_INVALID_CODEC_DEFINITION;
 exports.ERR_INVALID_CODEC_MODULE = ERR_INVALID_CODEC_MODULE;
 exports.ERR_INVALID_COMMENT = ERR_INVALID_COMMENT;
+exports.ERR_INVALID_COMMENT_TYPE = ERR_INVALID_COMMENT_TYPE;
 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_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;
 exports.ERR_INVALID_ENTRY_NAME = ERR_INVALID_ENTRY_NAME;
+exports.ERR_INVALID_EXTRAFIELD = ERR_INVALID_EXTRAFIELD;
 exports.ERR_INVALID_EXTRAFIELD_DATA = ERR_INVALID_EXTRAFIELD_DATA;
+exports.ERR_INVALID_EXTRAFIELD_DATA_TYPE = ERR_INVALID_EXTRAFIELD_DATA_TYPE;
 exports.ERR_INVALID_EXTRAFIELD_TYPE = ERR_INVALID_EXTRAFIELD_TYPE;
 exports.ERR_INVALID_FILENAME_VALIDATION = ERR_INVALID_FILENAME_VALIDATION;
+exports.ERR_INVALID_FUNCTION_OPTION = ERR_INVALID_FUNCTION_OPTION;
 exports.ERR_INVALID_GID = ERR_INVALID_GID;
 exports.ERR_INVALID_LEVEL = ERR_INVALID_LEVEL;
 exports.ERR_INVALID_MAX_APPENDED_DATA_SIZE = ERR_INVALID_MAX_APPENDED_DATA_SIZE;
+exports.ERR_INVALID_MAX_WORKERS = ERR_INVALID_MAX_WORKERS;
 exports.ERR_INVALID_MSDOS_ATTRIBUTES = ERR_INVALID_MSDOS_ATTRIBUTES;
 exports.ERR_INVALID_MSDOS_DATA = ERR_INVALID_MSDOS_DATA;
 exports.ERR_INVALID_PASSWORD = ERR_INVALID_PASSWORD;
 exports.ERR_INVALID_PASSWORD_TYPE = ERR_INVALID_PASSWORD_TYPE;
 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;
@@ -9793,6 +10126,10 @@ exports.TextWriter = TextWriter;
 exports.Uint8ArrayReader = Uint8ArrayReader;
 exports.Uint8ArrayWriter = Uint8ArrayWriter;
 exports.Writer = Writer;
+exports.ZipDirectoryEntry = ZipDirectoryEntry;
+exports.ZipEntry = ZipEntry;
+exports.ZipFS = ZipFS;
+exports.ZipFileEntry = ZipFileEntry;
 exports.ZipReader = ZipReader;
 exports.ZipReaderStream = ZipReaderStream;
 exports.ZipWriter = ZipWriter;