@zip.js/zip.js 2.6.32 → 2.6.34

package/lib/core/zip-reader.js

@@ -27,6 +27,7 @@
  */
 
 /* global BigInt, Response, ReadableStream, WritableStream */
+// deno-lint-ignore-file no-this-alias
 
 import {
 	MAX_32_BITS,
@@ -34,6 +35,7 @@ import {
 	COMPRESSION_METHOD_DEFLATE,
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
+	SPLIT_ZIP_FILE_SIGNATURE,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
 	END_OF_CENTRAL_DIR_SIGNATURE,
@@ -54,7 +56,8 @@ import {
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
 	FILE_ATTR_MSDOS_DIR_MASK,
-	DIRECTORY_SIGNATURE
+	DIRECTORY_SIGNATURE,
+	UNDEFINED_VALUE
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -76,7 +79,6 @@ import { decodeText } from "./util/decode-text.js";
 import { Crc32 } from "./streams/codecs/crc32.js";
 import { Entry } from "./zip-entry.js";
 
-const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
 const ERR_BAD_FORMAT = "File format is not recognized";
 const ERR_EOCDR_NOT_FOUND = "End of central directory not found";
 const ERR_EOCDR_ZIP64_NOT_FOUND = "End of Zip64 central directory not found";
@@ -127,7 +129,7 @@ class ZipReader {
 		let { reader } = zipReader;
 		const { config } = zipReader;
 		await initStream(reader);
-		if (reader.size === undefined || !reader.readUint8Array) {
+		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
 			if (Array.isArray(reader)) {
 				reader = new SplitZipReader(reader);
 			} else {
@@ -149,15 +151,16 @@ class ZipReader {
 				throw new Error(ERR_EOCDR_NOT_FOUND);
 			}
 		}
-		const { lastDiskNumber } = reader;
 		const endOfDirectoryView = getDataView(endOfDirectoryInfo);
 		let directoryDataLength = getUint32(endOfDirectoryView, 12);
 		let directoryDataOffset = getUint32(endOfDirectoryView, 16);
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
-		let diskNumber = getUint16(endOfDirectoryView, 4);
-		if (lastDiskNumber !== undefined && diskNumber != lastDiskNumber) {
+		const lastDiskNumber = getUint16(endOfDirectoryView, 4);
+		const expectedLastDiskNumber = reader.lastDiskNumber || 0;
+		let diskNumber = getUint16(endOfDirectoryView, 6);
+		if (expectedLastDiskNumber != lastDiskNumber) {
 			throw new Error(ERR_SPLIT_ZIP_FILE);
 		}
 		let filesLength = getUint16(endOfDirectoryView, 8);
@@ -343,7 +346,7 @@ class ZipEntry {
 			compressedSize
 		} = zipEntry;
 		const localDirectory = zipEntry.localDirectory = {};
-		let dataArray = await readUint8Array(reader, offset, 30, diskNumberStart);
+		const dataArray = await readUint8Array(reader, offset, 30, diskNumberStart);
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, "password");
 		password = password && password.length && password;
@@ -359,8 +362,9 @@ class ZipEntry {
 			throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
 		}
 		readCommonHeader(localDirectory, dataView, 4);
-		dataArray = await readUint8Array(reader, offset, 30 + localDirectory.filenameLength + localDirectory.extraFieldLength, diskNumberStart);
-		localDirectory.rawExtraField = dataArray.subarray(30 + localDirectory.filenameLength);
+		localDirectory.rawExtraField = localDirectory.extraFieldLength ?
+			await readUint8Array(reader, offset + 30 + localDirectory.filenameLength, localDirectory.extraFieldLength, diskNumberStart) :
+			new Uint8Array();
 		await readCommonFooter(zipEntry, localDirectory, dataView, 4);
 		Object.assign(fileEntry, {
 			lastAccessDate: localDirectory.lastAccessDate,
@@ -369,7 +373,7 @@ class ZipEntry {
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (encrypted) {
-			if (!zipCrypto && extraFieldAES.strength === undefined) {
+			if (!zipCrypto && extraFieldAES.strength === UNDEFINED_VALUE) {
 				throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
 			} else if (!password) {
 				throw new Error(ERR_ENCRYPTED);
@@ -386,7 +390,7 @@ class ZipEntry {
 			};
 		}
 		const { writable } = writer;
-		if (writable.size === undefined) {
+		if (writable.size === UNDEFINED_VALUE) {
 			writable.size = 0;
 		}
 		const signal = getOptionValue(zipEntry, options, "signal");
@@ -634,7 +638,7 @@ async function seekSignature(reader, signature, startOffset, minimumBytes, maxim
 }
 
 function getOptionValue(zipReader, options, name) {
-	return options[name] === undefined ? zipReader.options[name] : options[name];
+	return options[name] === UNDEFINED_VALUE ? zipReader.options[name] : options[name];
 }
 
 function getDate(timeRaw) {

package/lib/core/zip-writer.js

@@ -27,6 +27,7 @@
  */
 
 /* global BigInt, ReadableStream, WritableStream */
+// deno-lint-ignore-file no-this-alias
 
 import {
 	MAX_32_BITS,
@@ -34,19 +35,21 @@ import {
 	COMPRESSION_METHOD_DEFLATE,
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
+	SPLIT_ZIP_FILE_SIGNATURE,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
 	END_OF_CENTRAL_DIR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_SIGNATURE,
-	ZIP64_TOTAL_NUMBER_OF_DISKS,
 	EXTRAFIELD_TYPE_AES,
 	EXTRAFIELD_TYPE_ZIP64,
 	EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP,
 	EXTRAFIELD_TYPE_NTFS,
 	EXTRAFIELD_TYPE_NTFS_TAG1,
 	END_OF_CENTRAL_DIR_LENGTH,
+	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
+	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH,
 	BITFLAG_ENCRYPTED,
 	BITFLAG_DATA_DESCRIPTOR,
@@ -57,7 +60,9 @@ import {
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
-	MAX_DATE
+	MAX_DATE,
+	UNDEFINED_VALUE,
+	FUNCTION_TYPE
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -69,7 +74,8 @@ import {
 } from "./codec-pool.js";
 import {
 	initStream,
-	BlobWriter
+	BlobWriter,
+	SplitZipWriter
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
 import { Entry } from "./zip-entry.js";
@@ -85,7 +91,7 @@ const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
 const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (make sure 'keepOrder' is set to 'true')";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
-const EXTRAFIELD_LENGTH_ZIP64 = 24;
+const EXTRAFIELD_LENGTH_ZIP64 = 28;
 
 let workers = 0;
 const pendingEntries = [];
@@ -93,14 +99,26 @@ const pendingEntries = [];
 class ZipWriter {
 
 	constructor(writer, options = {}) {
+		if (writer.writable === UNDEFINED_VALUE && typeof writer.next == FUNCTION_TYPE) {
+			writer = new SplitZipWriter(writer);
+		}
 		if (writer instanceof WritableStream) {
 			writer = { writable: writer };
 		}
-		if (writer.writable.size === undefined) {
+		if (writer.writable.size === UNDEFINED_VALUE) {
 			writer.writable.size = 0;
 		}
+		const splitZipFile = writer instanceof SplitZipWriter;
+		if (!splitZipFile) {
+			Object.assign(writer, {
+				diskNumber: 0,
+				diskOffset: 0,
+				availableSize: Infinity
+			});
+		}
 		Object.assign(this, {
 			writer,
+			addSplitZipSignature: splitZipFile,
 			options,
 			config: getConfiguration(),
 			files: new Map(),
@@ -203,7 +221,7 @@ async function addFile(zipWriter, name, reader, options) {
 	const password = getOptionValue(zipWriter, options, "password");
 	const encryptionStrength = getOptionValue(zipWriter, options, "encryptionStrength") || 3;
 	const zipCrypto = getOptionValue(zipWriter, options, "zipCrypto");
-	if (password !== undefined && encryptionStrength !== undefined && (encryptionStrength < 1 || encryptionStrength > 3)) {
+	if (password !== UNDEFINED_VALUE && encryptionStrength !== UNDEFINED_VALUE && (encryptionStrength < 1 || encryptionStrength > 3)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
 	let rawExtraField = new Uint8Array();
@@ -227,18 +245,18 @@ async function addFile(zipWriter, name, reader, options) {
 		});
 	}
 	let extendedTimestamp = getOptionValue(zipWriter, options, "extendedTimestamp");
-	if (extendedTimestamp === undefined) {
+	if (extendedTimestamp === UNDEFINED_VALUE) {
 		extendedTimestamp = true;
 	}
 	let maximumCompressedSize = 0;
 	let maximumEntrySize = 0;
 	let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
-	if (keepOrder === undefined) {
+	if (keepOrder === UNDEFINED_VALUE) {
 		keepOrder = true;
 	}
 	let uncompressedSize = 0;
 	let msDosCompatible = getOptionValue(zipWriter, options, "msDosCompatible");
-	if (msDosCompatible === undefined) {
+	if (msDosCompatible === UNDEFINED_VALUE) {
 		msDosCompatible = true;
 	}
 	const internalFileAttribute = getOptionValue(zipWriter, options, "internalFileAttribute") || 0;
@@ -251,15 +269,16 @@ async function addFile(zipWriter, name, reader, options) {
 			};
 		}
 		await initStream(reader);
-		if (reader.size === undefined) {
+		if (reader.size === UNDEFINED_VALUE) {
 			options.dataDescriptor = true;
-			if (zip64 === undefined) {
+			if (zip64 || zip64 === UNDEFINED_VALUE) {
 				zip64 = true;
+				maximumCompressedSize = MAX_32_BITS;
 			}
 		} else {
 			uncompressedSize = reader.size;
+			maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 		}
-		maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 	}
 	if (zipWriter.offset + zipWriter.pendingEntriesSize >= MAX_32_BITS ||
 		uncompressedSize >= MAX_32_BITS ||
@@ -278,10 +297,10 @@ async function addFile(zipWriter, name, reader, options) {
 	let dataDescriptorSignature = getOptionValue(zipWriter, options, "dataDescriptorSignature");
 	const signal = getOptionValue(zipWriter, options, "signal");
 	const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
-	if (dataDescriptor === undefined) {
+	if (dataDescriptor === UNDEFINED_VALUE) {
 		dataDescriptor = true;
 	}
-	if (dataDescriptor && dataDescriptorSignature === undefined) {
+	if (dataDescriptor && dataDescriptorSignature === UNDEFINED_VALUE) {
 		dataDescriptorSignature = false;
 	}
 	options = Object.assign({}, options, {
@@ -364,10 +383,21 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			releaseLockWriter = () => delete zipWriter.lockWriter;
 		}
 		await initStream(fileWriter);
+		const { writable, diskNumber } = writer;
+		let { diskOffset } = writer;
+		if (zipWriter.addSplitZipSignature) {
+			delete zipWriter.addSplitZipSignature;
+			const signatureArray = new Uint8Array(4);
+			const signatureArrayView = new DataView(signatureArray.buffer);
+			setUint32(signatureArrayView, 0, SPLIT_ZIP_FILE_SIGNATURE);
+			await writeData(writable, signatureArray);
+			zipWriter.offset += 4;
+		}
 		if (!bufferedWrite) {
 			await lockPreviousFileEntry;
 		}
 		writingEntryData = true;
+		fileEntry.diskNumberStart = diskNumber;
 		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, zipWriter.config, options);
 		writingEntryData = false;
 		files.set(name, fileEntry);
@@ -378,7 +408,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await lockPreviousFileEntry;
 			await requestLockWriter();
 			writingBufferedEntryData = true;
-			const { writable } = writer;
 			if (!dataDescriptor) {
 				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, 26);
 				const arrayBufferView = new DataView(arrayBuffer);
@@ -395,13 +424,18 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 				await writeData(writable, new Uint8Array(arrayBuffer));
 				blob = blob.slice(arrayBuffer.byteLength);
 			}
+			fileEntry.diskNumberStart = writer.diskNumber;
+			diskOffset = writer.diskOffset;
 			await blob.stream().pipeTo(writable, { preventClose: true, signal });
+			writable.size += blob.size;
 			writingBufferedEntryData = false;
 		}
-		fileEntry.offset = zipWriter.offset;
+		fileEntry.offset = zipWriter.offset - diskOffset;
 		if (fileEntry.zip64) {
-			const rawExtraFieldZip64View = getDataView(fileEntry.rawExtraFieldZip64);
-			setBigUint64(rawExtraFieldZip64View, 20, BigInt(fileEntry.offset));
+			const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
+			const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
+			setBigUint64(rawExtraFieldZip64View, 20, BigInt(offset));
+			setUint32(rawExtraFieldZip64View, 28, diskNumberStart);
 		} else if (fileEntry.offset >= MAX_32_BITS) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
@@ -445,7 +479,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 	}
 }
 
-async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, config, options) {
+async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryInfo, config, options) {
 	const {
 		headerInfo,
 		dataDescriptorInfo
@@ -490,7 +524,7 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 		useCompressionStream
 	} = options;
 	const fileEntry = {
-		lock: pendingFileEntry.lock,
+		lock,
 		versionMadeBy,
 		zip64,
 		directory: Boolean(directory),
@@ -505,7 +539,8 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 		extendedTimestamp,
 		msDosCompatible,
 		internalFileAttribute,
-		externalFileAttribute
+		externalFileAttribute,
+		diskNumberStart
 	};
 	let uncompressedSize = 0;
 	let signature;
@@ -748,7 +783,7 @@ function setEntryInfo(entryInfo, options) {
 		zipCrypto,
 		dataDescriptor
 	} = options;
-	if ((!encrypted || zipCrypto) && signature !== undefined) {
+	if ((!encrypted || zipCrypto) && signature !== UNDEFINED_VALUE) {
 		setUint32(headerView, 10, signature);
 		if (dataDescriptor) {
 			setUint32(dataDescriptorView, dataDescriptorOffset, signature);
@@ -777,10 +812,12 @@ function setEntryInfo(entryInfo, options) {
 }
 
 async function closeFile(zipWriter, comment, options) {
-	const { files } = zipWriter;
+	const { files, writer } = zipWriter;
 	let offset = 0;
 	let directoryDataLength = 0;
-	let directoryOffset = zipWriter.offset;
+	const { diskOffset, writable } = writer;
+	let { diskNumber } = writer;
+	let directoryOffset = zipWriter.offset - diskOffset;
 	let filesLength = files.size;
 	for (const [, {
 		rawFilename,
@@ -809,7 +846,7 @@ async function closeFile(zipWriter, comment, options) {
 			zip64 = true;
 		}
 	}
-	const directoryArray = new Uint8Array(directoryDataLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH));
+	const directoryArray = new Uint8Array(directoryDataLength);
 	const directoryView = getDataView(directoryArray);
 	for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
 		const {
@@ -828,7 +865,8 @@ async function closeFile(zipWriter, comment, options) {
 			internalFileAttribute,
 			externalFileAttribute,
 			extendedTimestamp,
-			lastModDate
+			lastModDate,
+			diskNumberStart
 		} = fileEntry;
 		let rawExtraFieldExtendedTimestamp;
 		if (extendedTimestamp) {
@@ -847,17 +885,14 @@ async function closeFile(zipWriter, comment, options) {
 		arraySet(directoryArray, headerArray, offset + 6);
 		setUint16(directoryView, offset + 30, extraFieldLength);
 		setUint16(directoryView, offset + 32, getLength(rawComment));
+		setUint16(directoryView, offset + 34, zip64 ? MAX_16_BITS : diskNumberStart);
 		setUint16(directoryView, offset + 36, internalFileAttribute);
 		if (externalFileAttribute) {
 			setUint32(directoryView, offset + 38, externalFileAttribute);
 		} else if (directory && msDosCompatible) {
 			setUint8(directoryView, offset + 38, FILE_ATTR_MSDOS_DIR_MASK);
 		}
-		if (zip64) {
-			setUint32(directoryView, offset + 42, MAX_32_BITS);
-		} else {
-			setUint32(directoryView, offset + 42, fileEntryOffset);
-		}
+		setUint32(directoryView, offset + 42, zip64 ? MAX_32_BITS : fileEntryOffset);
 		arraySet(directoryArray, rawFilename, offset + 46);
 		arraySet(directoryArray, rawExtraFieldZip64, offset + 46 + getLength(rawFilename));
 		arraySet(directoryArray, rawExtraFieldAES, offset + 46 + getLength(rawFilename, rawExtraFieldZip64));
@@ -874,39 +909,52 @@ async function closeFile(zipWriter, comment, options) {
 			}
 		}
 	}
+	await initStream(writer);
+	await writeData(writable, directoryArray);
+	const endOfdirectoryArray = new Uint8Array(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+	const endOfdirectoryView = getDataView(endOfdirectoryArray);
+	let lastDiskNumber = writer.diskNumber;
+	const { availableSize } = writer;
+	if (availableSize < endOfdirectoryArray.length) {
+		lastDiskNumber++;
+	}
+	offset = 0;
 	if (zip64) {
-		setUint32(directoryView, offset, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
-		setBigUint64(directoryView, offset + 4, BigInt(44));
-		setUint16(directoryView, offset + 12, 45);
-		setUint16(directoryView, offset + 14, 45);
-		setBigUint64(directoryView, offset + 24, BigInt(filesLength));
-		setBigUint64(directoryView, offset + 32, BigInt(filesLength));
-		setBigUint64(directoryView, offset + 40, BigInt(directoryDataLength));
-		setBigUint64(directoryView, offset + 48, BigInt(directoryOffset));
-		setUint32(directoryView, offset + 56, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
-		setBigUint64(directoryView, offset + 64, BigInt(directoryOffset) + BigInt(directoryDataLength));
-		setUint32(directoryView, offset + 72, ZIP64_TOTAL_NUMBER_OF_DISKS);
+		setUint32(endOfdirectoryView, 0, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
+		setBigUint64(endOfdirectoryView, 4, BigInt(44));
+		setUint16(endOfdirectoryView, 12, 45);
+		setUint16(endOfdirectoryView, 14, 45);
+		setUint32(endOfdirectoryView, 16, lastDiskNumber);
+		setUint32(endOfdirectoryView, 20, diskNumber);
+		setBigUint64(endOfdirectoryView, 24, BigInt(filesLength));
+		setBigUint64(endOfdirectoryView, 32, BigInt(filesLength));
+		setBigUint64(endOfdirectoryView, 40, BigInt(directoryDataLength));
+		setBigUint64(endOfdirectoryView, 48, BigInt(directoryOffset));
+		setUint32(endOfdirectoryView, 56, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
+		setBigUint64(endOfdirectoryView, 64, BigInt(directoryOffset) + BigInt(directoryDataLength));
+		setUint32(endOfdirectoryView, 72, lastDiskNumber + 1);
+		diskNumber = MAX_16_BITS;
 		filesLength = MAX_16_BITS;
 		directoryOffset = MAX_32_BITS;
 		directoryDataLength = MAX_32_BITS;
-		offset += 76;
-	}
-	setUint32(directoryView, offset, END_OF_CENTRAL_DIR_SIGNATURE);
-	setUint16(directoryView, offset + 8, filesLength);
-	setUint16(directoryView, offset + 10, filesLength);
-	setUint32(directoryView, offset + 12, directoryDataLength);
-	setUint32(directoryView, offset + 16, directoryOffset);
+		offset += ZIP64_END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH;
+	}
+	setUint32(endOfdirectoryView, offset, END_OF_CENTRAL_DIR_SIGNATURE);
+	setUint16(endOfdirectoryView, offset + 4, lastDiskNumber);
+	setUint16(endOfdirectoryView, offset + 6, diskNumber);
+	setUint16(endOfdirectoryView, offset + 8, filesLength);
+	setUint16(endOfdirectoryView, offset + 10, filesLength);
+	setUint32(endOfdirectoryView, offset + 12, directoryDataLength);
+	setUint32(endOfdirectoryView, offset + 16, directoryOffset);
 	const commentLength = getLength(comment);
 	if (commentLength) {
 		if (commentLength <= MAX_16_BITS) {
-			setUint16(directoryView, offset + 20, commentLength);
+			setUint16(endOfdirectoryView, offset + 20, commentLength);
 		} else {
 			throw new Error(ERR_INVALID_COMMENT);
 		}
 	}
-	const { writable } = zipWriter.writer;
-	await initStream(zipWriter.writer);
-	await writeData(writable, directoryArray);
+	await writeData(writable, endOfdirectoryArray);
 	if (commentLength) {
 		await writeData(writable, comment);
 	}
@@ -935,7 +983,7 @@ function getTimeNTFS(date) {
 }
 
 function getOptionValue(zipWriter, options, name) {
-	return options[name] === undefined ? zipWriter.options[name] : options[name];
+	return options[name] === UNDEFINED_VALUE ? zipWriter.options[name] : options[name];
 }
 
 function getMaximumCompressedSize(uncompressedSize) {