@helloao/cli 0.0.1

package/node_modules/@zip.js/zip.js/lib/core/codec-pool.js

@@ -0,0 +1,127 @@
+/*
+ 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 setTimeout, clearTimeout */
+
+import { UNDEFINED_VALUE } from "./constants.js";
+import {
+	CODEC_INFLATE,
+	CODEC_DEFLATE,
+	ERR_INVALID_SIGNATURE,
+	ERR_INVALID_PASSWORD,
+	ERR_ABORT_CHECK_PASSWORD
+} from "./streams/codec-stream.js";
+import { CodecWorker } from "./codec-worker.js";
+
+let pool = [];
+const pendingRequests = [];
+
+export {
+	runWorker,
+	terminateWorkers,
+	CODEC_DEFLATE,
+	CODEC_INFLATE,
+	ERR_INVALID_SIGNATURE,
+	ERR_INVALID_PASSWORD,
+	ERR_ABORT_CHECK_PASSWORD
+};
+
+let indexWorker = 0;
+
+async function runWorker(stream, workerOptions) {
+	const { options, config } = workerOptions;
+	const { transferStreams, useWebWorkers, useCompressionStream, codecType, compressed, signed, encrypted } = options;
+	const { workerScripts, maxWorkers } = config;
+	workerOptions.transferStreams = transferStreams || transferStreams === UNDEFINED_VALUE;
+	const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
+	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
+	workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : [];
+	options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
+	return (await getWorker()).run();
+
+	async function getWorker() {
+		const workerData = pool.find(workerData => !workerData.busy);
+		if (workerData) {
+			clearTerminateTimeout(workerData);
+			return new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
+		} else if (pool.length < maxWorkers) {
+			const workerData = { indexWorker };
+			indexWorker++;
+			pool.push(workerData);
+			return new CodecWorker(workerData, stream, workerOptions, onTaskFinished);
+		} else {
+			return new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
+		}
+	}
+
+	function onTaskFinished(workerData) {
+		if (pendingRequests.length) {
+			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
+			resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
+		} else if (workerData.worker) {
+			clearTerminateTimeout(workerData);
+			terminateWorker(workerData, workerOptions);
+		} else {
+			pool = pool.filter(data => data != workerData);
+		}
+	}
+}
+
+function terminateWorker(workerData, workerOptions) {
+	const { config } = workerOptions;
+	const { terminateWorkerTimeout } = config;
+	if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
+		if (workerData.terminated) {
+			workerData.terminated = false;
+		} else {
+			workerData.terminateTimeout = setTimeout(async () => {
+				pool = pool.filter(data => data != workerData);
+				try {
+					await workerData.terminate();
+				} catch (_error) {
+					// ignored
+				}
+			}, terminateWorkerTimeout);
+		}
+	}
+}
+
+function clearTerminateTimeout(workerData) {
+	const { terminateTimeout } = workerData;
+	if (terminateTimeout) {
+		clearTimeout(terminateTimeout);
+		workerData.terminateTimeout = null;
+	}
+}
+
+async function terminateWorkers() {
+	await Promise.allSettled(pool.map(workerData => {
+		clearTerminateTimeout(workerData);
+		return workerData.terminate();
+	}));
+}

package/node_modules/@zip.js/zip.js/lib/core/codec-worker.js

@@ -0,0 +1,348 @@
+/*
+ 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 Worker, URL, TransformStream, WritableStream */
+
+import {
+	UNDEFINED_TYPE,
+	FUNCTION_TYPE
+} from "./constants.js";
+import {
+	CodecStream,
+	ChunkStream,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE
+} from "./streams/codec-stream.js";
+
+// deno-lint-ignore valid-typeof
+let WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
+
+export {
+	CodecWorker
+};
+
+class CodecWorker {
+
+	constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, scripts }, onTaskFinished) {
+		const { signal } = streamOptions;
+		Object.assign(workerData, {
+			busy: true,
+			readable: readable
+				.pipeThrough(new ChunkStream(config.chunkSize))
+				.pipeThrough(new ProgressWatcherStream(readable, streamOptions), { signal }),
+			writable,
+			options: Object.assign({}, options),
+			scripts,
+			transferStreams,
+			terminate() {
+				return new Promise(resolve => {
+					const { worker, busy } = workerData;
+					if (worker) {
+						if (busy) {
+							workerData.resolveTerminated = resolve;
+						} else {
+							worker.terminate();
+							resolve();
+						}
+						workerData.interface = null;
+					} else {
+						resolve();
+					}
+				});
+			},
+			onTaskFinished() {
+				const { resolveTerminated } = workerData;
+				if (resolveTerminated) {
+					workerData.resolveTerminated = null;
+					workerData.terminated = true;
+					workerData.worker.terminate();
+					resolveTerminated();
+				}
+				workerData.busy = false;
+				onTaskFinished(workerData);
+			}
+		});
+		return (useWebWorkers && WEB_WORKERS_SUPPORTED ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
+	}
+}
+
+class ProgressWatcherStream extends TransformStream {
+
+	constructor(readableSource, { onstart, onprogress, size, onend }) {
+		let chunkOffset = 0;
+		super({
+			async start() {
+				if (onstart) {
+					await callHandler(onstart, size);
+				}
+			},
+			async transform(chunk, controller) {
+				chunkOffset += chunk.length;
+				if (onprogress) {
+					await callHandler(onprogress, chunkOffset, size);
+				}
+				controller.enqueue(chunk);
+			},
+			async flush() {
+				readableSource.size = chunkOffset;
+				if (onend) {
+					await callHandler(onend, chunkOffset);
+				}
+			}
+		});
+	}
+}
+
+async function callHandler(handler, ...parameters) {
+	try {
+		await handler(...parameters);
+	} catch (_error) {
+		// ignored
+	}
+}
+
+function createWorkerInterface(workerData, config) {
+	return {
+		run: () => runWorker(workerData, config)
+	};
+}
+
+function createWebWorkerInterface(workerData, config) {
+	const { baseURL, chunkSize } = config;
+	if (!workerData.interface) {
+		let worker;
+		try {
+			worker = getWebWorker(workerData.scripts[0], baseURL, workerData);
+		} catch (error) {
+			WEB_WORKERS_SUPPORTED = false;
+			return createWorkerInterface(workerData, config);
+		}
+		Object.assign(workerData, {
+			worker,
+			interface: {
+				run: () => runWebWorker(workerData, { chunkSize })
+			}
+		});
+	}
+	return workerData.interface;
+}
+
+async function runWorker({ options, readable, writable, onTaskFinished }, config) {
+	try {
+		const codecStream = new CodecStream(options, config);
+		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
+		const {
+			signature,
+			inputSize,
+			outputSize
+		} = codecStream;
+		return {
+			signature,
+			inputSize,
+			outputSize
+		};
+	} finally {
+		onTaskFinished();
+	}
+}
+
+async function runWebWorker(workerData, config) {
+	let resolveResult, rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	Object.assign(workerData, {
+		reader: null,
+		writer: null,
+		resolveResult,
+		rejectResult,
+		result
+	});
+	const { readable, options, scripts } = workerData;
+	const { writable, closed } = watchClosedStream(workerData.writable);
+	const streamsTransferred = sendMessage({
+		type: MESSAGE_START,
+		scripts: scripts.slice(1),
+		options,
+		config,
+		readable,
+		writable
+	}, workerData);
+	if (!streamsTransferred) {
+		Object.assign(workerData, {
+			reader: readable.getReader(),
+			writer: writable.getWriter()
+		});
+	}
+	const resultValue = await result;
+	if (!streamsTransferred) {
+		await writable.getWriter().close();
+	}
+	await closed;
+	return resultValue;
+}
+
+function watchClosedStream(writableSource) {
+	let resolveStreamClosed;
+	const closed = new Promise(resolve => resolveStreamClosed = resolve);
+	const writable = new WritableStream({
+		async write(chunk) {
+			const writer = writableSource.getWriter();
+			await writer.ready;
+			await writer.write(chunk);
+			writer.releaseLock();
+		},
+		close() {
+			resolveStreamClosed();
+		},
+		abort(reason) {
+			const writer = writableSource.getWriter();
+			return writer.abort(reason);
+		}
+	});
+	return { writable, closed };
+}
+
+let classicWorkersSupported = true;
+let transferStreamsSupported = true;
+
+function getWebWorker(url, baseURL, workerData) {
+	const workerOptions = { type: "module" };
+	let scriptUrl, worker;
+	// deno-lint-ignore valid-typeof
+	if (typeof url == FUNCTION_TYPE) {
+		url = url();
+	}
+	try {
+		scriptUrl = new URL(url, baseURL);
+	} catch (_error) {
+		scriptUrl = url;
+	}
+	if (classicWorkersSupported) {
+		try {
+			worker = new Worker(scriptUrl);
+		} catch (_error) {
+			classicWorkersSupported = false;
+			worker = new Worker(scriptUrl, workerOptions);
+		}
+	} else {
+		worker = new Worker(scriptUrl, workerOptions);
+	}
+	worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData));
+	return worker;
+}
+
+function sendMessage(message, { worker, writer, onTaskFinished, transferStreams }) {
+	try {
+		let { value, readable, writable } = message;
+		const transferables = [];
+		if (value) {
+			if (value.byteLength < value.buffer.byteLength) {
+				message.value = value.buffer.slice(0, value.byteLength);
+			}
+			else {
+				message.value = value.buffer;
+			}
+			transferables.push(message.value);
+		}
+		if (transferStreams && transferStreamsSupported) {
+			if (readable) {
+				transferables.push(readable);
+			}
+			if (writable) {
+				transferables.push(writable);
+			}
+		} else {
+			message.readable = message.writable = null;
+		}
+		if (transferables.length) {
+			try {
+				worker.postMessage(message, transferables);
+				return true;
+			} catch (_error) {
+				transferStreamsSupported = false;
+				message.readable = message.writable = null;
+				worker.postMessage(message);
+			}
+		} else {
+			worker.postMessage(message);
+		}
+	} catch (error) {
+		if (writer) {
+			writer.releaseLock();
+		}
+		onTaskFinished();
+		throw error;
+	}
+}
+
+async function onMessage({ data }, workerData) {
+	const { type, value, messageId, result, error } = data;
+	const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
+	try {
+		if (error) {
+			const { message, stack, code, name } = error;
+			const responseError = new Error(message);
+			Object.assign(responseError, { stack, code, name });
+			close(responseError);
+		} else {
+			if (type == MESSAGE_PULL) {
+				const { value, done } = await reader.read();
+				sendMessage({ type: MESSAGE_DATA, value, done, messageId }, workerData);
+			}
+			if (type == MESSAGE_DATA) {
+				await writer.ready;
+				await writer.write(new Uint8Array(value));
+				sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
+			}
+			if (type == MESSAGE_CLOSE) {
+				close(null, result);
+			}
+		}
+	} catch (error) {
+		sendMessage({ type: MESSAGE_CLOSE, messageId }, workerData);
+		close(error);
+	}
+
+	function close(error, result) {
+		if (error) {
+			rejectResult(error);
+		} else {
+			resolveResult(result);
+		}
+		if (writer) {
+			writer.releaseLock();
+		}
+		onTaskFinished();
+	}
+}

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

@@ -0,0 +1,127 @@
+/*
+ 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 navigator, CompressionStream, DecompressionStream */
+
+import {
+	UNDEFINED_VALUE,
+	UNDEFINED_TYPE
+} from "./constants.js";
+import { StreamAdapter } from "./streams/stream-adapter.js";
+
+const MINIMUM_CHUNK_SIZE = 64;
+let maxWorkers = 2;
+try {
+	if (typeof navigator != UNDEFINED_TYPE && navigator.hardwareConcurrency) {
+		maxWorkers = navigator.hardwareConcurrency;
+	}
+} catch (_error) {
+	// ignored
+}
+const DEFAULT_CONFIGURATION = {
+	chunkSize: 512 * 1024,
+	maxWorkers,
+	terminateWorkerTimeout: 5000,
+	useWebWorkers: true,
+	useCompressionStream: true,
+	workerScripts: UNDEFINED_VALUE,
+	CompressionStreamNative: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
+	DecompressionStreamNative: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
+};
+
+const config = Object.assign({}, DEFAULT_CONFIGURATION);
+
+export {
+	configure,
+	getConfiguration,
+	getChunkSize
+};
+
+function getConfiguration() {
+	return config;
+}
+
+function getChunkSize(config) {
+	return Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
+}
+
+function configure(configuration) {
+	const {
+		baseURL,
+		chunkSize,
+		maxWorkers,
+		terminateWorkerTimeout,
+		useCompressionStream,
+		useWebWorkers,
+		Deflate,
+		Inflate,
+		CompressionStream,
+		DecompressionStream,
+		workerScripts
+	} = configuration;
+	setIfDefined("baseURL", baseURL);
+	setIfDefined("chunkSize", chunkSize);
+	setIfDefined("maxWorkers", maxWorkers);
+	setIfDefined("terminateWorkerTimeout", terminateWorkerTimeout);
+	setIfDefined("useCompressionStream", useCompressionStream);
+	setIfDefined("useWebWorkers", useWebWorkers);
+	if (Deflate) {
+		config.CompressionStream = new StreamAdapter(Deflate);
+	}
+	if (Inflate) {
+		config.DecompressionStream = new StreamAdapter(Inflate);
+	}
+	setIfDefined("CompressionStream", CompressionStream);
+	setIfDefined("DecompressionStream", DecompressionStream);
+	if (workerScripts !== UNDEFINED_VALUE) {
+		const { deflate, inflate } = workerScripts;
+		if (deflate || inflate) {
+			if (!config.workerScripts) {
+				config.workerScripts = {};
+			}
+		}
+		if (deflate) {
+			if (!Array.isArray(deflate)) {
+				throw new Error("workerScripts.deflate must be an array");
+			}
+			config.workerScripts.deflate = deflate;
+		}
+		if (inflate) {
+			if (!Array.isArray(inflate)) {
+				throw new Error("workerScripts.inflate must be an array");
+			}
+			config.workerScripts.inflate = inflate;
+		}
+	}
+}
+
+function setIfDefined(propertyName, propertyValue) {
+	if (propertyValue !== UNDEFINED_VALUE) {
+		config[propertyName] = propertyValue;
+	}
+}

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

@@ -0,0 +1,114 @@
+/*
+ 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.
+ */
+
+const MAX_32_BITS = 0xffffffff;
+const MAX_16_BITS = 0xffff;
+const COMPRESSION_METHOD_DEFLATE = 0x08;
+const COMPRESSION_METHOD_STORE = 0x00;
+const COMPRESSION_METHOD_AES = 0x63;
+
+const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
+const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
+const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
+const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
+const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE = 0x07064b50;
+const END_OF_CENTRAL_DIR_LENGTH = 22;
+const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
+const ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
+const ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LENGTH;
+
+const EXTRAFIELD_TYPE_ZIP64 = 0x0001;
+const EXTRAFIELD_TYPE_AES = 0x9901;
+const EXTRAFIELD_TYPE_NTFS = 0x000a;
+const EXTRAFIELD_TYPE_NTFS_TAG1 = 0x0001;
+const EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP = 0x5455;
+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 VERSION_DEFLATE = 0x14;
+const VERSION_ZIP64 = 0x2D;
+const VERSION_AES = 0x33;
+
+const DIRECTORY_SIGNATURE = "/";
+
+const MAX_DATE = new Date(2107, 11, 31);
+const MIN_DATE = new Date(1980, 0, 1);
+
+const UNDEFINED_VALUE = undefined;
+const UNDEFINED_TYPE = "undefined";
+const FUNCTION_TYPE = "function";
+
+export {
+	MAX_32_BITS,
+	MAX_16_BITS,
+	COMPRESSION_METHOD_DEFLATE,
+	COMPRESSION_METHOD_STORE,
+	COMPRESSION_METHOD_AES,
+	SPLIT_ZIP_FILE_SIGNATURE,
+	LOCAL_FILE_HEADER_SIGNATURE,
+	DATA_DESCRIPTOR_RECORD_SIGNATURE,
+	CENTRAL_FILE_HEADER_SIGNATURE,
+	END_OF_CENTRAL_DIR_SIGNATURE,
+	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE,
+	ZIP64_END_OF_CENTRAL_DIR_SIGNATURE,
+	EXTRAFIELD_TYPE_ZIP64,
+	EXTRAFIELD_TYPE_AES,
+	EXTRAFIELD_TYPE_NTFS,
+	EXTRAFIELD_TYPE_NTFS_TAG1,
+	EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP,
+	EXTRAFIELD_TYPE_UNICODE_PATH,
+	EXTRAFIELD_TYPE_UNICODE_COMMENT,
+	EXTRAFIELD_TYPE_USDZ,
+	END_OF_CENTRAL_DIR_LENGTH,
+	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH,
+	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
+	ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH,
+	BITFLAG_ENCRYPTED,
+	BITFLAG_LEVEL,
+	BITFLAG_DATA_DESCRIPTOR,
+	BITFLAG_LANG_ENCODING_FLAG,
+	FILE_ATTR_MSDOS_DIR_MASK,
+	VERSION_DEFLATE,
+	VERSION_ZIP64,
+	VERSION_AES,
+	DIRECTORY_SIGNATURE,
+	MIN_DATE,
+	MAX_DATE,
+	UNDEFINED_VALUE,
+	UNDEFINED_TYPE,
+	FUNCTION_TYPE
+};