@zip.js/zip.js 2.5.17 → 2.5.20

package/lib/core/codec-interface.js

@@ -26,7 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global AbortController */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -46,7 +45,7 @@ const MESSAGE_CLOSE = "close";
 const ERR_ABORT = "AbortError";
 
 export {
-	createCodec,
+	Codec,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
 	ERR_INVALID_SIGNATURE,
@@ -59,29 +58,21 @@ export {
 	ERR_ABORT
 };
 
-function createCodec(codecConstructor, readable, writable, options, config) {
-	const controller = new AbortController();
-	const { signal } = controller;
-	if (options.codecType.startsWith(CODEC_DEFLATE)) {
-		return {
-			run: () => run(DeflateStream),
-			abort
-		};
-	} else if (options.codecType.startsWith(CODEC_INFLATE)) {
-		return {
-			run: () => run(InflateStream),
-			abort
-		};
-	}
+class Codec {
 
-	async function run(StreamConstructor) {
-		const stream = new StreamConstructor(codecConstructor, options, config);
-		await readable.pipeThrough(stream, { signal }).pipeTo(writable, { preventClose: true });
-		const { length, signature } = stream;
-		return { length, signature };
-	}
+	constructor(codecConstructor, readable, writable, options, config) {
+		const { codecType } = options;
+		if (codecType.startsWith(CODEC_DEFLATE)) {
+			this.run = () => run(DeflateStream);
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
+			this.run = () => run(InflateStream);
+		}
 
-	function abort() {
-		controller.abort();
+		async function run(StreamConstructor) {
+			const stream = new StreamConstructor(codecConstructor, options, config);
+			await readable.pipeThrough(stream).pipeTo(writable, { preventClose: true });
+			const { length, signature } = stream;
+			return { length, signature };
+		}
 	}
 }

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

@@ -29,7 +29,7 @@
 /* global Worker, URL, TransformStream */
 
 import {
-	createCodec,
+	Codec,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -40,50 +40,54 @@ import {
 let classicWorkersSupported = true;
 
 export {
-	getWorker
+	CodecWorker
 };
 
-function getWorker(workerData, stream, workerOptions, onTaskFinished) {
-	const { readable, writable } = stream;
-	const { options, config, streamOptions, webWorker, scripts, codecConstructor } = workerOptions;
-	Object.assign(workerData, {
-		busy: true,
-		codecConstructor,
-		readable,
-		writable,
-		options: Object.assign({}, options),
-		scripts,
-		terminate() {
-			if (workerData.worker && !workerData.busy) {
-				workerData.worker.terminate();
-				workerData.interface = null;
+class CodecWorker {
+
+	constructor(workerData, stream, workerOptions, onTaskFinished) {
+		const { readable, writable } = stream;
+		const { options, config, streamOptions, webWorker, scripts, codecConstructor } = workerOptions;
+		Object.assign(workerData, {
+			busy: true,
+			codecConstructor,
+			readable,
+			writable,
+			options: Object.assign({}, options),
+			scripts,
+			terminate() {
+				if (workerData.worker && !workerData.busy) {
+					workerData.worker.terminate();
+					workerData.interface = null;
+				}
+			},
+			onTaskFinished() {
+				workerData.busy = false;
+				onTaskFinished(workerData);
 			}
-		},
-		onTaskFinished() {
-			workerData.busy = false;
-			onTaskFinished(workerData);
-		}
-	});
-	const { signal, size, onstart, onprogress, onend } = streamOptions;
-	if (signal || onstart || onprogress || onend) {
+		});
+		const { signal, onstart, onprogress, size, onend } = streamOptions;
 		let chunkOffset = 0;
 		const transformer = {};
 		if (onstart) {
 			transformer.start = () => callHandler(onstart, size());
 		}
-		if (onprogress) {
-			transformer.transform = async (chunk, controller) => {
-				chunkOffset += chunk.length;
+		transformer.transform = async (chunk, controller) => {
+			chunkOffset += chunk.length;
+			if (onprogress) {
 				await callHandler(onprogress, chunkOffset, size());
-				controller.enqueue(chunk);
-			};
-		}
-		if (onend) {
-			transformer.flush = () => callHandler(onend);
-		}
+			}
+			controller.enqueue(chunk);
+		};
+		transformer.flush = () => {
+			readable.size = () => chunkOffset;
+			if (onend) {
+				callHandler(onend, chunkOffset);
+			}
+		};
 		workerData.readable = readable.pipeThrough(new TransformStream(transformer, { highWaterMark: 1, size: () => config.chunkSize }), { signal });
+		return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 	}
-	return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 }
 
 async function callHandler(handler, ...parameters) {
@@ -95,17 +99,15 @@ async function callHandler(handler, ...parameters) {
 }
 
 function createWorkerInterface(workerData, config) {
-	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
+	const interfaceCodec = new Codec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
 	const { onTaskFinished } = workerData;
 	const codec = {
-		abort() {
-			interfaceCodec.abort();
-			onTaskFinished();
-		},
 		async run() {
-			const result = await interfaceCodec.run();
-			onTaskFinished();
-			return result;
+			try {
+				return await interfaceCodec.run();
+			} finally {
+				onTaskFinished();
+			}
 		}
 	};
 	return codec;
@@ -135,10 +137,6 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		}
 		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
 		workerData.interface = {
-			abort() {
-				workerData.writer.releaseLock();
-				workerData.onTaskFinished();
-			},
 			run() {
 				const { options } = workerData;
 				const scripts = workerData.scripts.slice(1);

package/lib/core/codec-pool.js

@@ -35,7 +35,7 @@ import {
 	ERR_INVALID_PASSWORD,
 	ERR_ABORT
 } from "./codec-interface.js";
-import { getWorker } from "./codec-pool-worker.js";
+import { CodecWorker } from "./codec-pool-worker.js";
 
 let pool = [];
 const pendingRequests = [];
@@ -60,27 +60,26 @@ async function runWorker(stream, workerOptions) {
 	workerOptions.webWorker = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
 	workerOptions.scripts = workerOptions.webWorker && workerScripts ? workerScripts[codecType] : [];
 	options.useCompressionStream = useCompressionStream === undefined ? config.useCompressionStream : useCompressionStream;
-	let codec;
+	let worker;
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };
 		indexWorker++;
 		pool.push(workerData);
-		codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
+		worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
 	} else {
 		const workerData = pool.find(workerData => !workerData.busy);
 		if (workerData) {
 			clearTerminateTimeout(workerData);
-			codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
+			worker = new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
 		} else {
-			codec = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
+			worker = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
 		}
 	}
-	const { signal } = streamOptions;
 	try {
-		return await codec.run(signal);
+		return await worker.run();
 	} catch (error) {
+		const { signal } = streamOptions;
 		if (signal && signal.aborted && (signal.reason == error || error.name == ERR_ABORT)) {
-			codec.abort();
 			throw new Error(ERR_ABORT);
 		} else {
 			throw error;
@@ -90,7 +89,7 @@ async function runWorker(stream, workerOptions) {
 	function onTaskFinished(workerData) {
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
-			resolve(getWorker(workerData, stream, workerOptions, onTaskFinished));
+			resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
 		} else if (workerData.worker) {
 			const { terminateWorkerTimeout } = config;
 			clearTerminateTimeout(workerData);

package/lib/core/io.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Blob, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream, TransformStream */
+/* global Blob, atob, btoa, XMLHttpRequest, URL, fetch, ReadableStream, WritableStream */
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
@@ -42,6 +42,8 @@ const HTTP_METHOD_GET = "GET";
 const HTTP_RANGE_UNIT = "bytes";
 const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
+import { getConfiguration } from "./configuration.js";
+
 class Stream {
 
 	constructor() {
@@ -55,13 +57,14 @@ class Stream {
 
 class Reader extends Stream {
 
-	getReadable({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
+	get readable() {
 		const reader = this;
-		return new ReadableStream({
+		const readable = new ReadableStream({
 			start() {
 				this.chunkOffset = 0;
 			},
 			async pull(controller) {
+				const { offset = 0, chunkSize = DEFAULT_CHUNK_SIZE, size } = readable;
 				const { chunkOffset } = this;
 				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size() - chunkOffset)));
 				if (chunkOffset + chunkSize > size()) {
@@ -71,18 +74,25 @@ class Reader extends Stream {
 				}
 			}
 		});
+		return readable;
 	}
 }
 
 class WriterStream extends Stream {
 
-	get writable() {
+	constructor() {
+		super();
 		const writer = this;
-		return new WritableStream({
+		const writable = new WritableStream({
 			write(chunk) {
 				return writer.writeUint8Array(chunk);
 			}
 		});
+		Object.defineProperty(this, "writable", {
+			get() {
+				return writable;
+			}
+		});
 	}
 }
 
@@ -247,30 +257,13 @@ function flushArrayBuffers(blobWriter) {
 	blobWriter.arrayBuffers = [];
 }
 
-class ReadableStreamReader {
+class ReadableStreamReader extends Stream {
 
 	constructor(readable) {
-		const reader = this;
+		super();
 		if (!readable) {
-			readable = new ReadableStream({});
+			this.readable = new ReadableStream({});
 		}
-		reader.readable = readable.pipeThrough(new TransformStream({
-			transform(chunk, controller) {
-				if (chunk) {
-					reader.size += chunk.length;
-					controller.enqueue(chunk);
-				}
-			}
-		}));
-		reader.size = 0;
-	}
-
-	init() {
-		this.initialized = true;
-	}
-
-	getReadable() {
-		return this.readable;
 	}
 }
 
@@ -288,15 +281,6 @@ class WritableStreamWriter extends Writer {
 			}
 		});
 	}
-
-	async getData() {
-		const writer = this;
-		const { writable } = writer;
-		if (!writer.preventClose) {
-			await writable.getWriter().close();
-		}
-		return writable;
-	}
 }
 
 class FetchReader extends Reader {
@@ -547,13 +531,9 @@ class Uint8ArrayWriter extends Writer {
 }
 
 function isHttpFamily(url) {
-	if (typeof document != "undefined") {
-		const anchor = document.createElement("a");
-		anchor.href = url;
-		return anchor.protocol == "http:" || anchor.protocol == "https:";
-	} else {
-		return /^https?:\/\//i.test(url);
-	}
+	const { baseURL } = getConfiguration();
+	const { protocol } = new URL(url, baseURL);
+	return protocol == "http:" || protocol == "https:";
 }
 
 export {

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

@@ -52,11 +52,10 @@ class DeflateStream extends TransformStream {
 
 	constructor(codecConstructor, options, { chunkSize }, ...strategies) {
 		super({}, ...strategies);
-		const { compressed, useCompressionStream, password, passwordVerification, encryptionStrength, zipCrypto, signed } = options;
+		const { compressed, encrypted, useCompressionStream, password, passwordVerification, encryptionStrength, zipCrypto, signed } = options;
 		const stream = this;
 		let crc32Stream, encryptionStream;
 		let readable = filterEmptyChunks(super.readable);
-		const encrypted = Boolean(password);
 		if ((!encrypted || zipCrypto) && signed) {
 			[readable, crc32Stream] = readable.tee();
 			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
@@ -99,11 +98,10 @@ class InflateStream extends TransformStream {
 
 	constructor(codecConstructor, options, { chunkSize }, ...strategies) {
 		super({}, ...strategies);
-		const { zipCrypto, password, passwordVerification, signed, encryptionStrength, compressed, useCompressionStream } = options;
+		const { zipCrypto, encrypted, password, passwordVerification, signed, encryptionStrength, compressed, useCompressionStream } = options;
 		const stream = this;
 		let crc32Stream, decryptionStream;
 		let readable = filterEmptyChunks(super.readable);
-		const encrypted = Boolean(password);
 		if (encrypted) {
 			if (zipCrypto) {
 				readable = readable.pipeThrough(new ZipCryptoDecryptionStream(password, passwordVerification));

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

@@ -29,7 +29,7 @@
 /* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
 
 import {
-	createCodec,
+	Codec,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
 	MESSAGE_EVENT_TYPE,
@@ -94,7 +94,7 @@ async function init(message) {
 				sendMessage({ type: MESSAGE_DATA, data });
 			}
 		}, strategy);
-		codec = createCodec(codecConstructor, readable, writable, options, config);
+		codec = new Codec(codecConstructor, readable, writable, options, config);
 		const result = await codec.run();
 		sendMessage({ type: MESSAGE_CLOSE, result });
 

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

@@ -117,7 +117,7 @@ class ZipFileEntry extends ZipEntry {
 		} else {
 			zipEntry.reader = new zipEntry.Reader(zipEntry.data, options);
 			await zipEntry.reader.init();
-			if (!writer.initialized) {
+			if (writer.init && !writer.initialized) {
 				await writer.init();
 			}
 			zipEntry.uncompressedSize = zipEntry.reader.size;

package/lib/core/zip-reader.js

@@ -266,9 +266,6 @@ class ZipEntry {
 			compressedSize
 		} = zipEntry;
 		const localDirectory = zipEntry.localDirectory = {};
-		if (!reader.initialized) {
-			await reader.init();
-		}
 		let dataArray = await readUint8Array(reader, offset, 30);
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, "password");
@@ -301,10 +298,13 @@ class ZipEntry {
 		}
 		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
 		const size = () => compressedSize;
-		const readable = reader.getReadable({ offset: dataOffset, size, chunkSize: getChunkSize(config) });
+		const readable = reader.readable;
+		readable.offset = dataOffset;
+		readable.size = size;
+		readable.chunkSize = getChunkSize(config);
 		const { writable } = writer;
 		const signal = getOptionValue(zipEntry, options, "signal");
-		if (!writer.initialized) {
+		if (writer.init && !writer.initialized) {
 			await writer.init();
 		}
 		const { onstart, onprogress, onend } = options;
@@ -327,7 +327,10 @@ class ZipEntry {
 			codecConstructor: config.Inflate
 		};
 		await runWorker({ readable, writable }, workerOptions);
-		return writer.getData();
+		if (!writer.preventClose) {
+			await writable.getWriter().close();
+		}
+		return writer.getData ? writer.getData() : writable;
 	}
 }
 

package/lib/core/zip-writer.js

@@ -94,7 +94,7 @@ class ZipWriter {
 			options,
 			config: getConfiguration(),
 			files: new Map(),
-			offset: writer.size,
+			offset: writer.size || 0,
 			pendingCompressedSize: 0,
 			pendingEntries: [],
 			pendingAddFileCalls: new Set()
@@ -126,11 +126,16 @@ class ZipWriter {
 	}
 
 	async close(comment = new Uint8Array(), options = {}) {
-		while (this.pendingAddFileCalls.size) {
-			await Promise.all(Array.from(this.pendingAddFileCalls));
+		const { pendingAddFileCalls, writer } = this;
+		const { writable } = writer;
+		while (pendingAddFileCalls.size) {
+			await Promise.all(Array.from(pendingAddFileCalls));
 		}
 		await closeFile(this, comment, options);
-		return this.writer.getData();
+		if (!writer.preventClose) {
+			await writable.getWriter().close();
+		}
+		return writer.getData ? writer.getData() : writable;
 	}
 }
 
@@ -220,10 +225,14 @@ async function addFile(zipWriter, name, reader, options) {
 	const internalFileAttribute = getOptionValue(zipWriter, options, "internalFileAttribute") || 0;
 	const externalFileAttribute = getOptionValue(zipWriter, options, "externalFileAttribute") || 0;
 	if (reader) {
-		if (!reader.initialized) {
+		if (reader.init && !reader.initialized) {
 			await reader.init();
 		}
-		uncompressedSize = reader.size;
+		if (reader.size === undefined) {
+			options.dataDescriptor = true;
+		} else {
+			uncompressedSize = reader.size;
+		}
 		maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
 	}
 	let zip64 = options.zip64 || zipWriter.options.zip64 || false;
@@ -304,8 +313,8 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			fileWriter.init();
 			bufferedWrite = true;
 		} else {
-			zipWriter.lockWrite = new Promise(resolve => resolveLockUnbufferedWrite = resolve);
-			if (!writer.initialized) {
+			zipWriter.lockWrite = Promise.resolve();
+			if (writer.init && !writer.initialized) {
 				await writer.init();
 			}
 			fileWriter = writer;
@@ -316,14 +325,8 @@ async function getFileEntry(zipWriter, name, reader, options) {
 		if (bufferedWrite) {
 			let indexWrittenData = 0;
 			const blob = fileWriter.getData();
-			await Promise.all([zipWriter.lockWrite, lockPreviousFileEntry]);
-			let pendingFileEntry;
-			do {
-				pendingFileEntry = Array.from(files.values()).find(fileEntry => fileEntry.writingBufferedData);
-				if (pendingFileEntry) {
-					await pendingFileEntry.lock;
-				}
-			} while (pendingFileEntry && pendingFileEntry.lock);
+			await lockPreviousFileEntry;
+			await lockWriterAccess();
 			fileEntry.writingBufferedData = true;
 			const { writable } = writer;
 			if (!options.dataDescriptor) {
@@ -370,6 +373,15 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			resolveLockUnbufferedWrite();
 		}
 	}
+
+	async function lockWriterAccess() {
+		if (zipWriter.lockWrite) {
+			await zipWriter.lockWrite.then(() => delete zipWriter.lockWrite);
+			await lockWriterAccess();
+		} else {
+			zipWriter.lockWrite = new Promise(resolve => resolveLockUnbufferedWrite = resolve);
+		}
+	}
 }
 
 async function createFileEntry(reader, writable, config, options) {
@@ -524,7 +536,9 @@ async function createFileEntry(reader, writable, config, options) {
 		await writeUint8Array(writable, localHeaderArray);
 		fileEntry.dataWritten = true;
 		const size = () => reader.size;
-		const readable = reader.getReadable({ offset: 0, size, chunkSize: getChunkSize(config) });
+		const readable = reader.readable;
+		readable.size = size;
+		readable.chunkSize = getChunkSize(config);
 		const workerOptions = {
 			options: {
 				codecType: CODEC_DEFLATE,
@@ -544,7 +558,7 @@ async function createFileEntry(reader, writable, config, options) {
 			codecConstructor: config.Deflate
 		};
 		result = await runWorker({ readable, writable }, workerOptions);
-		uncompressedSize = fileEntry.uncompressedSize = reader.size;
+		uncompressedSize = fileEntry.uncompressedSize = reader.size = readable.size();
 		compressedSize = result.length;
 	} else {
 		await writeUint8Array(writable, localHeaderArray);