@zip.js/zip.js 2.7.63 → 2.7.64

package/lib/core/zip-writer.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TransformStream, Response */
+/* global TransformStream, Response, ReadableStream */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -63,6 +63,7 @@ import {
 	VERSION_ZIP64,
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
+	HEADER_SIZE,
 	MIN_DATE,
 	MAX_DATE,
 	UNDEFINED_VALUE
@@ -99,6 +100,9 @@ import {
 	PROPERTY_NAME_EXECUTABLE,
 	Entry
 } from "./zip-entry.js";
+import {
+	ZipReader
+} from "./zip-reader.js";
 
 const ERR_DUPLICATED_NAME = "File already exists";
 const ERR_INVALID_COMMENT = "Zip file comment exceeds 64KB";
@@ -110,6 +114,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]);
 
@@ -137,6 +142,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 {
@@ -172,6 +270,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;
@@ -227,7 +341,8 @@ export {
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
 	ERR_UNSUPPORTED_FORMAT,
-	ERR_UNDEFINED_UNCOMPRESSED_SIZE
+	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
+	ERR_ZIP_NOT_EMPTY
 };
 
 async function addFile(zipWriter, name, reader, options) {
@@ -308,7 +423,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);
@@ -354,10 +475,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);
 		}
 	}
@@ -413,7 +535,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);
@@ -505,20 +630,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;
@@ -585,12 +716,15 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	const {
 		localHeaderArray,
 		headerArray,
+		headerView,
 		lastModDate,
 		rawLastModDate,
 		encrypted,
 		compressed,
 		version,
 		compressionMethod,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		extraFieldExtendedTimestampFlag,
 		rawExtraFieldNTFS,
@@ -639,6 +773,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawFilename,
 		commentUTF8: true,
 		rawComment,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldAES,
@@ -692,28 +828,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,
@@ -735,8 +851,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		compressionMethod,
 		version,
 		headerArray,
+		headerView,
 		signature,
-		rawExtraFieldZip64,
 		extraFieldExtendedTimestampFlag,
 		zip64UncompressedSize,
 		zip64CompressedSize,
@@ -761,10 +877,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);
@@ -813,69 +981,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,
@@ -887,6 +1038,8 @@ function getHeaderInfo(options) {
 		version,
 		compressionMethod,
 		extraFieldExtendedTimestampFlag,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldAES,
@@ -941,7 +1094,6 @@ function getDataDescriptorInfo(options) {
 function setEntryInfo(entryInfo, options) {
 	const {
 		signature,
-		rawExtraFieldZip64,
 		compressedSize,
 		uncompressedSize,
 		headerInfo,
@@ -957,8 +1109,6 @@ function setEntryInfo(entryInfo, options) {
 	} = dataDescriptorInfo;
 	const {
 		zip64,
-		zip64UncompressedSize,
-		zip64CompressedSize,
 		zipCrypto,
 		dataDescriptor
 	} = options;
@@ -969,19 +1119,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));
@@ -996,44 +1133,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);
 	}
 }
 
@@ -1068,7 +1243,7 @@ async function closeFile(zipWriter, comment, options) {
 		} else {
 			rawExtraFieldTimestamp = new Uint8Array();
 		}
-		fileEntry.rawExtraFieldCDExtendedTimestamp = rawExtraFieldTimestamp;
+		fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
 		directoryDataLength += 46 +
 			getLength(
 				rawFilename,
@@ -1089,12 +1264,13 @@ async function closeFile(zipWriter, comment, options) {
 			rawFilename,
 			rawExtraFieldZip64,
 			rawExtraFieldAES,
-			rawExtraFieldCDExtendedTimestamp,
+			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
 			rawExtraField,
 			rawComment,
 			versionMadeBy,
 			headerArray,
+			headerView,
 			zip64,
 			zip64UncompressedSize,
 			zip64CompressedSize,
@@ -1106,10 +1282,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);
 		}
@@ -1117,28 +1292,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, directoryOffset, 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;
+		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));
@@ -1265,3 +1452,64 @@ function getLength(...arrayLikes) {
 	arrayLikes.forEach(arrayLike => arrayLike && (result += arrayLike.length));
 	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;
+}