@zip.js/zip.js 2.8.22 → 2.8.24

package/index.cjs

@@ -4372,7 +4372,7 @@ const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 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 ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
 const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
 const ERR_INVALID_UID = "Invalid uid (must be integer 0..2^32-1)";
@@ -4788,14 +4788,11 @@ async function addFile(zipWriter, name, reader, options) {
 			maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 		}
 	}
-	const { diskOffset, diskNumber, maxSize } = zipWriter.writer;
+	const { diskOffset, diskNumber } = zipWriter.writer;
 	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, 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) {
+	if (zip64UncompressedSize || zip64CompressedSize) {
+		if (zip64 === false) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		} else {
 			zip64 = true;
@@ -4815,8 +4812,6 @@ async function addFile(zipWriter, name, reader, options) {
 		zip64,
 		zip64UncompressedSize,
 		zip64CompressedSize,
-		zip64Offset,
-		zip64DiskNumberStart,
 		password,
 		rawPassword,
 		level,
@@ -4944,7 +4939,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await writeData(fileWriter, localHeaderArray);
 		}
 		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, zipWriter.config, options);
-		const { zip64 } = fileEntry;
 		if (!bufferedWrite) {
 			writingEntryData = false;
 		}
@@ -4956,9 +4950,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			writingBufferedEntryData = true;
 			fileEntry.diskNumberStart = writer.diskNumber;
 			fileEntry.offset = zipWriter.offset - writer.diskOffset;
-			if (zip64) {
-				updateZip64ExtraField(fileEntry);
-			}
 			updateLocalHeader(fileEntry, localHeaderView, options);
 			await skipDiskIfNeeded(writable);
 			await writeData(writer, localHeaderArray);
@@ -4967,12 +4958,6 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			writingBufferedEntryData = false;
 		} else {
 			fileEntry.offset = zipWriter.offset - diskOffset;
-			if (zip64) {
-				updateZip64ExtraField(fileEntry);
-			}
-		}
-		if (fileEntry.offset > MAX_32_BITS && !zip64) {
-			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
 		zipWriter.offset += fileEntry.size;
 		return fileEntry;
@@ -5062,8 +5047,6 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		zip64,
 		zip64UncompressedSize,
 		zip64CompressedSize,
-		zip64Offset,
-		zip64DiskNumberStart,
 		zipCrypto,
 		dataDescriptor,
 		directory,
@@ -5201,9 +5184,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		signature,
 		extraFieldExtendedTimestampFlag,
 		zip64UncompressedSize,
-		zip64CompressedSize,
-		zip64Offset,
-		zip64DiskNumberStart
+		zip64CompressedSize
 	});
 	return fileEntry;
 }
@@ -5227,74 +5208,41 @@ function getHeaderInfo(options) {
 		encrypted,
 		zip64UncompressedSize,
 		zip64CompressedSize,
-		zip64Offset,
-		zip64DiskNumberStart,
-		uncompressedSize,
-		offset,
-		diskNumberStart
+		uncompressedSize
 	} = options;
 	let { version, compressionMethod } = options;
 	const compressed = !directory && (level > 0 || (level === UNDEFINED_VALUE && compressionMethod !== 0));
-	let rawExtraFieldZip64;
 	let rawLocalExtraFieldZip64;
 	const uncompressedFile = passThrough || !compressed;
 	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
 	if (zip64) {
-		let rawExtraFieldZip64Length = 4;
 		let rawLocalExtraFieldZip64Length = 4;
 		if (zip64UncompressedSize) {
-			rawExtraFieldZip64Length += 8;
 			rawLocalExtraFieldZip64Length += 8;
 		}
 		if (zip64CompressedSize) {
-			rawExtraFieldZip64Length += 8;
 			rawLocalExtraFieldZip64Length += 8;
 		}
-		if (zip64Offset) {
-			rawExtraFieldZip64Length += 8;
-		}
-		if (zip64DiskNumberStart) {
-			rawExtraFieldZip64Length += 4;
-		}
-		rawExtraFieldZip64 = new Uint8Array(rawExtraFieldZip64Length);
-		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 		rawLocalExtraFieldZip64 = new Uint8Array(rawLocalExtraFieldZip64Length);
 		const rawLocalExtraFieldZip64View = getDataView(rawLocalExtraFieldZip64);
-		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-		setUint16(rawExtraFieldZip64View, 2, getLength(rawExtraFieldZip64) - 4);
 		setUint16(rawLocalExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
 		setUint16(rawLocalExtraFieldZip64View, 2, getLength(rawLocalExtraFieldZip64) - 4);
 		if (zip64ExtraFieldComplete) {
-			const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 			const rawLocalExtraFieldZip64View = getDataView(rawLocalExtraFieldZip64);
-			let rawExtraFieldZip64Offset = 4;
 			let rawLocalExtraFieldZip64Offset = 4;
 			if (zip64UncompressedSize) {
-				setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
-				rawExtraFieldZip64Offset += 8;
 				setBigUint64(rawLocalExtraFieldZip64View, rawLocalExtraFieldZip64Offset, BigInt(uncompressedSize));
 				rawLocalExtraFieldZip64Offset += 8;
 			}
 			if (zip64CompressedSize && uncompressedFile) {
-				setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
-				rawExtraFieldZip64Offset += 8;
 				setBigUint64(rawLocalExtraFieldZip64View, rawLocalExtraFieldZip64Offset, BigInt(uncompressedSize));
 				rawLocalExtraFieldZip64Offset += 8;
 			}
-			if (zip64Offset) {
-				setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(offset));
-				rawExtraFieldZip64Offset += 8;
-			}
-			if (zip64DiskNumberStart) {
-				setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, diskNumberStart);
-				rawExtraFieldZip64Offset += 4;
-			}
 			if (rawLocalExtraFieldZip64Offset == 4) {
 				rawLocalExtraFieldZip64 = new Uint8Array();
 			}
 		}
 	} else {
-		rawExtraFieldZip64 = new Uint8Array();
 		rawLocalExtraFieldZip64 = new Uint8Array();
 	}
 	let rawExtraFieldAES;
@@ -5451,7 +5399,7 @@ function getHeaderInfo(options) {
 		version,
 		compressionMethod,
 		extraFieldExtendedTimestampFlag,
-		rawExtraFieldZip64,
+		rawExtraFieldZip64: new Uint8Array(),
 		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
@@ -5623,35 +5571,6 @@ function updateLocalHeader({
 	}
 }
 
-function updateZip64ExtraField({
-	compressedSize,
-	uncompressedSize,
-	offset,
-	diskNumberStart,
-	zip64UncompressedSize,
-	zip64CompressedSize,
-	zip64Offset,
-	zip64DiskNumberStart,
-	rawExtraFieldZip64
-}) {
-	const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
-	let rawExtraFieldZip64Offset = 4;
-	if (zip64UncompressedSize) {
-		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
-		rawExtraFieldZip64Offset += 8;
-	}
-	if (zip64CompressedSize) {
-		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(compressedSize));
-		rawExtraFieldZip64Offset += 8;
-	}
-	if (zip64Offset) {
-		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(offset));
-		rawExtraFieldZip64Offset += 8;
-	}
-	if (zip64DiskNumberStart) {
-		setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, diskNumberStart);
-	}
-}
 
 async function closeFile(zipWriter, comment, options) {
 	const { files, writer } = zipWriter;
@@ -5664,7 +5583,6 @@ async function closeFile(zipWriter, comment, options) {
 	for (const [, fileEntry] of files) {
 		const {
 			rawFilename,
-			rawExtraFieldZip64,
 			rawExtraFieldAES,
 			rawComment,
 			rawExtraFieldNTFS,
@@ -5672,8 +5590,36 @@ async function closeFile(zipWriter, comment, options) {
 			rawExtraField,
 			extendedTimestamp,
 			extraFieldExtendedTimestampFlag,
-			lastModDate
+			lastModDate,
+			zip64UncompressedSize,
+			zip64CompressedSize,
+			uncompressedSize,
+			compressedSize
 		} = fileEntry;
+		const zip64Offset = fileEntry.offset > MAX_32_BITS;
+		const zip64DiskNumberStart = fileEntry.diskNumberStart > MAX_16_BITS;
+		let rawExtraFieldZip64;
+		if (zip64Offset || zip64DiskNumberStart || zip64UncompressedSize || zip64CompressedSize) {
+			let length = 4;
+			if (zip64UncompressedSize) length += 8;
+			if (zip64CompressedSize) length += 8;
+			if (zip64Offset) length += 8;
+			if (zip64DiskNumberStart) length += 4;
+			rawExtraFieldZip64 = new Uint8Array(length);
+			const zip64View = getDataView(rawExtraFieldZip64);
+			setUint16(zip64View, 0, EXTRAFIELD_TYPE_ZIP64);
+			setUint16(zip64View, 2, length - 4);
+			let zip64FieldOffset = 4;
+			if (zip64UncompressedSize) { setBigUint64(zip64View, zip64FieldOffset, BigInt(uncompressedSize)); zip64FieldOffset += 8; }
+			if (zip64CompressedSize) { setBigUint64(zip64View, zip64FieldOffset, BigInt(compressedSize)); zip64FieldOffset += 8; }
+			if (zip64Offset) { setBigUint64(zip64View, zip64FieldOffset, BigInt(fileEntry.offset)); zip64FieldOffset += 8; }
+			if (zip64DiskNumberStart) { setUint32(zip64View, zip64FieldOffset, fileEntry.diskNumberStart); }
+		} else {
+			rawExtraFieldZip64 = new Uint8Array();
+		}
+		fileEntry.rawExtraFieldZip64 = rawExtraFieldZip64;
+		fileEntry.zip64Offset = zip64Offset;
+		fileEntry.zip64DiskNumberStart = zip64DiskNumberStart;
 		let rawExtraFieldTimestamp;
 		if (extendedTimestamp) {
 			rawExtraFieldTimestamp = new Uint8Array(9);
@@ -5715,7 +5661,6 @@ async function closeFile(zipWriter, comment, options) {
 			versionMadeBy,
 			headerArray,
 			headerView,
-			zip64,
 			zip64UncompressedSize,
 			zip64CompressedSize,
 			zip64DiskNumberStart,
@@ -5741,7 +5686,7 @@ async function closeFile(zipWriter, comment, options) {
 		directoryOffset += 2;
 		setUint16(directoryView, directoryOffset, getLength(rawComment));
 		directoryOffset += 2;
-		setUint16(directoryView, directoryOffset, zip64 && zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
+		setUint16(directoryView, directoryOffset, zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
 		directoryOffset += 2;
 		setUint16(directoryView, directoryOffset, internalFileAttributes);
 		directoryOffset += 2;
@@ -5749,7 +5694,7 @@ async function closeFile(zipWriter, comment, options) {
 			setUint32(directoryView, directoryOffset, externalFileAttributes);
 		}
 		directoryOffset += 4;
-		setUint32(directoryView, directoryOffset, zip64 && zip64Offset ? MAX_32_BITS : fileEntryOffset);
+		setUint32(directoryView, directoryOffset, zip64Offset ? MAX_32_BITS : fileEntryOffset);
 		directoryOffset += 4;
 		arraySet(directoryArray, rawFilename, directoryOffset);
 		directoryOffset += getLength(rawFilename);

package/index.d.ts

@@ -1448,8 +1448,7 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
   /**
    * `true` to keep the order of the entry physically in the zip file.
    *
-   * When set to `true`, the use of web workers will be improved. However, it also prevents files larger than 4GB from being created without setting the `zip64` option to `true` explicitly.
-   * Another solution to improve the use of web workers is to add entries from smallest to largest in uncompressed size.
+   * When set to `true`, the use of web workers will be improved.
    *
    * @defaultValue true
    */