@zip.js/zip.js 2.7.64 → 2.7.66

package/lib/core/codec-worker.js

@@ -57,7 +57,7 @@ class CodecWorker {
 			busy: true,
 			readable: readable
 				.pipeThrough(new ChunkStream(config.chunkSize))
-				.pipeThrough(new ProgressWatcherStream(readable, streamOptions), { signal }),
+				.pipeThrough(new ProgressWatcherStream(streamOptions), { signal }),
 			writable,
 			options: Object.assign({}, options),
 			scripts,
@@ -96,7 +96,7 @@ class CodecWorker {
 
 class ProgressWatcherStream extends TransformStream {
 
-	constructor(readableSource, { onstart, onprogress, size, onend }) {
+	constructor({ onstart, onprogress, size, onend }) {
 		let chunkOffset = 0;
 		super({
 			async start() {
@@ -112,7 +112,6 @@ class ProgressWatcherStream extends TransformStream {
 				controller.enqueue(chunk);
 			},
 			async flush() {
-				readableSource.size = chunkOffset;
 				if (onend) {
 					await callHandler(onend, chunkOffset);
 				}
@@ -158,8 +157,9 @@ function createWebWorkerInterface(workerData, config) {
 }
 
 async function runWorker({ options, readable, writable, onTaskFinished }, config) {
+	let codecStream;
 	try {
-		const codecStream = new CodecStream(options, config);
+		codecStream = new CodecStream(options, config);
 		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
 		const {
 			signature,
@@ -171,6 +171,11 @@ async function runWorker({ options, readable, writable, onTaskFinished }, config
 			inputSize,
 			outputSize
 		};
+	} catch (error) {
+		if (codecStream) {
+			error.outputSize = codecStream.outputSize;
+		}
+		throw error;
 	} finally {
 		onTaskFinished();
 	}
@@ -314,9 +319,9 @@ async function onMessage({ data }, workerData) {
 	const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
 	try {
 		if (error) {
-			const { message, stack, code, name } = error;
+			const { message, stack, code, name, outputSize } = error;
 			const responseError = new Error(message);
-			Object.assign(responseError, { stack, code, name });
+			Object.assign(responseError, { stack, code, name, outputSize });
 			close(responseError);
 		} else {
 			if (type == MESSAGE_PULL) {

package/lib/core/constants.js

@@ -53,13 +53,16 @@ const EXTRAFIELD_TYPE_UNICODE_PATH = 0x7075;
 const EXTRAFIELD_TYPE_UNICODE_COMMENT = 0x6375;
 const EXTRAFIELD_TYPE_USDZ = 0x1986;
 
-const BITFLAG_ENCRYPTED = 0x01;
-const BITFLAG_LEVEL = 0x06;
-const BITFLAG_DATA_DESCRIPTOR = 0x0008;
-const BITFLAG_LANG_ENCODING_FLAG = 0x0800;
-const FILE_ATTR_MSDOS_DIR_MASK = 0x10;
-const FILE_ATTR_UNIX_TYPE_MASK =  0o170000;
-const FILE_ATTR_UNIX_TYPE_DIR =   0o040000;
+const BITFLAG_ENCRYPTED = 0b1;
+const BITFLAG_LEVEL = 0b0110;
+const BITFLAG_LEVEL_MAX_MASK = 0b010;
+const BITFLAG_LEVEL_FAST_MASK = 0b100;
+const BITFLAG_LEVEL_SUPER_FAST_MASK = 0b110;
+const BITFLAG_DATA_DESCRIPTOR = 0b1000;
+const BITFLAG_LANG_ENCODING_FLAG = 0b100000000000;
+const FILE_ATTR_MSDOS_DIR_MASK = 0b10000;
+const FILE_ATTR_UNIX_TYPE_MASK = 0o170000;
+const FILE_ATTR_UNIX_TYPE_DIR = 0o040000;
 const FILE_ATTR_UNIX_EXECUTABLE_MASK = 0o111;
 const FILE_ATTR_UNIX_DEFAULT_MASK = 0o644;
 
@@ -70,6 +73,9 @@ const VERSION_AES = 0x33;
 const DIRECTORY_SIGNATURE = "/";
 
 const HEADER_SIZE = 26;
+const HEADER_OFFSET_SIGNATURE = 10;
+const HEADER_OFFSET_COMPRESSED_SIZE = 14;
+const HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
 
 const MAX_DATE = new Date(2107, 11, 31);
 const MIN_DATE = new Date(1980, 0, 1);
@@ -105,6 +111,9 @@ export {
 	ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH,
 	BITFLAG_ENCRYPTED,
 	BITFLAG_LEVEL,
+	BITFLAG_LEVEL_MAX_MASK,
+	BITFLAG_LEVEL_FAST_MASK,
+	BITFLAG_LEVEL_SUPER_FAST_MASK,
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
 	FILE_ATTR_MSDOS_DIR_MASK,
@@ -116,6 +125,9 @@ export {
 	VERSION_ZIP64,
 	VERSION_AES,
 	HEADER_SIZE,
+	HEADER_OFFSET_SIGNATURE,
+	HEADER_OFFSET_COMPRESSED_SIZE,
+	HEADER_OFFSET_UNCOMPRESSED_SIZE,
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
 	MAX_DATE,

package/lib/core/io.js

@@ -141,10 +141,16 @@ class Data64URIReader extends Reader {
 		const start = Math.floor(offset / 3) * 4;
 		const bytes = atob(dataURI.substring(start + dataStart, Math.ceil((offset + length) / 3) * 4 + dataStart));
 		const delta = offset - Math.floor(start / 4) * 3;
-		for (let indexByte = delta; indexByte < delta + length; indexByte++) {
+		let effectiveLength = 0;
+		for (let indexByte = delta; indexByte < delta + length && indexByte < bytes.length; indexByte++) {
 			dataArray[indexByte - delta] = bytes.charCodeAt(indexByte);
+			effectiveLength++;
+		}
+		if (effectiveLength < dataArray.length) {
+			return dataArray.subarray(0, effectiveLength);
+		} else {
+			return dataArray;
 		}
-		return dataArray;
 	}
 }
 
@@ -582,19 +588,28 @@ class SplitDataReader extends Reader {
 			currentDiskNumber = readers.length - 1;
 		}
 		let currentReaderOffset = offset;
-		while (currentReaderOffset >= readers[currentDiskNumber].size) {
+		while (readers[currentDiskNumber] && 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);
+		if (currentReader) {
+			const currentReaderSize = currentReader.size;
+			if (currentReaderOffset + length <= currentReaderSize) {
+				result = await readUint8Array(currentReader, currentReaderOffset, length);
+			} else {
+				const chunkLength = currentReaderSize - currentReaderOffset;
+				result = new Uint8Array(length);
+				const firstPart = await readUint8Array(currentReader, currentReaderOffset, chunkLength);
+				result.set(firstPart, 0);
+				const secondPart = await reader.readUint8Array(offset + chunkLength, length - chunkLength, diskNumber);
+				result.set(secondPart, chunkLength);
+				if (firstPart.length + secondPart.length < length) {
+					result = result.subarray(0, firstPart.length + secondPart.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);
+			result = new Uint8Array();
 		}
 		reader.lastDiskNumber = Math.max(currentDiskNumber, reader.lastDiskNumber);
 		return result;
@@ -634,12 +649,12 @@ class SplitDataWriter extends Stream {
 					}
 					await this.write(chunk);
 				} else if (chunk.length >= availableSize) {
-					await writeChunk(chunk.slice(0, availableSize));
+					await writeChunk(chunk.subarray(0, availableSize));
 					await closeDisk();
 					writer.diskOffset += diskSourceWriter.size;
 					writer.diskNumber++;
 					diskWriter = null;
-					await this.write(chunk.slice(availableSize));
+					await this.write(chunk.subarray(availableSize));
 				} else {
 					await writeChunk(chunk);
 				}
@@ -667,12 +682,52 @@ class SplitDataWriter extends Stream {
 		}
 
 		async function closeDisk() {
-			diskWritable.size = diskSourceWriter.size;
 			await diskWriter.close();
 		}
 	}
 }
 
+class GenericReader {
+
+	constructor(reader) {
+		if (Array.isArray(reader)) {
+			reader = new SplitDataReader(reader);
+		}
+		if (reader instanceof ReadableStream) {
+			reader = {
+				readable: reader
+			};
+		}
+		return reader;
+	}
+}
+
+class GenericWriter {
+
+	constructor(writer) {
+		if (writer.writable === UNDEFINED_VALUE && typeof writer.next == FUNCTION_TYPE) {
+			writer = new SplitDataWriter(writer);
+		}
+		if (writer instanceof WritableStream) {
+			writer = {
+				writable: writer
+			};
+		}
+		if (writer.size === UNDEFINED_VALUE) {
+			writer.size = 0;
+		}
+		if (!(writer instanceof SplitDataWriter)) {
+			Object.assign(writer, {
+				diskNumber: 0,
+				diskOffset: 0,
+				availableSize: Infinity,
+				maxSize: Infinity
+			});
+		}
+		return writer;
+	}
+}
+
 function isHttpFamily(url) {
 	const { baseURL } = getConfiguration();
 	const { protocol } = new URL(url, baseURL);
@@ -687,42 +742,6 @@ async function initStream(stream, initSize) {
 	}
 }
 
-function initReader(reader) {
-	if (Array.isArray(reader)) {
-		reader = new SplitDataReader(reader);
-	}
-	if (reader instanceof ReadableStream) {
-		reader = {
-			readable: reader
-		};
-	}
-	return reader;
-}
-
-function initWriter(writer) {
-	if (writer.writable === UNDEFINED_VALUE && typeof writer.next == FUNCTION_TYPE) {
-		writer = new SplitDataWriter(writer);
-	}
-	if (writer instanceof WritableStream) {
-		writer = {
-			writable: writer
-		};
-	}
-	const { writable } = writer;
-	if (writable.size === UNDEFINED_VALUE) {
-		writable.size = 0;
-	}
-	if (!(writer instanceof SplitDataWriter)) {
-		Object.assign(writer, {
-			diskNumber: 0,
-			diskOffset: 0,
-			availableSize: Infinity,
-			maxSize: Infinity
-		});
-	}
-	return writer;
-}
-
 function readUint8Array(reader, offset, size, diskNumber) {
 	return reader.readUint8Array(offset, size, diskNumber);
 }
@@ -732,8 +751,8 @@ const SplitZipWriter = SplitDataWriter;
 
 export {
 	initStream,
-	initReader,
-	initWriter,
+	GenericReader,
+	GenericWriter,
 	readUint8Array,
 	Reader,
 	Writer,

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

@@ -81,7 +81,7 @@ class CodecStream extends TransformStream {
 		} else if (codecType.startsWith(CODEC_INFLATE)) {
 			Stream = InflateStream;
 		}
-		let outputSize = 0;
+		codec.outputSize = 0;
 		let inputSize = 0;
 		const stream = new Stream(options, config);
 		const readable = super.readable;
@@ -101,15 +101,14 @@ class CodecStream extends TransformStream {
 		const outputSizeStream = new TransformStream({
 			transform(chunk, controller) {
 				if (chunk && chunk.length) {
-					outputSize += chunk.length;
 					controller.enqueue(chunk);
+					codec.outputSize += chunk.length;
 				}
 			},
 			flush() {
 				const { signature } = stream;
 				Object.assign(codec, {
 					signature,
-					outputSize,
 					inputSize
 				});
 			}

package/lib/core/z-worker-core.js

@@ -71,6 +71,7 @@ addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
 });
 
 async function init(message) {
+	let codecStream;
 	try {
 		const { options, scripts, config } = message;
 		if (scripts && scripts.length) {
@@ -142,6 +143,7 @@ async function init(message) {
 			}
 		});
 	} catch (error) {
+		error.outputSize = codecStream ? codecStream.outputSize : 0;
 		sendErrorMessage(error);
 	}
 }
@@ -173,6 +175,6 @@ function sendMessage(message) {
 }
 
 function sendErrorMessage(error = new Error("Unknown error")) {
-	const { message, stack, code, name } = error;
-	postMessage({ error: { message, stack, code, name } });
+	const { message, stack, code, name, outputSize } = error;
+	postMessage({ error: { message, stack, code, name, outputSize } });
 }

package/lib/core/zip-fs-core.js

@@ -144,8 +144,8 @@ class ZipFileEntry extends ZipEntry {
 			const reader = zipEntry.reader = new zipEntry.Reader(zipEntry.data, options);
 			const uncompressedSize = zipEntry.data ? zipEntry.data.uncompressedSize : reader.size;
 			await Promise.all([initStream(reader), initStream(writer, uncompressedSize)]);
-			const readable = reader.readable;
-			readable.size = zipEntry.uncompressedSize = reader.size;
+			const { readable } = reader;
+			zipEntry.uncompressedSize = reader.size;
 			await readable.pipeTo(writer.writable);
 			return writer.getData ? writer.getData() : writer.writable;
 		}
@@ -195,6 +195,10 @@ class ZipFileEntry extends ZipEntry {
 		return this.getData({ writable }, options);
 	}
 
+	getArrayBuffer(options) {
+		return this.data.arrayBuffer(options);
+	}
+
 	replaceBlob(blob) {
 		Object.assign(this, {
 			data: blob,

package/lib/core/zip-reader.js

@@ -62,6 +62,9 @@ import {
 	FILE_ATTR_UNIX_EXECUTABLE_MASK,
 	DIRECTORY_SIGNATURE,
 	HEADER_SIZE,
+	HEADER_OFFSET_SIGNATURE,
+	HEADER_OFFSET_COMPRESSED_SIZE,
+	HEADER_OFFSET_UNCOMPRESSED_SIZE,
 	UNDEFINED_VALUE
 } from "./constants.js";
 import {
@@ -77,10 +80,10 @@ import {
 } from "./codec-pool.js";
 import {
 	initStream,
-	initReader,
-	initWriter,
 	readUint8Array,
-	BlobReader
+	BlobReader,
+	GenericReader,
+	GenericWriter
 } from "./io.js";
 import { decodeText } from "./util/decode-text.js";
 import { Crc32 } from "./streams/codecs/crc32.js";
@@ -135,7 +138,7 @@ class ZipReader {
 
 	constructor(reader, options = {}) {
 		Object.assign(this, {
-			reader: initReader(reader),
+			reader: new GenericReader(reader),
 			options,
 			config: getConfiguration()
 		});
@@ -310,6 +313,13 @@ class ZipReader {
 			fileEntry.zipCrypto = fileEntry.encrypted && !fileEntry.extraFieldAES;
 			const entry = new Entry(fileEntry);
 			entry.getData = (writer, options) => fileEntry.getData(writer, entry, options);
+			entry.arrayBuffer = async options => {
+				const writer = new TransformStream();
+				const [arrayBuffer] = await Promise.all([
+					new Response(writer.readable).arrayBuffer(),
+					fileEntry.getData(writer, entry, options)]);
+				return arrayBuffer;
+			};
 			offset = endOffset;
 			const { onprogress } = options;
 			if (onprogress) {
@@ -470,7 +480,7 @@ class ZipEntry {
 		if (checkPasswordOnly) {
 			writer = new WritableStream();
 		}
-		writer = initWriter(writer);
+		writer = new GenericWriter(writer);
 		await initStream(writer, passThrough ? compressedSize : uncompressedSize);
 		const { writable } = writer;
 		const { onstart, onprogress, onend } = options;
@@ -494,16 +504,18 @@ class ZipEntry {
 			config,
 			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
-		let outputSize = 0;
 		try {
-			({ outputSize } = (await runWorker({ readable, writable }, workerOptions)));
+			const { outputSize } = await runWorker({ readable, writable }, workerOptions);
+			writer.size += outputSize;
 		} catch (error) {
+			if (error.outputSize !== UNDEFINED_VALUE) {
+				writer.size += error.outputSize;
+			}
 			if (!checkPasswordOnly || error.message != ERR_ABORT_CHECK_PASSWORD) {
 				throw error;
 			}
 		} finally {
 			const preventClose = getOptionValue(zipEntry, options, "preventClose");
-			writable.size += outputSize;
 			if (!preventClose && !writable.locked) {
 				await writable.getWriter().close();
 			}
@@ -552,9 +564,9 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	}
 	const compressionMethod = getUint16(dataView, offset + 4);
 	Object.assign(directory, {
-		signature: getUint32(dataView, offset + 10),
-		uncompressedSize: getUint32(dataView, offset + 18),
-		compressedSize: getUint32(dataView, offset + 14)
+		signature: getUint32(dataView, offset + HEADER_OFFSET_SIGNATURE),
+		compressedSize: getUint32(dataView, offset + HEADER_OFFSET_COMPRESSED_SIZE),
+		uncompressedSize: getUint32(dataView, offset + HEADER_OFFSET_UNCOMPRESSED_SIZE)
 	});
 	const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
 	if (extraFieldZip64) {