@zip.js/zip.js 2.7.63 → 2.7.64

package/index.cjs

@@ -4287,6 +4287,8 @@ const VERSION_AES = 0x33;
 
 const DIRECTORY_SIGNATURE = "/";
 
+const HEADER_SIZE = 26;
+
 const MAX_DATE = new Date(2107, 11, 31);
 const MIN_DATE = new Date(1980, 0, 1);
 
@@ -8868,6 +8870,7 @@ class Uint8ArrayReader extends Reader {
 
 	constructor(array) {
 		super();
+		array = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
 		Object.assign(this, {
 			array,
 			size: array.length
@@ -9562,7 +9565,8 @@ let ZipEntry$1 = class ZipEntry {
 			compressedSize
 		} = zipEntry;
 		const localDirectory = fileEntry.localDirectory = {};
-		const dataArray = await readUint8Array(reader, offset, 30, diskNumberStart);
+		const dataArraySize = HEADER_SIZE + 4;
+		const dataArray = await readUint8Array(reader, offset, dataArraySize + 4, diskNumberStart);
 		const dataView = getDataView$1(dataArray);
 		let password = getOptionValue$1(zipEntry, options, "password");
 		let rawPassword = getOptionValue$1(zipEntry, options, "rawPassword");
@@ -9582,7 +9586,7 @@ let ZipEntry$1 = class ZipEntry {
 		}
 		readCommonHeader(localDirectory, dataView, 4);
 		localDirectory.rawExtraField = localDirectory.extraFieldLength ?
-			await readUint8Array(reader, offset + 30 + localDirectory.filenameLength, localDirectory.extraFieldLength, diskNumberStart) :
+			await readUint8Array(reader, offset + dataArraySize + localDirectory.filenameLength, localDirectory.extraFieldLength, diskNumberStart) :
 			new Uint8Array();
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
 		Object.assign(fileEntry, {
@@ -9601,7 +9605,7 @@ let ZipEntry$1 = class ZipEntry {
 				throw new Error(ERR_ENCRYPTED);
 			}
 		}
-		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
+		const dataOffset = offset + dataArraySize + localDirectory.filenameLength + localDirectory.extraFieldLength;
 		const size = compressedSize;
 		const readable = reader.readable;
 		Object.assign(readable, {
@@ -9963,6 +9967,7 @@ 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_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
+const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 
@@ -9990,6 +9995,99 @@ class ZipWriter {
 		});
 	}
 
+	async prependZip(reader) {
+		if (this.filenames.size) {
+			throw new Error(ERR_ZIP_NOT_EMPTY);
+		}
+		({ reader } = initReader(reader));
+		const [zipEntriesReader, zipDataReader] = reader.readable.tee();
+		const zipReader = new ZipReader(new ReadableStream({
+			async start(controller) {
+				const reader = zipEntriesReader.getReader();
+				await readChunk();
+
+				async function readChunk() {
+					const { done, value } = await reader.read();
+					if (done) {
+						controller.close();
+					} else {
+						controller.enqueue(value);
+						await readChunk();
+					}
+				}
+			}
+		}));
+		const entries = await zipReader.getEntries();
+		await zipReader.close();
+		await zipDataReader.pipeTo(this.writer.writable, { preventClose: true, preventAbort: true });
+		this.writer.writable.size = this.offset = reader.size;
+		this.filenames = new Set(entries.map(entry => entry.filename));
+		this.files = new Map(entries.map(entry => {
+			const {
+				version,
+				compressionMethod,
+				lastModDate,
+				lastAccessDate,
+				creationDate,
+				rawFilename,
+				bitFlag,
+				encrypted,
+				uncompressedSize,
+				compressedSize,
+				diskOffset,
+				diskNumber,
+				zip64
+			} = entry;
+			let {
+				rawExtraFieldZip64,
+				rawExtraFieldAES,
+				rawExtraFieldExtendedTimestamp,
+				rawExtraFieldNTFS,
+				rawExtraField,
+			} = entry;
+			const { level, languageEncodingFlag, dataDescriptor } = bitFlag;
+			rawExtraFieldZip64 = rawExtraFieldZip64 || new Uint8Array();
+			rawExtraFieldAES = rawExtraFieldAES || new Uint8Array();
+			rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || new Uint8Array();
+			rawExtraFieldNTFS = rawExtraFieldNTFS || new Uint8Array();
+			rawExtraField = rawExtraField || new Uint8Array();
+			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
+			const zip64UncompressedSize = zip64 && uncompressedSize > MAX_32_BITS;
+			const zip64CompressedSize = zip64 && compressedSize > MAX_32_BITS;
+			const {
+				headerArray,
+				headerView
+			} = getHeaderArrayData({
+				version,
+				bitflag: getBitflag(level, languageEncodingFlag, dataDescriptor, encrypted),
+				compressionMethod,
+				uncompressedSize,
+				compressedSize,
+				lastModDate,
+				rawFilename,
+				zip64CompressedSize,
+				zip64UncompressedSize,
+				extraFieldLength
+			});
+			Object.assign(entry, {
+				zip64UncompressedSize,
+				zip64CompressedSize,
+				zip64Offset: zip64 && this.offset - diskOffset > MAX_32_BITS,
+				zip64DiskNumberStart: zip64 && diskNumber > MAX_16_BITS,
+				rawExtraFieldZip64,
+				rawExtraFieldAES,
+				rawExtraFieldExtendedTimestamp,
+				rawExtraFieldNTFS,
+				rawExtraField,
+				extendedTimestamp: rawExtraFieldExtendedTimestamp.length > 0 || rawExtraFieldNTFS.length > 0,
+				extraFieldExtendedTimestampFlag: 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0),
+				headerArray,
+				headerView
+			});
+			return [entry.filename, entry];
+		}));
+	}
+
 	async add(name = "", reader, options = {}) {
 		const zipWriter = this;
 		const {
@@ -10025,6 +10123,22 @@ class ZipWriter {
 		}
 	}
 
+	remove(entry) {
+		const { filenames, files } = this;
+		if (typeof entry == "string") {
+			entry = files.get(entry);
+		}
+		if (entry && entry.filename !== UNDEFINED_VALUE) {
+			const { filename } = entry;
+			if (filenames.has(filename) && files.has(filename)) {
+				filenames.delete(filename);
+				files.delete(filename);
+				return true;
+			}
+		}
+		return false;
+	}
+
 	async close(comment = new Uint8Array(), options = {}) {
 		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
@@ -10146,7 +10260,13 @@ async function addFile(zipWriter, name, reader, options) {
 	const useUnicodeFileNames = getOptionValue(zipWriter, options, "useUnicodeFileNames", true);
 	const useCompressionStream = getOptionValue(zipWriter, options, "useCompressionStream");
 	const compressionMethod = getOptionValue(zipWriter, options, "compressionMethod");
-	let dataDescriptor = getOptionValue(zipWriter, options, "dataDescriptor", true);
+	let dataDescriptor = getOptionValue(zipWriter, options, "dataDescriptor");
+	if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
+		dataDescriptor = false;
+	}
+	if (dataDescriptor === UNDEFINED_VALUE || zipCrypto) {
+		dataDescriptor = true;
+	}
 	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 	if (!zipCrypto && (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) && !(encryptionStrength >= 1 && encryptionStrength <= 3)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
@@ -10192,10 +10312,11 @@ async function addFile(zipWriter, name, reader, options) {
 					uncompressedSize = maximumCompressedSize = MAX_32_BITS + 1;
 				}
 			} else {
-				uncompressedSize = reader.size;
+				options.uncompressedSize = uncompressedSize = reader.size;
 				maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 			}
 		} else {
+			options.uncompressedSize = uncompressedSize;
 			maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 		}
 	}
@@ -10251,7 +10372,10 @@ async function addFile(zipWriter, name, reader, options) {
 		passThrough,
 		encrypted: Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted),
 		signature,
-		compressionMethod
+		compressionMethod,
+		uncompressedSize,
+		offset: zipWriter.offset - diskOffset,
+		diskNumberStart: diskNumber,
 	});
 	const headerInfo = getHeaderInfo(options);
 	const dataDescriptorInfo = getDataDescriptorInfo(options);
@@ -10343,20 +10467,26 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await lockPreviousFileEntry;
 			await requestLockWriter();
 			writingBufferedEntryData = true;
-			if (!dataDescriptor) {
-				blob = await writeExtraHeaderInfo(fileEntry, blob, writable, options);
-			}
-			await skipDiskIfNeeded(writable);
 			fileEntry.diskNumberStart = writer.diskNumber;
 			diskOffset = writer.diskOffset;
+			fileEntry.offset = zipWriter.offset - diskOffset;
+			if (fileEntry.zip64) {
+				setExtraFieldZip64Data(fileEntry);
+			}
+			if (fileEntry.zip64 || !dataDescriptor) {
+				blob = await patchLocalHeader(fileEntry, blob, writable, options);
+			}
+			await skipDiskIfNeeded(writable);
 			await blob.stream().pipeTo(writable, { preventClose: true, preventAbort: true, signal });
 			writable.size += blob.size;
 			writingBufferedEntryData = false;
+		} else {
+			fileEntry.offset = zipWriter.offset - diskOffset;
+			if (fileEntry.zip64) {
+				setExtraFieldZip64Data(fileEntry);
+			}
 		}
-		fileEntry.offset = zipWriter.offset - diskOffset;
-		if (fileEntry.zip64) {
-			setZip64ExtraInfo(fileEntry, options);
-		} else if (fileEntry.offset > MAX_32_BITS) {
+		if (fileEntry.offset > MAX_32_BITS && !fileEntry.zip64) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
 		zipWriter.offset += fileEntry.size;
@@ -10423,12 +10553,15 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	const {
 		localHeaderArray,
 		headerArray,
+		headerView,
 		lastModDate,
 		rawLastModDate,
 		encrypted,
 		compressed,
 		version,
 		compressionMethod,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		extraFieldExtendedTimestampFlag,
 		rawExtraFieldNTFS,
@@ -10477,6 +10610,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawFilename,
 		commentUTF8: true,
 		rawComment,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldAES,
@@ -10530,28 +10665,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	} else {
 		await writeData(writable, localHeaderArray);
 	}
-	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();
-	}
 	setEntryInfo({
 		signature,
-		rawExtraFieldZip64,
 		compressedSize,
 		uncompressedSize,
 		headerInfo,
@@ -10573,8 +10688,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		compressionMethod,
 		version,
 		headerArray,
+		headerView,
 		signature,
-		rawExtraFieldZip64,
 		extraFieldExtendedTimestampFlag,
 		zip64UncompressedSize,
 		zip64CompressedSize,
@@ -10599,10 +10714,62 @@ function getHeaderInfo(options) {
 		rawExtraField,
 		encryptionStrength,
 		extendedTimestamp,
-		encrypted
+		passThrough,
+		encrypted,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart,
+		uncompressedSize,
+		offset,
+		diskNumberStart
 	} = options;
 	let { version, compressionMethod } = options;
 	const compressed = !directory && (level > 0 || (level === UNDEFINED_VALUE && compressionMethod !== 0));
+	let rawExtraFieldZip64;
+	const uncompressedFile = passThrough || !compressed;
+	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
+	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);
+		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
+		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
+		setUint16(rawExtraFieldZip64View, 2, getLength(rawExtraFieldZip64) - 4);
+		if (zip64ExtraFieldComplete) {
+			const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
+			let rawExtraFieldZip64Offset = 4;
+			if (zip64UncompressedSize) {
+				setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
+				rawExtraFieldZip64Offset += 8;
+			}
+			if (zip64CompressedSize && uncompressedFile) {
+				setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
+				rawExtraFieldZip64Offset += 8;
+			}
+			if (zip64Offset) {
+				setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(offset));
+				rawExtraFieldZip64Offset += 8;
+			}
+			if (zip64DiskNumberStart) {
+				setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, diskNumberStart);
+				rawExtraFieldZip64Offset += 4;
+			}
+		}
+	} else {
+		rawExtraFieldZip64 = new Uint8Array();
+	}
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
 		rawExtraFieldAES = new Uint8Array(getLength(EXTRAFIELD_DATA_AES) + 2);
@@ -10651,69 +10818,52 @@ function getHeaderInfo(options) {
 	} else {
 		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 	}
-	let bitFlag = 0;
-	if (useUnicodeFileNames) {
-		bitFlag = bitFlag | BITFLAG_LANG_ENCODING_FLAG;
-	}
-	if (dataDescriptor) {
-		bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
-	}
 	if (compressionMethod === UNDEFINED_VALUE) {
 		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
 	}
-	if (compressionMethod == COMPRESSION_METHOD_DEFLATE) {
-		if (level >= 1 && level < 3) {
-			bitFlag = bitFlag | 0b110;
-		}
-		if (level >= 3 && level < 5) {
-			bitFlag = bitFlag | 0b01;
-		}
-		if (level === 9) {
-			bitFlag = bitFlag | 0b10;
-		}
-	}
 	if (zip64) {
 		version = version > VERSION_ZIP64 ? version : VERSION_ZIP64;
 	}
-	if (encrypted) {
-		bitFlag = bitFlag | BITFLAG_ENCRYPTED;
-		if (!zipCrypto) {
-			version = version > VERSION_AES ? version : VERSION_AES;
-			rawExtraFieldAES[9] = compressionMethod;
-			compressionMethod = COMPRESSION_METHOD_AES;
-		}
-	}
-	const headerArray = new Uint8Array(26);
-	const headerView = getDataView(headerArray);
-	setUint16(headerView, 0, version);
-	setUint16(headerView, 2, bitFlag);
-	setUint16(headerView, 4, compressionMethod);
-	const dateArray = new Uint32Array(1);
-	const dateView = getDataView(dateArray);
-	let lastModDateMsDos;
-	if (lastModDate < MIN_DATE) {
-		lastModDateMsDos = MIN_DATE;
-	} else if (lastModDate > MAX_DATE) {
-		lastModDateMsDos = MAX_DATE;
-	} else {
-		lastModDateMsDos = lastModDate;
+	if (encrypted && !zipCrypto) {
+		version = version > VERSION_AES ? version : VERSION_AES;
+		rawExtraFieldAES[9] = compressionMethod;
+		compressionMethod = COMPRESSION_METHOD_AES;
 	}
-	setUint16(dateView, 0, (((lastModDateMsDos.getHours() << 6) | lastModDateMsDos.getMinutes()) << 5) | lastModDateMsDos.getSeconds() / 2);
-	setUint16(dateView, 2, ((((lastModDateMsDos.getFullYear() - 1980) << 4) | (lastModDateMsDos.getMonth() + 1)) << 5) | lastModDateMsDos.getDate());
-	const rawLastModDate = dateArray[0];
-	setUint32(headerView, 6, rawLastModDate);
-	setUint16(headerView, 22, getLength(rawFilename));
-	const extraFieldLength = getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
-	setUint16(headerView, 24, extraFieldLength);
-	const localHeaderArray = new Uint8Array(30 + getLength(rawFilename) + extraFieldLength);
+	const localExtraFieldZip64Length = zip64ExtraFieldComplete ? getLength(rawExtraFieldZip64) : 0;
+	const extraFieldLength = localExtraFieldZip64Length + getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
+	const {
+		headerArray,
+		headerView,
+		rawLastModDate
+	} = getHeaderArrayData({
+		version,
+		bitflag: getBitflag(level, useUnicodeFileNames, dataDescriptor, encrypted),
+		compressionMethod,
+		uncompressedSize,
+		lastModDate: lastModDate < MIN_DATE ? MIN_DATE : lastModDate > MAX_DATE ? MAX_DATE : lastModDate,
+		rawFilename,
+		zip64CompressedSize,
+		zip64UncompressedSize,
+		extraFieldLength
+	});
+	let localHeaderOffset = HEADER_SIZE + 4;
+	const localHeaderArray = new Uint8Array(localHeaderOffset + getLength(rawFilename) + extraFieldLength);
 	const localHeaderView = getDataView(localHeaderArray);
 	setUint32(localHeaderView, 0, LOCAL_FILE_HEADER_SIGNATURE);
 	arraySet(localHeaderArray, headerArray, 4);
-	arraySet(localHeaderArray, rawFilename, 30);
-	arraySet(localHeaderArray, rawExtraFieldAES, 30 + getLength(rawFilename));
-	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, 30 + getLength(rawFilename, rawExtraFieldAES));
-	arraySet(localHeaderArray, rawExtraFieldNTFS, 30 + getLength(rawFilename, rawExtraFieldAES, rawExtraFieldExtendedTimestamp));
-	arraySet(localHeaderArray, rawExtraField, 30 + getLength(rawFilename, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS));
+	arraySet(localHeaderArray, rawFilename, localHeaderOffset);
+	localHeaderOffset += getLength(rawFilename);
+	if (zip64ExtraFieldComplete) {
+		arraySet(localHeaderArray, rawExtraFieldZip64, localHeaderOffset);
+	}
+	localHeaderOffset += localExtraFieldZip64Length;
+	arraySet(localHeaderArray, rawExtraFieldAES, localHeaderOffset);
+	localHeaderOffset += getLength(rawExtraFieldAES);
+	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, localHeaderOffset);
+	localHeaderOffset += getLength(rawExtraFieldExtendedTimestamp);
+	arraySet(localHeaderArray, rawExtraFieldNTFS, localHeaderOffset);
+	localHeaderOffset += getLength(rawExtraFieldNTFS);
+	arraySet(localHeaderArray, rawExtraField, localHeaderOffset);
 	return {
 		localHeaderArray,
 		headerArray,
@@ -10725,6 +10875,8 @@ function getHeaderInfo(options) {
 		version,
 		compressionMethod,
 		extraFieldExtendedTimestampFlag,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldAES,
@@ -10779,7 +10931,6 @@ function getDataDescriptorInfo(options) {
 function setEntryInfo(entryInfo, options) {
 	const {
 		signature,
-		rawExtraFieldZip64,
 		compressedSize,
 		uncompressedSize,
 		headerInfo,
@@ -10795,8 +10946,6 @@ function setEntryInfo(entryInfo, options) {
 	} = dataDescriptorInfo;
 	const {
 		zip64,
-		zip64UncompressedSize,
-		zip64CompressedSize,
 		zipCrypto,
 		dataDescriptor
 	} = options;
@@ -10807,19 +10956,6 @@ function setEntryInfo(entryInfo, options) {
 		}
 	}
 	if (zip64) {
-		const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
-		setUint16(rawExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-		setUint16(rawExtraFieldZip64View, 2, getLength(rawExtraFieldZip64) - 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));
@@ -10834,44 +10970,82 @@ function setEntryInfo(entryInfo, options) {
 	}
 }
 
-async function writeExtraHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
+async function patchLocalHeader(fileEntry, entryData, writable, { zipCrypto, dataDescriptor }) {
+	const {
+		zip64,
+		rawFilename,
+		localExtraFieldZip64Length,
+		signature,
+		encrypted,
+		zip64UncompressedSize,
+		zip64CompressedSize,
+		zip64Offset,
+		zip64DiskNumberStart,
+		uncompressedSize,
+		compressedSize,
+		offset,
+		diskNumberStart
+	} = fileEntry;
 	let arrayBuffer;
-	arrayBuffer = await entryData.slice(0, 26).arrayBuffer();
-	if (arrayBuffer.byteLength != 26) {
-		arrayBuffer = arrayBuffer.slice(0, 26);
+	let rawExtraFieldZip64Offset = HEADER_SIZE + 4 + getLength(rawFilename);
+	const arrayBufferSize = zip64 && localExtraFieldZip64Length ? rawExtraFieldZip64Offset + localExtraFieldZip64Length : HEADER_SIZE;
+	arrayBuffer = await entryData.slice(0, arrayBufferSize).arrayBuffer();
+	if (arrayBuffer.byteLength != arrayBufferSize) {
+		arrayBuffer = arrayBuffer.slice(0, arrayBufferSize);
 	}
 	const arrayBufferView = new DataView(arrayBuffer);
-	if (!fileEntry.encrypted || zipCrypto) {
-		setUint32(arrayBufferView, 14, fileEntry.signature);
+	if (!dataDescriptor) {
+		if (!encrypted || zipCrypto) {
+			setUint32(arrayBufferView, 14, signature);
+		}
+		if (!zip64) {
+			setUint32(arrayBufferView, 18, compressedSize);
+			setUint32(arrayBufferView, 22, uncompressedSize);
+		}
 	}
-	if (fileEntry.zip64) {
+	if (zip64) {
 		setUint32(arrayBufferView, 18, MAX_32_BITS);
 		setUint32(arrayBufferView, 22, MAX_32_BITS);
-	} else {
-		setUint32(arrayBufferView, 18, fileEntry.compressedSize);
-		setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
+		if (localExtraFieldZip64Length) {
+			rawExtraFieldZip64Offset += 4;
+			if (zip64UncompressedSize) {
+				setBigUint64(arrayBufferView, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
+				rawExtraFieldZip64Offset += 8;
+			}
+			if (zip64CompressedSize) {
+				setBigUint64(arrayBufferView, rawExtraFieldZip64Offset, BigInt(compressedSize));
+				rawExtraFieldZip64Offset += 8;
+			}
+			if (zip64Offset) {
+				setBigUint64(arrayBufferView, rawExtraFieldZip64Offset, BigInt(offset));
+				rawExtraFieldZip64Offset += 8;
+			}
+			if (zip64DiskNumberStart) {
+				setUint32(arrayBufferView, rawExtraFieldZip64Offset, diskNumberStart);
+			}
+		}
 	}
 	await writeData(writable, new Uint8Array(arrayBuffer));
 	return entryData.slice(arrayBuffer.byteLength);
 }
 
-function setZip64ExtraInfo(fileEntry, options) {
-	const { rawExtraFieldZip64, offset, diskNumberStart } = fileEntry;
-	const { zip64UncompressedSize, zip64CompressedSize, zip64Offset, zip64DiskNumberStart } = options;
-	const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
+function setExtraFieldZip64Data(fileEntry) {
+	const rawExtraFieldZip64View = getDataView(fileEntry.rawExtraFieldZip64);
 	let rawExtraFieldZip64Offset = 4;
-	if (zip64UncompressedSize) {
+	if (fileEntry.zip64UncompressedSize) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(fileEntry.uncompressedSize));
 		rawExtraFieldZip64Offset += 8;
 	}
-	if (zip64CompressedSize) {
+	if (fileEntry.zip64CompressedSize) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(fileEntry.compressedSize));
 		rawExtraFieldZip64Offset += 8;
 	}
-	if (zip64Offset) {
-		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(offset));
+	if (fileEntry.zip64Offset) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(fileEntry.offset));
 		rawExtraFieldZip64Offset += 8;
 	}
-	if (zip64DiskNumberStart) {
-		setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, diskNumberStart);
+	if (fileEntry.zip64DiskNumberStart) {
+		setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, fileEntry.diskNumberStart);
 	}
 }
 
@@ -10906,7 +11080,7 @@ async function closeFile(zipWriter, comment, options) {
 		} else {
 			rawExtraFieldTimestamp = new Uint8Array();
 		}
-		fileEntry.rawExtraFieldCDExtendedTimestamp = rawExtraFieldTimestamp;
+		fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
 		directoryDataLength += 46 +
 			getLength(
 				rawFilename,
@@ -10927,12 +11101,13 @@ async function closeFile(zipWriter, comment, options) {
 			rawFilename,
 			rawExtraFieldZip64,
 			rawExtraFieldAES,
-			rawExtraFieldCDExtendedTimestamp,
+			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
 			rawExtraField,
 			rawComment,
 			versionMadeBy,
 			headerArray,
+			headerView,
 			zip64,
 			zip64UncompressedSize,
 			zip64CompressedSize,
@@ -10944,10 +11119,9 @@ async function closeFile(zipWriter, comment, options) {
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
-		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldCDExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
+		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);
 		}
@@ -10955,28 +11129,40 @@ async function closeFile(zipWriter, comment, options) {
 			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 && zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
-		setUint16(directoryView, offset + 36, internalFileAttributes);
+		let directoryOffset = offset + HEADER_SIZE + 4;
+		setUint16(directoryView, directoryOffset, extraFieldLength);
+		directoryOffset += 2;
+		setUint16(directoryView, directoryOffset, getLength(rawComment));
+		directoryOffset += 2;
+		setUint16(directoryView, directoryOffset, zip64 && zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
+		directoryOffset += 2;
+		setUint16(directoryView, directoryOffset, internalFileAttributes);
+		directoryOffset += 2;
 		if (externalFileAttributes) {
-			setUint32(directoryView, offset + 38, externalFileAttributes);
-		}
-		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));
-		arraySet(directoryArray, rawExtraFieldCDExtendedTimestamp, offset + 46 + getLength(rawFilename, rawExtraFieldZip64, rawExtraFieldAES));
-		arraySet(directoryArray, rawExtraFieldNTFS, offset + 46 + getLength(rawFilename, rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldCDExtendedTimestamp));
-		arraySet(directoryArray, rawExtraField, offset + 46 + getLength(rawFilename, rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldCDExtendedTimestamp, rawExtraFieldNTFS));
-		arraySet(directoryArray, rawComment, offset + 46 + getLength(rawFilename) + extraFieldLength);
-		const directoryEntryLength = 46 + getLength(rawFilename, rawComment) + extraFieldLength;
+			setUint32(directoryView, directoryOffset, externalFileAttributes);
+		}
+		directoryOffset += 4;
+		setUint32(directoryView, directoryOffset, zip64 && zip64Offset ? MAX_32_BITS : fileEntryOffset);
+		directoryOffset += 4;
+		arraySet(directoryArray, rawFilename, directoryOffset);
+		directoryOffset += getLength(rawFilename);
+		arraySet(directoryArray, rawExtraFieldZip64, directoryOffset);
+		directoryOffset += getLength(rawExtraFieldZip64);
+		arraySet(directoryArray, rawExtraFieldAES, directoryOffset);
+		directoryOffset += getLength(rawExtraFieldAES);
+		arraySet(directoryArray, rawExtraFieldExtendedTimestamp, directoryOffset);
+		directoryOffset += getLength(rawExtraFieldExtendedTimestamp);
+		arraySet(directoryArray, rawExtraFieldNTFS, directoryOffset);
+		directoryOffset += getLength(rawExtraFieldNTFS);
+		arraySet(directoryArray, rawExtraField, directoryOffset);
+		directoryOffset += getLength(rawExtraField);
+		arraySet(directoryArray, rawComment, directoryOffset);
 		if (offset - directoryDiskOffset > writer.availableSize) {
 			writer.availableSize = 0;
 			await writeData(writable, directoryArray.slice(directoryDiskOffset, offset));
 			directoryDiskOffset = offset;
 		}
-		offset += directoryEntryLength;
+		offset = directoryOffset;
 		if (options.onprogress) {
 			try {
 				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
@@ -11104,6 +11290,67 @@ function getLength(...arrayLikes) {
 	return result;
 }
 
+function getHeaderArrayData({
+	version,
+	bitflag,
+	compressionMethod,
+	uncompressedSize,
+	compressedSize,
+	lastModDate,
+	rawFilename,
+	zip64CompressedSize,
+	zip64UncompressedSize,
+	extraFieldLength
+}) {
+	const headerArray = new Uint8Array(HEADER_SIZE);
+	const headerView = getDataView(headerArray);
+	setUint16(headerView, 0, version);
+	setUint16(headerView, 2, bitflag);
+	setUint16(headerView, 4, compressionMethod);
+	const dateArray = new Uint32Array(1);
+	const dateView = getDataView(dateArray);
+	setUint16(dateView, 0, (((lastModDate.getHours() << 6) | lastModDate.getMinutes()) << 5) | lastModDate.getSeconds() / 2);
+	setUint16(dateView, 2, ((((lastModDate.getFullYear() - 1980) << 4) | (lastModDate.getMonth() + 1)) << 5) | lastModDate.getDate());
+	const rawLastModDate = dateArray[0];
+	setUint32(headerView, 6, rawLastModDate);
+	if (zip64CompressedSize || compressedSize !== UNDEFINED_VALUE) {
+		setUint32(headerView, 14, zip64CompressedSize ? MAX_32_BITS : compressedSize);
+	}
+	if (zip64UncompressedSize || uncompressedSize !== UNDEFINED_VALUE) {
+		setUint32(headerView, 18, zip64UncompressedSize ? MAX_32_BITS : uncompressedSize);
+	}
+	setUint16(headerView, 22, getLength(rawFilename));
+	setUint16(headerView, 24, extraFieldLength);
+	return {
+		headerArray,
+		headerView,
+		rawLastModDate
+	};
+}
+
+function getBitflag(level, useUnicodeFileNames, dataDescriptor, encrypted) {
+	let bitFlag = 0;
+	if (useUnicodeFileNames) {
+		bitFlag = bitFlag | BITFLAG_LANG_ENCODING_FLAG;
+	}
+	if (dataDescriptor) {
+		bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
+	}
+	if (level >= 1 && level < 3) {
+		bitFlag = bitFlag | 0b110;
+	}
+	if (level >= 3 && level < 5) {
+		bitFlag = bitFlag | 0b01;
+	}
+	if (level === 9) {
+		bitFlag = bitFlag | 0b10;
+	}
+	if (encrypted) {
+		bitFlag = bitFlag | BITFLAG_ENCRYPTED;
+	}
+	return bitFlag;
+}
+
 /*
  Copyright (c) 2022 Gildas Lormeau. All rights reserved.
 
@@ -11850,9 +12097,8 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 					});
 				}
 			}
-			await zipWriter.add(name, child.reader, Object.assign({
-				directory: child.directory
-			}, Object.assign({}, options, zipEntryOptions, childOptions, {
+			await zipWriter.add(name, child.reader, Object.assign({}, options, zipEntryOptions, childOptions, {
+				directory: child.directory,
 				onprogress: async indexProgress => {
 					if (options.onprogress) {
 						entryOffsets.set(name, indexProgress);
@@ -11864,7 +12110,7 @@ async function exportZip(zipWriter, entry, totalSize, options) {
 						}
 					}
 				}
-			})));
+			}));
 			await process(zipWriter, child);
 		}
 	}
@@ -12045,6 +12291,7 @@ exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION;
 exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
 exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
 exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;
+exports.ERR_ZIP_NOT_EMPTY = ERR_ZIP_NOT_EMPTY;
 exports.HttpRangeReader = HttpRangeReader;
 exports.HttpReader = HttpReader;
 exports.Reader = Reader;