@zip.js/zip.js 2.7.70 → 2.7.72

package/lib/core/constants.js

@@ -45,6 +45,10 @@ const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
 const ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
 const ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 
+const DATA_DESCRIPTOR_RECORD_LENGTH = 12;
+const DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH = 20;
+const DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH = 4;
+
 const EXTRAFIELD_TYPE_ZIP64 = 0x0001;
 const EXTRAFIELD_TYPE_AES = 0x9901;
 const EXTRAFIELD_TYPE_NTFS = 0x000a;
@@ -73,7 +77,7 @@ const VERSION_AES = 0x33;
 
 const DIRECTORY_SIGNATURE = "/";
 
-const HEADER_SIZE = 26;
+const HEADER_SIZE = 30;
 const HEADER_OFFSET_SIGNATURE = 10;
 const HEADER_OFFSET_COMPRESSED_SIZE = 14;
 const HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
@@ -99,6 +103,9 @@ export {
 	END_OF_CENTRAL_DIR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_SIGNATURE,
+	DATA_DESCRIPTOR_RECORD_LENGTH,
+	DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH,
+	DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH,
 	EXTRAFIELD_TYPE_ZIP64,
 	EXTRAFIELD_TYPE_AES,
 	EXTRAFIELD_TYPE_NTFS,

package/lib/core/options.js

@@ -0,0 +1,89 @@
+/*
+ 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_SIGNATURE = "checkSignature";
+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_KEEP_ORDER = "keepOrder";
+const OPTION_LEVEL = "level";
+const OPTION_BUFFERED_WRITE = "bufferedWrite";
+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";
+
+export {
+	OPTION_FILENAME_ENCODING,
+	OPTION_COMMENT_ENCODING,
+	OPTION_DECODE_TEXT,
+	OPTION_EXTRACT_PREPENDED_DATA,
+	OPTION_EXTRACT_APPENDED_DATA,
+	OPTION_PASSWORD,
+	OPTION_RAW_PASSWORD,
+	OPTION_PASS_THROUGH,
+	OPTION_SIGNAL,
+	OPTION_CHECK_PASSWORD_ONLY,
+	OPTION_CHECK_OVERLAPPING_ENTRY_ONLY,
+	OPTION_CHECK_OVERLAPPING_ENTRY,
+	OPTION_CHECK_SIGNATURE,
+	OPTION_USE_WEB_WORKERS,
+	OPTION_USE_COMPRESSION_STREAM,
+	OPTION_TRANSFER_STREAMS,
+	OPTION_PREVENT_CLOSE,
+	OPTION_ENCRYPTION_STRENGTH,
+	OPTION_EXTENDED_TIMESTAMP,
+	OPTION_KEEP_ORDER,
+	OPTION_LEVEL,
+	OPTION_BUFFERED_WRITE,
+	OPTION_DATA_DESCRIPTOR_SIGNATURE,
+	OPTION_USE_UNICODE_FILE_NAMES,
+	OPTION_DATA_DESCRIPTOR,
+	OPTION_SUPPORT_ZIP64_SPLIT_FILE,
+	OPTION_ENCODE_TEXT,
+	OPTION_OFFSET,
+	OPTION_USDZ
+};

package/lib/core/streams/zip-crypto-stream.js

@@ -131,7 +131,7 @@ function createKeys(target, password) {
 	Object.assign(target, {
 		keys,
 		crcKey0: new Crc32(keys[0]),
-		crcKey2: new Crc32(keys[2]),
+		crcKey2: new Crc32(keys[2])
 	});
 	for (let index = 0; index < password.length; index++) {
 		updateKeys(target, password.charCodeAt(index));

package/lib/core/streams/zip-entry-stream.js

@@ -54,7 +54,7 @@ class DeflateStream extends TransformStream {
 		const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level } = options;
 		const stream = this;
 		let crc32Stream, encryptionStream;
-		let readable = filterEmptyChunks(super.readable);
+		let readable = super.readable;
 		if ((!encrypted || zipCrypto) && signed) {
 			crc32Stream = new Crc32Stream();
 			readable = pipeThrough(readable, crc32Stream);
@@ -89,7 +89,7 @@ class InflateStream extends TransformStream {
 		super({});
 		const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream } = options;
 		let crc32Stream, decryptionStream;
-		let readable = filterEmptyChunks(super.readable);
+		let readable = super.readable;
 		if (encrypted) {
 			if (zipCrypto) {
 				readable = pipeThrough(readable, new ZipCryptoDecryptionStream(options));
@@ -125,16 +125,6 @@ export {
 	ERR_ABORT_CHECK_PASSWORD
 };
 
-function filterEmptyChunks(readable) {
-	return pipeThrough(readable, new TransformStream({
-		transform(chunk, controller) {
-			if (chunk && chunk.length) {
-				controller.enqueue(chunk);
-			}
-		}
-	}));
-}
-
 function setReadable(stream, readable, flush) {
 	readable = pipeThrough(readable, new TransformStream({ flush }));
 	Object.defineProperty(stream, "readable", {
@@ -149,16 +139,11 @@ function pipeThroughCommpressionStream(readable, useCompressionStream, options,
 		const CompressionStream = useCompressionStream && CodecStreamNative ? CodecStreamNative : CodecStream;
 		readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options));
 		// eslint-disable-next-line no-unused-vars
-	} catch (_) {
+	} catch (error) {
 		if (useCompressionStream) {
-			try {
-				readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
-				// eslint-disable-next-line no-unused-vars
-			} catch (_) {
-				return readable;
-			}
+			readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
 		} else {
-			return readable;
+			throw error;
 		}
 	}
 	return readable;

package/lib/core/zip-entry.js

@@ -30,8 +30,8 @@ const PROPERTY_NAME_FILENAME = "filename";
 const PROPERTY_NAME_RAW_FILENAME = "rawFilename";
 const PROPERTY_NAME_COMMENT = "comment";
 const PROPERTY_NAME_RAW_COMMENT = "rawComment";
-const PROPERTY_NAME_UNCOMPPRESSED_SIZE = "uncompressedSize";
-const PROPERTY_NAME_COMPPRESSED_SIZE = "compressedSize";
+const PROPERTY_NAME_UNCOMPRESSED_SIZE = "uncompressedSize";
+const PROPERTY_NAME_COMPRESSED_SIZE = "compressedSize";
 const PROPERTY_NAME_OFFSET = "offset";
 const PROPERTY_NAME_DISK_NUMBER_START = "diskNumberStart";
 const PROPERTY_NAME_LAST_MODIFICATION_DATE = "lastModDate";
@@ -52,12 +52,20 @@ const PROPERTY_NAME_VERSION_MADE_BY = "versionMadeBy";
 const PROPERTY_NAME_ZIPCRYPTO = "zipCrypto";
 const PROPERTY_NAME_DIRECTORY = "directory";
 const PROPERTY_NAME_EXECUTABLE = "executable";
+const PROPERTY_NAME_COMPRESSION_METHOD = "compressionMethod";
+const PROPERTY_NAME_SIGNATURE = "signature";
+const PROPERTY_NAME_EXTRA_FIELD = "extraField";
 
 const PROPERTY_NAMES = [
-	PROPERTY_NAME_FILENAME, PROPERTY_NAME_RAW_FILENAME, PROPERTY_NAME_COMPPRESSED_SIZE, PROPERTY_NAME_UNCOMPPRESSED_SIZE,
+	PROPERTY_NAME_FILENAME, PROPERTY_NAME_RAW_FILENAME, PROPERTY_NAME_COMPRESSED_SIZE, PROPERTY_NAME_UNCOMPRESSED_SIZE,
 	PROPERTY_NAME_LAST_MODIFICATION_DATE, PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE, PROPERTY_NAME_COMMENT, PROPERTY_NAME_RAW_COMMENT,
 	PROPERTY_NAME_LAST_ACCESS_DATE, PROPERTY_NAME_CREATION_DATE, PROPERTY_NAME_OFFSET, PROPERTY_NAME_DISK_NUMBER_START,
-	PROPERTY_NAME_DISK_NUMBER_START, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_MS_DOS_COMPATIBLE, PROPERTY_NAME_ZIP64, PROPERTY_NAME_ENCRYPTED, PROPERTY_NAME_VERSION, PROPERTY_NAME_VERSION_MADE_BY, PROPERTY_NAME_ZIPCRYPTO, PROPERTY_NAME_DIRECTORY, PROPERTY_NAME_EXECUTABLE, "bitFlag", "signature", "filenameUTF8", "commentUTF8", "compressionMethod", "extraField", "rawExtraField", "extraFieldZip64", "extraFieldUnicodePath", "extraFieldUnicodeComment", "extraFieldAES", "extraFieldNTFS", "extraFieldExtendedTimestamp"];
+	PROPERTY_NAME_DISK_NUMBER_START, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
+	PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_MS_DOS_COMPATIBLE, PROPERTY_NAME_ZIP64,
+	PROPERTY_NAME_ENCRYPTED, PROPERTY_NAME_VERSION, PROPERTY_NAME_VERSION_MADE_BY, PROPERTY_NAME_ZIPCRYPTO, PROPERTY_NAME_DIRECTORY,
+	PROPERTY_NAME_EXECUTABLE, PROPERTY_NAME_COMPRESSION_METHOD, PROPERTY_NAME_SIGNATURE, PROPERTY_NAME_EXTRA_FIELD,
+	"bitFlag", "filenameUTF8", "commentUTF8", "rawExtraField", "extraFieldZip64", "extraFieldUnicodePath", "extraFieldUnicodeComment",
+	"extraFieldAES", "extraFieldNTFS", "extraFieldExtendedTimestamp"];
 
 class Entry {
 
@@ -72,8 +80,8 @@ export {
 	PROPERTY_NAME_RAW_FILENAME,
 	PROPERTY_NAME_COMMENT,
 	PROPERTY_NAME_RAW_COMMENT,
-	PROPERTY_NAME_UNCOMPPRESSED_SIZE,
-	PROPERTY_NAME_COMPPRESSED_SIZE,
+	PROPERTY_NAME_UNCOMPRESSED_SIZE,
+	PROPERTY_NAME_COMPRESSED_SIZE,
 	PROPERTY_NAME_OFFSET,
 	PROPERTY_NAME_DISK_NUMBER_START,
 	PROPERTY_NAME_LAST_MODIFICATION_DATE,
@@ -94,5 +102,8 @@ export {
 	PROPERTY_NAME_ZIPCRYPTO,
 	PROPERTY_NAME_DIRECTORY,
 	PROPERTY_NAME_EXECUTABLE,
+	PROPERTY_NAME_COMPRESSION_METHOD,
+	PROPERTY_NAME_SIGNATURE,
+	PROPERTY_NAME_EXTRA_FIELD,
 	Entry
 };

package/lib/core/zip-fs-core.js

@@ -874,7 +874,7 @@ async function transformToFileSystemhandles(entry) {
 				next() {
 					const result = {
 						value: entries[entryIndex],
-						done: entryIndex === entries.length
+						done: entryIndex == entries.length
 					};
 					entryIndex++;
 					return result;

package/lib/core/zip-reader.js

@@ -36,6 +36,10 @@ import {
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
 	SPLIT_ZIP_FILE_SIGNATURE,
+	DATA_DESCRIPTOR_RECORD_SIGNATURE,
+	DATA_DESCRIPTOR_RECORD_LENGTH,
+	DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH,
+	DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
 	END_OF_CENTRAL_DIR_SIGNATURE,
@@ -93,8 +97,8 @@ import {
 	PROPERTY_NAME_FILENAME,
 	PROPERTY_NAME_RAW_COMMENT,
 	PROPERTY_NAME_COMMENT,
-	PROPERTY_NAME_UNCOMPPRESSED_SIZE,
-	PROPERTY_NAME_COMPPRESSED_SIZE,
+	PROPERTY_NAME_UNCOMPRESSED_SIZE,
+	PROPERTY_NAME_COMPRESSED_SIZE,
 	PROPERTY_NAME_OFFSET,
 	PROPERTY_NAME_DISK_NUMBER_START,
 	PROPERTY_NAME_LAST_MODIFICATION_DATE,
@@ -105,6 +109,25 @@ import {
 	PROPERTY_NAME_RAW_CREATION_DATE,
 	Entry
 } from "./zip-entry.js";
+import {
+	OPTION_FILENAME_ENCODING,
+	OPTION_COMMENT_ENCODING,
+	OPTION_DECODE_TEXT,
+	OPTION_EXTRACT_PREPENDED_DATA,
+	OPTION_EXTRACT_APPENDED_DATA,
+	OPTION_PASSWORD,
+	OPTION_RAW_PASSWORD,
+	OPTION_PASS_THROUGH,
+	OPTION_SIGNAL,
+	OPTION_CHECK_PASSWORD_ONLY,
+	OPTION_CHECK_OVERLAPPING_ENTRY_ONLY,
+	OPTION_CHECK_OVERLAPPING_ENTRY,
+	OPTION_CHECK_SIGNATURE,
+	OPTION_USE_WEB_WORKERS,
+	OPTION_USE_COMPRESSION_STREAM,
+	OPTION_TRANSFER_STREAMS,
+	OPTION_PREVENT_CLOSE
+} from "./options.js";
 
 const ERR_BAD_FORMAT = "File format is not recognized";
 const ERR_EOCDR_NOT_FOUND = "End of central directory not found";
@@ -116,11 +139,12 @@ const ERR_ENCRYPTED = "File contains encrypted entry";
 const ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
 const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 const ERR_SPLIT_ZIP_FILE = "Split zip file";
+const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
 const CHARSET_UTF8 = "utf-8";
 const CHARSET_CP437 = "cp437";
 const ZIP64_PROPERTIES = [
-	[PROPERTY_NAME_UNCOMPPRESSED_SIZE, MAX_32_BITS],
-	[PROPERTY_NAME_COMPPRESSED_SIZE, MAX_32_BITS],
+	[PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
+	[PROPERTY_NAME_COMPRESSED_SIZE, MAX_32_BITS],
 	[PROPERTY_NAME_OFFSET, MAX_32_BITS],
 	[PROPERTY_NAME_DISK_NUMBER_START, MAX_16_BITS]
 ];
@@ -141,7 +165,8 @@ class ZipReader {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
 			options,
-			config: getConfiguration()
+			config: getConfiguration(),
+			readRanges: []
 		});
 	}
 
@@ -191,7 +216,9 @@ class ZipReader {
 				if (getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset) {
 					const originalDirectoryDataOffset = directoryDataOffset;
 					directoryDataOffset = expectedDirectoryDataOffset;
-					prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
+					if (directoryDataOffset > originalDirectoryDataOffset) {
+						prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
+					}
 					endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
 					endOfDirectoryView = getDataView(endOfDirectoryArray);
 				}
@@ -231,7 +258,9 @@ class ZipReader {
 			if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset) {
 				const originalDirectoryDataOffset = directoryDataOffset;
 				directoryDataOffset = expectedDirectoryDataOffset;
-				prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
+				if (directoryDataOffset > originalDirectoryDataOffset) {
+					prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
+				}
 				directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
 				directoryView = getDataView(directoryArray);
 			}
@@ -245,8 +274,8 @@ class ZipReader {
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
-		const filenameEncoding = getOptionValue(zipReader, options, "filenameEncoding");
-		const commentEncoding = getOptionValue(zipReader, options, "commentEncoding");
+		const filenameEncoding = getOptionValue(zipReader, options, OPTION_FILENAME_ENCODING);
+		const commentEncoding = getOptionValue(zipReader, options, OPTION_COMMENT_ENCODING);
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 			const fileEntry = new ZipEntry(reader, config, zipReader.options);
 			if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
@@ -292,7 +321,7 @@ class ZipReader {
 			});
 			fileEntry.internalFileAttribute = fileEntry.internalFileAttributes;
 			fileEntry.externalFileAttribute = fileEntry.externalFileAttributes;
-			const decode = getOptionValue(zipReader, options, "decodeText") || decodeText;
+			const decode = getOptionValue(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);
@@ -313,12 +342,12 @@ class ZipReader {
 			readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
 			fileEntry.zipCrypto = fileEntry.encrypted && !fileEntry.extraFieldAES;
 			const entry = new Entry(fileEntry);
-			entry.getData = (writer, options) => fileEntry.getData(writer, entry, options);
+			entry.getData = (writer, options) => fileEntry.getData(writer, entry, zipReader.readRanges, options);
 			entry.arrayBuffer = async options => {
 				const writer = new TransformStream();
 				const [arrayBuffer] = await Promise.all([
 					new Response(writer.readable).arrayBuffer(),
-					fileEntry.getData(writer, entry, options)]);
+					fileEntry.getData(writer, entry, zipReader.readRanges, options)]);
 				return arrayBuffer;
 			};
 			offset = endOffset;
@@ -333,8 +362,8 @@ class ZipReader {
 			}
 			yield entry;
 		}
-		const extractPrependedData = getOptionValue(zipReader, options, "extractPrependedData");
-		const extractAppendedData = getOptionValue(zipReader, options, "extractAppendedData");
+		const extractPrependedData = getOptionValue(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
+		const extractAppendedData = getOptionValue(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
 		if (extractPrependedData) {
 			zipReader.prependedData = startOffset > 0 ? await readUint8Array(reader, 0, startOffset) : new Uint8Array();
 		}
@@ -400,7 +429,8 @@ export {
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
-	ERR_SPLIT_ZIP_FILE
+	ERR_SPLIT_ZIP_FILE,
+	ERR_OVERLAPPING_ENTRY
 };
 
 class ZipEntry {
@@ -413,13 +443,14 @@ class ZipEntry {
 		});
 	}
 
-	async getData(writer, fileEntry, options = {}) {
+	async getData(writer, fileEntry, readRanges, options = {}) {
 		const zipEntry = this;
 		const {
 			reader,
 			offset,
 			diskNumberStart,
 			extraFieldAES,
+			extraFieldZip64,
 			compressionMethod,
 			config,
 			bitFlag,
@@ -428,13 +459,15 @@ class ZipEntry {
 			uncompressedSize,
 			compressedSize
 		} = zipEntry;
+		const {
+			dataDescriptor
+		} = bitFlag;
 		const localDirectory = fileEntry.localDirectory = {};
-		const dataArraySize = HEADER_SIZE + 4;
-		const dataArray = await readUint8Array(reader, offset, dataArraySize + 4, diskNumberStart);
+		const dataArray = await readUint8Array(reader, offset, HEADER_SIZE, diskNumberStart);
 		const dataView = getDataView(dataArray);
-		let password = getOptionValue(zipEntry, options, "password");
-		let rawPassword = getOptionValue(zipEntry, options, "rawPassword");
-		const passThrough = getOptionValue(zipEntry, options, "passThrough");
+		let password = getOptionValue(zipEntry, options, OPTION_PASSWORD);
+		let rawPassword = getOptionValue(zipEntry, options, OPTION_RAW_PASSWORD);
+		const passThrough = getOptionValue(zipEntry, options, OPTION_PASS_THROUGH);
 		password = password && password.length && password;
 		rawPassword = rawPassword && rawPassword.length && rawPassword;
 		if (extraFieldAES) {
@@ -449,14 +482,17 @@ class ZipEntry {
 			throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
 		}
 		readCommonHeader(localDirectory, dataView, 4);
-		localDirectory.rawExtraField = localDirectory.extraFieldLength ?
-			await readUint8Array(reader, offset + dataArraySize + localDirectory.filenameLength, localDirectory.extraFieldLength, diskNumberStart) :
+		const {
+			extraFieldLength,
+			filenameLength,
+			lastAccessDate,
+			creationDate
+		} = localDirectory;
+		localDirectory.rawExtraField = extraFieldLength ?
+			await readUint8Array(reader, offset + HEADER_SIZE + filenameLength, extraFieldLength, diskNumberStart) :
 			new Uint8Array();
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-		Object.assign(fileEntry, {
-			lastAccessDate: localDirectory.lastAccessDate,
-			creationDate: localDirectory.creationDate
-		});
+		Object.assign(fileEntry, { lastAccessDate, creationDate });
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (!passThrough) {
@@ -469,7 +505,7 @@ class ZipEntry {
 				throw new Error(ERR_ENCRYPTED);
 			}
 		}
-		const dataOffset = offset + dataArraySize + localDirectory.filenameLength + localDirectory.extraFieldLength;
+		const dataOffset = offset + HEADER_SIZE + filenameLength + extraFieldLength;
 		const size = compressedSize;
 		const readable = reader.readable;
 		Object.assign(readable, {
@@ -477,14 +513,13 @@ class ZipEntry {
 			offset: dataOffset,
 			size
 		});
-		const signal = getOptionValue(zipEntry, options, "signal");
-		const checkPasswordOnly = getOptionValue(zipEntry, options, "checkPasswordOnly");
-		if (checkPasswordOnly) {
-			writer = new WritableStream();
-		}
-		writer = new GenericWriter(writer);
-		await initStream(writer, passThrough ? compressedSize : uncompressedSize);
-		const { writable } = writer;
+		const signal = getOptionValue(zipEntry, options, OPTION_SIGNAL);
+		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
+		let checkOverlappingEntry = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
+		const checkOverlappingEntryOnly = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY_ONLY);
+		if (checkOverlappingEntryOnly) {
+			checkOverlappingEntry = true;
+		}
 		const { onstart, onprogress, onend } = options;
 		const workerOptions = {
 			options: {
@@ -493,23 +528,50 @@ class ZipEntry {
 				rawPassword,
 				zipCrypto,
 				encryptionStrength: extraFieldAES && extraFieldAES.strength,
-				signed: getOptionValue(zipEntry, options, "checkSignature") && !passThrough,
-				passwordVerification: zipCrypto && (bitFlag.dataDescriptor ? ((rawLastModDate >>> 8) & 0xFF) : ((signature >>> 24) & 0xFF)),
+				signed: getOptionValue(zipEntry, options, OPTION_CHECK_SIGNATURE) && !passThrough,
+				passwordVerification: zipCrypto && (dataDescriptor ? ((rawLastModDate >>> 8) & 0xFF) : ((signature >>> 24) & 0xFF)),
 				outputSize: uncompressedSize,
 				signature,
 				compressed: compressionMethod != 0 && !passThrough,
 				encrypted: zipEntry.encrypted && !passThrough,
-				useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
-				useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream"),
-				transferStreams: getOptionValue(zipEntry, options, "transferStreams"),
+				useWebWorkers: getOptionValue(zipEntry, options, OPTION_USE_WEB_WORKERS),
+				useCompressionStream: getOptionValue(zipEntry, options, OPTION_USE_COMPRESSION_STREAM),
+				transferStreams: getOptionValue(zipEntry, options, OPTION_TRANSFER_STREAMS),
 				checkPasswordOnly
 			},
 			config,
 			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
+		if (checkOverlappingEntry) {
+			await detectOverlappingEntry({
+				reader,
+				fileEntry,
+				offset,
+				diskNumberStart,
+				signature,
+				compressedSize,
+				uncompressedSize,
+				dataOffset,
+				dataDescriptor: dataDescriptor || localDirectory.bitFlag.dataDescriptor,
+				extraFieldZip64: extraFieldZip64 || localDirectory.extraFieldZip64,
+				readRanges
+			});
+		}
+		let writable;
 		try {
-			const { outputSize } = await runWorker({ readable, writable }, workerOptions);
-			writer.size += outputSize;
+			if (!checkOverlappingEntryOnly) {
+				if (checkPasswordOnly) {
+					writer = new WritableStream();
+				}
+				writer = new GenericWriter(writer);
+				await initStream(writer, passThrough ? compressedSize : uncompressedSize);
+				({ writable } = writer);
+				const { outputSize } = await runWorker({ readable, writable }, workerOptions);
+				writer.size += outputSize;
+				if (outputSize != (passThrough ? compressedSize : uncompressedSize)) {
+					throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
+				}
+			}
 		} catch (error) {
 			if (error.outputSize !== UNDEFINED_VALUE) {
 				writer.size += error.outputSize;
@@ -518,12 +580,12 @@ class ZipEntry {
 				throw error;
 			}
 		} finally {
-			const preventClose = getOptionValue(zipEntry, options, "preventClose");
-			if (!preventClose && !writable.locked) {
+			const preventClose = getOptionValue(zipEntry, options, OPTION_PREVENT_CLOSE);
+			if (!preventClose && writable && !writable.locked) {
 				await writable.getWriter().close();
 			}
 		}
-		return checkPasswordOnly ? UNDEFINED_VALUE : writer.getData ? writer.getData() : writable;
+		return checkPasswordOnly || checkOverlappingEntryOnly ? UNDEFINED_VALUE : writer.getData ? writer.getData() : writable;
 	}
 }
 
@@ -731,6 +793,71 @@ function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory,
 	});
 }
 
+async function detectOverlappingEntry({
+	reader,
+	fileEntry,
+	offset,
+	diskNumberStart,
+	signature,
+	compressedSize,
+	uncompressedSize,
+	dataOffset,
+	dataDescriptor,
+	extraFieldZip64,
+	readRanges
+}) {
+	let diskOffset = 0;
+	if (diskNumberStart) {
+		for (let indexReader = 0; indexReader < diskNumberStart; indexReader++) {
+			const diskReader = reader.readers[indexReader];
+			diskOffset += diskReader.size;
+		}
+	}
+	let dataDescriptorLength = 0;
+	if (dataDescriptor) {
+		if (extraFieldZip64) {
+			dataDescriptorLength = DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH;
+		} else {
+			dataDescriptorLength = DATA_DESCRIPTOR_RECORD_LENGTH;
+		}
+	}
+	if (dataDescriptorLength) {
+		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, diskNumberStart);
+		const dataDescriptorSignature = getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
+		if (dataDescriptorSignature) {
+			const readSignature = 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 matchSignature = (fileEntry.encrypted && !fileEntry.zipCrypto) || readSignature == signature;
+			if (matchSignature &&
+				readCompressedSize == compressedSize &&
+				readUncompressedSize == uncompressedSize) {
+				dataDescriptorLength += DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+			}
+		}
+	}
+	const range = {
+		start: diskOffset + offset,
+		end: diskOffset + dataOffset + compressedSize + dataDescriptorLength,
+		fileEntry
+	};
+	for (const otherRange of readRanges) {
+		if (otherRange.fileEntry != fileEntry && range.start >= otherRange.start && range.start < otherRange.end) {
+			const error = new Error(ERR_OVERLAPPING_ENTRY);
+			error.overlappingEntry = otherRange.fileEntry;
+			throw error;
+		}
+	}
+	readRanges.push(range);
+}
+
 async function seekSignature(reader, signature, startOffset, minimumBytes, maximumLength) {
 	const signatureArray = new Uint8Array(4);
 	const signatureView = getDataView(signatureArray);