@zip.js/zip.js 2.6.33 → 2.6.35

package/lib/core/streams/codec-stream.js

@@ -34,25 +34,72 @@
  */
 
 /* global TransformStream */
+// deno-lint-ignore-file no-this-alias
+
+import {
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	InflateStream,
+	DeflateStream
+} from "./zip-entry-stream.js";
+
+const MESSAGE_EVENT_TYPE = "message";
+const MESSAGE_START = "start";
+const MESSAGE_PULL = "pull";
+const MESSAGE_DATA = "data";
+const MESSAGE_ACK_DATA = "ack";
+const MESSAGE_CLOSE = "close";
+const CODEC_DEFLATE = "deflate";
+const CODEC_INFLATE = "inflate";
+
+export {
+	CODEC_DEFLATE,
+	CODEC_INFLATE,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE,
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	CodecStream
+};
 
 class CodecStream extends TransformStream {
 
-	constructor(Codec, options) {
-		const codec = new Codec(options);
-		super({
+	constructor(options, config) {
+		super({});
+		const codec = this;
+		const { codecType } = options;
+		let Stream;
+		if (codecType.startsWith(CODEC_DEFLATE)) {
+			Stream = DeflateStream;
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
+			Stream = InflateStream;
+		}
+		let size = 0;
+		const stream = new Stream(options, config);
+		const readable = super.readable;
+		const transformStream = new TransformStream({
 			transform(chunk, controller) {
-				controller.enqueue(codec.append(chunk));
-			},
-			flush(controller) {
-				const chunk = codec.flush();
-				if (chunk) {
+				if (chunk && chunk.length) {
+					size += chunk.length;
 					controller.enqueue(chunk);
 				}
+			},
+			flush() {
+				const { signature } = stream;
+				Object.assign(codec, {
+					signature,
+					size
+				});
+			}
+		});
+		Object.defineProperty(codec, "readable", {
+			get() {
+				return readable.pipeThrough(stream).pipeThrough(transformStream);
 			}
 		});
 	}
-}
-
-export {
-	CodecStream
-};
+}

package/lib/core/streams/codecs/sjcl.js

@@ -1,6 +1,6 @@
 // Derived from https://github.com/xqdoo00o/jszip/blob/master/lib/sjcl.js and https://github.com/bitwiseshiftleft/sjcl
 
-/*// deno-lint-ignore-file no-this-alias *
+// deno-lint-ignore-file no-this-alias
 
 /*
  * SJCL is open. You can use, modify and redistribute it under a BSD

package/lib/core/streams/stream-adapter.js

@@ -0,0 +1,55 @@
+/*
+ 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 TransformStream */
+
+export {
+	StreamAdapter
+};
+
+class StreamAdapter {
+
+	constructor(Codec) {
+		return class extends TransformStream {
+			constructor(options) {
+				const codec = new Codec(options);
+				super({
+					transform(chunk, controller) {
+						controller.enqueue(codec.append(chunk));
+					},
+					flush(controller) {
+						const chunk = codec.flush();
+						if (chunk) {
+							controller.enqueue(chunk);
+						}
+					}
+				});
+			}
+		};
+	}
+}

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

@@ -27,6 +27,7 @@
  */
 
 /* global TransformStream */
+// deno-lint-ignore-file no-this-alias
 
 import { Crc32 } from "./codecs/crc32.js";
 import {

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

@@ -27,6 +27,7 @@
  */
 
 /* global TransformStream */
+// deno-lint-ignore-file no-this-alias
 
 import { Crc32Stream } from "./crc32-stream.js";
 import {

package/lib/core/util/stream-codec-shim.js

@@ -27,6 +27,8 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+// deno-lint-ignore-file no-this-alias
+
 export {
 	initShimAsyncCodec
 };

package/lib/core/z-worker-core.js

@@ -29,23 +29,23 @@
 /* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
 
 import { UNDEFINED_VALUE } from "./constants.js";
+import { StreamAdapter } from "./streams/stream-adapter.js";
 import {
-	Codec,
-	getCodecStreamClass,
+	CodecStream,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
 	MESSAGE_DATA,
 	MESSAGE_ACK_DATA,
 	MESSAGE_CLOSE
-} from "./codec-interface.js";
+} from "./streams/codec-stream.js";
 
 const pendingPullMessages = new Map();
 const pendingDataMessages = new Map();
-let codec;
+
 let messageId = 0;
 
-addEventListener(MESSAGE_EVENT_TYPE, async event => {
+addEventListener(MESSAGE_EVENT_TYPE, event => {
 	const message = event.data;
 	const { type, messageId, data, done } = message;
 	try {
@@ -79,15 +79,15 @@ async function init(message) {
 		config.CompressionStreamNative = self.CompressionStream;
 		config.DecompressionStreamNative = self.DecompressionStream;
 		if (self.Deflate) {
-			config.CompressionStream = getCodecStreamClass(self.Deflate);
+			config.CompressionStream = new StreamAdapter(self.Deflate);
 		}
 		if (self.Inflate) {
-			config.DecompressionStream = getCodecStreamClass(self.Inflate);
+			config.DecompressionStream = new StreamAdapter(self.Inflate);
 		}
 		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
 		const readable = message.readable || new ReadableStream({
 			async pull(controller) {
-				let result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
+				const result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
 				sendMessage({ type: MESSAGE_PULL, messageId });
 				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
 				const { value, done } = await result;
@@ -107,14 +107,24 @@ async function init(message) {
 				await ackData;
 			}
 		}, strategy);
-		codec = new Codec(readable, writable, options, config);
-		const result = await codec.run();
+		const codecStream = new CodecStream(options, config);
+		await readable.pipeThrough(codecStream).pipeTo(writable, { preventAbort: true });
 		try {
 			await writable.close();
 		} catch (_error) {
 			// ignored
 		}
-		sendMessage({ type: MESSAGE_CLOSE, result });
+		const {
+			signature,
+			size
+		} = codecStream;
+		sendMessage({
+			type: MESSAGE_CLOSE,
+			result: {
+				signature,
+				size
+			}
+		});
 	} catch (error) {
 		sendErrorMessage(error);
 	}

package/lib/core/zip-entry.js

@@ -32,7 +32,8 @@ const PROPERTY_NAMES = [
 	"rawExtraField", "bitFlag", "extraFieldZip64", "extraFieldUnicodePath", "extraFieldUnicodeComment",
 	"extraFieldAES", "filenameUTF8", "commentUTF8", "offset", "zip64", "compressionMethod",
 	"extraFieldNTFS", "lastAccessDate", "creationDate", "extraFieldExtendedTimestamp",
-	"version", "versionMadeBy", "msDosCompatible", "internalFileAttribute", "externalFileAttribute"];
+	"version", "versionMadeBy", "msDosCompatible", "internalFileAttribute", "externalFileAttribute",
+	"diskNumberStart"];
 
 class Entry {
 

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

@@ -27,6 +27,7 @@
  */
 
 /* global WritableStream */
+// deno-lint-ignore-file no-this-alias
 
 import {
 	initStream,

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,
@@ -77,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";
@@ -150,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_VALUE && 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);
@@ -344,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;

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,
@@ -58,7 +61,8 @@ import {
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
 	MAX_DATE,
-	UNDEFINED_VALUE
+	UNDEFINED_VALUE,
+	FUNCTION_TYPE
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -70,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";
@@ -86,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 = [];
@@ -94,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_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(),
@@ -366,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);
@@ -380,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);
@@ -397,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);
 		}
@@ -447,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
@@ -492,7 +524,7 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 		useCompressionStream
 	} = options;
 	const fileEntry = {
-		lock: pendingFileEntry.lock,
+		lock,
 		versionMadeBy,
 		zip64,
 		directory: Boolean(directory),
@@ -507,7 +539,8 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 		extendedTimestamp,
 		msDosCompatible,
 		internalFileAttribute,
-		externalFileAttribute
+		externalFileAttribute,
+		diskNumberStart
 	};
 	let uncompressedSize = 0;
 	let signature;
@@ -779,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,
@@ -811,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 {
@@ -830,7 +865,8 @@ async function closeFile(zipWriter, comment, options) {
 			internalFileAttribute,
 			externalFileAttribute,
 			extendedTimestamp,
-			lastModDate
+			lastModDate,
+			diskNumberStart
 		} = fileEntry;
 		let rawExtraFieldExtendedTimestamp;
 		if (extendedTimestamp) {
@@ -849,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));
@@ -876,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);
 	}