@zip.js/zip.js 2.7.63 → 2.7.65

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 {
@@ -55,6 +55,9 @@ import {
 	BITFLAG_ENCRYPTED,
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
+	BITFLAG_LEVEL_FAST_MASK,
+	BITFLAG_LEVEL_SUPER_FAST_MASK,
+	BITFLAG_LEVEL_MAX_MASK,
 	FILE_ATTR_MSDOS_DIR_MASK,
 	FILE_ATTR_UNIX_TYPE_DIR,
 	FILE_ATTR_UNIX_EXECUTABLE_MASK,
@@ -63,6 +66,10 @@ import {
 	VERSION_ZIP64,
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
+	HEADER_SIZE,
+	HEADER_OFFSET_SIGNATURE,
+	HEADER_OFFSET_COMPRESSED_SIZE,
+	HEADER_OFFSET_UNCOMPRESSED_SIZE,
 	MIN_DATE,
 	MAX_DATE,
 	UNDEFINED_VALUE
@@ -77,8 +84,8 @@ import {
 } from "./codec-pool.js";
 import {
 	initStream,
-	initReader,
-	initWriter
+	GenericWriter,
+	GenericReader
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
 import {
@@ -99,6 +106,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 +120,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]);
 
@@ -119,7 +130,7 @@ const pendingEntries = [];
 class ZipWriter {
 
 	constructor(writer, options = {}) {
-		writer = initWriter(writer);
+		writer = new GenericWriter(writer);
 		const addSplitZipSignature =
 			writer.availableSize !== UNDEFINED_VALUE && writer.availableSize > 0 && writer.availableSize !== Infinity &&
 			writer.maxSize !== UNDEFINED_VALUE && writer.maxSize > 0 && writer.maxSize !== Infinity;
@@ -130,13 +141,106 @@ class ZipWriter {
 			config: getConfiguration(),
 			files: new Map(),
 			filenames: new Set(),
-			offset: options.offset === UNDEFINED_VALUE ? writer.writable.size : options.offset,
+			offset: options.offset === UNDEFINED_VALUE ? writer.size || writer.writable.size || 0 : options.offset,
 			pendingEntriesSize: 0,
 			pendingAddFileCalls: new Set(),
 			bufferedWrites: 0
 		});
 	}
 
+	async prependZip(reader) {
+		if (this.filenames.size) {
+			throw new Error(ERR_ZIP_NOT_EMPTY);
+		}
+		({ reader } = new GenericReader(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.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 +276,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 +347,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 +429,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);
@@ -344,7 +471,7 @@ async function addFile(zipWriter, name, reader, options) {
 	}
 	const zip64Enabled = zip64 === true;
 	if (reader) {
-		reader = initReader(reader);
+		reader = new GenericReader(reader);
 		await initStream(reader);
 		if (!passThrough) {
 			if (reader.size === UNDEFINED_VALUE) {
@@ -354,10 +481,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 +541,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);
@@ -465,8 +596,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 		if ((options.bufferedWrite || zipWriter.writerLocked || (zipWriter.bufferedWrites && keepOrder) || !dataDescriptor) && !usdz) {
 			fileWriter = new TransformStream();
-			blobPromise = new Response(fileWriter.readable).blob();
-			fileWriter.writable.size = 0;
+			fileWriter.size = 0;
 			bufferedWrite = true;
 			zipWriter.bufferedWrites++;
 			await initStream(writer);
@@ -475,19 +605,22 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await requestLockWriter();
 		}
 		await initStream(fileWriter);
-		const { writable } = writer;
-		let { diskOffset } = writer;
+		const { writable, diskOffset } = writer;
 		if (zipWriter.addSplitZipSignature) {
 			delete zipWriter.addSplitZipSignature;
 			const signatureArray = new Uint8Array(4);
 			const signatureArrayView = getDataView(signatureArray);
 			setUint32(signatureArrayView, 0, SPLIT_ZIP_FILE_SIGNATURE);
-			await writeData(writable, signatureArray);
+			await writeData(writer, signatureArray);
 			zipWriter.offset += 4;
 		}
 		if (usdz) {
 			appendExtraFieldUSDZ(entryInfo, zipWriter.offset - diskOffset);
 		}
+		const {
+			localHeaderView,
+			localHeaderArray
+		} = headerInfo;
 		if (!bufferedWrite) {
 			await lockPreviousFileEntry;
 			await skipDiskIfNeeded(writable);
@@ -495,30 +628,38 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		const { diskNumber } = writer;
 		writingEntryData = true;
 		fileEntry.diskNumberStart = diskNumber;
+		if (bufferedWrite) {
+			blobPromise = new Response(fileWriter.readable).blob();
+		} else {
+			await writeData(fileWriter, localHeaderArray);
+		}
 		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, zipWriter.config, options);
+		const { zip64 } = fileEntry;
 		writingEntryData = false;
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
-			await fileWriter.writable.getWriter().close();
-			let blob = await blobPromise;
-			await lockPreviousFileEntry;
+			const [blob] = await Promise.all([blobPromise, fileWriter.writable.getWriter().close(), lockPreviousFileEntry]);
 			await requestLockWriter();
 			writingBufferedEntryData = true;
-			if (!dataDescriptor) {
-				blob = await writeExtraHeaderInfo(fileEntry, blob, writable, options);
+			fileEntry.diskNumberStart = writer.diskNumber;
+			fileEntry.offset = zipWriter.offset - writer.diskOffset;
+			if (zip64) {
+				updateZip64ExtraField(fileEntry);
 			}
+			updateLocalHeader(fileEntry, localHeaderView);
 			await skipDiskIfNeeded(writable);
-			fileEntry.diskNumberStart = writer.diskNumber;
-			diskOffset = writer.diskOffset;
+			await writeData(writer, localHeaderArray);
 			await blob.stream().pipeTo(writable, { preventClose: true, preventAbort: true, signal });
-			writable.size += blob.size;
+			writer.size += fileWriter.size;
 			writingBufferedEntryData = false;
+		} else {
+			fileEntry.offset = zipWriter.offset - diskOffset;
+			if (zip64) {
+				updateZip64ExtraField(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 && !zip64) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
 		zipWriter.offset += fileEntry.size;
@@ -535,9 +676,9 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 				}
 			}
 			if (bufferedWrite) {
-				zipWriter.offset += fileWriter.writable.size;
+				zipWriter.offset += fileWriter.size;
 			} else {
-				zipWriter.offset = fileWriter.writable.size;
+				zipWriter.offset = fileWriter.size;
 			}
 		}
 		files.delete(name);
@@ -583,14 +724,16 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		metadataSize
 	} = entryInfo;
 	const {
-		localHeaderArray,
 		headerArray,
+		headerView,
 		lastModDate,
 		rawLastModDate,
 		encrypted,
 		compressed,
 		version,
 		compressionMethod,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		extraFieldExtendedTimestampFlag,
 		rawExtraFieldNTFS,
@@ -639,6 +782,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawFilename,
 		commentUTF8: true,
 		rawComment,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldAES,
@@ -660,9 +805,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 	const { writable } = writer;
 	if (reader) {
 		reader.chunkSize = getChunkSize(config);
-		await writeData(writable, localHeaderArray);
 		const readable = reader.readable;
-		const size = readable.size = reader.size;
+		const size = reader.size;
 		const workerOptions = {
 			options: {
 				codecType: CODEC_DEFLATE,
@@ -682,45 +826,31 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 			config,
 			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
-		const result = await runWorker({ readable, writable }, workerOptions);
-		compressedSize = result.outputSize;
-		if (!passThrough) {
-			uncompressedSize = result.inputSize;
-			signature = result.signature;
-		}
-		writable.size += uncompressedSize;
-	} 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;
+		try {
+			const result = await runWorker({ readable, writable }, workerOptions);
+			compressedSize = result.outputSize;
+			writer.size += compressedSize;
+			if (!passThrough) {
+				uncompressedSize = result.inputSize;
+				signature = result.signature;
+			}
+		} catch (error) {
+			if (error.outputSize !== UNDEFINED_VALUE) {
+				writer.size += error.outputSize;
+			}
+			throw error;
 		}
-		rawExtraFieldZip64 = new Uint8Array(rawExtraFieldZip64Length);
-	} else {
-		rawExtraFieldZip64 = new Uint8Array();
+
 	}
 	setEntryInfo({
 		signature,
-		rawExtraFieldZip64,
 		compressedSize,
 		uncompressedSize,
 		headerInfo,
 		dataDescriptorInfo
 	}, options);
 	if (dataDescriptor) {
-		await writeData(writable, dataDescriptorArray);
+		await writeData(writer, dataDescriptorArray);
 	}
 	Object.assign(fileEntry, {
 		uncompressedSize,
@@ -735,8 +865,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		compressionMethod,
 		version,
 		headerArray,
+		headerView,
 		signature,
-		rawExtraFieldZip64,
 		extraFieldExtendedTimestampFlag,
 		zip64UncompressedSize,
 		zip64CompressedSize,
@@ -761,10 +891,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,71 +995,55 @@ 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,
+		localHeaderView,
 		headerArray,
 		headerView,
 		lastModDate,
@@ -887,6 +1053,8 @@ function getHeaderInfo(options) {
 		version,
 		compressionMethod,
 		extraFieldExtendedTimestampFlag,
+		rawExtraFieldZip64,
+		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldAES,
@@ -915,12 +1083,11 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	entryInfo.metadataSize += extraBytesLength;
 }
 
-function getDataDescriptorInfo(options) {
-	const {
-		zip64,
-		dataDescriptor,
-		dataDescriptorSignature
-	} = options;
+function getDataDescriptorInfo({
+	zip64,
+	dataDescriptor,
+	dataDescriptorSignature
+}) {
 	let dataDescriptorArray = new Uint8Array();
 	let dataDescriptorView, dataDescriptorOffset = 0;
 	if (dataDescriptor) {
@@ -938,15 +1105,17 @@ function getDataDescriptorInfo(options) {
 	};
 }
 
-function setEntryInfo(entryInfo, options) {
-	const {
-		signature,
-		rawExtraFieldZip64,
-		compressedSize,
-		uncompressedSize,
-		headerInfo,
-		dataDescriptorInfo
-	} = entryInfo;
+function setEntryInfo({
+	signature,
+	compressedSize,
+	uncompressedSize,
+	headerInfo,
+	dataDescriptorInfo
+}, {
+	zip64,
+	zipCrypto,
+	dataDescriptor
+}) {
 	const {
 		headerView,
 		encrypted
@@ -955,40 +1124,20 @@ function setEntryInfo(entryInfo, options) {
 		dataDescriptorView,
 		dataDescriptorOffset
 	} = dataDescriptorInfo;
-	const {
-		zip64,
-		zip64UncompressedSize,
-		zip64CompressedSize,
-		zipCrypto,
-		dataDescriptor
-	} = options;
 	if ((!encrypted || zipCrypto) && signature !== UNDEFINED_VALUE) {
-		setUint32(headerView, 10, signature);
+		setUint32(headerView, HEADER_OFFSET_SIGNATURE, signature);
 		if (dataDescriptor) {
 			setUint32(dataDescriptorView, dataDescriptorOffset, signature);
 		}
 	}
 	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));
 		}
 	} else {
-		setUint32(headerView, 14, compressedSize);
-		setUint32(headerView, 18, uncompressedSize);
+		setUint32(headerView, HEADER_OFFSET_COMPRESSED_SIZE, compressedSize);
+		setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, uncompressedSize);
 		if (dataDescriptor) {
 			setUint32(dataDescriptorView, dataDescriptorOffset + 4, compressedSize);
 			setUint32(dataDescriptorView, dataDescriptorOffset + 8, uncompressedSize);
@@ -996,36 +1145,72 @@ function setEntryInfo(entryInfo, options) {
 	}
 }
 
-async function writeExtraHeaderInfo(fileEntry, entryData, writable, { zipCrypto }) {
-	let arrayBuffer;
-	arrayBuffer = await entryData.slice(0, 26).arrayBuffer();
-	if (arrayBuffer.byteLength != 26) {
-		arrayBuffer = arrayBuffer.slice(0, 26);
-	}
-	const arrayBufferView = new DataView(arrayBuffer);
-	if (!fileEntry.encrypted || zipCrypto) {
-		setUint32(arrayBufferView, 14, fileEntry.signature);
-	}
-	if (fileEntry.zip64) {
-		setUint32(arrayBufferView, 18, MAX_32_BITS);
-		setUint32(arrayBufferView, 22, MAX_32_BITS);
-	} else {
-		setUint32(arrayBufferView, 18, fileEntry.compressedSize);
-		setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
+function updateLocalHeader({
+	rawFilename,
+	dataDescriptor,
+	encrypted,
+	zip64,
+	localExtraFieldZip64Length,
+	signature,
+	compressedSize,
+	uncompressedSize,
+	offset,
+	diskNumberStart,
+	zip64UncompressedSize,
+	zip64CompressedSize,
+	zip64Offset,
+	zip64DiskNumberStart
+}, localHeaderView) {
+	if (!dataDescriptor) {
+		if (!encrypted) {
+			setUint32(localHeaderView, HEADER_OFFSET_SIGNATURE + 4, signature);
+		}
+		if (!zip64) {
+			setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + 4, compressedSize);
+			setUint32(localHeaderView, HEADER_OFFSET_UNCOMPRESSED_SIZE + 4, uncompressedSize);
+		}
+	}
+	if (zip64) {
+		if (localExtraFieldZip64Length) {
+			let localHeaderOffset = HEADER_SIZE + 4 + getLength(rawFilename) + 4;
+			if (zip64UncompressedSize) {
+				setBigUint64(localHeaderView, localHeaderOffset, BigInt(uncompressedSize));
+				localHeaderOffset += 8;
+			}
+			if (zip64CompressedSize) {
+				setBigUint64(localHeaderView, localHeaderOffset, BigInt(compressedSize));
+				localHeaderOffset += 8;
+			}
+			if (zip64Offset) {
+				setBigUint64(localHeaderView, localHeaderOffset, BigInt(offset));
+				localHeaderOffset += 8;
+			}
+			if (zip64DiskNumberStart) {
+				setUint32(localHeaderView, localHeaderOffset, 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;
+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) {
@@ -1039,7 +1224,7 @@ function setZip64ExtraInfo(fileEntry, options) {
 
 async function closeFile(zipWriter, comment, options) {
 	const { files, writer } = zipWriter;
-	const { diskOffset, writable } = writer;
+	const { diskOffset } = writer;
 	let { diskNumber } = writer;
 	let offset = 0;
 	let directoryDataLength = 0;
@@ -1068,7 +1253,7 @@ async function closeFile(zipWriter, comment, options) {
 		} else {
 			rawExtraFieldTimestamp = new Uint8Array();
 		}
-		fileEntry.rawExtraFieldCDExtendedTimestamp = rawExtraFieldTimestamp;
+		fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
 		directoryDataLength += 46 +
 			getLength(
 				rawFilename,
@@ -1089,12 +1274,13 @@ async function closeFile(zipWriter, comment, options) {
 			rawFilename,
 			rawExtraFieldZip64,
 			rawExtraFieldAES,
-			rawExtraFieldCDExtendedTimestamp,
+			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
 			rawExtraField,
 			rawComment,
 			versionMadeBy,
 			headerArray,
+			headerView,
 			zip64,
 			zip64UncompressedSize,
 			zip64CompressedSize,
@@ -1106,39 +1292,50 @@ 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);
+			setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, uncompressedSize);
 		}
 		if (!zip64CompressedSize) {
-			setUint32(headerView, 14, compressedSize);
+			setUint32(headerView, HEADER_OFFSET_COMPRESSED_SIZE, 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));
+			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
 			directoryDiskOffset = offset;
 		}
-		offset += directoryEntryLength;
+		offset = directoryOffset;
 		if (options.onprogress) {
 			try {
 				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
@@ -1148,7 +1345,7 @@ async function closeFile(zipWriter, comment, options) {
 			}
 		}
 	}
-	await writeData(writable, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
+	await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
 	let lastDiskNumber = writer.diskNumber;
 	const { availableSize } = writer;
 	if (availableSize < END_OF_CENTRAL_DIR_LENGTH) {
@@ -1204,17 +1401,18 @@ async function closeFile(zipWriter, comment, options) {
 			throw new Error(ERR_INVALID_COMMENT);
 		}
 	}
-	await writeData(writable, endOfdirectoryArray);
+	await writeData(writer, endOfdirectoryArray);
 	if (commentLength) {
-		await writeData(writable, comment);
+		await writeData(writer, comment);
 	}
 }
 
-async function writeData(writable, array) {
+async function writeData(writer, array) {
+	const { writable } = writer;
 	const streamWriter = writable.getWriter();
 	try {
 		await streamWriter.ready;
-		writable.size += getLength(array);
+		writer.size += getLength(array);
 		await streamWriter.write(array);
 	} finally {
 		streamWriter.releaseLock();
@@ -1265,3 +1463,65 @@ 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, HEADER_OFFSET_COMPRESSED_SIZE, zip64CompressedSize ? MAX_32_BITS : compressedSize);
+	}
+	if (zip64UncompressedSize || uncompressedSize !== UNDEFINED_VALUE) {
+		setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, 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 >= 0 && level < 2) {
+		bitFlag = bitFlag | BITFLAG_LEVEL_SUPER_FAST_MASK;
+	}
+	if (level >= 3 && level < 6) {
+		bitFlag = bitFlag | BITFLAG_LEVEL_FAST_MASK;
+	}
+	if (level == 9) {
+		bitFlag = bitFlag | BITFLAG_LEVEL_MAX_MASK;
+	}
+	if (encrypted) {
+		bitFlag = bitFlag | BITFLAG_ENCRYPTED;
+	}
+	return bitFlag;
+}