@zip.js/zip.js 2.6.60 → 2.6.61

package/index.cjs

@@ -8531,12 +8531,9 @@ class ZipReader {
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
-		const lastDiskNumber = getUint16(endOfDirectoryView, 4);
+		let 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);
 		let prependedDataLength = 0;
 		let startOffset = 0;
@@ -8560,8 +8557,11 @@ class ZipReader {
 			if (getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
 				throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
 			}
+			if (lastDiskNumber == MAX_16_BITS) {
+				lastDiskNumber = getUint32(endOfDirectoryView, 16);
+			}
 			if (diskNumber == MAX_16_BITS) {
-				diskNumber = getUint32(endOfDirectoryView, 16);
+				diskNumber = getUint32(endOfDirectoryView, 20);
 			}
 			if (filesLength == MAX_16_BITS) {
 				filesLength = getBigUint64(endOfDirectoryView, 32);
@@ -8571,6 +8571,9 @@ class ZipReader {
 			}
 			directoryDataOffset -= directoryDataLength;
 		}
+		if (expectedLastDiskNumber != lastDiskNumber) {
+			throw new Error(ERR_SPLIT_ZIP_FILE);
+		}
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
@@ -9067,7 +9070,6 @@ 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 = 28;
 
 let workers = 0;
 const pendingEntries = [];
@@ -9210,6 +9212,7 @@ async function addFile(zipWriter, name, reader, options) {
 	let maximumCompressedSize = 0;
 	let maximumEntrySize = 0;
 	let uncompressedSize = 0;
+	const zip64Enabled = zip64 === true;
 	if (reader) {
 		reader = initReader(reader);
 		await initStream(reader);
@@ -9225,10 +9228,12 @@ async function addFile(zipWriter, name, reader, options) {
 		}
 	}
 	const { diskOffset, diskNumber, maxSize } = zipWriter.writer;
-	if (zipWriter.offset + zipWriter.pendingEntriesSize - diskOffset >= MAX_32_BITS ||
-		uncompressedSize >= MAX_32_BITS ||
-		maximumCompressedSize >= MAX_32_BITS ||
-		diskNumber + Math.ceil(zipWriter.pendingEntriesSize / maxSize) >= MAX_16_BITS) {
+	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 zip64DiskNumberStart = (supportZip64SplitFile && zip64Enabled) || diskNumber + Math.ceil(zipWriter.pendingEntriesSize / maxSize) >= MAX_16_BITS;
+	if (zip64Offset || zip64UncompressedSize || zip64CompressedSize || zip64DiskNumberStart) {
 		if (zip64 === false || !keepOrder) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		} else {
@@ -9246,6 +9251,10 @@ async function addFile(zipWriter, name, reader, options) {
 		creationDate,
 		rawExtraField,
 		zip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart,
 		password,
 		level,
 		useWebWorkers,
@@ -9343,7 +9352,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await requestLockWriter();
 			writingBufferedEntryData = true;
 			if (!dataDescriptor) {
-				blob = await writeMissingHeaderInfo(fileEntry, blob, writable, options);
+				blob = await writeExtraHeaderInfo(fileEntry, blob, writable, options);
 			}
 			await skipDiskIfNeeded(writable);
 			fileEntry.diskNumberStart = writer.diskNumber;
@@ -9354,7 +9363,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 		fileEntry.offset = zipWriter.offset - diskOffset;
 		if (fileEntry.zip64) {
-			setZip64OffsetInfo(fileEntry);
+			setZip64ExtraInfo(fileEntry, options);
 		} else if (fileEntry.offset >= MAX_32_BITS) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
@@ -9392,7 +9401,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 
 	async function requestLockWriter() {
 		zipWriter.writerLocked = true;
-		const { lockWriter } = zipWriter; 
+		const { lockWriter } = zipWriter;
 		zipWriter.lockWriter = new Promise(resolve => releaseLockWriter = () => {
 			zipWriter.writerLocked = false;
 			resolve();
@@ -9434,6 +9443,10 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		password,
 		level,
 		zip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart,
 		zipCrypto,
 		dataDescriptor,
 		directory,
@@ -9506,7 +9519,25 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	} else {
 		await writeData(writable, localHeaderArray);
 	}
-	const rawExtraFieldZip64 = zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array();
+	let rawExtraFieldZip64;
+	if (zip64) {
+		let rawExtraFieldZip64Length = 4;
+		if (zip64UncompressedSize) {
+			rawExtraFieldZip64Length += 8;
+		}
+		if (zip64CompressedSize) {
+			rawExtraFieldZip64Length += 8;
+		}
+		if (zip64Offset) {
+			rawExtraFieldZip64Length += 8;
+		}
+		if (zip64DiskNumberStart) {
+			rawExtraFieldZip64Length += 4;
+		}
+		rawExtraFieldZip64 = new Uint8Array(rawExtraFieldZip64Length);
+	} else {
+		rawExtraFieldZip64 = new Uint8Array();
+	}
 	if (reader) {
 		setEntryInfo({
 			signature,
@@ -9521,6 +9552,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		await writeData(writable, dataDescriptorArray);
 	}
 	Object.assign(fileEntry, {
+		uncompressedSize,
 		compressedSize,
 		lastModDate,
 		rawLastModDate,
@@ -9532,7 +9564,11 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		version,
 		headerArray,
 		signature,
-		rawExtraFieldZip64
+		rawExtraFieldZip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart
 	});
 	return fileEntry;
 }
@@ -9709,6 +9745,8 @@ function setEntryInfo(entryInfo, options) {
 	} = dataDescriptorInfo;
 	const {
 		zip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
 		zipCrypto,
 		dataDescriptor
 	} = options;
@@ -9721,11 +9759,17 @@ function setEntryInfo(entryInfo, options) {
 	if (zip64) {
 		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-		setUint16(rawExtraFieldZip64View, 2, EXTRAFIELD_LENGTH_ZIP64);
-		setUint32(headerView, 14, MAX_32_BITS);
-		setBigUint64(rawExtraFieldZip64View, 12, BigInt(compressedSize));
-		setUint32(headerView, 18, MAX_32_BITS);
-		setBigUint64(rawExtraFieldZip64View, 4, BigInt(uncompressedSize));
+		setUint16(rawExtraFieldZip64View, 2, rawExtraFieldZip64.length - 4);
+		let rawExtraFieldZip64Offset = 4;
+		if (zip64UncompressedSize) {
+			setUint32(headerView, 18, MAX_32_BITS);
+			setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
+			rawExtraFieldZip64Offset += 8;
+		}
+		if (zip64CompressedSize) {
+			setUint32(headerView, 14, MAX_32_BITS);
+			setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(compressedSize));
+		}
 		if (dataDescriptor) {
 			setBigUint64(dataDescriptorView, dataDescriptorOffset + 4, BigInt(compressedSize));
 			setBigUint64(dataDescriptorView, dataDescriptorOffset + 12, BigInt(uncompressedSize));
@@ -9740,7 +9784,7 @@ function setEntryInfo(entryInfo, options) {
 	}
 }
 
-async function writeMissingHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
+async function writeExtraHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
 	const arrayBuffer = await sliceAsArrayBuffer(entryData, 0, 26);
 	const arrayBufferView = new DataView(arrayBuffer);
 	if (!fileEntry.encrypted || zipCrypto) {
@@ -9757,11 +9801,24 @@ async function writeMissingHeaderInfo(fileEntry, entryData, writable, { zipCrypt
 	return entryData.slice(arrayBuffer.byteLength);
 }
 
-function setZip64OffsetInfo(fileEntry) {
+function setZip64ExtraInfo(fileEntry, options) {
 	const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
+	const { zip64UncompressedSize, zip64CompressedSize, zip64Offset, zip64DiskNumberStart } = options;
 	const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
-	setBigUint64(rawExtraFieldZip64View, 20, BigInt(offset));
-	setUint32(rawExtraFieldZip64View, 28, diskNumberStart);
+	let rawExtraFieldZip64Offset = 4;
+	if (zip64UncompressedSize) {
+		rawExtraFieldZip64Offset += 8;
+	}
+	if (zip64CompressedSize) {
+		rawExtraFieldZip64Offset += 8;
+	}
+	if (zip64Offset) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(offset));
+		rawExtraFieldZip64Offset += 8;
+	}
+	if (zip64DiskNumberStart) {
+		setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, diskNumberStart);
+	}
 }
 
 async function closeFile(zipWriter, comment, options) {
@@ -9808,12 +9865,18 @@ async function closeFile(zipWriter, comment, options) {
 			headerArray,
 			directory,
 			zip64,
+			zip64UncompressedSize,
+			zip64CompressedSize,
+			zip64DiskNumberStart,
+			zip64Offset,
 			msDosCompatible,
 			internalFileAttribute,
 			externalFileAttribute,
 			extendedTimestamp,
 			lastModDate,
-			diskNumberStart
+			diskNumberStart,
+			uncompressedSize,
+			compressedSize
 		} = fileEntry;
 		let rawExtraFieldExtendedTimestamp;
 		if (extendedTimestamp) {
@@ -9829,17 +9892,24 @@ async function closeFile(zipWriter, comment, options) {
 		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
 		setUint32(directoryView, offset, CENTRAL_FILE_HEADER_SIGNATURE);
 		setUint16(directoryView, offset + 4, versionMadeBy);
+		const headerView = getDataView(headerArray);
+		if (!zip64UncompressedSize) {
+			setUint32(headerView, 18, uncompressedSize);
+		}
+		if (!zip64CompressedSize) {
+			setUint32(headerView, 14, compressedSize);
+		}
 		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 + 34, zip64 && zip64DiskNumberStart ? 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);
 		}
-		setUint32(directoryView, offset + 42, zip64 ? MAX_32_BITS : fileEntryOffset);
+		setUint32(directoryView, offset + 42, zip64 && zip64Offset ? MAX_32_BITS : fileEntryOffset);
 		arraySet(directoryArray, rawFilename, offset + 46);
 		arraySet(directoryArray, rawExtraFieldZip64, offset + 46 + getLength(rawFilename));
 		arraySet(directoryArray, rawExtraFieldAES, offset + 46 + getLength(rawFilename, rawExtraFieldZip64));
@@ -9893,7 +9963,11 @@ 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);
-		diskNumber = MAX_16_BITS;
+		const supportZip64SplitFile = getOptionValue(zipWriter, options, "supportZip64SplitFile", true);
+		if (supportZip64SplitFile) {
+			lastDiskNumber = MAX_16_BITS;
+			diskNumber = MAX_16_BITS;
+		}
 		filesLength = MAX_16_BITS;
 		directoryOffset = MAX_32_BITS;
 		directoryDataLength = MAX_32_BITS;

package/index.d.ts

@@ -1106,6 +1106,12 @@ interface ZipWriterConstructorOptions {
      * @defaultValue 0
      */
     internalFileAttribute?: number
+    /**
+     * `false` to never write disk numbers in zip64 data.
+     * 
+     * @defaultValue true
+     */
+    supportZip64SplitFile?: boolean
 }
 
 /**

package/lib/core/zip-reader.js

@@ -165,12 +165,9 @@ class ZipReader {
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
-		const lastDiskNumber = getUint16(endOfDirectoryView, 4);
+		let 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);
 		let prependedDataLength = 0;
 		let startOffset = 0;
@@ -194,8 +191,11 @@ class ZipReader {
 			if (getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
 				throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
 			}
+			if (lastDiskNumber == MAX_16_BITS) {
+				lastDiskNumber = getUint32(endOfDirectoryView, 16);
+			}
 			if (diskNumber == MAX_16_BITS) {
-				diskNumber = getUint32(endOfDirectoryView, 16);
+				diskNumber = getUint32(endOfDirectoryView, 20);
 			}
 			if (filesLength == MAX_16_BITS) {
 				filesLength = getBigUint64(endOfDirectoryView, 32);
@@ -205,6 +205,9 @@ class ZipReader {
 			}
 			directoryDataOffset -= directoryDataLength;
 		}
+		if (expectedLastDiskNumber != lastDiskNumber) {
+			throw new Error(ERR_SPLIT_ZIP_FILE);
+		}
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 			throw new Error(ERR_BAD_FORMAT);
 		}

package/lib/core/zip-writer.js

@@ -101,7 +101,6 @@ 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 = 28;
 
 let workers = 0;
 const pendingEntries = [];
@@ -257,6 +256,7 @@ async function addFile(zipWriter, name, reader, options) {
 	let maximumCompressedSize = 0;
 	let maximumEntrySize = 0;
 	let uncompressedSize = 0;
+	const zip64Enabled = zip64 === true;
 	if (reader) {
 		reader = initReader(reader);
 		await initStream(reader);
@@ -272,10 +272,12 @@ async function addFile(zipWriter, name, reader, options) {
 		}
 	}
 	const { diskOffset, diskNumber, maxSize } = zipWriter.writer;
-	if (zipWriter.offset + zipWriter.pendingEntriesSize - diskOffset >= MAX_32_BITS ||
-		uncompressedSize >= MAX_32_BITS ||
-		maximumCompressedSize >= MAX_32_BITS ||
-		diskNumber + Math.ceil(zipWriter.pendingEntriesSize / maxSize) >= MAX_16_BITS) {
+	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 zip64DiskNumberStart = (supportZip64SplitFile && zip64Enabled) || diskNumber + Math.ceil(zipWriter.pendingEntriesSize / maxSize) >= MAX_16_BITS;
+	if (zip64Offset || zip64UncompressedSize || zip64CompressedSize || zip64DiskNumberStart) {
 		if (zip64 === false || !keepOrder) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		} else {
@@ -293,6 +295,10 @@ async function addFile(zipWriter, name, reader, options) {
 		creationDate,
 		rawExtraField,
 		zip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart,
 		password,
 		level,
 		useWebWorkers,
@@ -390,7 +396,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await requestLockWriter();
 			writingBufferedEntryData = true;
 			if (!dataDescriptor) {
-				blob = await writeMissingHeaderInfo(fileEntry, blob, writable, options);
+				blob = await writeExtraHeaderInfo(fileEntry, blob, writable, options);
 			}
 			await skipDiskIfNeeded(writable);
 			fileEntry.diskNumberStart = writer.diskNumber;
@@ -401,7 +407,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 		fileEntry.offset = zipWriter.offset - diskOffset;
 		if (fileEntry.zip64) {
-			setZip64OffsetInfo(fileEntry);
+			setZip64ExtraInfo(fileEntry, options);
 		} else if (fileEntry.offset >= MAX_32_BITS) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
@@ -439,7 +445,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 
 	async function requestLockWriter() {
 		zipWriter.writerLocked = true;
-		const { lockWriter } = zipWriter; 
+		const { lockWriter } = zipWriter;
 		zipWriter.lockWriter = new Promise(resolve => releaseLockWriter = () => {
 			zipWriter.writerLocked = false;
 			resolve();
@@ -481,6 +487,10 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		password,
 		level,
 		zip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart,
 		zipCrypto,
 		dataDescriptor,
 		directory,
@@ -553,7 +563,25 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	} else {
 		await writeData(writable, localHeaderArray);
 	}
-	const rawExtraFieldZip64 = zip64 ? new Uint8Array(EXTRAFIELD_LENGTH_ZIP64 + 4) : new Uint8Array();
+	let rawExtraFieldZip64;
+	if (zip64) {
+		let rawExtraFieldZip64Length = 4;
+		if (zip64UncompressedSize) {
+			rawExtraFieldZip64Length += 8;
+		}
+		if (zip64CompressedSize) {
+			rawExtraFieldZip64Length += 8;
+		}
+		if (zip64Offset) {
+			rawExtraFieldZip64Length += 8;
+		}
+		if (zip64DiskNumberStart) {
+			rawExtraFieldZip64Length += 4;
+		}
+		rawExtraFieldZip64 = new Uint8Array(rawExtraFieldZip64Length);
+	} else {
+		rawExtraFieldZip64 = new Uint8Array();
+	}
 	if (reader) {
 		setEntryInfo({
 			signature,
@@ -568,6 +596,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		await writeData(writable, dataDescriptorArray);
 	}
 	Object.assign(fileEntry, {
+		uncompressedSize,
 		compressedSize,
 		lastModDate,
 		rawLastModDate,
@@ -579,7 +608,11 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		version,
 		headerArray,
 		signature,
-		rawExtraFieldZip64
+		rawExtraFieldZip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart
 	});
 	return fileEntry;
 }
@@ -756,6 +789,8 @@ function setEntryInfo(entryInfo, options) {
 	} = dataDescriptorInfo;
 	const {
 		zip64,
+		zip64UncompressedSize,
+		zip64CompressedSize,
 		zipCrypto,
 		dataDescriptor
 	} = options;
@@ -768,11 +803,17 @@ function setEntryInfo(entryInfo, options) {
 	if (zip64) {
 		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-		setUint16(rawExtraFieldZip64View, 2, EXTRAFIELD_LENGTH_ZIP64);
-		setUint32(headerView, 14, MAX_32_BITS);
-		setBigUint64(rawExtraFieldZip64View, 12, BigInt(compressedSize));
-		setUint32(headerView, 18, MAX_32_BITS);
-		setBigUint64(rawExtraFieldZip64View, 4, BigInt(uncompressedSize));
+		setUint16(rawExtraFieldZip64View, 2, rawExtraFieldZip64.length - 4);
+		let rawExtraFieldZip64Offset = 4;
+		if (zip64UncompressedSize) {
+			setUint32(headerView, 18, MAX_32_BITS);
+			setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
+			rawExtraFieldZip64Offset += 8;
+		}
+		if (zip64CompressedSize) {
+			setUint32(headerView, 14, MAX_32_BITS);
+			setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(compressedSize));
+		}
 		if (dataDescriptor) {
 			setBigUint64(dataDescriptorView, dataDescriptorOffset + 4, BigInt(compressedSize));
 			setBigUint64(dataDescriptorView, dataDescriptorOffset + 12, BigInt(uncompressedSize));
@@ -787,7 +828,7 @@ function setEntryInfo(entryInfo, options) {
 	}
 }
 
-async function writeMissingHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
+async function writeExtraHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
 	const arrayBuffer = await sliceAsArrayBuffer(entryData, 0, 26);
 	const arrayBufferView = new DataView(arrayBuffer);
 	if (!fileEntry.encrypted || zipCrypto) {
@@ -804,11 +845,24 @@ async function writeMissingHeaderInfo(fileEntry, entryData, writable, { zipCrypt
 	return entryData.slice(arrayBuffer.byteLength);
 }
 
-function setZip64OffsetInfo(fileEntry) {
+function setZip64ExtraInfo(fileEntry, options) {
 	const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
+	const { zip64UncompressedSize, zip64CompressedSize, zip64Offset, zip64DiskNumberStart } = options;
 	const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
-	setBigUint64(rawExtraFieldZip64View, 20, BigInt(offset));
-	setUint32(rawExtraFieldZip64View, 28, diskNumberStart);
+	let rawExtraFieldZip64Offset = 4;
+	if (zip64UncompressedSize) {
+		rawExtraFieldZip64Offset += 8;
+	}
+	if (zip64CompressedSize) {
+		rawExtraFieldZip64Offset += 8;
+	}
+	if (zip64Offset) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(offset));
+		rawExtraFieldZip64Offset += 8;
+	}
+	if (zip64DiskNumberStart) {
+		setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, diskNumberStart);
+	}
 }
 
 async function closeFile(zipWriter, comment, options) {
@@ -855,12 +909,18 @@ async function closeFile(zipWriter, comment, options) {
 			headerArray,
 			directory,
 			zip64,
+			zip64UncompressedSize,
+			zip64CompressedSize,
+			zip64DiskNumberStart,
+			zip64Offset,
 			msDosCompatible,
 			internalFileAttribute,
 			externalFileAttribute,
 			extendedTimestamp,
 			lastModDate,
-			diskNumberStart
+			diskNumberStart,
+			uncompressedSize,
+			compressedSize
 		} = fileEntry;
 		let rawExtraFieldExtendedTimestamp;
 		if (extendedTimestamp) {
@@ -876,17 +936,24 @@ async function closeFile(zipWriter, comment, options) {
 		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
 		setUint32(directoryView, offset, CENTRAL_FILE_HEADER_SIGNATURE);
 		setUint16(directoryView, offset + 4, versionMadeBy);
+		const headerView = getDataView(headerArray);
+		if (!zip64UncompressedSize) {
+			setUint32(headerView, 18, uncompressedSize);
+		}
+		if (!zip64CompressedSize) {
+			setUint32(headerView, 14, compressedSize);
+		}
 		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 + 34, zip64 && zip64DiskNumberStart ? 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);
 		}
-		setUint32(directoryView, offset + 42, zip64 ? MAX_32_BITS : fileEntryOffset);
+		setUint32(directoryView, offset + 42, zip64 && zip64Offset ? MAX_32_BITS : fileEntryOffset);
 		arraySet(directoryArray, rawFilename, offset + 46);
 		arraySet(directoryArray, rawExtraFieldZip64, offset + 46 + getLength(rawFilename));
 		arraySet(directoryArray, rawExtraFieldAES, offset + 46 + getLength(rawFilename, rawExtraFieldZip64));
@@ -940,7 +1007,11 @@ 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);
-		diskNumber = MAX_16_BITS;
+		const supportZip64SplitFile = getOptionValue(zipWriter, options, "supportZip64SplitFile", true);
+		if (supportZip64SplitFile) {
+			lastDiskNumber = MAX_16_BITS;
+			diskNumber = MAX_16_BITS;
+		}
 		filesLength = MAX_16_BITS;
 		directoryOffset = MAX_32_BITS;
 		directoryDataLength = MAX_32_BITS;

package/package.json

@@ -3,7 +3,7 @@
     "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
     "author": "Gildas Lormeau",
     "license": "BSD-3-Clause",
-    "version": "2.6.60",
+    "version": "2.6.61",
     "type": "module",
     "keywords": [
         "zip",