@zip.js/zip.js 2.6.28 → 2.6.30

package/index.d.ts

@@ -366,6 +366,11 @@ export class Data64URIReader extends Reader<string> { }
  */
 export class Uint8ArrayReader extends Reader<Uint8Array> { }
 
+/**
+ * Represents a `Reader` instance used to read data provided as an array of `Reader` instances (i.e. split zip files).
+ */
+export class SplitZipReader extends Reader<Reader<any>[] | ReadableReader[] | ReadableStream[]> { }
+
 /** 
  * Represents a URL stored into a `string`.
  */
@@ -579,7 +584,7 @@ export class ZipReader<Type> {
      * @param reader The `Reader` instance used to read data.
      * @param options The options.
      */
-    constructor(reader: Reader<Type> | ReadableReader | ReadableStream, options?: ZipReaderConstructorOptions)
+    constructor(reader: Reader<Type> | ReadableReader | ReadableStream | Reader<any>[] | ReadableReader[] | ReadableStream[], options?: ZipReaderConstructorOptions)
     /**
      * The global comment of the zip file.
      */
@@ -1440,4 +1445,5 @@ export const ERR_INVALID_VERSION: string
 export const ERR_INVALID_EXTRAFIELD_TYPE: string
 export const ERR_INVALID_EXTRAFIELD_DATA: string
 export const ERR_INVALID_ENCRYPTION_STRENGTH: string
-export const ERR_UNSUPPORTED_FORMAT: string
+export const ERR_UNSUPPORTED_FORMAT: string
+export const ERR_SPLIT_ZIP_FILE: string

package/index.js

@@ -54,6 +54,7 @@ export {
 	HttpRangeReader,
 	Uint8ArrayWriter,
 	Uint8ArrayReader,
+	SplitZipReader,
 	ERR_HTTP_RANGE,
 	ERR_BAD_FORMAT,
 	ERR_EOCDR_NOT_FOUND,
@@ -75,6 +76,7 @@ export {
 	ERR_INVALID_EXTRAFIELD_TYPE,
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
-	ERR_UNSUPPORTED_FORMAT
+	ERR_UNSUPPORTED_FORMAT,
+	ERR_SPLIT_ZIP_FILE
 } from "./lib/zip-fs.js";
 export { getMimeType, terminateWorkers };

package/lib/core/codec-pool-worker.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Worker, URL, TransformStream */
+/* global Worker, URL, TransformStream, setTimeout */
 
 import {
 	Codec,
@@ -141,7 +141,7 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		}
 		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
 		workerData.interface = {
-			run() {
+			async run() {
 				const { readable, writable, options } = workerData;
 				const scripts = workerData.scripts.slice(1);
 				const message = { type: MESSAGE_START, scripts, options, config: { chunkSize } };
@@ -155,7 +155,18 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 					sendMessage(message);
 					initStreams(readable, writable);
 				}
-				return workerData.result;
+				const result = await workerData.result;
+				if (workerData.transferStreams && transferStreamsSupported && writable.locked) {
+					await waitForUnlockedWritable();
+				}
+				return result;
+
+				async function waitForUnlockedWritable() {
+					await new Promise(resolve => setTimeout(resolve, 10));
+					if (writable.locked) {
+						return await waitForUnlockedWritable();
+					}
+				}
 			}
 		};
 	}

package/lib/core/io.js

@@ -64,9 +64,9 @@ class Reader extends Stream {
 				this.chunkOffset = 0;
 			},
 			async pull(controller) {
-				const { offset = 0, size } = readable;
+				const { offset = 0, size, diskNumberStart } = readable;
 				const { chunkOffset } = this;
-				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size - chunkOffset)));
+				controller.enqueue(await readUint8Array(reader, offset + chunkOffset, Math.min(chunkSize, size - chunkOffset), diskNumberStart));
 				if (chunkOffset + chunkSize > size) {
 					controller.close();
 				} else {
@@ -483,6 +483,52 @@ class Uint8ArrayWriter extends Writer {
 	}
 }
 
+class SplitZipReader extends Reader {
+
+	constructor(readers) {
+		super();
+		this.readers = readers;
+	}
+
+	async init() {
+		super.init();
+		const reader = this;
+		const { readers } = reader;
+		reader.lastDiskNumber = 0;
+		await Promise.all(readers.map(async diskReader => {
+			await diskReader.init();
+			reader.size += diskReader.size;
+		}));
+	}
+
+	async readUint8Array(offset, length, diskNumber = 0) {
+		const reader = this;
+		const { readers } = this;
+		let result;
+		let currentDiskNumber = diskNumber;
+		if (currentDiskNumber == -1) {
+			currentDiskNumber = readers.length - 1;
+		}
+		let currentReaderOffset = offset;
+		while (currentReaderOffset >= readers[currentDiskNumber].size) {
+			currentReaderOffset -= readers[currentDiskNumber].size;
+			currentDiskNumber++;
+		}
+		const currentReader = readers[currentDiskNumber];
+		const currentReaderSize = currentReader.size;
+		if (currentReaderOffset + length <= currentReaderSize) {
+			result = await readUint8Array(currentReader, currentReaderOffset, length);
+		} else {
+			const chunkLength = currentReaderSize - currentReaderOffset;
+			result = new Uint8Array(length);
+			result.set(await readUint8Array(currentReader, currentReaderOffset, chunkLength));
+			result.set(await reader.readUint8Array(offset + chunkLength, length - chunkLength, diskNumber), chunkLength);
+		}
+		reader.lastDiskNumber = Math.max(currentDiskNumber, reader.lastDiskNumber);
+		return result;
+	}
+}
+
 function isHttpFamily(url) {
 	const { baseURL } = getConfiguration();
 	const { protocol } = new URL(url, baseURL);
@@ -495,8 +541,13 @@ async function initStream(stream, initSize) {
 	}
 }
 
+function readUint8Array(reader, offset, size, diskNumber) {
+	return reader.readUint8Array(offset, size, diskNumber);
+}
+
 export {
 	initStream,
+	readUint8Array,
 	Reader,
 	Writer,
 	TextReader,
@@ -509,5 +560,6 @@ export {
 	Uint8ArrayWriter,
 	HttpReader,
 	HttpRangeReader,
+	SplitZipReader,
 	ERR_HTTP_RANGE
 };

package/lib/core/streams/codec-stream.js

@@ -38,11 +38,8 @@
 class CodecStream extends TransformStream {
 
 	constructor(Codec, options) {
-		let codec;
+		const codec = new Codec(options);
 		super({
-			start() {
-				codec = new Codec(options);
-			},
 			transform(chunk, controller) {
 				controller.enqueue(codec.append(chunk));
 			},

package/lib/core/streams/zip-crypto-stream.js

@@ -91,8 +91,6 @@ class ZipCryptoEncryptionStream extends TransformStream {
 				}
 				output.set(encrypt(zipCrypto, chunk), offset);
 				controller.enqueue(output);
-			},
-			flush() {
 			}
 		});
 	}

package/lib/core/zip-reader.js

@@ -68,12 +68,15 @@ import {
 } from "./codec-pool.js";
 import {
 	initStream,
-	BlobReader
+	readUint8Array,
+	BlobReader,
+	SplitZipReader
 } from "./io.js";
 import { decodeText } from "./util/decode-text.js";
 import { Crc32 } from "./streams/codecs/crc32.js";
 import { Entry } from "./zip-entry.js";
 
+const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
 const ERR_BAD_FORMAT = "File format is not recognized";
 const ERR_EOCDR_NOT_FOUND = "End of central directory not found";
 const ERR_EOCDR_ZIP64_NOT_FOUND = "End of Zip64 central directory not found";
@@ -84,9 +87,25 @@ const ERR_EXTRAFIELD_ZIP64_NOT_FOUND = "Zip64 extra field not found";
 const ERR_ENCRYPTED = "File contains encrypted entry";
 const ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
 const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
+const ERR_SPLIT_ZIP_FILE = "Split zip file";
 const CHARSET_UTF8 = "utf-8";
 const CHARSET_CP437 = "cp437";
-const ZIP64_PROPERTIES = ["uncompressedSize", "compressedSize", "offset"];
+const ZIP64_PROPERTIES = [
+	["uncompressedSize", MAX_32_BITS],
+	["compressedSize", MAX_32_BITS],
+	["offset", MAX_32_BITS],
+	["diskNumberStart", MAX_16_BITS]
+];
+const ZIP64_EXTRACTION = {
+	[MAX_16_BITS]: {
+		getValue: getUint32,
+		bytes: 4
+	},
+	[MAX_32_BITS]: {
+		getValue: getBigUint64,
+		bytes: 8
+	}
+};
 
 class ZipReader {
 
@@ -109,8 +128,12 @@ class ZipReader {
 		const { config } = zipReader;
 		await initStream(reader);
 		if (reader.size === undefined || !reader.readUint8Array) {
-			const blob = await new Response(reader.readable).blob();
-			reader = new BlobReader(blob);
+			if (Array.isArray(reader)) {
+				reader = new SplitZipReader(reader);
+			} else {
+				reader = new BlobReader(await new Response(reader.readable).blob());
+			}
+			await initStream(reader);
 		}
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
@@ -118,46 +141,64 @@ class ZipReader {
 		reader.chunkSize = getChunkSize(config);
 		const endOfDirectoryInfo = await seekSignature(reader, END_OF_CENTRAL_DIR_SIGNATURE, reader.size, END_OF_CENTRAL_DIR_LENGTH, MAX_16_BITS * 16);
 		if (!endOfDirectoryInfo) {
-			throw new Error(ERR_EOCDR_NOT_FOUND);
+			const signatureArray = await readUint8Array(reader, 0, 4);
+			const signatureView = getDataView(signatureArray);
+			if (getUint32(signatureView) == SPLIT_ZIP_FILE_SIGNATURE) {
+				throw new Error(ERR_SPLIT_ZIP_FILE);
+			} else {
+				throw new Error(ERR_EOCDR_NOT_FOUND);
+			}
 		}
+		const { lastDiskNumber } = reader;
 		const endOfDirectoryView = getDataView(endOfDirectoryInfo);
 		let directoryDataLength = getUint32(endOfDirectoryView, 12);
 		let directoryDataOffset = getUint32(endOfDirectoryView, 16);
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
+		let diskNumber = getUint16(endOfDirectoryView, 4);
+		if (lastDiskNumber !== undefined && diskNumber != lastDiskNumber) {
+			throw new Error(ERR_SPLIT_ZIP_FILE);
+		}
 		let filesLength = getUint16(endOfDirectoryView, 8);
 		let prependedDataLength = 0;
 		let startOffset = 0;
-		if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS) {
+		if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS) {
 			const endOfDirectoryLocatorArray = await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH);
 			const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
 			if (getUint32(endOfDirectoryLocatorView, 0) != ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
 				throw new Error(ERR_EOCDR_ZIP64_NOT_FOUND);
 			}
 			directoryDataOffset = getBigUint64(endOfDirectoryLocatorView, 8);
-			let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+			let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
 			let endOfDirectoryView = getDataView(endOfDirectoryArray);
 			const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 			if (getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset) {
 				const originalDirectoryDataOffset = directoryDataOffset;
 				directoryDataOffset = expectedDirectoryDataOffset;
 				prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
-				endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+				endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
 				endOfDirectoryView = getDataView(endOfDirectoryArray);
 			}
 			if (getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
 				throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
 			}
-			filesLength = getBigUint64(endOfDirectoryView, 32);
-			directoryDataLength = getBigUint64(endOfDirectoryView, 40);
+			if (diskNumber == MAX_16_BITS) {
+				diskNumber = getUint32(endOfDirectoryView, 16);
+			}
+			if (filesLength == MAX_16_BITS) {
+				filesLength = getBigUint64(endOfDirectoryView, 32);
+			}
+			if (directoryDataLength == MAX_32_BITS) {
+				directoryDataLength = getBigUint64(endOfDirectoryView, 40);
+			}
 			directoryDataOffset -= directoryDataLength;
 		}
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
 		let offset = 0;
-		let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+		let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
 		let directoryView = getDataView(directoryArray);
 		if (directoryDataLength) {
 			const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - directoryDataLength;
@@ -165,7 +206,7 @@ class ZipReader {
 				const originalDirectoryDataOffset = directoryDataOffset;
 				directoryDataOffset = expectedDirectoryDataOffset;
 				prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
-				directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+				directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
 				directoryView = getDataView(directoryArray);
 			}
 		}
@@ -186,40 +227,49 @@ class ZipReader {
 			const commentOffset = extraFieldOffset + fileEntry.extraFieldLength;
 			const versionMadeBy = getUint16(directoryView, offset + 4);
 			const msDosCompatible = (versionMadeBy & 0) == 0;
+			const rawFilename = directoryArray.subarray(filenameOffset, extraFieldOffset);
+			const commentLength = getUint16(directoryView, offset + 32);
+			const endOffset = commentOffset + commentLength;
+			const rawComment = directoryArray.subarray(commentOffset, endOffset);
+			const filenameUTF8 = languageEncodingFlag;
+			const commentUTF8 = languageEncodingFlag;
+			const directory = msDosCompatible && ((getUint8(directoryView, offset + 38) & FILE_ATTR_MSDOS_DIR_MASK) == FILE_ATTR_MSDOS_DIR_MASK);
+			const offsetFileEntry = getUint32(directoryView, offset + 42) + prependedDataLength;
 			Object.assign(fileEntry, {
 				versionMadeBy,
 				msDosCompatible,
 				compressedSize: 0,
 				uncompressedSize: 0,
-				commentLength: getUint16(directoryView, offset + 32),
-				directory: msDosCompatible && ((getUint8(directoryView, offset + 38) & FILE_ATTR_MSDOS_DIR_MASK) == FILE_ATTR_MSDOS_DIR_MASK),
-				offset: getUint32(directoryView, offset + 42) + prependedDataLength,
+				commentLength,
+				directory,
+				offset: offsetFileEntry,
+				diskNumberStart: getUint16(directoryView, offset + 34),
 				internalFileAttribute: getUint16(directoryView, offset + 36),
 				externalFileAttribute: getUint32(directoryView, offset + 38),
-				rawFilename: directoryArray.subarray(filenameOffset, extraFieldOffset),
-				filenameUTF8: languageEncodingFlag,
-				commentUTF8: languageEncodingFlag,
+				rawFilename,
+				filenameUTF8,
+				commentUTF8,
 				rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset)
 			});
-			startOffset = Math.max(fileEntry.offset, startOffset);
-			const endOffset = commentOffset + fileEntry.commentLength;
-			fileEntry.rawComment = directoryArray.subarray(commentOffset, endOffset);
 			const [filename, comment] = await Promise.all([
-				decodeText(fileEntry.rawFilename, fileEntry.filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437),
-				decodeText(fileEntry.rawComment, fileEntry.commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437)
+				decodeText(rawFilename, filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437),
+				decodeText(rawComment, commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437)
 			]);
-			fileEntry.filename = filename;
-			fileEntry.comment = comment;
-			if (!fileEntry.directory && fileEntry.filename.endsWith(DIRECTORY_SIGNATURE)) {
-				fileEntry.directory = true;
-			}
+			Object.assign(fileEntry, {
+				rawComment,
+				filename,
+				comment,
+				directory: directory || filename.endsWith(DIRECTORY_SIGNATURE)
+			});
+			startOffset = Math.max(offsetFileEntry, startOffset);
 			await readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
 			const entry = new Entry(fileEntry);
 			entry.getData = (writer, options) => fileEntry.getData(writer, entry, options);
 			offset = endOffset;
-			if (options.onprogress) {
+			const { onprogress } = options;
+			if (onprogress) {
 				try {
-					await options.onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
+					await onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
 				} catch (_error) {
 					// ignored
 				}
@@ -263,7 +313,8 @@ export {
 	ERR_UNSUPPORTED_ENCRYPTION,
 	ERR_UNSUPPORTED_COMPRESSION,
 	ERR_INVALID_SIGNATURE,
-	ERR_INVALID_PASSWORD
+	ERR_INVALID_PASSWORD,
+	ERR_SPLIT_ZIP_FILE
 };
 
 class ZipEntry {
@@ -281,6 +332,7 @@ class ZipEntry {
 		const {
 			reader,
 			offset,
+			diskNumberStart,
 			extraFieldAES,
 			compressionMethod,
 			config,
@@ -291,7 +343,7 @@ class ZipEntry {
 			compressedSize
 		} = zipEntry;
 		const localDirectory = zipEntry.localDirectory = {};
-		let dataArray = await readUint8Array(reader, offset, 30);
+		let dataArray = await readUint8Array(reader, offset, 30, diskNumberStart);
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, "password");
 		password = password && password.length && password;
@@ -307,11 +359,13 @@ class ZipEntry {
 			throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
 		}
 		readCommonHeader(localDirectory, dataView, 4);
-		dataArray = await readUint8Array(reader, offset, 30 + localDirectory.filenameLength + localDirectory.extraFieldLength);
+		dataArray = await readUint8Array(reader, offset, 30 + localDirectory.filenameLength + localDirectory.extraFieldLength, diskNumberStart);
 		localDirectory.rawExtraField = dataArray.subarray(30 + localDirectory.filenameLength);
 		await readCommonFooter(zipEntry, localDirectory, dataView, 4);
-		fileEntry.lastAccessDate = localDirectory.lastAccessDate;
-		fileEntry.creationDate = localDirectory.creationDate;
+		Object.assign(fileEntry, {
+			lastAccessDate: localDirectory.lastAccessDate,
+			creationDate: localDirectory.creationDate
+		});
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (encrypted) {
@@ -323,6 +377,7 @@ class ZipEntry {
 		}
 		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
 		const readable = reader.readable;
+		readable.diskNumberStart = diskNumberStart;
 		readable.offset = dataOffset;
 		const size = readable.size = compressedSize;
 		if (writer instanceof WritableStream) {
@@ -407,9 +462,11 @@ async function readCommonFooter(fileEntry, directory, dataView, offset) {
 		// ignored
 	}
 	const compressionMethod = getUint16(dataView, offset + 4);
-	directory.signature = getUint32(dataView, offset + 10);
-	directory.uncompressedSize = getUint32(dataView, offset + 18);
-	directory.compressedSize = getUint32(dataView, offset + 14);
+	Object.assign(directory, {
+		signature: getUint32(dataView, offset + 10),
+		uncompressedSize: getUint32(dataView, offset + 18),
+		compressedSize: getUint32(dataView, offset + 14)
+	});
 	const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
 	if (extraFieldZip64) {
 		readExtraFieldZip64(extraFieldZip64, directory);
@@ -447,35 +504,31 @@ async function readCommonFooter(fileEntry, directory, dataView, offset) {
 function readExtraFieldZip64(extraFieldZip64, directory) {
 	directory.zip64 = true;
 	const extraFieldView = getDataView(extraFieldZip64.data);
-	extraFieldZip64.values = [];
-	for (let indexValue = 0; indexValue < Math.floor(extraFieldZip64.data.length / 8); indexValue++) {
-		extraFieldZip64.values.push(getBigUint64(extraFieldView, 0 + indexValue * 8));
-	}
-	const missingProperties = ZIP64_PROPERTIES.filter(propertyName => directory[propertyName] == MAX_32_BITS);
-	for (let indexMissingProperty = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
-		extraFieldZip64[missingProperties[indexMissingProperty]] = extraFieldZip64.values[indexMissingProperty];
-	}
-	ZIP64_PROPERTIES.forEach(propertyName => {
-		if (directory[propertyName] == MAX_32_BITS) {
-			if (extraFieldZip64[propertyName] !== undefined) {
-				directory[propertyName] = extraFieldZip64[propertyName];
-			} else {
-				throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
-			}
+	const missingProperties = ZIP64_PROPERTIES.filter(([propertyName, max]) => directory[propertyName] == max);
+	for (let indexMissingProperty = 0, offset = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
+		const [propertyName, max] = missingProperties[indexMissingProperty];
+		if (directory[propertyName] == max) {
+			const extraction = ZIP64_EXTRACTION[max];
+			directory[propertyName] = extraFieldZip64[propertyName] = extraction.getValue(extraFieldView, offset);
+			offset += extraction.bytes;
+		} else if (extraFieldZip64[propertyName]) {
+			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
 		}
-	});
+	}
 }
 
 async function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
 	const extraFieldView = getDataView(extraFieldUnicode.data);
-	extraFieldUnicode.version = getUint8(extraFieldView, 0);
-	extraFieldUnicode.signature = getUint32(extraFieldView, 1);
 	const crc32 = new Crc32();
 	crc32.append(fileEntry[rawPropertyName]);
 	const dataViewSignature = getDataView(new Uint8Array(4));
 	dataViewSignature.setUint32(0, crc32.get(), true);
-	extraFieldUnicode[propertyName] = await decodeText(extraFieldUnicode.data.subarray(5));
-	extraFieldUnicode.valid = !fileEntry.bitFlag.languageEncodingFlag && extraFieldUnicode.signature == getUint32(dataViewSignature, 0);
+	Object.assign(extraFieldUnicode, {
+		version: getUint8(extraFieldView, 0),
+		signature: getUint32(extraFieldView, 1),
+		[propertyName]: await decodeText(extraFieldUnicode.data.subarray(5)),
+		valid: !fileEntry.bitFlag.languageEncodingFlag && extraFieldUnicode.signature == getUint32(dataViewSignature, 0)
+	});
 	if (extraFieldUnicode.valid) {
 		directory[propertyName] = extraFieldUnicode[propertyName];
 		directory[propertyName + "UTF8"] = true;
@@ -484,12 +537,15 @@ async function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropert
 
 function readExtraFieldAES(extraFieldAES, directory, compressionMethod) {
 	const extraFieldView = getDataView(extraFieldAES.data);
-	extraFieldAES.vendorVersion = getUint8(extraFieldView, 0);
-	extraFieldAES.vendorId = getUint8(extraFieldView, 2);
 	const strength = getUint8(extraFieldView, 4);
-	extraFieldAES.strength = strength;
-	extraFieldAES.originalCompressionMethod = compressionMethod;
-	directory.compressionMethod = extraFieldAES.compressionMethod = getUint16(extraFieldView, 5);
+	Object.assign(extraFieldAES, {
+		vendorVersion: getUint8(extraFieldView, 0),
+		vendorId: getUint8(extraFieldView, 2),
+		strength,
+		originalCompressionMethod: compressionMethod,
+		compressionMethod: getUint16(extraFieldView, 5)
+	});
+	directory.compressionMethod = extraFieldAES.compressionMethod;
 }
 
 function readExtraFieldNTFS(extraFieldNTFS, directory) {
@@ -621,8 +677,4 @@ function setUint32(view, offset, value) {
 
 function getDataView(array) {
 	return new DataView(array.buffer);
-}
-
-function readUint8Array(reader, offset, size) {
-	return reader.readUint8Array(offset, size);
 }