@zip.js/zip.js 2.7.69 → 2.7.71

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,
@@ -76,6 +80,7 @@ import {
 	CODEC_INFLATE,
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD,
+	ERR_INVALID_UNCOMPRESSED_SIZE,
 	ERR_ABORT_CHECK_PASSWORD
 } from "./codec-pool.js";
 import {
@@ -92,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,
@@ -104,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";
@@ -115,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]
 ];
@@ -140,7 +165,8 @@ class ZipReader {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
 			options,
-			config: getConfiguration()
+			config: getConfiguration(),
+			readRanges: []
 		});
 	}
 
@@ -190,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);
 				}
@@ -230,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);
 			}
@@ -244,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) {
@@ -291,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);
@@ -312,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;
@@ -332,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();
 		}
@@ -398,7 +428,9 @@ export {
 	ERR_UNSUPPORTED_COMPRESSION,
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD,
-	ERR_SPLIT_ZIP_FILE
+	ERR_INVALID_UNCOMPRESSED_SIZE,
+	ERR_SPLIT_ZIP_FILE,
+	ERR_OVERLAPPING_ENTRY
 };
 
 class ZipEntry {
@@ -411,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,
@@ -426,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) {
@@ -447,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) {
@@ -467,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, {
@@ -475,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: {
@@ -491,22 +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;
@@ -515,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;
 	}
 }
 
@@ -728,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);

package/lib/core/zip-writer.js

@@ -43,6 +43,9 @@ import {
 	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_AES,
 	EXTRAFIELD_TYPE_ZIP64,
 	EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP,
@@ -105,8 +108,34 @@ import {
 	PROPERTY_NAME_ZIPCRYPTO,
 	PROPERTY_NAME_DIRECTORY,
 	PROPERTY_NAME_EXECUTABLE,
+	PROPERTY_NAME_COMPRESSION_METHOD,
+	PROPERTY_NAME_SIGNATURE,
+	PROPERTY_NAME_COMMENT,
+	PROPERTY_NAME_UNCOMPRESSED_SIZE,
+	PROPERTY_NAME_EXTRA_FIELD,
 	Entry
 } from "./zip-entry.js";
+import {
+	OPTION_PASSWORD,
+	OPTION_RAW_PASSWORD,
+	OPTION_PASS_THROUGH,
+	OPTION_SIGNAL,
+	OPTION_USE_WEB_WORKERS,
+	OPTION_USE_COMPRESSION_STREAM,
+	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
+} from "./options.js";
 import {
 	ZipReader
 } from "./zip-reader.js";
@@ -142,7 +171,7 @@ class ZipWriter {
 			config: getConfiguration(),
 			files: new Map(),
 			filenames: new Set(),
-			offset: options.offset === UNDEFINED_VALUE ? writer.size || writer.writable.size || 0 : options.offset,
+			offset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? writer.size || writer.writable.size || 0 : options[OPTION_OFFSET],
 			pendingEntriesSize: 0,
 			pendingAddFileCalls: new Set(),
 			bufferedWrites: 0
@@ -181,7 +210,7 @@ class ZipWriter {
 				rawExtraFieldAES,
 				rawExtraFieldExtendedTimestamp,
 				rawExtraFieldNTFS,
-				rawExtraField,
+				rawExtraField
 			} = entry;
 			const { level, languageEncodingFlag, dataDescriptor } = bitFlag;
 			rawExtraFieldZip64 = rawExtraFieldZip64 || new Uint8Array();
@@ -285,7 +314,7 @@ class ZipWriter {
 			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
 		await closeFile(this, comment, options);
-		const preventClose = getOptionValue(zipWriter, options, "preventClose");
+		const preventClose = getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
 		if (!preventClose) {
 			await writable.getWriter().close();
 		}
@@ -348,8 +377,8 @@ async function addFile(zipWriter, name, reader, options) {
 	if (externalFileAttributes === 0) {
 		externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTE, 0);
 	}
-	if (!options.directory && name.endsWith(DIRECTORY_SIGNATURE)) {
-		options.directory = true;
+	if (!options[PROPERTY_NAME_DIRECTORY] && name.endsWith(DIRECTORY_SIGNATURE)) {
+		options[PROPERTY_NAME_DIRECTORY] = true;
 	}
 	const directory = getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY);
 	if (directory) {
@@ -369,7 +398,7 @@ async function addFile(zipWriter, name, reader, options) {
 			externalFileAttributes = FILE_ATTR_UNIX_DEFAULT_MASK << 16;
 		}
 	}
-	const encode = getOptionValue(zipWriter, options, "encodeText", encodeText);
+	const encode = getOptionValue(zipWriter, options, OPTION_ENCODE_TEXT, encodeText);
 	let rawFilename = encode(name);
 	if (rawFilename === UNDEFINED_VALUE) {
 		rawFilename = encodeText(name);
@@ -377,7 +406,7 @@ async function addFile(zipWriter, name, reader, options) {
 	if (getLength(rawFilename) > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_ENTRY_NAME);
 	}
-	const comment = options.comment || "";
+	const comment = options[PROPERTY_NAME_COMMENT] || "";
 	let rawComment = encode(comment);
 	if (rawComment === UNDEFINED_VALUE) {
 		rawComment = encodeText(comment);
@@ -396,25 +425,25 @@ async function addFile(zipWriter, name, reader, options) {
 	if (internalFileAttributes === 0) {
 		internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTE, 0);
 	}
-	const passThrough = getOptionValue(zipWriter, options, "passThrough");
+	const passThrough = getOptionValue(zipWriter, options, OPTION_PASS_THROUGH);
 	let password, rawPassword;
 	if (!passThrough) {
-		password = getOptionValue(zipWriter, options, "password");
-		rawPassword = getOptionValue(zipWriter, options, "rawPassword");
+		password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
+		rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
 	}
-	const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength", 3);
+	const encryptionStrength = getOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 	const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
-	const extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp", true);
-	const keepOrder = getOptionValue(zipWriter, options, "keepOrder", true);
-	const level = getOptionValue(zipWriter, options, "level");
-	const useWebWorkers = getOptionValue(zipWriter, options, "useWebWorkers");
-	const bufferedWrite = getOptionValue(zipWriter, options, "bufferedWrite");
-	const dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature", false);
-	const signal = getOptionValue(zipWriter, options, "signal");
-	const useUnicodeFileNames = getOptionValue(zipWriter, options, "useUnicodeFileNames", true);
-	const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
-	const compressionMethod = getOptionValue(zipWriter, options, "compressionMethod");
-	let dataDescriptor = getOptionValue(zipWriter, options, "dataDescriptor");
+	const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
+	const keepOrder = getOptionValue(zipWriter, options, OPTION_KEEP_ORDER, true);
+	const level = getOptionValue(zipWriter, options, OPTION_LEVEL);
+	const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
+	const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
+	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, false);
+	const signal = getOptionValue(zipWriter, options, OPTION_SIGNAL);
+	const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
+	const useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
+	const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
+	let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
 	if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
 		dataDescriptor = false;
 	}
@@ -426,7 +455,7 @@ async function addFile(zipWriter, name, reader, options) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
 	let rawExtraField = new Uint8Array();
-	const { extraField } = options;
+	const extraField = options[PROPERTY_NAME_EXTRA_FIELD];
 	if (extraField) {
 		let extraFieldSize = 0;
 		let offset = 0;
@@ -449,7 +478,7 @@ async function addFile(zipWriter, name, reader, options) {
 	let maximumEntrySize = 0;
 	let uncompressedSize = 0;
 	if (passThrough) {
-		({ uncompressedSize } = options);
+		uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 		if (uncompressedSize === UNDEFINED_VALUE) {
 			throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
 		}
@@ -478,7 +507,7 @@ async function addFile(zipWriter, name, reader, options) {
 	const zip64UncompressedSize = zip64Enabled || uncompressedSize > MAX_32_BITS;
 	const zip64CompressedSize = zip64Enabled || maximumCompressedSize > MAX_32_BITS;
 	const zip64Offset = zip64Enabled || zipWriter.offset + zipWriter.pendingEntriesSize - diskOffset > MAX_32_BITS;
-	const supportZip64SplitFile = getOptionValue(zipWriter, options, "supportZip64SplitFile", true);
+	const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 	const zip64DiskNumberStart = (supportZip64SplitFile && zip64Enabled) || diskNumber + Math.ceil(zipWriter.pendingEntriesSize / maxSize) > MAX_16_BITS;
 	if (zip64Offset || zip64UncompressedSize || zip64CompressedSize || zip64DiskNumberStart) {
 		if (zip64 === false || !keepOrder) {
@@ -489,7 +518,6 @@ async function addFile(zipWriter, name, reader, options) {
 	}
 	zip64 = zip64 || false;
 	const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
-	const { signature } = options;
 	options = Object.assign({}, options, {
 		rawFilename,
 		rawComment,
@@ -525,17 +553,17 @@ async function addFile(zipWriter, name, reader, options) {
 		useCompressionStream,
 		passThrough,
 		encrypted: Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted),
-		signature,
+		signature: options[PROPERTY_NAME_SIGNATURE],
 		compressionMethod,
 		uncompressedSize,
 		offset: zipWriter.offset - diskOffset,
-		diskNumberStart: diskNumber,
+		diskNumberStart: diskNumber
 	});
 	const headerInfo = getHeaderInfo(options);
 	const dataDescriptorInfo = getDataDescriptorInfo(options);
 	const metadataSize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray);
 	maximumEntrySize = metadataSize + maximumCompressedSize;
-	if (zipWriter.options.usdz) {
+	if (zipWriter.options[OPTION_USDZ]) {
 		maximumEntrySize += maximumEntrySize + 64;
 	}
 	zipWriter.pendingEntriesSize += maximumEntrySize;
@@ -562,7 +590,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	const {
 		headerInfo
 	} = entryInfo;
-	const { usdz } = zipWriter.options;
+	const usdz = zipWriter.options[OPTION_USDZ];
 	const previousFileEntry = Array.from(files.values()).pop();
 	let fileEntry = {};
 	let bufferedWrite;
@@ -1008,7 +1036,7 @@ function getHeaderInfo(options) {
 		zip64UncompressedSize,
 		extraFieldLength
 	});
-	let localHeaderOffset = HEADER_SIZE + 4;
+	let localHeaderOffset = HEADER_SIZE;
 	const localHeaderArray = new Uint8Array(localHeaderOffset + getLength(rawFilename) + extraFieldLength);
 	const localHeaderView = getDataView(localHeaderArray);
 	setUint32(localHeaderView, 0, LOCAL_FILE_HEADER_SIGNATURE);
@@ -1079,11 +1107,15 @@ function getDataDescriptorInfo({
 }) {
 	let dataDescriptorArray = new Uint8Array();
 	let dataDescriptorView, dataDescriptorOffset = 0;
+	let dataDescriptorLength = zip64 ? DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH : DATA_DESCRIPTOR_RECORD_LENGTH;
+	if (dataDescriptorSignature) {
+		dataDescriptorLength += DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+	}
 	if (dataDescriptor) {
-		dataDescriptorArray = new Uint8Array(zip64 ? (dataDescriptorSignature ? 24 : 20) : (dataDescriptorSignature ? 16 : 12));
+		dataDescriptorArray = new Uint8Array(dataDescriptorLength);
 		dataDescriptorView = getDataView(dataDescriptorArray);
 		if (dataDescriptorSignature) {
-			dataDescriptorOffset = 4;
+			dataDescriptorOffset = DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
 			setUint32(dataDescriptorView, 0, DATA_DESCRIPTOR_RECORD_SIGNATURE);
 		}
 	}
@@ -1160,7 +1192,7 @@ function updateLocalHeader({
 	}
 	if (zip64) {
 		if (localExtraFieldZip64Length) {
-			let localHeaderOffset = HEADER_SIZE + 4 + getLength(rawFilename) + 4;
+			let localHeaderOffset = HEADER_SIZE + getLength(rawFilename) + 4;
 			if (zip64UncompressedSize) {
 				setBigUint64(localHeaderView, localHeaderOffset, BigInt(uncompressedSize));
 				localHeaderOffset += 8;
@@ -1290,7 +1322,7 @@ async function closeFile(zipWriter, comment, options) {
 			setUint32(headerView, HEADER_OFFSET_COMPRESSED_SIZE, compressedSize);
 		}
 		arraySet(directoryArray, headerArray, offset + 6);
-		let directoryOffset = offset + HEADER_SIZE + 4;
+		let directoryOffset = offset + HEADER_SIZE;
 		setUint16(directoryView, directoryOffset, extraFieldLength);
 		directoryOffset += 2;
 		setUint16(directoryView, directoryOffset, getLength(rawComment));
@@ -1364,7 +1396,7 @@ async function closeFile(zipWriter, comment, options) {
 		setUint32(endOfdirectoryView, 56, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
 		setBigUint64(endOfdirectoryView, 64, BigInt(directoryOffset) + BigInt(directoryDataLength));
 		setUint32(endOfdirectoryView, 72, lastDiskNumber + 1);
-		const supportZip64SplitFile = getOptionValue(zipWriter, options, "supportZip64SplitFile", true);
+		const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 		if (supportZip64SplitFile) {
 			lastDiskNumber = MAX_16_BITS;
 			diskNumber = MAX_16_BITS;
@@ -1464,7 +1496,7 @@ function getHeaderArrayData({
 	zip64UncompressedSize,
 	extraFieldLength
 }) {
-	const headerArray = new Uint8Array(HEADER_SIZE);
+	const headerArray = new Uint8Array(HEADER_SIZE - 4);
 	const headerView = getDataView(headerArray);
 	setUint16(headerView, 0, version);
 	setUint16(headerView, 2, bitFlag);