@helloao/cli 0.0.1

package/node_modules/@zip.js/zip.js/lib/core/io.js

@@ -0,0 +1,749 @@
+/*
+ Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* global Blob, atob, btoa, XMLHttpRequest, URL, fetch, ReadableStream, WritableStream, FileReader, TransformStream, Response */
+// deno-lint-ignore-file no-this-alias
+
+import {
+	UNDEFINED_VALUE,
+	FUNCTION_TYPE,
+	END_OF_CENTRAL_DIR_LENGTH
+} from "./constants.js";
+import { getConfiguration } from "./configuration.js";
+
+const ERR_HTTP_STATUS = "HTTP error ";
+const ERR_HTTP_RANGE = "HTTP Range not supported";
+const ERR_ITERATOR_COMPLETED_TOO_SOON = "Writer iterator completed too soon";
+
+const CONTENT_TYPE_TEXT_PLAIN = "text/plain";
+const HTTP_HEADER_CONTENT_LENGTH = "Content-Length";
+const HTTP_HEADER_CONTENT_RANGE = "Content-Range";
+const HTTP_HEADER_ACCEPT_RANGES = "Accept-Ranges";
+const HTTP_HEADER_RANGE = "Range";
+const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
+const HTTP_METHOD_HEAD = "HEAD";
+const HTTP_METHOD_GET = "GET";
+const HTTP_RANGE_UNIT = "bytes";
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+const PROPERTY_NAME_WRITABLE = "writable";
+
+class Stream {
+
+	constructor() {
+		this.size = 0;
+	}
+
+	init() {
+		this.initialized = true;
+	}
+}
+
+class Reader extends Stream {
+
+	get readable() {
+		const reader = this;
+		const { chunkSize = DEFAULT_CHUNK_SIZE } = reader;
+		const readable = new ReadableStream({
+			start() {
+				this.chunkOffset = 0;
+			},
+			async pull(controller) {
+				const { offset = 0, size, diskNumberStart } = readable;
+				const { chunkOffset } = this;
+				controller.enqueue(await readUint8Array(reader, offset + chunkOffset, Math.min(chunkSize, size - chunkOffset), diskNumberStart));
+				if (chunkOffset + chunkSize > size) {
+					controller.close();
+				} else {
+					this.chunkOffset += chunkSize;
+				}
+			}
+		});
+		return readable;
+	}
+}
+
+class Writer extends Stream {
+
+	constructor() {
+		super();
+		const writer = this;
+		const writable = new WritableStream({
+			write(chunk) {
+				return writer.writeUint8Array(chunk);
+			}
+		});
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
+			get() {
+				return writable;
+			}
+		});
+	}
+
+	writeUint8Array() {
+		// abstract
+	}
+}
+
+class Data64URIReader extends Reader {
+
+	constructor(dataURI) {
+		super();
+		let dataEnd = dataURI.length;
+		while (dataURI.charAt(dataEnd - 1) == "=") {
+			dataEnd--;
+		}
+		const dataStart = dataURI.indexOf(",") + 1;
+		Object.assign(this, {
+			dataURI,
+			dataStart,
+			size: Math.floor((dataEnd - dataStart) * 0.75)
+		});
+	}
+
+	readUint8Array(offset, length) {
+		const {
+			dataStart,
+			dataURI
+		} = this;
+		const dataArray = new Uint8Array(length);
+		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++) {
+			dataArray[indexByte - delta] = bytes.charCodeAt(indexByte);
+		}
+		return dataArray;
+	}
+}
+
+class Data64URIWriter extends Writer {
+
+	constructor(contentType) {
+		super();
+		Object.assign(this, {
+			data: "data:" + (contentType || "") + ";base64,",
+			pending: []
+		});
+	}
+
+	writeUint8Array(array) {
+		const writer = this;
+		let indexArray = 0;
+		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++) {
+			writer.pending += String.fromCharCode(array[indexArray]);
+		}
+		if (dataString.length > 2) {
+			writer.data += btoa(dataString);
+		} else {
+			writer.pending = dataString;
+		}
+	}
+
+	getData() {
+		return this.data + btoa(this.pending);
+	}
+}
+
+class BlobReader extends Reader {
+
+	constructor(blob) {
+		super();
+		Object.assign(this, {
+			blob,
+			size: blob.size
+		});
+	}
+
+	async readUint8Array(offset, length) {
+		const reader = this;
+		const offsetEnd = offset + length;
+		const blob = offset || offsetEnd < reader.size ? reader.blob.slice(offset, offsetEnd) : reader.blob;
+		let arrayBuffer = await blob.arrayBuffer();
+		if (arrayBuffer.byteLength > length) {
+			arrayBuffer = arrayBuffer.slice(offset, offsetEnd);
+		}
+		return new Uint8Array(arrayBuffer);
+	}
+}
+
+class BlobWriter extends Stream {
+
+	constructor(contentType) {
+		super();
+		const writer = this;
+		const transformStream = new TransformStream();
+		const headers = [];
+		if (contentType) {
+			headers.push([HTTP_HEADER_CONTENT_TYPE, contentType]);
+		}
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
+			get() {
+				return transformStream.writable;
+			}
+		});
+		writer.blob = new Response(transformStream.readable, { headers }).blob();
+	}
+
+	getData() {
+		return this.blob;
+	}
+}
+
+class TextReader extends BlobReader {
+
+	constructor(text) {
+		super(new Blob([text], { type: CONTENT_TYPE_TEXT_PLAIN }));
+	}
+}
+
+class TextWriter extends BlobWriter {
+
+	constructor(encoding) {
+		super(encoding);
+		Object.assign(this, {
+			encoding,
+			utf8: !encoding || encoding.toLowerCase() == "utf-8"
+		});
+	}
+
+	async getData() {
+		const {
+			encoding,
+			utf8
+		} = this;
+		const blob = await super.getData();
+		if (blob.text && utf8) {
+			return blob.text();
+		} else {
+			const reader = new FileReader();
+			return new Promise((resolve, reject) => {
+				Object.assign(reader, {
+					onload: ({ target }) => resolve(target.result),
+					onerror: () => reject(reader.error)
+				});
+				reader.readAsText(blob, encoding);
+			});
+		}
+	}
+}
+
+class FetchReader extends Reader {
+
+	constructor(url, options) {
+		super();
+		createHttpReader(this, url, options);
+	}
+
+	async init() {
+		await initHttpReader(this, sendFetchRequest, getFetchRequestData);
+		super.init();
+	}
+
+	readUint8Array(index, length) {
+		return readUint8ArrayHttpReader(this, index, length, sendFetchRequest, getFetchRequestData);
+	}
+}
+
+class XHRReader extends Reader {
+
+	constructor(url, options) {
+		super();
+		createHttpReader(this, url, options);
+	}
+
+	async init() {
+		await initHttpReader(this, sendXMLHttpRequest, getXMLHttpRequestData);
+		super.init();
+	}
+
+	readUint8Array(index, length) {
+		return readUint8ArrayHttpReader(this, index, length, sendXMLHttpRequest, getXMLHttpRequestData);
+	}
+}
+
+function createHttpReader(httpReader, url, options) {
+	const {
+		preventHeadRequest,
+		useRangeHeader,
+		forceRangeRequests,
+		combineSizeEocd
+	} = options;
+	options = Object.assign({}, options);
+	delete options.preventHeadRequest;
+	delete options.useRangeHeader;
+	delete options.forceRangeRequests;
+	delete options.combineSizeEocd;
+	delete options.useXHR;
+	Object.assign(httpReader, {
+		url,
+		options,
+		preventHeadRequest,
+		useRangeHeader,
+		forceRangeRequests,
+		combineSizeEocd
+	});
+}
+
+async function initHttpReader(httpReader, sendRequest, getRequestData) {
+	const {
+		url,
+		preventHeadRequest,
+		useRangeHeader,
+		forceRangeRequests,
+		combineSizeEocd
+	} = httpReader;
+	if (isHttpFamily(url) && (useRangeHeader || forceRangeRequests) && (typeof preventHeadRequest == "undefined" || preventHeadRequest)) {
+		const response = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, combineSizeEocd ? -END_OF_CENTRAL_DIR_LENGTH : undefined));
+		if (!forceRangeRequests && response.headers.get(HTTP_HEADER_ACCEPT_RANGES) != HTTP_RANGE_UNIT) {
+			throw new Error(ERR_HTTP_RANGE);
+		} else {
+			if (combineSizeEocd) {
+				httpReader.eocdCache = new Uint8Array(await response.arrayBuffer());
+			}
+			let contentSize;
+			const contentRangeHeader = response.headers.get(HTTP_HEADER_CONTENT_RANGE);
+			if (contentRangeHeader) {
+				const splitHeader = contentRangeHeader.trim().split(/\s*\/\s*/);
+				if (splitHeader.length) {
+					const headerValue = splitHeader[1];
+					if (headerValue && headerValue != "*") {
+						contentSize = Number(headerValue);
+					}
+				}
+			}
+			if (contentSize === UNDEFINED_VALUE) {
+				await getContentLength(httpReader, sendRequest, getRequestData);
+			} else {
+				httpReader.size = contentSize;
+			}
+		}
+	} else {
+		await getContentLength(httpReader, sendRequest, getRequestData);
+	}
+}
+
+async function readUint8ArrayHttpReader(httpReader, index, length, sendRequest, getRequestData) {
+	const {
+		useRangeHeader,
+		forceRangeRequests,
+		eocdCache,
+		size,
+		options
+	} = httpReader;
+	if (useRangeHeader || forceRangeRequests) {
+		if (eocdCache && index == size - END_OF_CENTRAL_DIR_LENGTH && length == END_OF_CENTRAL_DIR_LENGTH) {
+			return eocdCache;
+		}
+		const response = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, index, length));
+		if (response.status != 206) {
+			throw new Error(ERR_HTTP_RANGE);
+		}
+		return new Uint8Array(await response.arrayBuffer());
+	} else {
+		const { data } = httpReader;
+		if (!data) {
+			await getRequestData(httpReader, options);
+		}
+		return new Uint8Array(httpReader.data.subarray(index, index + length));
+	}
+}
+
+function getRangeHeaders(httpReader, index = 0, length = 1) {
+	return Object.assign({}, getHeaders(httpReader), { [HTTP_HEADER_RANGE]: HTTP_RANGE_UNIT + "=" + (index < 0 ? index : index + "-" + (index + length - 1)) });
+}
+
+function getHeaders({ options }) {
+	const { headers } = options;
+	if (headers) {
+		if (Symbol.iterator in headers) {
+			return Object.fromEntries(headers);
+		} else {
+			return headers;
+		}
+	}
+}
+
+async function getFetchRequestData(httpReader) {
+	await getRequestData(httpReader, sendFetchRequest);
+}
+
+async function getXMLHttpRequestData(httpReader) {
+	await getRequestData(httpReader, sendXMLHttpRequest);
+}
+
+async function getRequestData(httpReader, sendRequest) {
+	const response = await sendRequest(HTTP_METHOD_GET, httpReader, getHeaders(httpReader));
+	httpReader.data = new Uint8Array(await response.arrayBuffer());
+	if (!httpReader.size) {
+		httpReader.size = httpReader.data.length;
+	}
+}
+
+async function getContentLength(httpReader, sendRequest, getRequestData) {
+	if (httpReader.preventHeadRequest) {
+		await getRequestData(httpReader, httpReader.options);
+	} else {
+		const response = await sendRequest(HTTP_METHOD_HEAD, httpReader, getHeaders(httpReader));
+		const contentLength = response.headers.get(HTTP_HEADER_CONTENT_LENGTH);
+		if (contentLength) {
+			httpReader.size = Number(contentLength);
+		} else {
+			await getRequestData(httpReader, httpReader.options);
+		}
+	}
+}
+
+async function sendFetchRequest(method, { options, url }, headers) {
+	const response = await fetch(url, Object.assign({}, options, { method, headers }));
+	if (response.status < 400) {
+		return response;
+	} else {
+		throw response.status == 416 ? new Error(ERR_HTTP_RANGE) : new Error(ERR_HTTP_STATUS + (response.statusText || response.status));
+	}
+}
+
+function sendXMLHttpRequest(method, { url }, headers) {
+	return new Promise((resolve, reject) => {
+		const request = new XMLHttpRequest();
+		request.addEventListener("load", () => {
+			if (request.status < 400) {
+				const headers = [];
+				request.getAllResponseHeaders().trim().split(/[\r\n]+/).forEach(header => {
+					const splitHeader = header.trim().split(/\s*:\s*/);
+					splitHeader[0] = splitHeader[0].trim().replace(/^[a-z]|-[a-z]/g, value => value.toUpperCase());
+					headers.push(splitHeader);
+				});
+				resolve({
+					status: request.status,
+					arrayBuffer: () => request.response,
+					headers: new Map(headers)
+				});
+			} else {
+				reject(request.status == 416 ? new Error(ERR_HTTP_RANGE) : new Error(ERR_HTTP_STATUS + (request.statusText || request.status)));
+			}
+		}, false);
+		request.addEventListener("error", event => reject(event.detail ? event.detail.error : new Error("Network error")), false);
+		request.open(method, url);
+		if (headers) {
+			for (const entry of Object.entries(headers)) {
+				request.setRequestHeader(entry[0], entry[1]);
+			}
+		}
+		request.responseType = "arraybuffer";
+		request.send();
+	});
+}
+
+class HttpReader extends Reader {
+
+	constructor(url, options = {}) {
+		super();
+		Object.assign(this, {
+			url,
+			reader: options.useXHR ? new XHRReader(url, options) : new FetchReader(url, options)
+		});
+	}
+
+	set size(value) {
+		// ignored
+	}
+
+	get size() {
+		return this.reader.size;
+	}
+
+	async init() {
+		await this.reader.init();
+		super.init();
+	}
+
+	readUint8Array(index, length) {
+		return this.reader.readUint8Array(index, length);
+	}
+}
+
+class HttpRangeReader extends HttpReader {
+
+	constructor(url, options = {}) {
+		options.useRangeHeader = true;
+		super(url, options);
+	}
+}
+
+
+class Uint8ArrayReader extends Reader {
+
+	constructor(array) {
+		super();
+		Object.assign(this, {
+			array,
+			size: array.length
+		});
+	}
+
+	readUint8Array(index, length) {
+		return this.array.slice(index, index + length);
+	}
+}
+
+class Uint8ArrayWriter extends Writer {
+
+	init(initSize = 0) {
+		Object.assign(this, {
+			offset: 0,
+			array: new Uint8Array(initSize)
+		});
+		super.init();
+	}
+
+	writeUint8Array(array) {
+		const writer = this;
+		if (writer.offset + array.length > writer.array.length) {
+			const previousArray = writer.array;
+			writer.array = new Uint8Array(previousArray.length + array.length);
+			writer.array.set(previousArray);
+		}
+		writer.array.set(array, writer.offset);
+		writer.offset += array.length;
+	}
+
+	getData() {
+		return this.array;
+	}
+}
+
+class SplitDataReader extends Reader {
+
+	constructor(readers) {
+		super();
+		this.readers = readers;
+	}
+
+	async init() {
+		const reader = this;
+		const { readers } = reader;
+		reader.lastDiskNumber = 0;
+		reader.lastDiskOffset = 0;
+		await Promise.all(readers.map(async (diskReader, indexDiskReader) => {
+			await diskReader.init();
+			if (indexDiskReader != readers.length - 1) {
+				reader.lastDiskOffset += diskReader.size;
+			}
+			reader.size += diskReader.size;
+		}));
+		super.init();
+	}
+
+	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;
+	}
+}
+
+class SplitDataWriter extends Stream {
+
+	constructor(writerGenerator, maxSize = 4294967295) {
+		super();
+		const writer = this;
+		Object.assign(writer, {
+			diskNumber: 0,
+			diskOffset: 0,
+			size: 0,
+			maxSize,
+			availableSize: maxSize
+		});
+		let diskSourceWriter, diskWritable, diskWriter;
+		const writable = new WritableStream({
+			async write(chunk) {
+				const { availableSize } = writer;
+				if (!diskWriter) {
+					const { value, done } = await writerGenerator.next();
+					if (done && !value) {
+						throw new Error(ERR_ITERATOR_COMPLETED_TOO_SOON);
+					} else {
+						diskSourceWriter = value;
+						diskSourceWriter.size = 0;
+						if (diskSourceWriter.maxSize) {
+							writer.maxSize = diskSourceWriter.maxSize;
+						}
+						writer.availableSize = writer.maxSize;
+						await initStream(diskSourceWriter);
+						diskWritable = value.writable;
+						diskWriter = diskWritable.getWriter();
+					}
+					await this.write(chunk);
+				} else if (chunk.length >= availableSize) {
+					await writeChunk(chunk.slice(0, availableSize));
+					await closeDisk();
+					writer.diskOffset += diskSourceWriter.size;
+					writer.diskNumber++;
+					diskWriter = null;
+					await this.write(chunk.slice(availableSize));
+				} else {
+					await writeChunk(chunk);
+				}
+			},
+			async close() {
+				await diskWriter.ready;
+				await closeDisk();
+			}
+		});
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
+			get() {
+				return writable;
+			}
+		});
+
+		async function writeChunk(chunk) {
+			const chunkLength = chunk.length;
+			if (chunkLength) {
+				await diskWriter.ready;
+				await diskWriter.write(chunk);
+				diskSourceWriter.size += chunkLength;
+				writer.size += chunkLength;
+				writer.availableSize -= chunkLength;
+			}
+		}
+
+		async function closeDisk() {
+			diskWritable.size = diskSourceWriter.size;
+			await diskWriter.close();
+		}
+	}
+}
+
+function isHttpFamily(url) {
+	const { baseURL } = getConfiguration();
+	const { protocol } = new URL(url, baseURL);
+	return protocol == "http:" || protocol == "https:";
+}
+
+async function initStream(stream, initSize) {
+	if (stream.init && !stream.initialized) {
+		await stream.init(initSize);
+	} else {
+		return Promise.resolve();
+	}
+}
+
+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);
+}
+
+const SplitZipReader = SplitDataReader;
+const SplitZipWriter = SplitDataWriter;
+
+export {
+	initStream,
+	initReader,
+	initWriter,
+	readUint8Array,
+	Reader,
+	Writer,
+	TextReader,
+	TextWriter,
+	Data64URIReader,
+	Data64URIWriter,
+	BlobReader,
+	BlobWriter,
+	Uint8ArrayReader,
+	Uint8ArrayWriter,
+	HttpReader,
+	HttpRangeReader,
+	SplitZipReader,
+	SplitZipWriter,
+	SplitDataReader,
+	SplitDataWriter,
+	ERR_HTTP_RANGE,
+	ERR_ITERATOR_COMPLETED_TOO_SOON
+};