@zip.js/zip.js 2.5.3 → 2.5.4

package/lib/core/io.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Blob, FileReader, atob, btoa, XMLHttpRequest, document, fetch */
+/* global Blob, FileReader, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream */
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
@@ -40,6 +40,7 @@ const HTTP_HEADER_RANGE = "Range";
 const HTTP_METHOD_HEAD = "HEAD";
 const HTTP_METHOD_GET = "GET";
 const HTTP_RANGE_UNIT = "bytes";
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
 class Stream {
 
@@ -53,9 +54,48 @@ class Stream {
 }
 
 class Reader extends Stream {
+
+	getStream({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
+		const reader = this;
+		return new ReadableStream({
+			start() {
+				this.chunkOffset = 0;
+			},
+			async pull(controller) {
+				const { chunkOffset } = this;
+				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size() - chunkOffset)));
+				if (chunkOffset + chunkSize > size()) {
+					controller.close();
+				} else {
+					this.chunkOffset += chunkSize;
+				}
+			}
+		});
+	}
+}
+
+class WriterStream extends Stream {
+	getStream() {
+		const writer = this;
+		return new WritableStream({
+			write(chunk) {
+				if (chunk && chunk.length) {
+					return writer.writeUint8Array(chunk);
+				}
+			}
+		});
+	}
+
+	getStreamWriter() {
+		const writer = this;
+		if (!writer.streamWriter) {
+			writer.streamWriter = writer.getStream().getWriter();
+		}
+		return writer.streamWriter;
+	}
 }
 
-class Writer extends Stream {
+class Writer extends WriterStream {
 
 	writeUint8Array(array) {
 		this.size += array.length;
@@ -70,9 +110,10 @@ class TextReader extends Reader {
 	}
 
 	init() {
+		const reader = this;
 		super.init();
-		this.blobReader.init();
-		this.size = this.blobReader.size;
+		reader.blobReader.init();
+		reader.size = reader.blobReader.size;
 	}
 
 	readUint8Array(offset, length) {
@@ -94,14 +135,15 @@ class TextWriter extends Writer {
 	}
 
 	getData() {
-		if (this.blob.text) {
-			return this.blob.text();
+		const writer = this;
+		if (writer.blob.text) {
+			return writer.blob.text();
 		} else {
 			const reader = new FileReader();
 			return new Promise((resolve, reject) => {
 				reader.onload = event => resolve(event.target.result);
 				reader.onerror = () => reject(reader.error);
-				reader.readAsText(this.blob, this.encoding);
+				reader.readAsText(writer.blob, writer.encoding);
 			});
 		}
 	}
@@ -111,19 +153,21 @@ class Data64URIReader extends Reader {
 
 	constructor(dataURI) {
 		super();
-		this.dataURI = dataURI;
+		const reader = this;
+		reader.dataURI = dataURI;
 		let dataEnd = dataURI.length;
 		while (dataURI.charAt(dataEnd - 1) == "=") {
 			dataEnd--;
 		}
-		this.dataStart = dataURI.indexOf(",") + 1;
-		this.size = Math.floor((dataEnd - this.dataStart) * 0.75);
+		reader.dataStart = dataURI.indexOf(",") + 1;
+		reader.size = Math.floor((dataEnd - reader.dataStart) * 0.75);
 	}
 
 	readUint8Array(offset, length) {
 		const dataArray = new Uint8Array(length);
 		const start = Math.floor(offset / 3) * 4;
-		const bytes = atob(this.dataURI.substring(start + this.dataStart, Math.ceil((offset + length) / 3) * 4 + this.dataStart));
+		const dataStart = this.dataStart;
+		const bytes = atob(this.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++) {
 			dataArray[indexByte - delta] = bytes.charCodeAt(indexByte);
@@ -142,20 +186,21 @@ class Data64URIWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
+		const writer = this;
 		let indexArray = 0;
-		let dataString = this.pending;
-		const delta = this.pending.length;
-		this.pending = "";
+		let dataString = writer.pending;
+		const delta = writer.pending.length;
+		writer.pending = "";
 		for (indexArray = 0; indexArray < (Math.floor((delta + array.length) / 3) * 3) - delta; indexArray++) {
 			dataString += String.fromCharCode(array[indexArray]);
 		}
 		for (; indexArray < array.length; indexArray++) {
-			this.pending += String.fromCharCode(array[indexArray]);
+			writer.pending += String.fromCharCode(array[indexArray]);
 		}
 		if (dataString.length > 2) {
-			this.data += btoa(dataString);
+			writer.data += btoa(dataString);
 		} else {
-			this.pending = dataString;
+			writer.pending = dataString;
 		}
 	}
 
@@ -173,14 +218,15 @@ class BlobReader extends Reader {
 	}
 
 	async readUint8Array(offset, length) {
-		if (this.blob.arrayBuffer) {
-			return new Uint8Array(await this.blob.slice(offset, offset + length).arrayBuffer());
+		const reader = this;
+		if (reader.blob.arrayBuffer) {
+			return new Uint8Array(await reader.blob.slice(offset, offset + length).arrayBuffer());
 		} else {
 			const reader = new FileReader();
 			return new Promise((resolve, reject) => {
 				reader.onload = event => resolve(new Uint8Array(event.target.result));
 				reader.onerror = () => reject(reader.error);
-				reader.readAsArrayBuffer(this.blob.slice(offset, offset + length));
+				reader.readAsArrayBuffer(reader.blob.slice(offset, offset + length));
 			});
 		}
 	}
@@ -197,21 +243,23 @@ class BlobWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
-		if (this.arrayBuffers.length == this.arrayBuffersMaxlength) {
-			flushArrayBuffers(this);
+		const writer = this;
+		if (writer.arrayBuffers.length == writer.arrayBuffersMaxlength) {
+			flushArrayBuffers(writer);
 		}
-		this.arrayBuffers.push(array.buffer);
+		writer.arrayBuffers.push(array.buffer);
 	}
 
 	getData() {
-		if (!this.blob) {
-			if (this.arrayBuffers.length) {
-				flushArrayBuffers(this);
+		const writer = this;
+		if (!writer.blob) {
+			if (writer.arrayBuffers.length) {
+				flushArrayBuffers(writer);
 			}
-			this.blob = this.pendingBlob;
-			initArrayBuffers(this);
+			writer.blob = writer.pendingBlob;
+			initArrayBuffers(writer);
 		}
-		return this.blob;
+		return writer.blob;
 	}
 }
 
@@ -229,58 +277,16 @@ class ReadableStreamReader {
 
 	constructor(readableStream) {
 		this.readableStream = readableStream;
-		this.reader = readableStream.getReader();
 		this.size = Infinity;
-		this.index = 0;
-		this.currentSize = 0;
-		this.pendingValue = new Uint8Array();
 	}
 
-	init() {
+	init(size) {
+		this.size = size;
 		this.initialized = true;
 	}
 
-	async readUint8Array(index, length) {
-		if (this.index != index) {
-			throw new Error(ERR_NOT_SEEKABLE_READER);
-		}
-		let data = new Uint8Array(length);
-		let size = 0, done;
-		do {
-			const result = await this.reader.read();
-			let { value } = result;
-			done = result.done;
-			if (value) {
-				this.currentSize += value.length;
-			} else {
-				value = this.pendingValue;
-				this.pendingValue = new Uint8Array();
-			}
-			if (this.pendingValue.length) {
-				const newValue = new Uint8Array(this.pendingValue.length + value.length);
-				newValue.set(this.pendingValue);
-				newValue.set(value, this.pendingValue.length);
-				this.pendingValue = new Uint8Array();
-				value = newValue;
-			}
-			if (size + value.length > length) {
-				data.set(value.subarray(0, length), size);
-				this.pendingValue = value.subarray(length);
-				size += length;
-			} else {
-				data.set(value, size);
-				size += value.length;
-			}
-		} while (size < length && !done);
-		if (done && this.size == Infinity) {
-			this.size = this.currentSize;
-		}
-		if (this.size < length) {
-			data = data.slice(0, this.size);
-			length = this.size;
-		}
-		this.index += length;
-		return data;
+	getStream() {
+		return this.readableStream;
 	}
 }
 
@@ -288,8 +294,9 @@ class WritableStreamWriter extends Writer {
 
 	constructor(writableStream) {
 		super();
-		this.writableStream = writableStream;
-		this.writer = writableStream.getWriter();
+		const writer = this;
+		writer.writableStream = writableStream;
+		writer.writer = writer.getStreamWriter();
 	}
 
 	async writeUint8Array(array) {
@@ -297,26 +304,32 @@ class WritableStreamWriter extends Writer {
 		return this.writer.write(array);
 	}
 
-	async getData() {
-		await this.writer.ready;
-		await this.writer.close();
+	getStream() {
 		return this.writableStream;
 	}
+
+	async getData() {
+		const writer = this;
+		await writer.writer.ready;
+		await writer.writer.close();
+		return writer.writableStream;
+	}
 }
 
 class FetchReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		this.url = url;
-		this.preventHeadRequest = options.preventHeadRequest;
-		this.useRangeHeader = options.useRangeHeader;
-		this.forceRangeRequests = options.forceRangeRequests;
-		this.options = Object.assign({}, options);
-		delete this.options.preventHeadRequest;
-		delete this.options.useRangeHeader;
-		delete this.options.forceRangeRequests;
-		delete this.options.useXHR;
+		const reader = this;
+		reader.url = url;
+		reader.preventHeadRequest = options.preventHeadRequest;
+		reader.useRangeHeader = options.useRangeHeader;
+		reader.forceRangeRequests = options.forceRangeRequests;
+		reader.options = Object.assign({}, options);
+		delete reader.options.preventHeadRequest;
+		delete reader.options.useRangeHeader;
+		delete reader.options.forceRangeRequests;
+		delete reader.options.useXHR;
 	}
 
 	async init() {
@@ -333,11 +346,12 @@ class XHRReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		this.url = url;
-		this.preventHeadRequest = options.preventHeadRequest;
-		this.useRangeHeader = options.useRangeHeader;
-		this.forceRangeRequests = options.forceRangeRequests;
-		this.options = options;
+		const reader = this;
+		reader.url = url;
+		reader.preventHeadRequest = options.preventHeadRequest;
+		reader.useRangeHeader = options.useRangeHeader;
+		reader.forceRangeRequests = options.forceRangeRequests;
+		reader.options = options;
 	}
 
 	async init() {
@@ -540,10 +554,11 @@ class Uint8ArrayWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
-		const previousArray = this.array;
-		this.array = new Uint8Array(previousArray.length + array.length);
-		this.array.set(previousArray);
-		this.array.set(array, previousArray.length);
+		const writer = this;
+		const previousArray = writer.array;
+		writer.array = new Uint8Array(previousArray.length + array.length);
+		writer.array.set(previousArray);
+		writer.array.set(array, previousArray.length);
 	}
 
 	getData() {

package/lib/core/zip-reader.js

@@ -56,7 +56,7 @@ import {
 	FILE_ATTR_MSDOS_DIR_MASK,
 	DIRECTORY_SIGNATURE
 } from "./constants.js";
-import { getConfiguration } from "./configuration.js";
+import { getConfiguration, getChunkSize } from "./configuration.js";
 import { createCodec, CODEC_INFLATE, ERR_INVALID_SIGNATURE, ERR_INVALID_PASSWORD } from "./codecs/codec-pool.js";
 import decodeText from "./util/decode-text.js";
 import Crc32 from "./codecs/crc32.js";
@@ -310,7 +310,13 @@ class ZipEntry {
 		}
 		const signal = getOptionValue(zipEntry, options, "signal");
 		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
-		await processData(codec, reader, writer, dataOffset, () => compressedSize, config, { onprogress: options.onprogress, signal });
+		const size = () => compressedSize;
+		await processData(
+			codec,
+			reader.getStream({ offset: dataOffset, size, chunkSize: getChunkSize(config) }).getReader(),
+			writer.getStreamWriter(),
+			size,
+			{ onprogress: options.onprogress, signal });
 		return writer.getData();
 	}
 }

package/lib/core/zip-writer.js

@@ -59,7 +59,7 @@ import {
 	MIN_DATE,
 	MAX_DATE
 } from "./constants.js";
-import { getConfiguration } from "./configuration.js";
+import { getConfiguration, getChunkSize } from "./configuration.js";
 import { CODEC_DEFLATE, createCodec } from "./codecs/codec-pool.js";
 import encodeText from "./util/encode-text.js";
 import { BlobWriter } from "./io.js";
@@ -280,8 +280,8 @@ async function addFile(zipWriter, name, reader, options) {
 }
 
 async function getFileEntry(zipWriter, name, reader, options) {
-	const files = zipWriter.files;
-	const writer = zipWriter.writer;
+	const { files, writer } = zipWriter;
+	const streamWriter = writer.getStreamWriter();
 	const previousFileEntry = Array.from(files.values()).pop();
 	let fileEntry = {};
 	let bufferedWrite;
@@ -307,7 +307,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			}
 			fileWriter = writer;
 		}
-		fileEntry = await createFileEntry(reader, fileWriter, zipWriter.config, options);
+		fileEntry = await createFileEntry(reader, fileWriter.getStreamWriter(), zipWriter.config, options);
 		fileEntry.lock = lockCurrentFileEntry;
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
@@ -337,10 +337,10 @@ async function getFileEntry(zipWriter, name, reader, options) {
 					setUint32(arrayBufferView, 18, fileEntry.compressedSize);
 					setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
 				}
-				await writer.writeUint8Array(new Uint8Array(arrayBuffer));
+				await writeUint8Array(streamWriter, new Uint8Array(arrayBuffer));
 				indexWrittenData = headerLength;
 			}
-			await writeBlob(writer, blob, indexWrittenData);
+			await writeBlob(streamWriter, blob, indexWrittenData);
 			delete fileEntry.writingBufferedData;
 		}
 		fileEntry.offset = zipWriter.offset;
@@ -369,7 +369,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	}
 }
 
-async function createFileEntry(reader, writer, config, options) {
+async function createFileEntry(reader, streamWriter, config, options) {
 	const {
 		rawFilename,
 		lastAccessDate,
@@ -529,13 +529,19 @@ async function createFileEntry(reader, writer, config, options) {
 			useWebWorkers,
 			useCompressionStream
 		}, config);
-		await writer.writeUint8Array(localHeaderArray);
+		await writeUint8Array(streamWriter, localHeaderArray);
 		fileEntry.dataWritten = true;
-		result = await processData(codec, reader, writer, 0, () => reader.size, config, { onprogress, signal });
+		const size = () => reader.size;
+		result = await processData(
+			codec,
+			reader.getStream({ offset: 0, size, chunkSize: getChunkSize(config) }).getReader(),
+			streamWriter,
+			() => reader.size,
+			{ onprogress, signal });
 		uncompressedSize = fileEntry.uncompressedSize = reader.size;
 		compressedSize = result.length;
 	} else {
-		await writer.writeUint8Array(localHeaderArray);
+		await writeUint8Array(streamWriter, localHeaderArray);
 		fileEntry.dataWritten = true;
 	}
 	let dataDescriptorArray = new Uint8Array(0);
@@ -579,7 +585,7 @@ async function createFileEntry(reader, writer, config, options) {
 		}
 	}
 	if (dataDescriptor) {
-		await writer.writeUint8Array(dataDescriptorArray);
+		await writeUint8Array(streamWriter, dataDescriptorArray);
 	}
 	const length = localHeaderArray.length + compressedSize + dataDescriptorArray.length;
 	Object.assign(fileEntry, { compressedSize, lastModDate, rawLastModDate, creationDate, lastAccessDate, encrypted, length });
@@ -587,8 +593,8 @@ async function createFileEntry(reader, writer, config, options) {
 }
 
 async function closeFile(zipWriter, comment, options) {
-	const writer = zipWriter.writer;
-	const files = zipWriter.files;
+	const { files } = zipWriter;
+	const streamWriter = zipWriter.writer.getStreamWriter();
 	let offset = 0;
 	let directoryDataLength = 0;
 	let directoryOffset = zipWriter.offset;
@@ -703,9 +709,9 @@ async function closeFile(zipWriter, comment, options) {
 	setUint16(directoryView, offset + 10, filesLength);
 	setUint32(directoryView, offset + 12, directoryDataLength);
 	setUint32(directoryView, offset + 16, directoryOffset);
-	await writer.writeUint8Array(directoryArray);
+	await writeUint8Array(streamWriter, directoryArray);
 	if (comment && comment.length) {
-		await writer.writeUint8Array(comment);
+		await writeUint8Array(streamWriter, comment);
 	}
 }
 
@@ -726,20 +732,25 @@ function sliceAsArrayBuffer(blob, start, end) {
 	}
 }
 
-async function writeBlob(writer, blob, start = 0) {
+async function writeBlob(streamWriter, blob, start = 0) {
 	const blockSize = 512 * 1024 * 1024;
 	await writeSlice();
 
 	async function writeSlice() {
 		if (start < blob.size) {
 			const arrayBuffer = await sliceAsArrayBuffer(blob, start, start + blockSize);
-			await writer.writeUint8Array(new Uint8Array(arrayBuffer));
+			await writeUint8Array(streamWriter, new Uint8Array(arrayBuffer));
 			start += blockSize;
 			await writeSlice();
 		}
 	}
 }
 
+async function writeUint8Array(streamWriter, array) {
+	await streamWriter.ready;
+	await streamWriter.write(array);
+}
+
 function getTimeNTFS(date) {
 	if (date) {
 		return ((BigInt(date.getTime()) + BigInt(11644473600000)) * BigInt(10000));