@zip.js/zip.js 2.6.29 → 2.6.31

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, WritableStream */
 
 import {
 	Codec,
@@ -141,8 +141,24 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		}
 		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
 		workerData.interface = {
-			run() {
-				const { readable, writable, options } = workerData;
+			async run() {
+				const { readable, options } = workerData;
+				const writer = workerData.writable.getWriter();
+				let resolveStreamClosed, streamClosed;
+				streamClosed = new Promise(resolve => resolveStreamClosed = resolve);
+				const writable = new WritableStream({
+					async write(chunk) {
+						await writer.ready;
+						await writer.write(new Uint8Array(chunk));
+					},
+					async close() {
+						writer.releaseLock();
+						resolveStreamClosed();
+					},
+					abort(reason) {
+						writer.abort(reason);
+					}
+				});
 				const scripts = workerData.scripts.slice(1);
 				const message = { type: MESSAGE_START, scripts, options, config: { chunkSize } };
 				if (workerData.transferStreams && transferStreamsSupported) {
@@ -155,7 +171,14 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 					sendMessage(message);
 					initStreams(readable, writable);
 				}
-				return workerData.result;
+				const result = await workerData.result;
+				try {
+					await writable.close();
+				} catch (_error) {
+					// ignored
+				}
+				await streamClosed;
+				return result;
 			}
 		};
 	}

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/z-worker-core.js

@@ -108,8 +108,10 @@ async function init(message) {
 		}, strategy);
 		codec = new Codec(readable, writable, options, config);
 		const result = await codec.run();
-		if (message.writable && !options.preventClose) {
-			await message.writable.close();
+		try {
+			await writable.close();
+		} catch (_error) {
+			// ignored
 		}
 		sendMessage({ type: MESSAGE_CLOSE, result });
 	} catch (error) {

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);
 			}
 		}
@@ -202,6 +243,7 @@ class ZipReader {
 				commentLength,
 				directory,
 				offset: offsetFileEntry,
+				diskNumberStart: getUint16(directoryView, offset + 34),
 				internalFileAttribute: getUint16(directoryView, offset + 36),
 				externalFileAttribute: getUint32(directoryView, offset + 38),
 				rawFilename,
@@ -271,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 {
@@ -289,6 +332,7 @@ class ZipEntry {
 		const {
 			reader,
 			offset,
+			diskNumberStart,
 			extraFieldAES,
 			compressionMethod,
 			config,
@@ -299,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;
@@ -315,7 +359,7 @@ 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);
 		Object.assign(fileEntry, {
@@ -333,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) {
@@ -345,7 +390,6 @@ class ZipEntry {
 			writable.size = 0;
 		}
 		const signal = getOptionValue(zipEntry, options, "signal");
-		const preventClose = getOptionValue(zipEntry, options, "preventClose");
 		await initStream(writer, uncompressedSize);
 		const { onstart, onprogress, onend } = options;
 		const workerOptions = {
@@ -361,19 +405,15 @@ class ZipEntry {
 				encrypted,
 				useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
 				useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream"),
-				transferStreams: getOptionValue(zipEntry, options, "transferStreams"),
-				preventClose
+				transferStreams: getOptionValue(zipEntry, options, "transferStreams")
 			},
 			config,
 			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
 		writable.size += (await runWorker({ readable, writable }, workerOptions)).size;
+		const preventClose = getOptionValue(zipEntry, options, "preventClose");
 		if (!preventClose) {
-			try {
-				await writable.close();
-			} catch (_error) {
-				// ignored
-			}
+			await writable.close();
 		}
 		return writer.getData ? writer.getData() : writable;
 	}
@@ -459,23 +499,17 @@ 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) {
@@ -638,8 +672,4 @@ function setUint32(view, offset, value) {
 
 function getDataView(array) {
 	return new DataView(array.buffer);
-}
-
-function readUint8Array(reader, offset, size) {
-	return reader.readUint8Array(offset, size);
 }