@zip.js/zip.js 2.8.45 → 2.8.47

package/dist/zip-core.js

@@ -47,6 +47,7 @@
 	const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
 	const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
 	const ARCHIVE_EXTRA_DATA_SIGNATURE = 0x08064b50;
+	const DIGITAL_SIGNATURE_RECORD_SIGNATURE = 0x05054b50;
 	const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 	const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 	const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
@@ -176,6 +177,7 @@
 		"baseURI",
 		"wasmURI",
 		"workerURI",
+		"createWorker",
 		"chunkSize",
 		"maxWorkers",
 		"terminateWorkerTimeout",
@@ -186,8 +188,8 @@
 		"transferStreams",
 		"CompressionStream",
 		"DecompressionStream",
-		"CompressionStreamZlib",
-		"DecompressionStreamZlib"
+		"CompressionStreamFallback",
+		"DecompressionStreamFallback"
 	];
 
 	const config = { ...DEFAULT_CONFIGURATION };
@@ -201,6 +203,7 @@
 	}
 
 	function configure(configuration) {
+		configuration = normalizeConfiguration(configuration);
 		for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
 			const propertyValue = configuration[propertyName];
 			if (propertyValue !== UNDEFINED_VALUE) {
@@ -209,7 +212,23 @@
 		}
 	}
 
+	function normalizeConfiguration(configuration) {
+		const { CompressionStreamZlib, DecompressionStreamZlib } = configuration;
+		if (CompressionStreamZlib === UNDEFINED_VALUE && DecompressionStreamZlib === UNDEFINED_VALUE) {
+			return configuration;
+		}
+		const normalizedConfiguration = Object.assign({}, configuration);
+		if (normalizedConfiguration.CompressionStreamFallback === UNDEFINED_VALUE) {
+			normalizedConfiguration.CompressionStreamFallback = CompressionStreamZlib;
+		}
+		if (normalizedConfiguration.DecompressionStreamFallback === UNDEFINED_VALUE) {
+			normalizedConfiguration.DecompressionStreamFallback = DecompressionStreamZlib;
+		}
+		return normalizedConfiguration;
+	}
+
 	function setDefaultConfiguration(configuration) {
+		configuration = normalizeConfiguration(configuration);
 		for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
 			const propertyValue = configuration[propertyName];
 			if (propertyValue !== UNDEFINED_VALUE) {
@@ -1936,7 +1955,7 @@
 
 	class DeflateStream extends TransformStream {
 
-		constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
+		constructor(options, { chunkSize, CompressionStreamFallback, CompressionStream }) {
 			super({});
 			const { compressed, encrypted, useCompressionStream, zipCrypto, computeCrc32, level, deflate64, format, compressionMethod } = options;
 			const stream = this;
@@ -1958,7 +1977,7 @@
 					readable = pipeThrough(readable, gzipCrc32Stream);
 				} else {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 					} catch (error) {
 						let gzipStream;
 						try {
@@ -2100,7 +2119,7 @@
 
 	class InflateStream extends TransformStream {
 
-		constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
+		constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream }) {
 			super({});
 			const { zipCrypto, encrypted, checkCrc32, crc32, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
 			let crc32Stream, decryptionStream;
@@ -2119,7 +2138,7 @@
 					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
 				} else {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
 					} catch (error) {
 						if (deflate64 || outputSize === UNDEFINED_VALUE) {
 							throw error;
@@ -2198,17 +2217,17 @@
 		return new CodecStreamClass(format, options);
 	}
 
-	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib) {
+	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
 		const Stream = useCompressionStream && CompressionStreamNative ?
 			CompressionStreamNative :
-			CompressionStreamZlib || CompressionStreamNative;
+			CompressionStreamFallback || CompressionStreamNative;
 		const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
 		let codecStream;
 		try {
 			codecStream = new Stream(format, options);
 		} catch (error) {
-			if (useCompressionStream && CompressionStreamZlib && Stream != CompressionStreamZlib) {
-				codecStream = new CompressionStreamZlib(format, options);
+			if (useCompressionStream && CompressionStreamFallback && Stream != CompressionStreamFallback) {
+				codecStream = new CompressionStreamFallback(format, options);
 			} else {
 				throw error;
 			}
@@ -2471,7 +2490,7 @@
 	const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
 	const ERR_WORKER_STARTUP_TIMEOUT = "Worker startup timeout";
 
-	let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions;
+	let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions, createWorkerFailed;
 	let transferStreamsSupported = true;
 	try {
 		transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
@@ -2481,14 +2500,14 @@
 	let initModule = () => { };
 
 	async function supportsDeflate(config) {
-		const { CompressionStream: NativeStream, CompressionStreamZlib: ZlibStream } = config;
-		if (ZlibStream && !ZlibStream.requiresModule) {
+		const { CompressionStream: NativeStream, CompressionStreamFallback: FallbackStream } = config;
+		if (FallbackStream && !FallbackStream.requiresModule) {
 			return true;
 		}
 		if (supportsDeflateRaw(NativeStream) || supportsGzip(NativeStream)) {
 			return true;
 		}
-		if (ZlibStream) {
+		if (FallbackStream) {
 			try {
 				await initModule(config);
 				return true;
@@ -2501,12 +2520,16 @@
 
 	function resetWebWorkerSupport() {
 		webWorkerSupported = UNDEFINED_VALUE;
+		createWorkerFailed = false;
 	}
 
 	class CodecWorker {
 
-		constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI }, onTaskFinished) {
+		constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI, createWorker }, onTaskFinished) {
 			const { signal } = streamOptions;
+			if (createWorkerFailed) {
+				createWorker = UNDEFINED_VALUE;
+			}
 			Object.assign(workerData, {
 				busy: true,
 				generation: (workerData.generation || 0) + 1,
@@ -2516,6 +2539,7 @@
 				writable,
 				options: Object.assign({}, options),
 				workerURI,
+				createWorker,
 				transferStreams,
 				terminate() {
 					return new Promise(resolve => {
@@ -2551,7 +2575,7 @@
 				// deno-lint-ignore valid-typeof
 				webWorkerSupported = typeof Worker != UNDEFINED_TYPE;
 			}
-			return (useWebWorkers && webWorkerSupported ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
+			return (useWebWorkers && ((webWorkerSupported && workerURI) || createWorker) ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
 		}
 	}
 
@@ -2608,7 +2632,11 @@
 			try {
 				worker = getWebWorker(workerData.workerURI, baseURI, workerData);
 			} catch {
-				webWorkerSupported = false;
+				if (workerData.createWorker) {
+					createWorkerFailed = true;
+				} else {
+					webWorkerSupported = false;
+				}
 				return createWorkerInterface(workerData, config);
 			}
 			Object.assign(workerData, {
@@ -2621,7 +2649,11 @@
 							return await runWebWorker(workerData, { chunkSize, wasmURI, baseURI, workerStartupTimeout });
 						} catch (error) {
 							if (error && error.workerStartupFailed) {
-								webWorkerSupported = false;
+								if (workerData.createWorker) {
+									createWorkerFailed = true;
+								} else {
+									webWorkerSupported = false;
+								}
 								const { reader } = workerData;
 								if (reader) {
 									reader.releaseLock();
@@ -2644,17 +2676,17 @@
 		try {
 			if (options.compressed && !options.format) {
 				const deflate = options.codecType.startsWith(CODEC_DEFLATE);
-				const ZlibStream = deflate ? config.CompressionStreamZlib : config.DecompressionStreamZlib;
+				const FallbackStream = deflate ? config.CompressionStreamFallback : config.DecompressionStreamFallback;
 				const NativeStream = deflate ? config.CompressionStream : config.DecompressionStream;
 				if (!options.useCompressionStream) {
 					try {
 						await initModule(config);
 					} catch {
-						if (!ZlibStream || ZlibStream.requiresModule) {
+						if (!FallbackStream || FallbackStream.requiresModule) {
 							options.useCompressionStream = true;
 						}
 					}
-				} else if (ZlibStream && ZlibStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
+				} else if (FallbackStream && FallbackStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
 					try {
 						await initModule(config);
 					} catch {
@@ -2779,8 +2811,11 @@
 	}
 
 	function getWebWorker(url, baseURI, workerData, isModuleType, useBlobURI = true) {
+		const { createWorker } = workerData;
 		let worker, resolvedURI, resolvedOptions;
-		if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
+		if (createWorker) {
+			worker = createWorker();
+		} else if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
 			// deno-lint-ignore valid-typeof
 			const isFunctionURI = typeof url == FUNCTION_TYPE;
 			if (isFunctionURI) {
@@ -3035,7 +3070,7 @@
 	async function runWorker(stream, workerOptions) {
 		const { options, config } = workerOptions;
 		const { transferStreams, useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
-		const { workerURI, maxWorkers } = config;
+		const { workerURI, createWorker, maxWorkers } = config;
 		if (format) {
 			if (codecURI) {
 				options.codecURI = resolveCodecURI(codecURI, config.baseURI);
@@ -3047,6 +3082,7 @@
 		const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
 		workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 		workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
+		workerOptions.createWorker = workerOptions.useWebWorkers && createWorker ? createWorker : UNDEFINED_VALUE;
 		options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 		return (await getWorker()).run();
 
@@ -3110,7 +3146,7 @@
 		starvationTimeout = null;
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
-			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE });
+			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
 			resolve(new CodecWorker({}, stream, inlineWorkerOptions, onInlineTaskFinished));
 			armStarvationTimeout();
 		}
@@ -4419,6 +4455,8 @@
 	const OPTION_LOCAL_EXTRA_FIELD = "localExtraField";
 	const OPTION_STRICTNESS = "strictness";
 	const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
+	const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
+	const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
 	const STRICTNESS_STRICT = "strict";
 	const STRICTNESS_BALANCED = "balanced";
 	const STRICTNESS_TOLERANT = "tolerant";
@@ -4544,6 +4582,7 @@
 			let startOffset;
 			let zip64EndOfDirectory;
 			let zip64EndOfDirectoryVersion2;
+			let directoryEncryptionInfo;
 			const requiresZip64 = directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS;
 			if (directoryDataOffset != MAX_32_BITS && diskNumber != MAX_16_BITS) {
 				directoryDataOffset += getDiskOffset$1(reader, diskNumber);
@@ -4574,6 +4613,15 @@
 					}
 					zip64EndOfDirectory = true;
 					zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
+					if (zip64EndOfDirectoryVersion2) {
+						const extensibleDataLength = Math.min(
+							Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
+							reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+						if (extensibleDataLength > 0) {
+							const rawExtensibleData = await readUint8Array(reader, directoryDataOffset + ZIP64_END_OF_CENTRAL_DIR_LENGTH, extensibleDataLength);
+							directoryEncryptionInfo = getDirectoryEncryptionInfo(rawExtensibleData);
+						}
+					}
 					if (lastDiskNumber == MAX_16_BITS) {
 						lastDiskNumber = getUint32(endOfDirectoryView, 16);
 					} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
@@ -4597,7 +4645,7 @@
 					directoryDataOffset = getDiskOffset$1(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 				}
 			}
-			const declaredDirectoryDataLength = directoryDataLength;
+			let declaredDirectoryDataLength = directoryDataLength;
 			const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
 				(zip64EndOfDirectory ? ZIP64_END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
 			if (directoryDataOffset >= reader.size) {
@@ -4645,6 +4693,18 @@
 			if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 				throw new Error(ERR_BAD_FORMAT);
 			}
+			zipReader.directoryOffset = directoryDataOffset;
+			zipReader.directoryLength = declaredDirectoryDataLength;
+			const decryptCentralDirectory = getOptionValue$1(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
+			let decryptedDirectory;
+			if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
+				getUint32(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
+				(zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+				directoryArray = await decryptCentralDirectory(directoryArray, directoryEncryptionInfo);
+				directoryView = getDataView(directoryArray);
+				declaredDirectoryDataLength = directoryArray.length;
+				decryptedDirectory = true;
+			}
 			startOffset = directoryDataOffset;
 			const filenameEncoding = getOptionValue$1(zipReader, options, OPTION_FILENAME_ENCODING);
 			const commentEncoding = getOptionValue$1(zipReader, options, OPTION_COMMENT_ENCODING);
@@ -4653,7 +4713,7 @@
 			for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 				const fileEntry = new ZipEntry(reader, config, zipReader.options);
 				if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
-					if (indexFile == 0 && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+					if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 						throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
 					}
 					throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
@@ -4766,7 +4826,15 @@
 				}
 				yield entry;
 			}
-			if (checkAmbiguity && offset != declaredDirectoryDataLength) {
+			let offsetAfterSignature = offset;
+			if (offset + 6 <= directoryArray.length && getUint32(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+				const signatureDataLength = getUint16(directoryView, offset + 4);
+				if (offset + 6 + signatureDataLength <= directoryArray.length) {
+					zipReader.digitalSignature = directoryArray.subarray(offset + 6, offset + 6 + signatureDataLength);
+					offsetAfterSignature = offset + 6 + signatureDataLength;
+				}
+			}
+			if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
 				throwAmbiguousArchive("trailing central directory data");
 			}
 			if (duplicateFilename) {
@@ -5038,6 +5106,25 @@
 		return false;
 	}
 
+	function getDirectoryEncryptionInfo(rawExtensibleData) {
+		const directoryEncryptionInfo = { rawExtensibleData };
+		if (rawExtensibleData.length >= 28) {
+			const extensibleDataView = getDataView(rawExtensibleData);
+			const hashDataLength = getUint16(extensibleDataView, 26);
+			Object.assign(directoryEncryptionInfo, {
+				compressionMethod: getUint16(extensibleDataView, 0),
+				compressedSize: Number(getBigUint64(extensibleDataView, 2)),
+				uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
+				encryptionAlgorithm: getUint16(extensibleDataView, 18),
+				bitLength: getUint16(extensibleDataView, 20),
+				flags: getUint16(extensibleDataView, 22),
+				hashAlgorithm: getUint16(extensibleDataView, 24),
+				hashData: rawExtensibleData.subarray(28, 28 + hashDataLength)
+			});
+		}
+		return directoryEncryptionInfo;
+	}
+
 	function readCommonHeader(directory, dataView, offset) {
 		const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset + 2);
 		const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;
@@ -5589,6 +5676,7 @@
 		ERR_SPLIT_ZIP_FILE: ERR_SPLIT_ZIP_FILE,
 		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
 		ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
+		ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
 		ZipReader: ZipReader,
 		ZipReaderStream: ZipReaderStream
 	});
@@ -5647,6 +5735,7 @@
 	const ERR_INVALID_UNIX_ID_SIZE = "uid/gid must be 0..65535 for unixExtraFieldType 'unix' (use 'infozip' for larger ids)";
 	const ERR_INVALID_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be integer 0..255)";
 	const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
+	const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
 
 	const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 	const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
@@ -7006,8 +7095,9 @@
 
 	async function closeFile(zipWriter, comment, options) {
 		const directoryDataLength = createDirectoryRecords(zipWriter.files);
-		const directoryStart = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
-		await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength });
+		const { directoryStart, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+		const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
+		await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength, signatureLength });
 	}
 
 	function createDirectoryRecords(files) {
@@ -7164,12 +7254,33 @@
 			}
 		}
 		await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
-		return { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset };
+		return {
+			directoryStart: { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset },
+			directoryArray
+		};
+	}
+
+	async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
+		const signCentralDirectory = getOptionValue(zipWriter, options, OPTION_SIGN_CENTRAL_DIRECTORY);
+		if (signCentralDirectory) {
+			const signatureData = await signCentralDirectory(directoryArray);
+			const signatureDataLength = getLength(signatureData);
+			if (signatureDataLength > MAX_16_BITS) {
+				throw new Error(ERR_INVALID_SIGNATURE_DATA);
+			}
+			const signatureRecord = createRecordWriter(6 + signatureDataLength);
+			signatureRecord.uint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
+			signatureRecord.uint16(signatureDataLength);
+			signatureRecord.bytes(signatureData);
+			await writeData(zipWriter.writer, signatureRecord.array);
+			return 6 + signatureDataLength;
+		}
+		return 0;
 	}
 
 	async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		const { writer } = zipWriter;
-		const { directoryStart } = cdInfo;
+		const { directoryStart, signatureLength } = cdInfo;
 		let { directoryDataLength } = cdInfo;
 		let filesLength = zipWriter.files.size;
 		let diskNumber = directoryStart.diskNumber;
@@ -7208,7 +7319,7 @@
 			endOfdirectoryRecord.uint64(directoryOffset);
 			endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
 			endOfdirectoryRecord.uint32(lastDiskNumber);
-			endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength));
+			endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength) + BigInt(signatureLength));
 			endOfdirectoryRecord.uint32(lastDiskNumber + 1);
 			const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 			if (supportZip64SplitFile) {
@@ -7913,9 +8024,17 @@
 	exports.ERR_INVALID_ENTRY_NAME = ERR_INVALID_ENTRY_NAME;
 	exports.ERR_INVALID_EXTRAFIELD_DATA = ERR_INVALID_EXTRAFIELD_DATA;
 	exports.ERR_INVALID_EXTRAFIELD_TYPE = ERR_INVALID_EXTRAFIELD_TYPE;
+	exports.ERR_INVALID_GID = ERR_INVALID_GID;
+	exports.ERR_INVALID_MSDOS_ATTRIBUTES = ERR_INVALID_MSDOS_ATTRIBUTES;
+	exports.ERR_INVALID_MSDOS_DATA = ERR_INVALID_MSDOS_DATA;
 	exports.ERR_INVALID_PASSWORD = ERR_INVALID_PASSWORD;
 	exports.ERR_INVALID_SIGNATURE = ERR_INVALID_SIGNATURE;
+	exports.ERR_INVALID_SIGNATURE_DATA = ERR_INVALID_SIGNATURE_DATA;
+	exports.ERR_INVALID_UID = ERR_INVALID_UID;
 	exports.ERR_INVALID_UNCOMPRESSED_SIZE = ERR_INVALID_UNCOMPRESSED_SIZE;
+	exports.ERR_INVALID_UNIX_EXTRA_FIELD_TYPE = ERR_INVALID_UNIX_EXTRA_FIELD_TYPE;
+	exports.ERR_INVALID_UNIX_ID_SIZE = ERR_INVALID_UNIX_ID_SIZE;
+	exports.ERR_INVALID_UNIX_MODE = ERR_INVALID_UNIX_MODE;
 	exports.ERR_INVALID_VERSION = ERR_INVALID_VERSION;
 	exports.ERR_ITERATOR_COMPLETED_TOO_SOON = ERR_ITERATOR_COMPLETED_TOO_SOON;
 	exports.ERR_LOCAL_FILE_HEADER_NOT_FOUND = ERR_LOCAL_FILE_HEADER_NOT_FOUND;
@@ -7925,9 +8044,12 @@
 	exports.ERR_UNDEFINED_READER = ERR_UNDEFINED_READER;
 	exports.ERR_UNDEFINED_UNCOMPRESSED_SIZE = ERR_UNDEFINED_UNCOMPRESSED_SIZE;
 	exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION$1;
+	exports.ERR_UNSUPPORTED_CONTEXT = ERR_UNSUPPORTED_CONTEXT;
+	exports.ERR_UNSUPPORTED_CRYPTO_API = ERR_UNSUPPORTED_CRYPTO_API;
 	exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
 	exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+	exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;
 	exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;
 	exports.ERR_ZIP_NOT_EMPTY = ERR_ZIP_NOT_EMPTY;
 	exports.HttpRangeReader = HttpRangeReader;