@zip.js/zip.js 2.7.64 → 2.7.66

package/lib/core/zip-writer.js

@@ -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,
@@ -64,6 +67,9 @@ import {
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
 	HEADER_SIZE,
+	HEADER_OFFSET_SIGNATURE,
+	HEADER_OFFSET_COMPRESSED_SIZE,
+	HEADER_OFFSET_UNCOMPRESSED_SIZE,
 	MIN_DATE,
 	MAX_DATE,
 	UNDEFINED_VALUE
@@ -78,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 {
@@ -124,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;
@@ -135,7 +141,7 @@ 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
@@ -146,7 +152,7 @@ class ZipWriter {
 		if (this.filenames.size) {
 			throw new Error(ERR_ZIP_NOT_EMPTY);
 		}
-		({ reader } = initReader(reader));
+		({ reader } = new GenericReader(reader));
 		const [zipEntriesReader, zipDataReader] = reader.readable.tee();
 		const zipReader = new ZipReader(new ReadableStream({
 			async start(controller) {
@@ -167,7 +173,7 @@ class ZipWriter {
 		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.writer.size = this.offset = reader.size;
 		this.filenames = new Set(entries.map(entry => entry.filename));
 		this.files = new Map(entries.map(entry => {
 			const {
@@ -206,7 +212,7 @@ class ZipWriter {
 				headerView
 			} = getHeaderArrayData({
 				version,
-				bitflag: getBitflag(level, languageEncodingFlag, dataDescriptor, encrypted),
+				bitFlag: getBitFlag(level, languageEncodingFlag, dataDescriptor, encrypted),
 				compressionMethod,
 				uncompressedSize,
 				compressedSize,
@@ -465,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) {
@@ -590,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);
@@ -600,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);
@@ -620,36 +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;
 			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);
+			fileEntry.offset = zipWriter.offset - writer.diskOffset;
+			if (zip64) {
+				updateZip64ExtraField(fileEntry);
 			}
+			updateLocalHeader(fileEntry, localHeaderView);
 			await skipDiskIfNeeded(writable);
+			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 (fileEntry.zip64) {
-				setExtraFieldZip64Data(fileEntry);
+			if (zip64) {
+				updateZip64ExtraField(fileEntry);
 			}
 		}
-		if (fileEntry.offset > MAX_32_BITS && !fileEntry.zip64) {
+		if (fileEntry.offset > MAX_32_BITS && !zip64) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
 		zipWriter.offset += fileEntry.size;
@@ -666,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);
@@ -714,7 +724,6 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		metadataSize
 	} = entryInfo;
 	const {
-		localHeaderArray,
 		headerArray,
 		headerView,
 		lastModDate,
@@ -796,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,
@@ -818,15 +826,21 @@ 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;
+		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;
 		}
-		writable.size += uncompressedSize;
-	} else {
-		await writeData(writable, localHeaderArray);
+
 	}
 	setEntryInfo({
 		signature,
@@ -836,7 +850,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		dataDescriptorInfo
 	}, options);
 	if (dataDescriptor) {
-		await writeData(writable, dataDescriptorArray);
+		await writeData(writer, dataDescriptorArray);
 	}
 	Object.assign(fileEntry, {
 		uncompressedSize,
@@ -1000,7 +1014,7 @@ function getHeaderInfo(options) {
 		rawLastModDate
 	} = getHeaderArrayData({
 		version,
-		bitflag: getBitflag(level, useUnicodeFileNames, dataDescriptor, encrypted),
+		bitFlag: getBitFlag(level, useUnicodeFileNames, dataDescriptor, encrypted),
 		compressionMethod,
 		uncompressedSize,
 		lastModDate: lastModDate < MIN_DATE ? MIN_DATE : lastModDate > MAX_DATE ? MAX_DATE : lastModDate,
@@ -1029,6 +1043,7 @@ function getHeaderInfo(options) {
 	arraySet(localHeaderArray, rawExtraField, localHeaderOffset);
 	return {
 		localHeaderArray,
+		localHeaderView,
 		headerArray,
 		headerView,
 		lastModDate,
@@ -1068,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) {
@@ -1091,14 +1105,17 @@ function getDataDescriptorInfo(options) {
 	};
 }
 
-function setEntryInfo(entryInfo, options) {
-	const {
-		signature,
-		compressedSize,
-		uncompressedSize,
-		headerInfo,
-		dataDescriptorInfo
-	} = entryInfo;
+function setEntryInfo({
+	signature,
+	compressedSize,
+	uncompressedSize,
+	headerInfo,
+	dataDescriptorInfo
+}, {
+	zip64,
+	zipCrypto,
+	dataDescriptor
+}) {
 	const {
 		headerView,
 		encrypted
@@ -1107,13 +1124,8 @@ function setEntryInfo(entryInfo, options) {
 		dataDescriptorView,
 		dataDescriptorOffset
 	} = dataDescriptorInfo;
-	const {
-		zip64,
-		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);
 		}
@@ -1124,8 +1136,8 @@ function setEntryInfo(entryInfo, options) {
 			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);
@@ -1133,88 +1145,86 @@ function setEntryInfo(entryInfo, options) {
 	}
 }
 
-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;
-	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);
+function updateLocalHeader({
+	rawFilename,
+	dataDescriptor,
+	encrypted,
+	zip64,
+	localExtraFieldZip64Length,
+	signature,
+	compressedSize,
+	uncompressedSize,
+	offset,
+	diskNumberStart,
+	zip64UncompressedSize,
+	zip64CompressedSize,
+	zip64Offset,
+	zip64DiskNumberStart
+}, localHeaderView) {
 	if (!dataDescriptor) {
-		if (!encrypted || zipCrypto) {
-			setUint32(arrayBufferView, 14, signature);
+		if (!encrypted) {
+			setUint32(localHeaderView, HEADER_OFFSET_SIGNATURE + 4, signature);
 		}
 		if (!zip64) {
-			setUint32(arrayBufferView, 18, compressedSize);
-			setUint32(arrayBufferView, 22, uncompressedSize);
+			setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + 4, compressedSize);
+			setUint32(localHeaderView, HEADER_OFFSET_UNCOMPRESSED_SIZE + 4, uncompressedSize);
 		}
 	}
 	if (zip64) {
-		setUint32(arrayBufferView, 18, MAX_32_BITS);
-		setUint32(arrayBufferView, 22, MAX_32_BITS);
 		if (localExtraFieldZip64Length) {
-			rawExtraFieldZip64Offset += 4;
+			let localHeaderOffset = HEADER_SIZE + 4 + getLength(rawFilename) + 4;
 			if (zip64UncompressedSize) {
-				setBigUint64(arrayBufferView, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
-				rawExtraFieldZip64Offset += 8;
+				setBigUint64(localHeaderView, localHeaderOffset, BigInt(uncompressedSize));
+				localHeaderOffset += 8;
 			}
 			if (zip64CompressedSize) {
-				setBigUint64(arrayBufferView, rawExtraFieldZip64Offset, BigInt(compressedSize));
-				rawExtraFieldZip64Offset += 8;
+				setBigUint64(localHeaderView, localHeaderOffset, BigInt(compressedSize));
+				localHeaderOffset += 8;
 			}
 			if (zip64Offset) {
-				setBigUint64(arrayBufferView, rawExtraFieldZip64Offset, BigInt(offset));
-				rawExtraFieldZip64Offset += 8;
+				setBigUint64(localHeaderView, localHeaderOffset, BigInt(offset));
+				localHeaderOffset += 8;
 			}
 			if (zip64DiskNumberStart) {
-				setUint32(arrayBufferView, rawExtraFieldZip64Offset, diskNumberStart);
+				setUint32(localHeaderView, localHeaderOffset, diskNumberStart);
 			}
 		}
 	}
-	await writeData(writable, new Uint8Array(arrayBuffer));
-	return entryData.slice(arrayBuffer.byteLength);
 }
 
-function setExtraFieldZip64Data(fileEntry) {
-	const rawExtraFieldZip64View = getDataView(fileEntry.rawExtraFieldZip64);
+function updateZip64ExtraField({
+	compressedSize,
+	uncompressedSize,
+	offset,
+	diskNumberStart,
+	zip64UncompressedSize,
+	zip64CompressedSize,
+	zip64Offset,
+	zip64DiskNumberStart,
+	rawExtraFieldZip64
+}) {
+	const rawExtraFieldZip64View = getDataView(rawExtraFieldZip64);
 	let rawExtraFieldZip64Offset = 4;
-	if (fileEntry.zip64UncompressedSize) {
-		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(fileEntry.uncompressedSize));
+	if (zip64UncompressedSize) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(uncompressedSize));
 		rawExtraFieldZip64Offset += 8;
 	}
-	if (fileEntry.zip64CompressedSize) {
-		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(fileEntry.compressedSize));
+	if (zip64CompressedSize) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(compressedSize));
 		rawExtraFieldZip64Offset += 8;
 	}
-	if (fileEntry.zip64Offset) {
-		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(fileEntry.offset));
+	if (zip64Offset) {
+		setBigUint64(rawExtraFieldZip64View, rawExtraFieldZip64Offset, BigInt(offset));
 		rawExtraFieldZip64Offset += 8;
 	}
-	if (fileEntry.zip64DiskNumberStart) {
-		setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, fileEntry.diskNumberStart);
+	if (zip64DiskNumberStart) {
+		setUint32(rawExtraFieldZip64View, rawExtraFieldZip64Offset, diskNumberStart);
 	}
 }
 
 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;
@@ -1286,10 +1296,10 @@ async function closeFile(zipWriter, comment, options) {
 		setUint32(directoryView, offset, CENTRAL_FILE_HEADER_SIGNATURE);
 		setUint16(directoryView, offset + 4, versionMadeBy);
 		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);
 		let directoryOffset = offset + HEADER_SIZE + 4;
@@ -1322,7 +1332,7 @@ async function closeFile(zipWriter, comment, options) {
 		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 = directoryOffset;
@@ -1335,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) {
@@ -1391,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();
@@ -1455,7 +1466,7 @@ function getLength(...arrayLikes) {
 
 function getHeaderArrayData({
 	version,
-	bitflag,
+	bitFlag,
 	compressionMethod,
 	uncompressedSize,
 	compressedSize,
@@ -1468,7 +1479,7 @@ function getHeaderArrayData({
 	const headerArray = new Uint8Array(HEADER_SIZE);
 	const headerView = getDataView(headerArray);
 	setUint16(headerView, 0, version);
-	setUint16(headerView, 2, bitflag);
+	setUint16(headerView, 2, bitFlag);
 	setUint16(headerView, 4, compressionMethod);
 	const dateArray = new Uint32Array(1);
 	const dateView = getDataView(dateArray);
@@ -1477,10 +1488,10 @@ function getHeaderArrayData({
 	const rawLastModDate = dateArray[0];
 	setUint32(headerView, 6, rawLastModDate);
 	if (zip64CompressedSize || compressedSize !== UNDEFINED_VALUE) {
-		setUint32(headerView, 14, zip64CompressedSize ? MAX_32_BITS : compressedSize);
+		setUint32(headerView, HEADER_OFFSET_COMPRESSED_SIZE, zip64CompressedSize ? MAX_32_BITS : compressedSize);
 	}
 	if (zip64UncompressedSize || uncompressedSize !== UNDEFINED_VALUE) {
-		setUint32(headerView, 18, zip64UncompressedSize ? MAX_32_BITS : uncompressedSize);
+		setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, zip64UncompressedSize ? MAX_32_BITS : uncompressedSize);
 	}
 	setUint16(headerView, 22, getLength(rawFilename));
 	setUint16(headerView, 24, extraFieldLength);
@@ -1491,7 +1502,8 @@ function getHeaderArrayData({
 	};
 }
 
-function getBitflag(level, useUnicodeFileNames, dataDescriptor, encrypted) {
+
+function getBitFlag(level, useUnicodeFileNames, dataDescriptor, encrypted) {
 	let bitFlag = 0;
 	if (useUnicodeFileNames) {
 		bitFlag = bitFlag | BITFLAG_LANG_ENCODING_FLAG;
@@ -1499,14 +1511,14 @@ function getBitflag(level, useUnicodeFileNames, dataDescriptor, encrypted) {
 	if (dataDescriptor) {
 		bitFlag = bitFlag | BITFLAG_DATA_DESCRIPTOR;
 	}
-	if (level >= 1 && level < 3) {
-		bitFlag = bitFlag | 0b110;
+	if (level > 0 && level <= 3) {
+		bitFlag = bitFlag | BITFLAG_LEVEL_SUPER_FAST_MASK;
 	}
-	if (level >= 3 && level < 5) {
-		bitFlag = bitFlag | 0b01;
+	if (level > 3 && level <= 5) {
+		bitFlag = bitFlag | BITFLAG_LEVEL_FAST_MASK;
 	}
-	if (level === 9) {
-		bitFlag = bitFlag | 0b10;
+	if (level == 9) {
+		bitFlag = bitFlag | BITFLAG_LEVEL_MAX_MASK;
 	}
 	if (encrypted) {
 		bitFlag = bitFlag | BITFLAG_ENCRYPTED;