@manot40/genql-cli 1.0.0 → 1.0.2

package/dist/main-DnxPgNLv.mjs

@@ -0,0 +1,4937 @@
+import { n as __toESM, t as __commonJSMin } from "./chunk-BBnsswwY.mjs";
+import * as tty from "tty";
+import { format } from "util";
+import { EOL } from "os";
+import { StringDecoder } from "string_decoder";
+import { Writable } from "stream";
+import { randomUUID } from "crypto";
+import fs, { glob, mkdir, rm, writeFile } from "node:fs/promises";
+import url from "node:url";
+import path, { resolve } from "node:path";
+import { assertValidSchema, buildClientSchema, getIntrospectionQuery, getNamedType, isEnumType, isInputObjectType, isInterfaceType, isListType, isNamedType, isNonNullType, isObjectType, isScalarType, isUnionType, lexicographicSortSchema, printSchema } from "graphql";
+import path$1 from "path";
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { loadSchema } from "@graphql-tools/load";
+
+//#region node_modules/eventemitter3/index.js
+var require_eventemitter3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var has = Object.prototype.hasOwnProperty, prefix = "~";
+	/**
+	* Constructor to create a storage for our `EE` objects.
+	* An `Events` instance is a plain object whose properties are event names.
+	*
+	* @constructor
+	* @private
+	*/
+	function Events() {}
+	if (Object.create) {
+		Events.prototype = Object.create(null);
+		if (!new Events().__proto__) prefix = false;
+	}
+	/**
+	* Representation of a single event listener.
+	*
+	* @param {Function} fn The listener function.
+	* @param {*} context The context to invoke the listener with.
+	* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+	* @constructor
+	* @private
+	*/
+	function EE(fn, context, once) {
+		this.fn = fn;
+		this.context = context;
+		this.once = once || false;
+	}
+	/**
+	* Add a listener for a given event.
+	*
+	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} context The context to invoke the listener with.
+	* @param {Boolean} once Specify if the listener is a one-time listener.
+	* @returns {EventEmitter}
+	* @private
+	*/
+	function addListener(emitter, event, fn, context, once) {
+		if (typeof fn !== "function") throw new TypeError("The listener must be a function");
+		var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+		if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+		else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+		else emitter._events[evt] = [emitter._events[evt], listener];
+		return emitter;
+	}
+	/**
+	* Clear event by name.
+	*
+	* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	* @param {(String|Symbol)} evt The Event name.
+	* @private
+	*/
+	function clearEvent(emitter, evt) {
+		if (--emitter._eventsCount === 0) emitter._events = new Events();
+		else delete emitter._events[evt];
+	}
+	/**
+	* Minimal `EventEmitter` interface that is molded against the Node.js
+	* `EventEmitter` interface.
+	*
+	* @constructor
+	* @public
+	*/
+	function EventEmitter() {
+		this._events = new Events();
+		this._eventsCount = 0;
+	}
+	/**
+	* Return an array listing the events for which the emitter has registered
+	* listeners.
+	*
+	* @returns {Array}
+	* @public
+	*/
+	EventEmitter.prototype.eventNames = function eventNames() {
+		var names = [], events, name;
+		if (this._eventsCount === 0) return names;
+		for (name in events = this._events) if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+		if (Object.getOwnPropertySymbols) return names.concat(Object.getOwnPropertySymbols(events));
+		return names;
+	};
+	/**
+	* Return the listeners registered for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Array} The registered listeners.
+	* @public
+	*/
+	EventEmitter.prototype.listeners = function listeners(event) {
+		var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+		if (!handlers) return [];
+		if (handlers.fn) return [handlers.fn];
+		for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) ee[i] = handlers[i].fn;
+		return ee;
+	};
+	/**
+	* Return the number of listeners listening to a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Number} The number of listeners.
+	* @public
+	*/
+	EventEmitter.prototype.listenerCount = function listenerCount(event) {
+		var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+		if (!listeners) return 0;
+		if (listeners.fn) return 1;
+		return listeners.length;
+	};
+	/**
+	* Calls each of the listeners registered for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @returns {Boolean} `true` if the event had listeners, else `false`.
+	* @public
+	*/
+	EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+		var evt = prefix ? prefix + event : event;
+		if (!this._events[evt]) return false;
+		var listeners = this._events[evt], len = arguments.length, args, i;
+		if (listeners.fn) {
+			if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+			switch (len) {
+				case 1: return listeners.fn.call(listeners.context), true;
+				case 2: return listeners.fn.call(listeners.context, a1), true;
+				case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+				case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+				case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+				case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+			}
+			for (i = 1, args = new Array(len - 1); i < len; i++) args[i - 1] = arguments[i];
+			listeners.fn.apply(listeners.context, args);
+		} else {
+			var length = listeners.length, j;
+			for (i = 0; i < length; i++) {
+				if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+				switch (len) {
+					case 1:
+						listeners[i].fn.call(listeners[i].context);
+						break;
+					case 2:
+						listeners[i].fn.call(listeners[i].context, a1);
+						break;
+					case 3:
+						listeners[i].fn.call(listeners[i].context, a1, a2);
+						break;
+					case 4:
+						listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+						break;
+					default:
+						if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) args[j - 1] = arguments[j];
+						listeners[i].fn.apply(listeners[i].context, args);
+				}
+			}
+		}
+		return true;
+	};
+	/**
+	* Add a listener for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} [context=this] The context to invoke the listener with.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.on = function on(event, fn, context) {
+		return addListener(this, event, fn, context, false);
+	};
+	/**
+	* Add a one-time listener for a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn The listener function.
+	* @param {*} [context=this] The context to invoke the listener with.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.once = function once(event, fn, context) {
+		return addListener(this, event, fn, context, true);
+	};
+	/**
+	* Remove the listeners of a given event.
+	*
+	* @param {(String|Symbol)} event The event name.
+	* @param {Function} fn Only remove the listeners that match this function.
+	* @param {*} context Only remove the listeners that have this context.
+	* @param {Boolean} once Only remove one-time listeners.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+		var evt = prefix ? prefix + event : event;
+		if (!this._events[evt]) return this;
+		if (!fn) {
+			clearEvent(this, evt);
+			return this;
+		}
+		var listeners = this._events[evt];
+		if (listeners.fn) {
+			if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) clearEvent(this, evt);
+		} else {
+			for (var i = 0, events = [], length = listeners.length; i < length; i++) if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) events.push(listeners[i]);
+			if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+			else clearEvent(this, evt);
+		}
+		return this;
+	};
+	/**
+	* Remove all listeners, or those of the specified event.
+	*
+	* @param {(String|Symbol)} [event] The event name.
+	* @returns {EventEmitter} `this`.
+	* @public
+	*/
+	EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+		var evt;
+		if (event) {
+			evt = prefix ? prefix + event : event;
+			if (this._events[evt]) clearEvent(this, evt);
+		} else {
+			this._events = new Events();
+			this._eventsCount = 0;
+		}
+		return this;
+	};
+	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+	EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+	EventEmitter.prefixed = prefix;
+	EventEmitter.EventEmitter = EventEmitter;
+	if ("undefined" !== typeof module) module.exports = EventEmitter;
+}));
+
+//#endregion
+//#region node_modules/eventemitter3/index.mjs
+var import_eventemitter3 = /* @__PURE__ */ __toESM(require_eventemitter3(), 1);
+var eventemitter3_default = import_eventemitter3.default;
+
+//#endregion
+//#region node_modules/colorette/index.js
+const { env = {}, argv = [], platform = "" } = typeof process === "undefined" ? {} : process;
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = platform === "win32";
+const isDumbTerminal = env.TERM === "dumb";
+const isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+const isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+const isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+const replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+const clearBleed = (index, string, open, close, replace) => index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+const filterEmpty = (open, close, replace = open, at = open.length + 1) => (string) => string || !(string === "" || string === void 0) ? clearBleed(("" + string).indexOf(close, at), string, open, close, replace) : "";
+const init = (open, close, replace) => filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+const colors = {
+	reset: init(0, 0),
+	bold: init(1, 22, "\x1B[22m\x1B[1m"),
+	dim: init(2, 22, "\x1B[22m\x1B[2m"),
+	italic: init(3, 23),
+	underline: init(4, 24),
+	inverse: init(7, 27),
+	hidden: init(8, 28),
+	strikethrough: init(9, 29),
+	black: init(30, 39),
+	red: init(31, 39),
+	green: init(32, 39),
+	yellow: init(33, 39),
+	blue: init(34, 39),
+	magenta: init(35, 39),
+	cyan: init(36, 39),
+	white: init(37, 39),
+	gray: init(90, 39),
+	bgBlack: init(40, 49),
+	bgRed: init(41, 49),
+	bgGreen: init(42, 49),
+	bgYellow: init(43, 49),
+	bgBlue: init(44, 49),
+	bgMagenta: init(45, 49),
+	bgCyan: init(46, 49),
+	bgWhite: init(47, 49),
+	blackBright: init(90, 39),
+	redBright: init(91, 39),
+	greenBright: init(92, 39),
+	yellowBright: init(93, 39),
+	blueBright: init(94, 39),
+	magentaBright: init(95, 39),
+	cyanBright: init(96, 39),
+	whiteBright: init(97, 39),
+	bgBlackBright: init(100, 49),
+	bgRedBright: init(101, 49),
+	bgGreenBright: init(102, 49),
+	bgYellowBright: init(103, 49),
+	bgBlueBright: init(104, 49),
+	bgMagentaBright: init(105, 49),
+	bgCyanBright: init(106, 49),
+	bgWhiteBright: init(107, 49)
+};
+const createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors : Object.keys(colors).reduce((colors$1, key) => ({
+	...colors$1,
+	[key]: String
+}), {});
+const { reset, bold, dim, italic, underline, inverse, hidden, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, blackBright, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlackBright, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = createColors();
+
+//#endregion
+//#region node_modules/rfdc/index.js
+var require_rfdc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = rfdc;
+	function copyBuffer(cur) {
+		if (cur instanceof Buffer) return Buffer.from(cur);
+		return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+	}
+	function rfdc(opts) {
+		opts = opts || {};
+		if (opts.circles) return rfdcCircles(opts);
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler$1 of opts.constructorHandlers) constructorHandlers.set(handler$1[0], handler$1[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone$1;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else a2[k] = fn(cur);
+			}
+			return a2;
+		}
+		function clone$1(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone$1);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone$1);
+			const o2 = {};
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone$1);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = clone$1(cur);
+			}
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = cloneProto(cur);
+			}
+			return o2;
+		}
+	}
+	function rfdcCircles(opts) {
+		const refs = [];
+		const refsNew = [];
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler$1 of opts.constructorHandlers) constructorHandlers.set(handler$1[0], handler$1[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone$1;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else {
+					const index = refs.indexOf(cur);
+					if (index !== -1) a2[k] = refsNew[index];
+					else a2[k] = fn(cur);
+				}
+			}
+			return a2;
+		}
+		function clone$1(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone$1);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone$1);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone$1);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = clone$1(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = cloneProto(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+	}
+}));
+
+//#endregion
+//#region node_modules/listr2/dist/index.js
+var import_rfdc = /* @__PURE__ */ __toESM(require_rfdc(), 1);
+/**
+* Indicates an UNICODE characters is coming up.
+*/
+const ANSI_ESCAPE = "\x1B[";
+/**
+* Generic ANSI escape characters for terminal based operations.
+*/
+const ANSI_ESCAPE_CODES = {
+	CURSOR_HIDE: ANSI_ESCAPE + "?25l",
+	CURSOR_SHOW: ANSI_ESCAPE + "?25h"
+};
+/**
+* Environment variables for Listr.
+*/
+let ListrEnvironmentVariables = /* @__PURE__ */ function(ListrEnvironmentVariables$1) {
+	ListrEnvironmentVariables$1["FORCE_UNICODE"] = "LISTR_FORCE_UNICODE";
+	ListrEnvironmentVariables$1["FORCE_TTY"] = "LISTR_FORCE_TTY";
+	ListrEnvironmentVariables$1["DISABLE_COLOR"] = "NO_COLOR";
+	ListrEnvironmentVariables$1["FORCE_COLOR"] = "FORCE_COLOR";
+	return ListrEnvironmentVariables$1;
+}({});
+/**
+* The actual error type that is collected and to help identify where the error is triggered from.
+*/
+let ListrErrorTypes = /* @__PURE__ */ function(ListrErrorTypes$1) {
+	/** Task has failed and will try to retry. */
+	ListrErrorTypes$1["WILL_RETRY"] = "WILL_RETRY";
+	/** Task has failed and will try to rollback. */
+	ListrErrorTypes$1["WILL_ROLLBACK"] = "WILL_ROLLBACK";
+	/** Task has failed, ran the rollback action but the rollback action itself has failed. */
+	ListrErrorTypes$1["HAS_FAILED_TO_ROLLBACK"] = "HAS_FAILED_TO_ROLLBACK";
+	/** Task has failed. */
+	ListrErrorTypes$1["HAS_FAILED"] = "HAS_FAILED";
+	/** Task has failed, but exitOnError is set to false, so will ignore this error. */
+	ListrErrorTypes$1["HAS_FAILED_WITHOUT_ERROR"] = "HAS_FAILED_WITHOUT_ERROR";
+	return ListrErrorTypes$1;
+}({});
+/**
+* Events that are triggered by Listr.
+*
+* These are stateful and singleton events by being attached to the main Listr class and propagating to the subtasks.
+*
+* @see {@link https://listr2.kilic.dev/listr/events.html}
+*/
+let ListrEventType = /* @__PURE__ */ function(ListrEventType$1) {
+	/** Indicates that underlying renderer should refresh the current render. */
+	ListrEventType$1["SHOULD_REFRESH_RENDER"] = "SHOUD_REFRESH_RENDER";
+	return ListrEventType$1;
+}({});
+let ListrRendererSelection = /* @__PURE__ */ function(ListrRendererSelection$1) {
+	ListrRendererSelection$1["PRIMARY"] = "PRIMARY";
+	ListrRendererSelection$1["SECONDARY"] = "SECONDARY";
+	ListrRendererSelection$1["SILENT"] = "SILENT";
+	return ListrRendererSelection$1;
+}({});
+/**
+* Internal events that are fired from the Task.
+*
+* @see {@link https://listr2.kilic.dev/task/events.html}
+*/
+let ListrTaskEventType = /* @__PURE__ */ function(ListrTaskEventType$1) {
+	/** Title has changed for the current Task. */
+	ListrTaskEventType$1["TITLE"] = "TITLE";
+	/**
+	* State has changed for the current Task.
+	*
+	* @see {@link module:listr2.ListrTaskState}
+	*/
+	ListrTaskEventType$1["STATE"] = "STATE";
+	/** The current Task has been marked as enabled. */
+	ListrTaskEventType$1["ENABLED"] = "ENABLED";
+	/** The current Task is currently processing subtasks. */
+	ListrTaskEventType$1["SUBTASK"] = "SUBTASK";
+	/** The current Task is now processing a prompt. */
+	ListrTaskEventType$1["PROMPT"] = "PROMPT";
+	/** The current Task is now dumping output. */
+	ListrTaskEventType$1["OUTPUT"] = "OUTPUT";
+	/**
+	* The current Task is now dumping a message.
+	*
+	* @see {module:Listr2.ListrTaskMessage}
+	*/
+	ListrTaskEventType$1["MESSAGE"] = "MESSAGE";
+	/** The current Task is closed and no further action in expected. */
+	ListrTaskEventType$1["CLOSED"] = "CLOSED";
+	return ListrTaskEventType$1;
+}({});
+/**
+* Tasks can be in various states during the execution.
+*
+* Whenever a state change occurs, the task will emit a {@link module:listr2.ListrTaskEventType.STATE} with the appropriate state.
+*/
+let ListrTaskState = /* @__PURE__ */ function(ListrTaskState$1) {
+	/** Task has not started yet, waiting for pick-up. */
+	ListrTaskState$1["WAITING"] = "WAITING";
+	/** Task has started. */
+	ListrTaskState$1["STARTED"] = "STARTED";
+	/** Task has been completed. */
+	ListrTaskState$1["COMPLETED"] = "COMPLETED";
+	/** Task has failed. */
+	ListrTaskState$1["FAILED"] = "FAILED";
+	/** Task has been skipped. */
+	ListrTaskState$1["SKIPPED"] = "SKIPPED";
+	/** Task is currently trying to rollback. */
+	ListrTaskState$1["ROLLING_BACK"] = "ROLLING_BACK";
+	/** Task has rolledback successfully after failing. */
+	ListrTaskState$1["ROLLED_BACK"] = "ROLLED_BACK";
+	/** Task is currently retrying. */
+	ListrTaskState$1["RETRY"] = "RETRY";
+	/** Task is currently paused. */
+	ListrTaskState$1["PAUSED"] = "PAUSED";
+	/** Task is currently trying to process a prompt. */
+	ListrTaskState$1["PROMPT"] = "PROMPT";
+	/** Task has successfully processed the prompt. */
+	ListrTaskState$1["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
+	/** Task has failed to process the prompt. */
+	ListrTaskState$1["PROMPT_FAILED"] = "PROMPT_FAILED";
+	return ListrTaskState$1;
+}({});
+var EventManager = class {
+	emitter = new eventemitter3_default();
+	emit(dispatch, args) {
+		this.emitter.emit(dispatch, args);
+	}
+	on(dispatch, handler) {
+		this.emitter.addListener(dispatch, handler);
+	}
+	once(dispatch, handler) {
+		this.emitter.once(dispatch, handler);
+	}
+	off(dispatch, handler) {
+		this.emitter.off(dispatch, handler);
+	}
+	complete() {
+		this.emitter.removeAllListeners();
+	}
+};
+/**
+* Tests to see if the object is an RxJS {@link Observable}
+* @param obj the object to test
+*/
+function isObservable(obj) {
+	return !!obj && typeof obj === "object" && typeof obj.subscribe === "function";
+}
+/**
+* Tests to see if the object is an Readable or NodeJS.ReadableStream {@link Readable, NodeJS.ReadableStream}
+* @param obj the object to test
+*/
+function isReadable(obj) {
+	return !!obj && typeof obj === "object" && obj.readable === true && typeof obj.read === "function" && typeof obj.on === "function";
+}
+function isUnicodeSupported() {
+	/* istanbul ignore next */
+	return !!process.env[ListrEnvironmentVariables.FORCE_UNICODE] || process.platform !== "win32" || !!process.env.CI || !!process.env.WT_SESSION || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
+}
+const CLEAR_LINE_REGEX = "(?:\\u001b|\\u009b)\\[[\\=><~/#&.:=?%@~_-]*[0-9]*[\\a-ln-tqyz=><~/#&.:=?%@~_-]+";
+const BELL_REGEX = /\u0007/;
+function cleanseAnsi(chunk) {
+	return String(chunk).replace(new RegExp(CLEAR_LINE_REGEX, "gmi"), "").replace(new RegExp(BELL_REGEX, "gmi"), "").trim();
+}
+/**
+* Creates color palette through underlying dependency of `colorette`.
+*
+* @see {@link https://www.npmjs.com/package/colorette}
+*/
+const color = createColors();
+function indent(string, count) {
+	return string.replace(/^(?!\s*$)/gm, " ".repeat(count));
+}
+const FIGURES_MAIN = {
+	warning: "⚠",
+	cross: "✖",
+	arrowDown: "↓",
+	tick: "✔",
+	arrowRight: "→",
+	pointer: "❯",
+	checkboxOn: "☒",
+	arrowLeft: "←",
+	squareSmallFilled: "◼",
+	pointerSmall: "›"
+};
+const FIGURES_FALLBACK = {
+	...FIGURES_MAIN,
+	warning: "‼",
+	cross: "×",
+	tick: "√",
+	pointer: ">",
+	checkboxOn: "[×]",
+	squareSmallFilled: "■"
+};
+const figures = isUnicodeSupported() ? FIGURES_MAIN : FIGURES_FALLBACK;
+function splat(message, ...splat$1) {
+	return format(String(message), ...splat$1);
+}
+/** Default ListrLogLevels for the logger */
+let ListrLogLevels = /* @__PURE__ */ function(ListrLogLevels$1) {
+	ListrLogLevels$1["STARTED"] = "STARTED";
+	ListrLogLevels$1["COMPLETED"] = "COMPLETED";
+	ListrLogLevels$1["FAILED"] = "FAILED";
+	ListrLogLevels$1["SKIPPED"] = "SKIPPED";
+	ListrLogLevels$1["OUTPUT"] = "OUTPUT";
+	ListrLogLevels$1["TITLE"] = "TITLE";
+	ListrLogLevels$1["ROLLBACK"] = "ROLLBACK";
+	ListrLogLevels$1["RETRY"] = "RETRY";
+	ListrLogLevels$1["PROMPT"] = "PROMPT";
+	ListrLogLevels$1["PAUSED"] = "PAUSED";
+	return ListrLogLevels$1;
+}({});
+const LISTR_LOGGER_STYLE = {
+	icon: {
+		[ListrLogLevels.STARTED]: figures.pointer,
+		[ListrLogLevels.FAILED]: figures.cross,
+		[ListrLogLevels.SKIPPED]: figures.arrowDown,
+		[ListrLogLevels.COMPLETED]: figures.tick,
+		[ListrLogLevels.OUTPUT]: figures.pointerSmall,
+		[ListrLogLevels.TITLE]: figures.arrowRight,
+		[ListrLogLevels.RETRY]: figures.warning,
+		[ListrLogLevels.ROLLBACK]: figures.arrowLeft,
+		[ListrLogLevels.PAUSED]: figures.squareSmallFilled
+	},
+	color: {
+		[ListrLogLevels.STARTED]: color.yellow,
+		[ListrLogLevels.FAILED]: color.red,
+		[ListrLogLevels.SKIPPED]: color.yellow,
+		[ListrLogLevels.COMPLETED]: color.green,
+		[ListrLogLevels.RETRY]: color.yellowBright,
+		[ListrLogLevels.ROLLBACK]: color.redBright,
+		[ListrLogLevels.PAUSED]: color.yellowBright
+	}
+};
+const LISTR_LOGGER_STDERR_LEVELS = [
+	ListrLogLevels.RETRY,
+	ListrLogLevels.ROLLBACK,
+	ListrLogLevels.FAILED
+];
+/**
+* Creates a new Listr2 logger.
+*
+* This logger is used throughout the renderers for consistency.
+*
+* @see {@link https://listr2.kilic.dev/renderer/logger.html}
+*/
+var ListrLogger = class {
+	process;
+	constructor(options) {
+		this.options = options;
+		this.options = {
+			useIcons: true,
+			toStderr: [],
+			...options ?? {}
+		};
+		this.options.fields ??= {};
+		this.options.fields.prefix ??= [];
+		this.options.fields.suffix ??= [];
+		this.process = this.options.processOutput ?? new ProcessOutput();
+	}
+	log(level, message, options) {
+		const output = this.format(level, message, options);
+		if (this.options.toStderr.includes(level)) {
+			this.process.toStderr(output);
+			return;
+		}
+		this.process.toStdout(output);
+	}
+	toStdout(message, options, eol = true) {
+		this.process.toStdout(this.format(null, message, options), eol);
+	}
+	toStderr(message, options, eol = true) {
+		this.process.toStderr(this.format(null, message, options), eol);
+	}
+	wrap(message, options) {
+		if (!message) return message;
+		return this.applyFormat(`[${message}]`, options);
+	}
+	splat(...args) {
+		const message = args.shift() ?? "";
+		return args.length === 0 ? message : splat(message, args);
+	}
+	suffix(message, ...suffixes) {
+		suffixes.filter(Boolean).forEach((suffix) => {
+			message += this.spacing(message);
+			if (typeof suffix === "string") message += this.wrap(suffix);
+			else if (typeof suffix === "object") {
+				suffix.args ??= [];
+				if (typeof suffix.condition === "function" ? !suffix.condition(...suffix.args) : !(suffix.condition ?? true)) return message;
+				message += this.wrap(typeof suffix.field === "function" ? suffix.field(...suffix.args) : suffix.field, { format: suffix?.format(...suffix.args) });
+			}
+		});
+		return message;
+	}
+	prefix(message, ...prefixes) {
+		prefixes.filter(Boolean).forEach((prefix) => {
+			message = this.spacing(message) + message;
+			if (typeof prefix === "string") message = this.wrap(prefix) + message;
+			else if (typeof prefix === "object") {
+				prefix.args ??= [];
+				if (typeof prefix.condition === "function" ? !prefix.condition(...prefix.args) : !(prefix.condition ?? true)) return message;
+				message = this.wrap(typeof prefix.field === "function" ? prefix.field(...prefix.args) : prefix.field, { format: prefix?.format() }) + message;
+			}
+		});
+		return message;
+	}
+	fields(message, options) {
+		if (this.options?.fields?.prefix) message = this.prefix(message, ...this.options.fields.prefix);
+		if (options?.prefix) message = this.prefix(message, ...options.prefix);
+		if (options?.suffix) message = this.suffix(message, ...options.suffix);
+		if (this.options?.fields?.suffix) message = this.suffix(message, ...this.options.fields.suffix);
+		return message;
+	}
+	icon(level, icon) {
+		if (!level) return null;
+		if (!icon) {
+			const i = this.options.icon?.[level];
+			icon = typeof i === "function" ? i() : i;
+		}
+		const coloring = this.options.color?.[level];
+		if (icon && coloring) icon = coloring(icon);
+		return icon;
+	}
+	format(level, message, options) {
+		if (!Array.isArray(message)) message = [message];
+		message = this.splat(message.shift(), ...message).toString().split(EOL).filter((m) => !m || m.trim() !== "").map((m) => {
+			return this.style(level, this.fields(m, {
+				prefix: Array.isArray(options?.prefix) ? options.prefix : [options?.prefix],
+				suffix: Array.isArray(options?.suffix) ? options.suffix : [options?.suffix]
+			}));
+		}).join(EOL);
+		return message;
+	}
+	style(level, message) {
+		if (!level || !message) return message;
+		const icon = this.icon(level, !this.options.useIcons && this.wrap(level));
+		if (icon) message = icon + " " + message;
+		return message;
+	}
+	applyFormat(message, options) {
+		if (options?.format) return options.format(message);
+		return message;
+	}
+	spacing(message) {
+		return typeof message === "undefined" || message.trim() === "" ? "" : " ";
+	}
+};
+var ProcessOutputBuffer = class {
+	buffer = [];
+	decoder = new StringDecoder();
+	constructor(options) {
+		this.options = options;
+	}
+	get all() {
+		return this.buffer;
+	}
+	get last() {
+		return this.buffer.at(-1);
+	}
+	get length() {
+		return this.buffer.length;
+	}
+	write(data, ...args) {
+		const callback = args[args.length - 1];
+		this.buffer.push({
+			time: Date.now(),
+			stream: this.options?.stream,
+			entry: this.decoder.write(typeof data === "string" ? Buffer.from(data, typeof args[0] === "string" ? args[0] : void 0) : Buffer.from(data))
+		});
+		if (this.options?.limit) this.buffer = this.buffer.slice(-this.options.limit);
+		if (typeof callback === "function") callback();
+		return true;
+	}
+	reset() {
+		this.buffer = [];
+	}
+};
+var ProcessOutputStream = class {
+	method;
+	buffer;
+	constructor(stream) {
+		this.stream = stream;
+		this.method = stream.write;
+		this.buffer = new ProcessOutputBuffer({ stream });
+	}
+	get out() {
+		return Object.assign({}, this.stream, { write: this.write.bind(this) });
+	}
+	hijack() {
+		this.stream.write = this.buffer.write.bind(this.buffer);
+	}
+	release() {
+		this.stream.write = this.method;
+		const buffer = [...this.buffer.all];
+		this.buffer.reset();
+		return buffer;
+	}
+	write(...args) {
+		return this.method.apply(this.stream, args);
+	}
+};
+/**
+* Creates a new Listr2 process-output controller.
+*
+* This is used to control the flow to `process.stdout` and `process.stderr` for all renderers.
+*
+* @see {@link https://listr2.kilic.dev/renderer/process-output.html}
+*/
+var ProcessOutput = class {
+	stream;
+	active;
+	constructor(stdout, stderr, options) {
+		this.options = options;
+		this.stream = {
+			stdout: new ProcessOutputStream(stdout ?? process.stdout),
+			stderr: new ProcessOutputStream(stderr ?? process.stderr)
+		};
+		this.options = {
+			dump: ["stdout", "stderr"],
+			leaveEmptyLine: true,
+			...options
+		};
+	}
+	get stdout() {
+		return this.stream.stdout.out;
+	}
+	get stderr() {
+		return this.stream.stderr.out;
+	}
+	hijack() {
+		if (this.active) throw new Error("ProcessOutput has been already hijacked!");
+		this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_HIDE);
+		Object.values(this.stream).forEach((stream) => stream.hijack());
+		this.active = true;
+	}
+	release() {
+		const output = Object.entries(this.stream).map(([name, stream]) => ({
+			name,
+			buffer: stream.release()
+		})).filter((output$1) => this.options.dump.includes(output$1.name)).flatMap((output$1) => output$1.buffer).sort((a, b) => a.time - b.time).map((message) => {
+			return {
+				...message,
+				entry: cleanseAnsi(message.entry)
+			};
+		}).filter((message) => message.entry);
+		if (output.length > 0) {
+			if (this.options.leaveEmptyLine) this.stdout.write(EOL);
+			output.forEach((message) => {
+				(message.stream ?? this.stdout).write(message.entry + EOL);
+			});
+		}
+		this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_SHOW);
+		this.active = false;
+	}
+	toStdout(buffer, eol = true) {
+		if (eol) buffer = buffer + EOL;
+		return this.stream.stdout.write(buffer);
+	}
+	toStderr(buffer, eol = true) {
+		if (eol) buffer = buffer + EOL;
+		return this.stream.stderr.write(buffer);
+	}
+};
+/* istanbul ignore next */
+function createWritable(cb) {
+	const writable = new Writable();
+	writable.rows = Infinity;
+	writable.columns = Infinity;
+	writable.write = (chunk) => {
+		cb(chunk.toString());
+		return true;
+	};
+	return writable;
+}
+/* istanbul ignore next */
+var Spinner = class {
+	spinner = !isUnicodeSupported() ? [
+		"-",
+		"\\",
+		"|",
+		"/"
+	] : [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	];
+	id;
+	spinnerPosition = 0;
+	spin() {
+		this.spinnerPosition = ++this.spinnerPosition % this.spinner.length;
+	}
+	fetch() {
+		return this.spinner[this.spinnerPosition];
+	}
+	isRunning() {
+		return !!this.id;
+	}
+	start(cb, interval = 100) {
+		this.id = setInterval(() => {
+			this.spin();
+			if (cb) cb();
+		}, interval);
+	}
+	stop() {
+		clearInterval(this.id);
+	}
+};
+let ListrDefaultRendererLogLevels = /* @__PURE__ */ function(ListrDefaultRendererLogLevels$1) {
+	ListrDefaultRendererLogLevels$1["SKIPPED_WITH_COLLAPSE"] = "SKIPPED_WITH_COLLAPSE";
+	ListrDefaultRendererLogLevels$1["SKIPPED_WITHOUT_COLLAPSE"] = "SKIPPED_WITHOUT_COLLAPSE";
+	ListrDefaultRendererLogLevels$1["OUTPUT"] = "OUTPUT";
+	ListrDefaultRendererLogLevels$1["OUTPUT_WITH_BOTTOMBAR"] = "OUTPUT_WITH_BOTTOMBAR";
+	ListrDefaultRendererLogLevels$1["PENDING"] = "PENDING";
+	ListrDefaultRendererLogLevels$1["COMPLETED"] = "COMPLETED";
+	ListrDefaultRendererLogLevels$1["COMPLETED_WITH_FAILED_SUBTASKS"] = "COMPLETED_WITH_FAILED_SUBTASKS";
+	ListrDefaultRendererLogLevels$1["COMPLETED_WITH_FAILED_SISTER_TASKS"] = "COMPLETED_WITH_SISTER_TASKS_FAILED";
+	ListrDefaultRendererLogLevels$1["RETRY"] = "RETRY";
+	ListrDefaultRendererLogLevels$1["ROLLING_BACK"] = "ROLLING_BACK";
+	ListrDefaultRendererLogLevels$1["ROLLED_BACK"] = "ROLLED_BACK";
+	ListrDefaultRendererLogLevels$1["FAILED"] = "FAILED";
+	ListrDefaultRendererLogLevels$1["FAILED_WITH_FAILED_SUBTASKS"] = "FAILED_WITH_SUBTASKS";
+	ListrDefaultRendererLogLevels$1["WAITING"] = "WAITING";
+	ListrDefaultRendererLogLevels$1["PAUSED"] = "PAUSED";
+	return ListrDefaultRendererLogLevels$1;
+}({});
+const LISTR_DEFAULT_RENDERER_STYLE = {
+	icon: {
+		[ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE]: figures.arrowDown,
+		[ListrDefaultRendererLogLevels.SKIPPED_WITHOUT_COLLAPSE]: figures.warning,
+		[ListrDefaultRendererLogLevels.OUTPUT]: figures.pointerSmall,
+		[ListrDefaultRendererLogLevels.OUTPUT_WITH_BOTTOMBAR]: figures.pointerSmall,
+		[ListrDefaultRendererLogLevels.PENDING]: figures.pointer,
+		[ListrDefaultRendererLogLevels.COMPLETED]: figures.tick,
+		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS]: figures.warning,
+		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SISTER_TASKS]: figures.squareSmallFilled,
+		[ListrDefaultRendererLogLevels.RETRY]: figures.warning,
+		[ListrDefaultRendererLogLevels.ROLLING_BACK]: figures.warning,
+		[ListrDefaultRendererLogLevels.ROLLED_BACK]: figures.arrowLeft,
+		[ListrDefaultRendererLogLevels.FAILED]: figures.cross,
+		[ListrDefaultRendererLogLevels.FAILED_WITH_FAILED_SUBTASKS]: figures.pointer,
+		[ListrDefaultRendererLogLevels.WAITING]: figures.squareSmallFilled,
+		[ListrDefaultRendererLogLevels.PAUSED]: figures.squareSmallFilled
+	},
+	color: {
+		[ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE]: color.yellow,
+		[ListrDefaultRendererLogLevels.SKIPPED_WITHOUT_COLLAPSE]: color.yellow,
+		[ListrDefaultRendererLogLevels.PENDING]: color.yellow,
+		[ListrDefaultRendererLogLevels.COMPLETED]: color.green,
+		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS]: color.yellow,
+		[ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SISTER_TASKS]: color.red,
+		[ListrDefaultRendererLogLevels.RETRY]: color.yellowBright,
+		[ListrDefaultRendererLogLevels.ROLLING_BACK]: color.redBright,
+		[ListrDefaultRendererLogLevels.ROLLED_BACK]: color.redBright,
+		[ListrDefaultRendererLogLevels.FAILED]: color.red,
+		[ListrDefaultRendererLogLevels.FAILED_WITH_FAILED_SUBTASKS]: color.red,
+		[ListrDefaultRendererLogLevels.WAITING]: color.dim,
+		[ListrDefaultRendererLogLevels.PAUSED]: color.yellowBright
+	}
+};
+/**
+* A basic function to parse minutes and tasks passed given a duration.
+* Useful for renderers to show the task time.
+*/
+/* istanbul ignore next */
+function parseTimer(duration) {
+	const seconds = Math.floor(duration / 1e3);
+	const minutes = Math.floor(seconds / 60);
+	let parsedTime;
+	if (seconds === 0 && minutes === 0) parsedTime = `0.${Math.floor(duration / 100)}s`;
+	if (seconds > 0) parsedTime = `${seconds % 60}s`;
+	if (minutes > 0) parsedTime = `${minutes}m${parsedTime}`;
+	return parsedTime;
+}
+/* istanbul ignore next */
+const PRESET_TIMER = {
+	condition: true,
+	field: parseTimer,
+	format: () => color.dim
+};
+var DefaultRenderer = class DefaultRenderer$1 {
+	static nonTTY = false;
+	static rendererOptions = {
+		indentation: 2,
+		clearOutput: false,
+		showSubtasks: true,
+		collapseSubtasks: true,
+		collapseSkips: true,
+		showSkipMessage: true,
+		suffixSkips: false,
+		collapseErrors: true,
+		showErrorMessage: true,
+		suffixRetries: true,
+		lazy: false,
+		removeEmptyLines: true,
+		formatOutput: "wrap",
+		pausedTimer: {
+			...PRESET_TIMER,
+			format: () => color.yellowBright
+		}
+	};
+	static rendererTaskOptions = { outputBar: true };
+	prompt;
+	activePrompt;
+	spinner;
+	logger;
+	updater;
+	truncate;
+	wrap;
+	buffer = {
+		output: /* @__PURE__ */ new Map(),
+		bottom: /* @__PURE__ */ new Map()
+	};
+	cache = {
+		render: /* @__PURE__ */ new Map(),
+		rendererOptions: /* @__PURE__ */ new Map(),
+		rendererTaskOptions: /* @__PURE__ */ new Map()
+	};
+	constructor(tasks, options, events) {
+		this.tasks = tasks;
+		this.options = options;
+		this.events = events;
+		this.options = {
+			...DefaultRenderer$1.rendererOptions,
+			...this.options,
+			icon: {
+				...LISTR_DEFAULT_RENDERER_STYLE.icon,
+				...options?.icon ?? {}
+			},
+			color: {
+				...LISTR_DEFAULT_RENDERER_STYLE.color,
+				...options?.color ?? {}
+			}
+		};
+		this.spinner = this.options.spinner ?? new Spinner();
+		this.logger = this.options.logger ?? new ListrLogger({
+			useIcons: true,
+			toStderr: []
+		});
+		this.logger.options.icon = this.options.icon;
+		this.logger.options.color = this.options.color;
+	}
+	async render() {
+		const { createLogUpdate } = await import("./log-update-C7F4wEC4.mjs");
+		const { default: truncate } = await import("./cli-truncate-D9-H5ZcK.mjs");
+		const { default: wrap } = await import("./wrap-ansi-B5Z_xwBN.mjs");
+		this.updater = createLogUpdate(this.logger.process.stdout);
+		this.truncate = truncate;
+		this.wrap = wrap;
+		this.logger.process.hijack();
+		/* istanbul ignore if */
+		if (!this.options?.lazy) this.spinner.start(() => {
+			this.update();
+		});
+		this.events.on(ListrEventType.SHOULD_REFRESH_RENDER, () => {
+			this.update();
+		});
+	}
+	update() {
+		this.updater(this.create());
+	}
+	end() {
+		this.spinner.stop();
+		this.updater.clear();
+		this.updater.done();
+		if (!this.options.clearOutput) this.logger.process.toStdout(this.create({ prompt: false }));
+		this.logger.process.release();
+	}
+	create(options) {
+		options = {
+			tasks: true,
+			bottomBar: true,
+			prompt: true,
+			...options
+		};
+		const render = [];
+		const renderTasks = this.renderer(this.tasks);
+		const renderBottomBar = this.renderBottomBar();
+		const renderPrompt = this.renderPrompt();
+		if (options.tasks && renderTasks.length > 0) render.push(...renderTasks);
+		if (options.bottomBar && renderBottomBar.length > 0) {
+			if (render.length > 0) render.push("");
+			render.push(...renderBottomBar);
+		}
+		if (options.prompt && renderPrompt.length > 0) {
+			if (render.length > 0) render.push("");
+			render.push(...renderPrompt);
+		}
+		return render.join(EOL);
+	}
+	style(task, output = false) {
+		const rendererOptions = this.cache.rendererOptions.get(task.id);
+		if (task.isSkipped()) {
+			if (output || rendererOptions.collapseSkips) return this.logger.icon(ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE);
+			else if (rendererOptions.collapseSkips === false) return this.logger.icon(ListrDefaultRendererLogLevels.SKIPPED_WITHOUT_COLLAPSE);
+		}
+		if (output) {
+			if (this.shouldOutputToBottomBar(task)) return this.logger.icon(ListrDefaultRendererLogLevels.OUTPUT_WITH_BOTTOMBAR);
+			return this.logger.icon(ListrDefaultRendererLogLevels.OUTPUT);
+		}
+		if (task.hasSubtasks()) {
+			if (task.isStarted() || task.isPrompt() && rendererOptions.showSubtasks !== false && !task.subtasks.every((subtask) => !subtask.hasTitle())) return this.logger.icon(ListrDefaultRendererLogLevels.PENDING);
+			else if (task.isCompleted() && task.subtasks.some((subtask) => subtask.hasFailed())) return this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS);
+			else if (task.hasFailed()) return this.logger.icon(ListrDefaultRendererLogLevels.FAILED_WITH_FAILED_SUBTASKS);
+		}
+		if (task.isStarted() || task.isPrompt()) return this.logger.icon(ListrDefaultRendererLogLevels.PENDING, !this.options?.lazy && this.spinner.fetch());
+		else if (task.isCompleted()) return this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED);
+		else if (task.isRetrying()) return this.logger.icon(ListrDefaultRendererLogLevels.RETRY, !this.options?.lazy && this.spinner.fetch());
+		else if (task.isRollingBack()) return this.logger.icon(ListrDefaultRendererLogLevels.ROLLING_BACK, !this.options?.lazy && this.spinner.fetch());
+		else if (task.hasRolledBack()) return this.logger.icon(ListrDefaultRendererLogLevels.ROLLED_BACK);
+		else if (task.hasFailed()) return this.logger.icon(ListrDefaultRendererLogLevels.FAILED);
+		else if (task.isPaused()) return this.logger.icon(ListrDefaultRendererLogLevels.PAUSED);
+		return this.logger.icon(ListrDefaultRendererLogLevels.WAITING);
+	}
+	format(message, icon, level) {
+		if (message.trim() === "") return [];
+		if (icon) message = icon + " " + message;
+		let parsed;
+		const columns = (process.stdout.columns ?? 80) - level * this.options.indentation - 2;
+		switch (this.options.formatOutput) {
+			case "truncate":
+				parsed = message.split(EOL).map((s, i) => {
+					return this.truncate(this.indent(s, i), columns);
+				});
+				break;
+			case "wrap":
+				parsed = this.wrap(message, columns, {
+					hard: true,
+					trim: false
+				}).split(EOL).map((s, i) => this.indent(s, i));
+				break;
+			default: throw new ListrRendererError("Format option for the renderer is wrong.");
+		}
+		if (this.options.removeEmptyLines) parsed = parsed.filter(Boolean);
+		return parsed.map((str) => indent(str, level * this.options.indentation));
+	}
+	shouldOutputToOutputBar(task) {
+		const outputBar = this.cache.rendererTaskOptions.get(task.id).outputBar;
+		return typeof outputBar === "number" && outputBar !== 0 || typeof outputBar === "boolean" && outputBar !== false;
+	}
+	shouldOutputToBottomBar(task) {
+		const bottomBar = this.cache.rendererTaskOptions.get(task.id).bottomBar;
+		return typeof bottomBar === "number" && bottomBar !== 0 || typeof bottomBar === "boolean" && bottomBar !== false || !task.hasTitle();
+	}
+	renderer(tasks, level = 0) {
+		return tasks.flatMap((task) => {
+			if (!task.isEnabled()) return [];
+			if (this.cache.render.has(task.id)) return this.cache.render.get(task.id);
+			this.calculate(task);
+			this.setupBuffer(task);
+			const rendererOptions = this.cache.rendererOptions.get(task.id);
+			const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+			const output = [];
+			if (task.isPrompt()) {
+				if (this.activePrompt && this.activePrompt !== task.id) throw new ListrRendererError("Only one prompt can be active at the given time, please re-evaluate your task design.");
+				else if (!this.activePrompt) {
+					task.on(ListrTaskEventType.PROMPT, (prompt) => {
+						const cleansed = cleanseAnsi(prompt);
+						if (cleansed) this.prompt = cleansed;
+					});
+					task.on(ListrTaskEventType.STATE, (state) => {
+						if (state === ListrTaskState.PROMPT_COMPLETED || task.hasFinalized() || task.hasReset()) {
+							this.prompt = null;
+							this.activePrompt = null;
+							task.off(ListrTaskEventType.PROMPT);
+						}
+					});
+					this.activePrompt = task.id;
+				}
+			}
+			if (task.hasTitle()) if (!(tasks.some((task$1) => task$1.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped()))) if (task.hasFailed() && rendererOptions.collapseErrors) output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
+			else if (task.isSkipped() && rendererOptions.collapseSkips) output.push(...this.format(this.logger.suffix(task.message.skip && rendererOptions.showSkipMessage ? task.message.skip : task.title, {
+				field: ListrLogLevels.SKIPPED,
+				condition: rendererOptions.suffixSkips,
+				format: () => color.dim
+			}), this.style(task), level));
+			else if (task.isRetrying()) output.push(...this.format(this.logger.suffix(task.title, {
+				field: `${ListrLogLevels.RETRY}:${task.message.retry.count}`,
+				format: () => color.yellow,
+				condition: rendererOptions.suffixRetries
+			}), this.style(task), level));
+			else if (task.isCompleted() && task.hasTitle() && assertFunctionOrSelf(rendererTaskOptions.timer?.condition, task.message.duration)) output.push(...this.format(this.logger.suffix(task?.title, {
+				...rendererTaskOptions.timer,
+				args: [task.message.duration]
+			}), this.style(task), level));
+			else if (task.isPaused()) output.push(...this.format(this.logger.suffix(task.title, {
+				...rendererOptions.pausedTimer,
+				args: [task.message.paused - Date.now()]
+			}), this.style(task), level));
+			else output.push(...this.format(task.title, this.style(task), level));
+			else output.push(...this.format(task.title, this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SISTER_TASKS), level));
+			if (!task.hasSubtasks() || !rendererOptions.showSubtasks) {
+				if (task.hasFailed() && rendererOptions.collapseErrors === false && (rendererOptions.showErrorMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, ListrLogLevels.FAILED));
+				else if (task.isSkipped() && rendererOptions.collapseSkips === false && (rendererOptions.showSkipMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, ListrLogLevels.SKIPPED));
+			}
+			if (task.isPending() || rendererTaskOptions.persistentOutput) output.push(...this.renderOutputBar(task, level));
+			if (rendererOptions.showSubtasks !== false && task.hasSubtasks() && (task.isPending() || task.hasFinalized() && !task.hasTitle() || task.isCompleted() && rendererOptions.collapseSubtasks === false && !task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === true) || task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === false) || task.subtasks.some((subtask) => subtask.hasFailed()) || task.subtasks.some((subtask) => subtask.hasRolledBack()))) {
+				const subtaskLevel = !task.hasTitle() ? level : level + 1;
+				const subtaskRender = this.renderer(task.subtasks, subtaskLevel);
+				output.push(...subtaskRender);
+			}
+			if (task.hasFinalized()) {
+				if (!rendererTaskOptions.persistentOutput) {
+					this.buffer.bottom.delete(task.id);
+					this.buffer.output.delete(task.id);
+				}
+			}
+			if (task.isClosed()) {
+				this.cache.render.set(task.id, output);
+				this.reset(task);
+			}
+			return output;
+		});
+	}
+	renderOutputBar(task, level) {
+		const output = this.buffer.output.get(task.id);
+		if (!output) return [];
+		return output.all.flatMap((o) => this.dump(task, level, ListrLogLevels.OUTPUT, o.entry));
+	}
+	renderBottomBar() {
+		if (this.buffer.bottom.size === 0) return [];
+		return Array.from(this.buffer.bottom.values()).flatMap((output) => output.all).sort((a, b) => a.time - b.time).map((output) => output.entry);
+	}
+	renderPrompt() {
+		if (!this.prompt) return [];
+		return [this.prompt];
+	}
+	calculate(task) {
+		if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) return;
+		const rendererOptions = {
+			...this.options,
+			...task.rendererOptions
+		};
+		this.cache.rendererOptions.set(task.id, rendererOptions);
+		this.cache.rendererTaskOptions.set(task.id, {
+			...DefaultRenderer$1.rendererTaskOptions,
+			timer: rendererOptions.timer,
+			...task.rendererTaskOptions
+		});
+	}
+	setupBuffer(task) {
+		if (this.buffer.bottom.has(task.id) || this.buffer.output.has(task.id)) return;
+		const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+		if (this.shouldOutputToBottomBar(task) && !this.buffer.bottom.has(task.id)) {
+			this.buffer.bottom.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.bottomBar === "number" ? rendererTaskOptions.bottomBar : 1 }));
+			task.on(ListrTaskEventType.OUTPUT, (output) => {
+				const data = this.dump(task, -1, ListrLogLevels.OUTPUT, output);
+				this.buffer.bottom.get(task.id).write(data.join(EOL));
+			});
+			task.on(ListrTaskEventType.STATE, (state) => {
+				switch (state) {
+					case ListrTaskState.RETRY || ListrTaskState.ROLLING_BACK:
+						this.buffer.bottom.delete(task.id);
+						break;
+				}
+			});
+		} else if (this.shouldOutputToOutputBar(task) && !this.buffer.output.has(task.id)) {
+			this.buffer.output.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.outputBar === "number" ? rendererTaskOptions.outputBar : 1 }));
+			task.on(ListrTaskEventType.OUTPUT, (output) => {
+				this.buffer.output.get(task.id).write(output);
+			});
+			task.on(ListrTaskEventType.STATE, (state) => {
+				switch (state) {
+					case ListrTaskState.RETRY || ListrTaskState.ROLLING_BACK:
+						this.buffer.output.delete(task.id);
+						break;
+				}
+			});
+		}
+	}
+	reset(task) {
+		this.cache.rendererOptions.delete(task.id);
+		this.cache.rendererTaskOptions.delete(task.id);
+		this.buffer.output.delete(task.id);
+	}
+	dump(task, level, source = ListrLogLevels.OUTPUT, data) {
+		if (!data) switch (source) {
+			case ListrLogLevels.OUTPUT:
+				data = task.output;
+				break;
+			case ListrLogLevels.SKIPPED:
+				data = task.message.skip;
+				break;
+			case ListrLogLevels.FAILED:
+				data = task.message.error;
+				break;
+		}
+		if (task.hasTitle() && source === ListrLogLevels.FAILED && data === task.title || typeof data !== "string") return [];
+		if (source === ListrLogLevels.OUTPUT) data = cleanseAnsi(data);
+		return this.format(data, this.style(task, true), level + 1);
+	}
+	indent(str, i) {
+		return i > 0 ? indent(str.trimEnd(), this.options.indentation) : str.trimEnd();
+	}
+};
+var SilentRenderer = class {
+	static nonTTY = true;
+	static rendererOptions;
+	static rendererTaskOptions;
+	constructor(tasks, options) {
+		this.tasks = tasks;
+		this.options = options;
+	}
+	render() {}
+	end() {}
+};
+var SimpleRenderer = class SimpleRenderer$1 {
+	static nonTTY = true;
+	static rendererOptions = { pausedTimer: {
+		...PRESET_TIMER,
+		field: (time) => `${ListrLogLevels.PAUSED}:${time}`,
+		format: () => color.yellowBright
+	} };
+	static rendererTaskOptions = {};
+	logger;
+	cache = {
+		rendererOptions: /* @__PURE__ */ new Map(),
+		rendererTaskOptions: /* @__PURE__ */ new Map()
+	};
+	constructor(tasks, options) {
+		this.tasks = tasks;
+		this.options = options;
+		this.options = {
+			...SimpleRenderer$1.rendererOptions,
+			...options,
+			icon: {
+				...LISTR_LOGGER_STYLE.icon,
+				...options?.icon ?? {}
+			},
+			color: {
+				...LISTR_LOGGER_STYLE.color,
+				...options?.color ?? {}
+			}
+		};
+		this.logger = this.options.logger ?? new ListrLogger({
+			useIcons: true,
+			toStderr: LISTR_LOGGER_STDERR_LEVELS
+		});
+		this.logger.options.icon = this.options.icon;
+		this.logger.options.color = this.options.color;
+		if (this.options.timestamp) this.logger.options.fields.prefix.unshift(this.options.timestamp);
+	}
+	end() {}
+	render() {
+		this.renderer(this.tasks);
+	}
+	renderer(tasks) {
+		tasks.forEach((task) => {
+			this.calculate(task);
+			task.once(ListrTaskEventType.CLOSED, () => {
+				this.reset(task);
+			});
+			const rendererOptions = this.cache.rendererOptions.get(task.id);
+			const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+			task.on(ListrTaskEventType.SUBTASK, (subtasks) => {
+				this.renderer(subtasks);
+			});
+			task.on(ListrTaskEventType.STATE, (state) => {
+				if (!task.hasTitle()) return;
+				if (state === ListrTaskState.STARTED) this.logger.log(ListrLogLevels.STARTED, task.title);
+				else if (state === ListrTaskState.COMPLETED) {
+					const timer = rendererTaskOptions?.timer;
+					this.logger.log(ListrLogLevels.COMPLETED, task.title, timer && { suffix: {
+						...timer,
+						condition: !!task.message?.duration && timer.condition,
+						args: [task.message.duration]
+					} });
+				} else if (state === ListrTaskState.PROMPT) {
+					this.logger.process.hijack();
+					task.on(ListrTaskEventType.PROMPT, (prompt) => {
+						this.logger.process.toStderr(prompt, false);
+					});
+				} else if (state === ListrTaskState.PROMPT_COMPLETED) {
+					task.off(ListrTaskEventType.PROMPT);
+					this.logger.process.release();
+				}
+			});
+			task.on(ListrTaskEventType.OUTPUT, (output) => {
+				this.logger.log(ListrLogLevels.OUTPUT, output);
+			});
+			task.on(ListrTaskEventType.MESSAGE, (message) => {
+				if (message.error) this.logger.log(ListrLogLevels.FAILED, task.title, { suffix: {
+					field: `${ListrLogLevels.FAILED}: ${message.error}`,
+					format: () => color.red
+				} });
+				else if (message.skip) this.logger.log(ListrLogLevels.SKIPPED, task.title, { suffix: {
+					field: `${ListrLogLevels.SKIPPED}: ${message.skip}`,
+					format: () => color.yellow
+				} });
+				else if (message.rollback) this.logger.log(ListrLogLevels.ROLLBACK, task.title, { suffix: {
+					field: `${ListrLogLevels.ROLLBACK}: ${message.rollback}`,
+					format: () => color.red
+				} });
+				else if (message.retry) this.logger.log(ListrLogLevels.RETRY, task.title, { suffix: {
+					field: `${ListrLogLevels.RETRY}:${message.retry.count}`,
+					format: () => color.red
+				} });
+				else if (message.paused) {
+					const timer = rendererOptions?.pausedTimer;
+					this.logger.log(ListrLogLevels.PAUSED, task.title, timer && { suffix: {
+						...timer,
+						condition: !!message?.paused && timer.condition,
+						args: [message.paused - Date.now()]
+					} });
+				}
+			});
+		});
+	}
+	calculate(task) {
+		if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) return;
+		const rendererOptions = {
+			...this.options,
+			...task.rendererOptions
+		};
+		this.cache.rendererOptions.set(task.id, rendererOptions);
+		this.cache.rendererTaskOptions.set(task.id, {
+			...SimpleRenderer$1.rendererTaskOptions,
+			timer: rendererOptions.timer,
+			...task.rendererTaskOptions
+		});
+	}
+	reset(task) {
+		this.cache.rendererOptions.delete(task.id);
+		this.cache.rendererTaskOptions.delete(task.id);
+	}
+};
+var TestRendererSerializer = class {
+	constructor(options) {
+		this.options = options;
+	}
+	serialize(event, data, task) {
+		return JSON.stringify(this.generate(event, data, task));
+	}
+	generate(event, data, task) {
+		const output = {
+			event,
+			data
+		};
+		if (typeof this.options?.task !== "boolean") {
+			const t = Object.fromEntries(this.options.task.map((entity) => {
+				const property = task[entity];
+				if (typeof property === "function") return [entity, property.call(task)];
+				return [entity, property];
+			}));
+			if (Object.keys(task).length > 0) output.task = t;
+		}
+		return output;
+	}
+};
+var TestRenderer = class TestRenderer$1 {
+	static nonTTY = true;
+	static rendererOptions = {
+		subtasks: true,
+		state: Object.values(ListrTaskState),
+		output: true,
+		prompt: true,
+		title: true,
+		messages: [
+			"skip",
+			"error",
+			"retry",
+			"rollback",
+			"paused"
+		],
+		messagesToStderr: [
+			"error",
+			"rollback",
+			"retry"
+		],
+		task: [
+			"hasRolledBack",
+			"isRollingBack",
+			"isCompleted",
+			"isSkipped",
+			"hasFinalized",
+			"hasSubtasks",
+			"title",
+			"hasReset",
+			"hasTitle",
+			"isPrompt",
+			"isPaused",
+			"isPending",
+			"isSkipped",
+			"isStarted",
+			"hasFailed",
+			"isEnabled",
+			"isRetrying",
+			"path"
+		]
+	};
+	static rendererTaskOptions;
+	logger;
+	serializer;
+	constructor(tasks, options) {
+		this.tasks = tasks;
+		this.options = options;
+		this.options = {
+			...TestRenderer$1.rendererOptions,
+			...this.options
+		};
+		this.logger = this.options.logger ?? new ListrLogger({ useIcons: false });
+		this.serializer = new TestRendererSerializer(this.options);
+	}
+	render() {
+		this.renderer(this.tasks);
+	}
+	end() {}
+	renderer(tasks) {
+		tasks.forEach((task) => {
+			if (this.options.subtasks) task.on(ListrTaskEventType.SUBTASK, (subtasks) => {
+				this.renderer(subtasks);
+			});
+			if (this.options.state) task.on(ListrTaskEventType.STATE, (state) => {
+				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.STATE, state, task));
+			});
+			if (this.options.output) task.on(ListrTaskEventType.OUTPUT, (data) => {
+				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.OUTPUT, data, task));
+			});
+			if (this.options.prompt) task.on(ListrTaskEventType.PROMPT, (prompt) => {
+				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.PROMPT, prompt, task));
+			});
+			if (this.options.title) task.on(ListrTaskEventType.TITLE, (title) => {
+				this.logger.toStdout(this.serializer.serialize(ListrTaskEventType.TITLE, title, task));
+			});
+			task.on(ListrTaskEventType.MESSAGE, (message) => {
+				const parsed = Object.fromEntries(Object.entries(message).map(([key, value]) => {
+					if (this.options.messages.includes(key)) return [key, value];
+				}).filter(Boolean));
+				if (Object.keys(parsed).length > 0) {
+					const output = this.serializer.serialize(ListrTaskEventType.MESSAGE, parsed, task);
+					if (this.options.messagesToStderr.some((state) => Object.keys(parsed).includes(state))) this.logger.toStderr(output);
+					else this.logger.toStdout(output);
+				}
+			});
+		});
+	}
+};
+var VerboseRenderer = class VerboseRenderer$1 {
+	static nonTTY = true;
+	static rendererOptions = {
+		logTitleChange: false,
+		pausedTimer: {
+			...PRESET_TIMER,
+			format: () => color.yellowBright
+		}
+	};
+	static rendererTaskOptions;
+	logger;
+	cache = {
+		rendererOptions: /* @__PURE__ */ new Map(),
+		rendererTaskOptions: /* @__PURE__ */ new Map()
+	};
+	constructor(tasks, options) {
+		this.tasks = tasks;
+		this.options = options;
+		this.options = {
+			...VerboseRenderer$1.rendererOptions,
+			...this.options,
+			icon: {
+				...LISTR_LOGGER_STYLE.icon,
+				...options?.icon ?? {}
+			},
+			color: {
+				...LISTR_LOGGER_STYLE.color,
+				...options?.color ?? {}
+			}
+		};
+		this.logger = this.options.logger ?? new ListrLogger({
+			useIcons: false,
+			toStderr: LISTR_LOGGER_STDERR_LEVELS
+		});
+		this.logger.options.icon = this.options.icon;
+		this.logger.options.color = this.options.color;
+		if (this.options.timestamp) this.logger.options.fields.prefix.unshift(this.options.timestamp);
+	}
+	render() {
+		this.renderer(this.tasks);
+	}
+	end() {}
+	renderer(tasks) {
+		tasks.forEach((task) => {
+			this.calculate(task);
+			task.once(ListrTaskEventType.CLOSED, () => {
+				this.reset(task);
+			});
+			const rendererOptions = this.cache.rendererOptions.get(task.id);
+			const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+			task.on(ListrTaskEventType.SUBTASK, (subtasks) => {
+				this.renderer(subtasks);
+			});
+			task.on(ListrTaskEventType.STATE, (state) => {
+				if (!task.hasTitle()) return;
+				if (state === ListrTaskState.STARTED) this.logger.log(ListrLogLevels.STARTED, task.title);
+				else if (state === ListrTaskState.COMPLETED) {
+					const timer = rendererTaskOptions.timer;
+					this.logger.log(ListrLogLevels.COMPLETED, task.title, timer && { suffix: {
+						...timer,
+						condition: !!task.message?.duration && timer.condition,
+						args: [task.message.duration]
+					} });
+				}
+			});
+			task.on(ListrTaskEventType.OUTPUT, (data) => {
+				this.logger.log(ListrLogLevels.OUTPUT, data);
+			});
+			task.on(ListrTaskEventType.PROMPT, (prompt) => {
+				const cleansed = cleanseAnsi(prompt);
+				if (cleansed) this.logger.log(ListrLogLevels.PROMPT, cleansed);
+			});
+			if (this.options?.logTitleChange !== false) task.on(ListrTaskEventType.TITLE, (title) => {
+				this.logger.log(ListrLogLevels.TITLE, title);
+			});
+			task.on(ListrTaskEventType.MESSAGE, (message) => {
+				if (message?.error) this.logger.log(ListrLogLevels.FAILED, message.error);
+				else if (message?.skip) this.logger.log(ListrLogLevels.SKIPPED, message.skip);
+				else if (message?.rollback) this.logger.log(ListrLogLevels.ROLLBACK, message.rollback);
+				else if (message?.retry) this.logger.log(ListrLogLevels.RETRY, task.title, { suffix: message.retry.count.toString() });
+				else if (message?.paused) {
+					const timer = rendererOptions?.pausedTimer;
+					this.logger.log(ListrLogLevels.PAUSED, task.title, timer && { suffix: {
+						...timer,
+						condition: !!message?.paused && timer.condition,
+						args: [message.paused - Date.now()]
+					} });
+				}
+			});
+		});
+	}
+	calculate(task) {
+		if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) return;
+		const rendererOptions = {
+			...this.options,
+			...task.rendererOptions
+		};
+		this.cache.rendererOptions.set(task.id, rendererOptions);
+		this.cache.rendererTaskOptions.set(task.id, {
+			...VerboseRenderer$1.rendererTaskOptions,
+			timer: rendererOptions.timer,
+			...task.rendererTaskOptions
+		});
+	}
+	reset(task) {
+		this.cache.rendererOptions.delete(task.id);
+		this.cache.rendererTaskOptions.delete(task.id);
+	}
+};
+const RENDERERS = {
+	default: DefaultRenderer,
+	simple: SimpleRenderer,
+	verbose: VerboseRenderer,
+	test: TestRenderer,
+	silent: SilentRenderer
+};
+function isRendererSupported(renderer) {
+	return process.stdout.isTTY === true || renderer.nonTTY === true;
+}
+function getRendererClass(renderer) {
+	if (typeof renderer === "string") return RENDERERS[renderer] ?? RENDERERS.default;
+	return typeof renderer === "function" ? renderer : RENDERERS.default;
+}
+function getRenderer(options) {
+	if (assertFunctionOrSelf(options?.silentRendererCondition)) return {
+		renderer: getRendererClass("silent"),
+		selection: ListrRendererSelection.SILENT
+	};
+	const r = {
+		renderer: getRendererClass(options.renderer),
+		options: options.rendererOptions,
+		selection: ListrRendererSelection.PRIMARY
+	};
+	if (!isRendererSupported(r.renderer) || assertFunctionOrSelf(options?.fallbackRendererCondition)) return {
+		renderer: getRendererClass(options.fallbackRenderer),
+		options: options.fallbackRendererOptions,
+		selection: ListrRendererSelection.SECONDARY
+	};
+	return r;
+}
+/**
+* This function asserts the given value as a function or itself.
+* If the value itself is a function it will evaluate it with the passed in arguments,
+* elsewise it will directly return itself.
+*/
+function assertFunctionOrSelf(functionOrSelf, ...args) {
+	if (typeof functionOrSelf === "function") return functionOrSelf(...args);
+	else return functionOrSelf;
+}
+const clone = (0, import_rfdc.default)({ circles: true });
+/**
+* Deep clones a object in the easiest manner.
+*/
+function cloneObject(obj) {
+	return clone(obj);
+}
+var Concurrency = class {
+	concurrency;
+	count;
+	queue;
+	constructor(options) {
+		this.concurrency = options.concurrency;
+		this.count = 0;
+		this.queue = /* @__PURE__ */ new Set();
+	}
+	add(fn) {
+		if (this.count < this.concurrency) return this.run(fn);
+		return new Promise((resolve$2) => {
+			const callback = () => resolve$2(this.run(fn));
+			this.queue.add(callback);
+		});
+	}
+	flush() {
+		for (const callback of this.queue) {
+			if (this.count >= this.concurrency) break;
+			this.queue.delete(callback);
+			callback();
+		}
+	}
+	run(fn) {
+		this.count++;
+		const promise = fn();
+		const cleanup = () => {
+			this.count--;
+			this.flush();
+		};
+		promise.then(cleanup, () => {
+			this.queue.clear();
+		});
+		return promise;
+	}
+};
+function delay(time) {
+	return new Promise((resolve$2) => {
+		setTimeout(resolve$2, time);
+	});
+}
+/**
+* Internal error handling mechanism for Listr collects the errors and details for a failed task.
+*
+* @see {@link https://listr2.kilic.dev/task/error-handling.html}
+*/
+var ListrError = class extends Error {
+	path;
+	ctx;
+	constructor(error, type, task) {
+		super(error.message);
+		this.error = error;
+		this.type = type;
+		this.task = task;
+		this.name = "ListrError";
+		this.path = task.path;
+		if (task?.options.collectErrors === "full") {
+			this.task = cloneObject(task);
+			this.ctx = cloneObject(task.listr.ctx);
+		}
+		this.stack = error?.stack;
+	}
+};
+/**
+* Internal error coming from renderer.
+*/
+var ListrRendererError = class extends Error {};
+/**
+* Internal error handling mechanism for Listr prompts to identify the failing cause is coming from a prompt.
+*
+* @see {@link https://listr2.kilic.dev/task/prompts.html}
+*/
+var PromptError = class extends Error {};
+/**
+* The original Task that is defined by the user is wrapped with the TaskWrapper to provide additional functionality.
+*
+* @see {@link https://listr2.kilic.dev/task/task.html}
+*/
+var TaskWrapper = class {
+	constructor(task) {
+		this.task = task;
+	}
+	/* istanbul ignore next */
+	get title() {
+		return this.task.title;
+	}
+	/**
+	* Title of the current task.
+	*
+	* @see {@link https://listr2.kilic.dev/task/title.html}
+	*/
+	set title(title) {
+		title = Array.isArray(title) ? title : [title];
+		this.task.title$ = splat(title.shift(), ...title);
+	}
+	/* istanbul ignore next */
+	get output() {
+		return this.task.output;
+	}
+	/* istanbul ignore next */
+	/**
+	* Send output from the current task to the renderer.
+	*
+	* @see {@link https://listr2.kilic.dev/task/output.html}
+	*/
+	set output(output) {
+		output = Array.isArray(output) ? output : [output];
+		this.task.output$ = splat(output.shift(), ...output);
+	}
+	/* istanbul ignore next */
+	/** Send an output to the output channel as prompt. */
+	set promptOutput(output) {
+		this.task.promptOutput$ = output;
+	}
+	/**
+	* Creates a new set of Listr subtasks.
+	*
+	* @see {@link https://listr2.kilic.dev/task/subtasks.html}
+	*/
+	newListr(task, options) {
+		let tasks;
+		if (typeof task === "function") tasks = task(this);
+		else tasks = task;
+		return new Listr(tasks, options, this.task);
+	}
+	/**
+	* Report an error that has to be collected and handled.
+	*
+	* @see {@link https://listr2.kilic.dev/task/error-handling.html}
+	*/
+	report(error, type) {
+		if (this.task.options.collectErrors !== false) this.task.listr.errors.push(new ListrError(error, type, this.task));
+		this.task.message$ = { error: error.message ?? this.task?.title };
+	}
+	/**
+	* Skip the current task.
+	*
+	* @see {@link https://listr2.kilic.dev/task/skip.html}
+	*/
+	skip(message, ...metadata) {
+		this.task.state$ = ListrTaskState.SKIPPED;
+		if (message) this.task.message$ = { skip: message ? splat(message, ...metadata) : this.task?.title };
+	}
+	/**
+	* Check whether this task is currently in a retry state.
+	*
+	* @see {@link https://listr2.kilic.dev/task/retry.html}
+	*/
+	isRetrying() {
+		return this.task.isRetrying() ? this.task.retry : { count: 0 };
+	}
+	/* istanbul ignore next */
+	/**
+	* Create a new prompt for getting user input through the prompt adapter.
+	* This will create a new prompt through the adapter if the task is not currently rendering a prompt or will return the active instance.
+	*
+	* This part of the application requires optional peer dependencies, please refer to documentation.
+	*
+	* @see {@link https://listr2.kilic.dev/task/prompt.html}
+	*/
+	prompt(adapter) {
+		if (this.task.prompt) return this.task.prompt;
+		return new adapter(this.task, this);
+	}
+	/* istanbul ignore next */
+	/**
+	* Generates a fake stdout for your use case, where it will be tunnelled through Listr to handle the rendering process.
+	*
+	* @see {@link https://listr2.kilic.dev/renderer/process-output.html}
+	*/
+	stdout(type) {
+		return createWritable((chunk) => {
+			switch (type) {
+				case ListrTaskEventType.PROMPT:
+					this.promptOutput = chunk;
+					break;
+				default: this.output = chunk;
+			}
+		});
+	}
+	/** Run this task. */
+	run(ctx) {
+		return this.task.run(ctx, this);
+	}
+};
+var ListrTaskEventManager = class extends EventManager {};
+/**
+* Creates and handles a runnable instance of the Task.
+*/
+var Task = class extends ListrTaskEventManager {
+	/** Unique id per task, can be used for identifying a Task. */
+	id = randomUUID();
+	/** The current state of the task. */
+	state = ListrTaskState.WAITING;
+	/** Subtasks of the current task. */
+	subtasks;
+	/** Title of the task. */
+	title;
+	/** Initial/Untouched version of the title for using whenever task has a reset. */
+	initialTitle;
+	/** Output channel for the task. */
+	output;
+	/** Current state of the retry process whenever the task is retrying. */
+	retry;
+	/**
+	* A channel for messages.
+	*
+	* This requires a separate channel for messages like error, skip or runtime messages to further utilize in the renderers.
+	*/
+	message = {};
+	/** Current prompt instance or prompt error whenever the task is prompting. */
+	prompt;
+	/** Parent task of the current task. */
+	parent;
+	/** Enable flag of this task. */
+	enabled;
+	/** User provided Task callback function to run. */
+	taskFn;
+	/** Marks the task as closed. This is different from finalized since this is not really related to task itself. */
+	closed;
+	constructor(listr, task, options, rendererOptions, rendererTaskOptions) {
+		super();
+		this.listr = listr;
+		this.task = task;
+		this.options = options;
+		this.rendererOptions = rendererOptions;
+		this.rendererTaskOptions = rendererTaskOptions;
+		if (task.title) {
+			const title = Array.isArray(task?.title) ? task.title : [task.title];
+			this.title = splat(title.shift(), ...title);
+			this.initialTitle = this.title;
+		}
+		this.taskFn = task.task;
+		this.parent = listr.parentTask;
+	}
+	/**
+	* Update the current state of the Task and emit the neccassary events.
+	*/
+	set state$(state) {
+		this.state = state;
+		this.emit(ListrTaskEventType.STATE, state);
+		if (this.hasSubtasks() && this.hasFailed()) {
+			for (const subtask of this.subtasks) if (subtask.state === ListrTaskState.STARTED) subtask.state$ = ListrTaskState.FAILED;
+		}
+		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+	}
+	/**
+	* Update the current output of the Task and emit the neccassary events.
+	*/
+	set output$(data) {
+		this.output = data;
+		this.emit(ListrTaskEventType.OUTPUT, data);
+		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+	}
+	/**
+	* Update the current prompt output of the Task and emit the neccassary events.
+	*/
+	set promptOutput$(data) {
+		this.emit(ListrTaskEventType.PROMPT, data);
+		if (cleanseAnsi(data)) this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+	}
+	/**
+	* Update or extend the current message of the Task and emit the neccassary events.
+	*/
+	set message$(data) {
+		this.message = {
+			...this.message,
+			...data
+		};
+		this.emit(ListrTaskEventType.MESSAGE, data);
+		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+	}
+	/**
+	* Update the current title of the Task and emit the neccassary events.
+	*/
+	set title$(title) {
+		this.title = title;
+		this.emit(ListrTaskEventType.TITLE, title);
+		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+	}
+	/**
+	* Current task path in the hierarchy.
+	*/
+	get path() {
+		return [...this.listr.path, this.initialTitle];
+	}
+	/**
+	* Checks whether the current task with the given context should be set as enabled.
+	*/
+	async check(ctx) {
+		if (this.state === ListrTaskState.WAITING) {
+			this.enabled = await assertFunctionOrSelf(this.task?.enabled ?? true, ctx);
+			this.emit(ListrTaskEventType.ENABLED, this.enabled);
+			this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		}
+		return this.enabled;
+	}
+	/** Returns whether this task has subtasks. */
+	hasSubtasks() {
+		return this.subtasks?.length > 0;
+	}
+	/** Returns whether this task is finalized in someform. */
+	hasFinalized() {
+		return this.isCompleted() || this.hasFailed() || this.isSkipped() || this.hasRolledBack();
+	}
+	/** Returns whether this task is in progress. */
+	isPending() {
+		return this.isStarted() || this.isPrompt() || this.hasReset();
+	}
+	/** Returns whether this task has started. */
+	isStarted() {
+		return this.state === ListrTaskState.STARTED;
+	}
+	/** Returns whether this task is skipped. */
+	isSkipped() {
+		return this.state === ListrTaskState.SKIPPED;
+	}
+	/** Returns whether this task has been completed. */
+	isCompleted() {
+		return this.state === ListrTaskState.COMPLETED;
+	}
+	/** Returns whether this task has been failed. */
+	hasFailed() {
+		return this.state === ListrTaskState.FAILED;
+	}
+	/** Returns whether this task has an active rollback task going on. */
+	isRollingBack() {
+		return this.state === ListrTaskState.ROLLING_BACK;
+	}
+	/** Returns whether the rollback action was successful. */
+	hasRolledBack() {
+		return this.state === ListrTaskState.ROLLED_BACK;
+	}
+	/** Returns whether this task has an actively retrying task going on. */
+	isRetrying() {
+		return this.state === ListrTaskState.RETRY;
+	}
+	/** Returns whether this task has some kind of reset like retry and rollback going on. */
+	hasReset() {
+		return this.state === ListrTaskState.RETRY || this.state === ListrTaskState.ROLLING_BACK;
+	}
+	/** Returns whether enabled function resolves to true. */
+	isEnabled() {
+		return this.enabled;
+	}
+	/** Returns whether this task actually has a title. */
+	hasTitle() {
+		return typeof this?.title === "string";
+	}
+	/** Returns whether this task has a prompt inside. */
+	isPrompt() {
+		return this.state === ListrTaskState.PROMPT;
+	}
+	/** Returns whether this task is currently paused. */
+	isPaused() {
+		return this.state === ListrTaskState.PAUSED;
+	}
+	/** Returns whether this task is closed. */
+	isClosed() {
+		return this.closed;
+	}
+	/** Pause the given task for certain time. */
+	async pause(time) {
+		const state = this.state;
+		this.state$ = ListrTaskState.PAUSED;
+		this.message$ = { paused: Date.now() + time };
+		await delay(time);
+		this.state$ = state;
+		this.message$ = { paused: null };
+	}
+	/** Run the current task. */
+	async run(context, wrapper) {
+		const handleResult = (result) => {
+			if (result instanceof Listr) {
+				result.options = {
+					...this.options,
+					...result.options
+				};
+				result.rendererClass = getRendererClass("silent");
+				this.subtasks = result.tasks;
+				result.errors = this.listr.errors;
+				this.emit(ListrTaskEventType.SUBTASK, this.subtasks);
+				result = result.run(context);
+			} else if (result instanceof Promise) result = result.then(handleResult);
+			else if (isReadable(result)) result = new Promise((resolve$2, reject) => {
+				result.on("data", (data) => {
+					this.output$ = data.toString();
+				});
+				result.on("error", (error) => reject(error));
+				result.on("end", () => resolve$2(null));
+			});
+			else if (isObservable(result)) result = new Promise((resolve$2, reject) => {
+				result.subscribe({
+					next: (data) => {
+						this.output$ = data;
+					},
+					error: reject,
+					complete: resolve$2
+				});
+			});
+			return result;
+		};
+		const startTime = Date.now();
+		this.state$ = ListrTaskState.STARTED;
+		const skipped = await assertFunctionOrSelf(this.task?.skip ?? false, context);
+		if (skipped) {
+			if (typeof skipped === "string") this.message$ = { skip: skipped };
+			else if (this.hasTitle()) this.message$ = { skip: this.title };
+			else this.message$ = { skip: "Skipped task without a title." };
+			this.state$ = ListrTaskState.SKIPPED;
+			return;
+		}
+		try {
+			const retryCount = typeof this.task?.retry === "number" && this.task.retry > 0 ? this.task.retry + 1 : typeof this.task?.retry === "object" && this.task.retry.tries > 0 ? this.task.retry.tries + 1 : 1;
+			const retryDelay = typeof this.task.retry === "object" && this.task.retry.delay;
+			for (let retries = 1; retries <= retryCount; retries++) try {
+				await handleResult(this.taskFn(context, wrapper));
+				break;
+			} catch (err) {
+				if (retries !== retryCount) {
+					this.retry = {
+						count: retries,
+						error: err
+					};
+					this.message$ = { retry: this.retry };
+					this.title$ = this.initialTitle;
+					this.output = void 0;
+					wrapper.report(err, ListrErrorTypes.WILL_RETRY);
+					this.state$ = ListrTaskState.RETRY;
+					if (retryDelay) await this.pause(retryDelay);
+				} else throw err;
+			}
+			if (this.isStarted() || this.isRetrying()) {
+				this.message$ = { duration: Date.now() - startTime };
+				this.state$ = ListrTaskState.COMPLETED;
+			}
+		} catch (error) {
+			if (this.prompt instanceof PromptError) error = this.prompt;
+			if (this.task?.rollback) {
+				wrapper.report(error, ListrErrorTypes.WILL_ROLLBACK);
+				try {
+					this.state$ = ListrTaskState.ROLLING_BACK;
+					await this.task.rollback(context, wrapper);
+					this.message$ = { rollback: this.title };
+					this.state$ = ListrTaskState.ROLLED_BACK;
+				} catch (err) {
+					this.state$ = ListrTaskState.FAILED;
+					wrapper.report(err, ListrErrorTypes.HAS_FAILED_TO_ROLLBACK);
+					this.close();
+					throw err;
+				}
+				if (this.listr.options?.exitAfterRollback !== false) {
+					this.close();
+					throw error;
+				}
+			} else {
+				this.state$ = ListrTaskState.FAILED;
+				if (this.listr.options.exitOnError !== false && await assertFunctionOrSelf(this.task?.exitOnError, context) !== false) {
+					wrapper.report(error, ListrErrorTypes.HAS_FAILED);
+					this.close();
+					throw error;
+				} else if (!this.hasSubtasks()) wrapper.report(error, ListrErrorTypes.HAS_FAILED_WITHOUT_ERROR);
+			}
+		} finally {
+			this.close();
+		}
+	}
+	close() {
+		this.emit(ListrTaskEventType.CLOSED);
+		this.listr.events.emit(ListrEventType.SHOULD_REFRESH_RENDER);
+		this.complete();
+	}
+};
+var ListrEventManager = class extends EventManager {};
+/**
+* Create a new task list with Listr.
+*
+* @see {@link https://listr2.kilic.dev/listr/listr.html}
+*/
+var Listr = class {
+	tasks = [];
+	errors = [];
+	ctx;
+	events;
+	path = [];
+	rendererClass;
+	rendererClassOptions;
+	rendererSelection;
+	boundSignalHandler;
+	concurrency;
+	renderer;
+	constructor(task, options, parentTask) {
+		this.task = task;
+		this.options = options;
+		this.parentTask = parentTask;
+		this.options = {
+			concurrent: false,
+			renderer: "default",
+			fallbackRenderer: "simple",
+			exitOnError: true,
+			exitAfterRollback: true,
+			collectErrors: false,
+			registerSignalListeners: true,
+			...this.parentTask?.options ?? {},
+			...options
+		};
+		if (this.options.concurrent === true) this.options.concurrent = Infinity;
+		else if (typeof this.options.concurrent !== "number") this.options.concurrent = 1;
+		this.concurrency = new Concurrency({ concurrency: this.options.concurrent });
+		if (parentTask) {
+			this.path = [...parentTask.listr.path, parentTask.title];
+			this.errors = parentTask.listr.errors;
+		}
+		if (this.parentTask?.listr.events instanceof ListrEventManager) this.events = this.parentTask.listr.events;
+		else this.events = new ListrEventManager();
+		/* istanbul ignore if */
+		if (this.options?.forceTTY || process.env[ListrEnvironmentVariables.FORCE_TTY]) {
+			process.stdout.isTTY = true;
+			process.stderr.isTTY = true;
+		}
+		/* istanbul ignore if */
+		if (this.options?.forceUnicode) process.env[ListrEnvironmentVariables.FORCE_UNICODE] = "1";
+		const renderer = getRenderer({
+			renderer: this.options.renderer,
+			rendererOptions: this.options.rendererOptions,
+			fallbackRenderer: this.options.fallbackRenderer,
+			fallbackRendererOptions: this.options.fallbackRendererOptions,
+			fallbackRendererCondition: this.options?.fallbackRendererCondition,
+			silentRendererCondition: this.options?.silentRendererCondition
+		});
+		this.rendererClass = renderer.renderer;
+		this.rendererClassOptions = renderer.options;
+		this.rendererSelection = renderer.selection;
+		/* istanbul ignore next */
+		this.add(task ?? []);
+		/* istanbul ignore if */
+		if (this.options.registerSignalListeners) {
+			this.boundSignalHandler = this.signalHandler.bind(this);
+			process.once("SIGINT", this.boundSignalHandler).setMaxListeners(0);
+		}
+	}
+	/**
+	* Whether this is the root task.
+	*/
+	isRoot() {
+		return !this.parentTask;
+	}
+	/**
+	* Whether this is a subtask of another task list.
+	*/
+	isSubtask() {
+		return !!this.parentTask;
+	}
+	/**
+	* Add tasks to current task list.
+	*
+	* @see {@link https://listr2.kilic.dev/task/task.html}
+	*/
+	add(tasks) {
+		this.tasks.push(...this.generate(tasks));
+	}
+	/**
+	* Run the task list.
+	*
+	* @see {@link https://listr2.kilic.dev/listr/listr.html#run-the-generated-task-list}
+	*/
+	async run(context) {
+		if (!this.renderer) this.renderer = new this.rendererClass(this.tasks, this.rendererClassOptions, this.events);
+		await this.renderer.render();
+		this.ctx = this.options?.ctx ?? context ?? {};
+		try {
+			await Promise.all(this.tasks.map((task) => task.check(this.ctx)));
+			await Promise.all(this.tasks.map((task) => this.concurrency.add(() => this.runTask(task))));
+			this.renderer.end();
+			this.removeSignalHandler();
+		} catch (err) {
+			if (this.options.exitOnError !== false) {
+				this.renderer.end(err);
+				this.removeSignalHandler();
+				throw err;
+			}
+		}
+		return this.ctx;
+	}
+	generate(tasks) {
+		tasks = Array.isArray(tasks) ? tasks : [tasks];
+		return tasks.map((task) => {
+			let rendererTaskOptions;
+			if (this.rendererSelection === ListrRendererSelection.PRIMARY) rendererTaskOptions = task.rendererOptions;
+			else if (this.rendererSelection === ListrRendererSelection.SECONDARY) rendererTaskOptions = task.fallbackRendererOptions;
+			return new Task(this, task, this.options, this.rendererClassOptions, rendererTaskOptions);
+		});
+	}
+	async runTask(task) {
+		if (!await task.check(this.ctx)) return;
+		return new TaskWrapper(task).run(this.ctx);
+	}
+	signalHandler() {
+		this.tasks?.forEach(async (task) => {
+			if (task.isPending()) task.state$ = ListrTaskState.FAILED;
+		});
+		if (this.isRoot()) {
+			this.renderer?.end(/* @__PURE__ */ new Error("Interrupted."));
+			process.exit(127);
+		}
+	}
+	removeSignalHandler() {
+		if (this.boundSignalHandler) process.removeListener("SIGINT", this.boundSignalHandler);
+	}
+};
+
+//#endregion
+//#region node_modules/lodash-es/_freeGlobal.js
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var _freeGlobal_default = freeGlobal;
+
+//#endregion
+//#region node_modules/lodash-es/_root.js
+/** Detect free variable `self`. */
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+/** Used as a reference to the global object. */
+var root = _freeGlobal_default || freeSelf || Function("return this")();
+var _root_default = root;
+
+//#endregion
+//#region node_modules/lodash-es/_Symbol.js
+/** Built-in value references. */
+var Symbol = _root_default.Symbol;
+var _Symbol_default = Symbol;
+
+//#endregion
+//#region node_modules/lodash-es/_arrayMap.js
+/**
+* A specialized version of `_.map` for arrays without support for iteratee
+* shorthands.
+*
+* @private
+* @param {Array} [array] The array to iterate over.
+* @param {Function} iteratee The function invoked per iteration.
+* @returns {Array} Returns the new mapped array.
+*/
+function arrayMap(array, iteratee) {
+	var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+	while (++index < length) result[index] = iteratee(array[index], index, array);
+	return result;
+}
+var _arrayMap_default = arrayMap;
+
+//#endregion
+//#region node_modules/lodash-es/isArray.js
+/**
+* Checks if `value` is classified as an `Array` object.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is an array, else `false`.
+* @example
+*
+* _.isArray([1, 2, 3]);
+* // => true
+*
+* _.isArray(document.body.children);
+* // => false
+*
+* _.isArray('abc');
+* // => false
+*
+* _.isArray(_.noop);
+* // => false
+*/
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+//#endregion
+//#region node_modules/lodash-es/_getRawTag.js
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+/** Used to check objects for own properties. */
+var hasOwnProperty$3 = objectProto$1.hasOwnProperty;
+/**
+* Used to resolve the
+* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+* of values.
+*/
+var nativeObjectToString$1 = objectProto$1.toString;
+/** Built-in value references. */
+var symToStringTag$1 = _Symbol_default ? _Symbol_default.toStringTag : void 0;
+/**
+* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+*
+* @private
+* @param {*} value The value to query.
+* @returns {string} Returns the raw `toStringTag`.
+*/
+function getRawTag(value) {
+	var isOwn = hasOwnProperty$3.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+	try {
+		value[symToStringTag$1] = void 0;
+		var unmasked = true;
+	} catch (e) {}
+	var result = nativeObjectToString$1.call(value);
+	if (unmasked) if (isOwn) value[symToStringTag$1] = tag;
+	else delete value[symToStringTag$1];
+	return result;
+}
+var _getRawTag_default = getRawTag;
+
+//#endregion
+//#region node_modules/lodash-es/_objectToString.js
+/**
+* Used to resolve the
+* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+* of values.
+*/
+var nativeObjectToString = Object.prototype.toString;
+/**
+* Converts `value` to a string using `Object.prototype.toString`.
+*
+* @private
+* @param {*} value The value to convert.
+* @returns {string} Returns the converted string.
+*/
+function objectToString(value) {
+	return nativeObjectToString.call(value);
+}
+var _objectToString_default = objectToString;
+
+//#endregion
+//#region node_modules/lodash-es/_baseGetTag.js
+/** `Object#toString` result references. */
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+/** Built-in value references. */
+var symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : void 0;
+/**
+* The base implementation of `getTag` without fallbacks for buggy environments.
+*
+* @private
+* @param {*} value The value to query.
+* @returns {string} Returns the `toStringTag`.
+*/
+function baseGetTag(value) {
+	if (value == null) return value === void 0 ? undefinedTag : nullTag;
+	return symToStringTag && symToStringTag in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
+}
+var _baseGetTag_default = baseGetTag;
+
+//#endregion
+//#region node_modules/lodash-es/isObjectLike.js
+/**
+* Checks if `value` is object-like. A value is object-like if it's not `null`
+* and has a `typeof` result of "object".
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+* @example
+*
+* _.isObjectLike({});
+* // => true
+*
+* _.isObjectLike([1, 2, 3]);
+* // => true
+*
+* _.isObjectLike(_.noop);
+* // => false
+*
+* _.isObjectLike(null);
+* // => false
+*/
+function isObjectLike(value) {
+	return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+//#endregion
+//#region node_modules/lodash-es/isSymbol.js
+/** `Object#toString` result references. */
+var symbolTag = "[object Symbol]";
+/**
+* Checks if `value` is classified as a `Symbol` primitive or object.
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+* @example
+*
+* _.isSymbol(Symbol.iterator);
+* // => true
+*
+* _.isSymbol('abc');
+* // => false
+*/
+function isSymbol(value) {
+	return typeof value == "symbol" || isObjectLike_default(value) && _baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+//#endregion
+//#region node_modules/lodash-es/_baseToString.js
+/** Used as references for various `Number` constants. */
+var INFINITY = Infinity;
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = _Symbol_default ? _Symbol_default.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+/**
+* The base implementation of `_.toString` which doesn't convert nullish
+* values to empty strings.
+*
+* @private
+* @param {*} value The value to process.
+* @returns {string} Returns the string.
+*/
+function baseToString(value) {
+	if (typeof value == "string") return value;
+	if (isArray_default(value)) return _arrayMap_default(value, baseToString) + "";
+	if (isSymbol_default(value)) return symbolToString ? symbolToString.call(value) : "";
+	var result = value + "";
+	return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var _baseToString_default = baseToString;
+
+//#endregion
+//#region node_modules/lodash-es/toString.js
+/**
+* Converts `value` to a string. An empty string is returned for `null`
+* and `undefined` values. The sign of `-0` is preserved.
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to convert.
+* @returns {string} Returns the converted string.
+* @example
+*
+* _.toString(null);
+* // => ''
+*
+* _.toString(-0);
+* // => '-0'
+*
+* _.toString([1, 2, 3]);
+* // => '1,2,3'
+*/
+function toString(value) {
+	return value == null ? "" : _baseToString_default(value);
+}
+var toString_default = toString;
+
+//#endregion
+//#region node_modules/lodash-es/_baseSlice.js
+/**
+* The base implementation of `_.slice` without an iteratee call guard.
+*
+* @private
+* @param {Array} array The array to slice.
+* @param {number} [start=0] The start position.
+* @param {number} [end=array.length] The end position.
+* @returns {Array} Returns the slice of `array`.
+*/
+function baseSlice(array, start, end) {
+	var index = -1, length = array.length;
+	if (start < 0) start = -start > length ? 0 : length + start;
+	end = end > length ? length : end;
+	if (end < 0) end += length;
+	length = start > end ? 0 : end - start >>> 0;
+	start >>>= 0;
+	var result = Array(length);
+	while (++index < length) result[index] = array[index + start];
+	return result;
+}
+var _baseSlice_default = baseSlice;
+
+//#endregion
+//#region node_modules/lodash-es/_castSlice.js
+/**
+* Casts `array` to a slice if it's needed.
+*
+* @private
+* @param {Array} array The array to inspect.
+* @param {number} start The start position.
+* @param {number} [end=array.length] The end position.
+* @returns {Array} Returns the cast slice.
+*/
+function castSlice(array, start, end) {
+	var length = array.length;
+	end = end === void 0 ? length : end;
+	return !start && end >= length ? array : _baseSlice_default(array, start, end);
+}
+var _castSlice_default = castSlice;
+
+//#endregion
+//#region node_modules/lodash-es/_hasUnicode.js
+/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+var reHasUnicode = RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");
+/**
+* Checks if `string` contains Unicode symbols.
+*
+* @private
+* @param {string} string The string to inspect.
+* @returns {boolean} Returns `true` if a symbol is found, else `false`.
+*/
+function hasUnicode(string) {
+	return reHasUnicode.test(string);
+}
+var _hasUnicode_default = hasUnicode;
+
+//#endregion
+//#region node_modules/lodash-es/_asciiToArray.js
+/**
+* Converts an ASCII `string` to an array.
+*
+* @private
+* @param {string} string The string to convert.
+* @returns {Array} Returns the converted array.
+*/
+function asciiToArray(string) {
+	return string.split("");
+}
+var _asciiToArray_default = asciiToArray;
+
+//#endregion
+//#region node_modules/lodash-es/_unicodeToArray.js
+/** Used to compose unicode character classes. */
+var rsAstralRange$1 = "\\ud800-\\udfff", rsComboRange$1 = "\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff", rsVarRange$1 = "\\ufe0e\\ufe0f";
+/** Used to compose unicode capture groups. */
+var rsAstral = "[" + rsAstralRange$1 + "]", rsCombo$1 = "[" + rsComboRange$1 + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier$1 = "(?:" + rsCombo$1 + "|" + rsFitz + ")", rsNonAstral$1 = "[^" + rsAstralRange$1 + "]", rsRegional$1 = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair$1 = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsZWJ$1 = "\\u200d";
+/** Used to compose unicode regexes. */
+var reOptMod$1 = rsModifier$1 + "?", rsOptVar$1 = "[" + rsVarRange$1 + "]?", rsOptJoin$1 = "(?:" + rsZWJ$1 + "(?:" + [
+	rsNonAstral$1,
+	rsRegional$1,
+	rsSurrPair$1
+].join("|") + ")" + rsOptVar$1 + reOptMod$1 + ")*", rsSeq$1 = rsOptVar$1 + reOptMod$1 + rsOptJoin$1, rsSymbol = "(?:" + [
+	rsNonAstral$1 + rsCombo$1 + "?",
+	rsCombo$1,
+	rsRegional$1,
+	rsSurrPair$1,
+	rsAstral
+].join("|") + ")";
+/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq$1, "g");
+/**
+* Converts a Unicode `string` to an array.
+*
+* @private
+* @param {string} string The string to convert.
+* @returns {Array} Returns the converted array.
+*/
+function unicodeToArray(string) {
+	return string.match(reUnicode) || [];
+}
+var _unicodeToArray_default = unicodeToArray;
+
+//#endregion
+//#region node_modules/lodash-es/_stringToArray.js
+/**
+* Converts `string` to an array.
+*
+* @private
+* @param {string} string The string to convert.
+* @returns {Array} Returns the converted array.
+*/
+function stringToArray(string) {
+	return _hasUnicode_default(string) ? _unicodeToArray_default(string) : _asciiToArray_default(string);
+}
+var _stringToArray_default = stringToArray;
+
+//#endregion
+//#region node_modules/lodash-es/_createCaseFirst.js
+/**
+* Creates a function like `_.lowerFirst`.
+*
+* @private
+* @param {string} methodName The name of the `String` case method to use.
+* @returns {Function} Returns the new case function.
+*/
+function createCaseFirst(methodName) {
+	return function(string) {
+		string = toString_default(string);
+		var strSymbols = _hasUnicode_default(string) ? _stringToArray_default(string) : void 0;
+		var chr = strSymbols ? strSymbols[0] : string.charAt(0);
+		var trailing = strSymbols ? _castSlice_default(strSymbols, 1).join("") : string.slice(1);
+		return chr[methodName]() + trailing;
+	};
+}
+var _createCaseFirst_default = createCaseFirst;
+
+//#endregion
+//#region node_modules/lodash-es/upperFirst.js
+/**
+* Converts the first character of `string` to upper case.
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category String
+* @param {string} [string=''] The string to convert.
+* @returns {string} Returns the converted string.
+* @example
+*
+* _.upperFirst('fred');
+* // => 'Fred'
+*
+* _.upperFirst('FRED');
+* // => 'FRED'
+*/
+var upperFirst = _createCaseFirst_default("toUpperCase");
+var upperFirst_default = upperFirst;
+
+//#endregion
+//#region node_modules/lodash-es/capitalize.js
+/**
+* Converts the first character of `string` to upper case and the remaining
+* to lower case.
+*
+* @static
+* @memberOf _
+* @since 3.0.0
+* @category String
+* @param {string} [string=''] The string to capitalize.
+* @returns {string} Returns the capitalized string.
+* @example
+*
+* _.capitalize('FRED');
+* // => 'Fred'
+*/
+function capitalize$1(string) {
+	return upperFirst_default(toString_default(string).toLowerCase());
+}
+var capitalize_default = capitalize$1;
+
+//#endregion
+//#region node_modules/lodash-es/_arrayReduce.js
+/**
+* A specialized version of `_.reduce` for arrays without support for
+* iteratee shorthands.
+*
+* @private
+* @param {Array} [array] The array to iterate over.
+* @param {Function} iteratee The function invoked per iteration.
+* @param {*} [accumulator] The initial value.
+* @param {boolean} [initAccum] Specify using the first element of `array` as
+*  the initial value.
+* @returns {*} Returns the accumulated value.
+*/
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+	var index = -1, length = array == null ? 0 : array.length;
+	if (initAccum && length) accumulator = array[++index];
+	while (++index < length) accumulator = iteratee(accumulator, array[index], index, array);
+	return accumulator;
+}
+var _arrayReduce_default = arrayReduce;
+
+//#endregion
+//#region node_modules/lodash-es/_basePropertyOf.js
+/**
+* The base implementation of `_.propertyOf` without support for deep paths.
+*
+* @private
+* @param {Object} object The object to query.
+* @returns {Function} Returns the new accessor function.
+*/
+function basePropertyOf(object) {
+	return function(key) {
+		return object == null ? void 0 : object[key];
+	};
+}
+var _basePropertyOf_default = basePropertyOf;
+
+//#endregion
+//#region node_modules/lodash-es/_deburrLetter.js
+/**
+* Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+* letters to basic Latin letters.
+*
+* @private
+* @param {string} letter The matched letter to deburr.
+* @returns {string} Returns the deburred letter.
+*/
+var deburrLetter = _basePropertyOf_default({
+	"À": "A",
+	"Á": "A",
+	"Â": "A",
+	"Ã": "A",
+	"Ä": "A",
+	"Å": "A",
+	"à": "a",
+	"á": "a",
+	"â": "a",
+	"ã": "a",
+	"ä": "a",
+	"å": "a",
+	"Ç": "C",
+	"ç": "c",
+	"Ð": "D",
+	"ð": "d",
+	"È": "E",
+	"É": "E",
+	"Ê": "E",
+	"Ë": "E",
+	"è": "e",
+	"é": "e",
+	"ê": "e",
+	"ë": "e",
+	"Ì": "I",
+	"Í": "I",
+	"Î": "I",
+	"Ï": "I",
+	"ì": "i",
+	"í": "i",
+	"î": "i",
+	"ï": "i",
+	"Ñ": "N",
+	"ñ": "n",
+	"Ò": "O",
+	"Ó": "O",
+	"Ô": "O",
+	"Õ": "O",
+	"Ö": "O",
+	"Ø": "O",
+	"ò": "o",
+	"ó": "o",
+	"ô": "o",
+	"õ": "o",
+	"ö": "o",
+	"ø": "o",
+	"Ù": "U",
+	"Ú": "U",
+	"Û": "U",
+	"Ü": "U",
+	"ù": "u",
+	"ú": "u",
+	"û": "u",
+	"ü": "u",
+	"Ý": "Y",
+	"ý": "y",
+	"ÿ": "y",
+	"Æ": "Ae",
+	"æ": "ae",
+	"Þ": "Th",
+	"þ": "th",
+	"ß": "ss",
+	"Ā": "A",
+	"Ă": "A",
+	"Ą": "A",
+	"ā": "a",
+	"ă": "a",
+	"ą": "a",
+	"Ć": "C",
+	"Ĉ": "C",
+	"Ċ": "C",
+	"Č": "C",
+	"ć": "c",
+	"ĉ": "c",
+	"ċ": "c",
+	"č": "c",
+	"Ď": "D",
+	"Đ": "D",
+	"ď": "d",
+	"đ": "d",
+	"Ē": "E",
+	"Ĕ": "E",
+	"Ė": "E",
+	"Ę": "E",
+	"Ě": "E",
+	"ē": "e",
+	"ĕ": "e",
+	"ė": "e",
+	"ę": "e",
+	"ě": "e",
+	"Ĝ": "G",
+	"Ğ": "G",
+	"Ġ": "G",
+	"Ģ": "G",
+	"ĝ": "g",
+	"ğ": "g",
+	"ġ": "g",
+	"ģ": "g",
+	"Ĥ": "H",
+	"Ħ": "H",
+	"ĥ": "h",
+	"ħ": "h",
+	"Ĩ": "I",
+	"Ī": "I",
+	"Ĭ": "I",
+	"Į": "I",
+	"İ": "I",
+	"ĩ": "i",
+	"ī": "i",
+	"ĭ": "i",
+	"į": "i",
+	"ı": "i",
+	"Ĵ": "J",
+	"ĵ": "j",
+	"Ķ": "K",
+	"ķ": "k",
+	"ĸ": "k",
+	"Ĺ": "L",
+	"Ļ": "L",
+	"Ľ": "L",
+	"Ŀ": "L",
+	"Ł": "L",
+	"ĺ": "l",
+	"ļ": "l",
+	"ľ": "l",
+	"ŀ": "l",
+	"ł": "l",
+	"Ń": "N",
+	"Ņ": "N",
+	"Ň": "N",
+	"Ŋ": "N",
+	"ń": "n",
+	"ņ": "n",
+	"ň": "n",
+	"ŋ": "n",
+	"Ō": "O",
+	"Ŏ": "O",
+	"Ő": "O",
+	"ō": "o",
+	"ŏ": "o",
+	"ő": "o",
+	"Ŕ": "R",
+	"Ŗ": "R",
+	"Ř": "R",
+	"ŕ": "r",
+	"ŗ": "r",
+	"ř": "r",
+	"Ś": "S",
+	"Ŝ": "S",
+	"Ş": "S",
+	"Š": "S",
+	"ś": "s",
+	"ŝ": "s",
+	"ş": "s",
+	"š": "s",
+	"Ţ": "T",
+	"Ť": "T",
+	"Ŧ": "T",
+	"ţ": "t",
+	"ť": "t",
+	"ŧ": "t",
+	"Ũ": "U",
+	"Ū": "U",
+	"Ŭ": "U",
+	"Ů": "U",
+	"Ű": "U",
+	"Ų": "U",
+	"ũ": "u",
+	"ū": "u",
+	"ŭ": "u",
+	"ů": "u",
+	"ű": "u",
+	"ų": "u",
+	"Ŵ": "W",
+	"ŵ": "w",
+	"Ŷ": "Y",
+	"ŷ": "y",
+	"Ÿ": "Y",
+	"Ź": "Z",
+	"Ż": "Z",
+	"Ž": "Z",
+	"ź": "z",
+	"ż": "z",
+	"ž": "z",
+	"IJ": "IJ",
+	"ij": "ij",
+	"Œ": "Oe",
+	"œ": "oe",
+	"ʼn": "'n",
+	"ſ": "s"
+});
+var _deburrLetter_default = deburrLetter;
+
+//#endregion
+//#region node_modules/lodash-es/deburr.js
+/** Used to match Latin Unicode letters (excluding mathematical operators). */
+var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+/**
+* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+*/
+var reComboMark = RegExp("[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]", "g");
+/**
+* Deburrs `string` by converting
+* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+* and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+* letters to basic Latin letters and removing
+* [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+*
+* @static
+* @memberOf _
+* @since 3.0.0
+* @category String
+* @param {string} [string=''] The string to deburr.
+* @returns {string} Returns the deburred string.
+* @example
+*
+* _.deburr('déjà vu');
+* // => 'deja vu'
+*/
+function deburr(string) {
+	string = toString_default(string);
+	return string && string.replace(reLatin, _deburrLetter_default).replace(reComboMark, "");
+}
+var deburr_default = deburr;
+
+//#endregion
+//#region node_modules/lodash-es/_asciiWords.js
+/** Used to match words composed of alphanumeric characters. */
+var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+/**
+* Splits an ASCII `string` into an array of its words.
+*
+* @private
+* @param {string} The string to inspect.
+* @returns {Array} Returns the words of `string`.
+*/
+function asciiWords(string) {
+	return string.match(reAsciiWord) || [];
+}
+var _asciiWords_default = asciiWords;
+
+//#endregion
+//#region node_modules/lodash-es/_hasUnicodeWord.js
+/** Used to detect strings that need a more robust regexp to match words. */
+var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+/**
+* Checks if `string` contains a word composed of Unicode symbols.
+*
+* @private
+* @param {string} string The string to inspect.
+* @returns {boolean} Returns `true` if a word is found, else `false`.
+*/
+function hasUnicodeWord(string) {
+	return reHasUnicodeWord.test(string);
+}
+var _hasUnicodeWord_default = hasUnicodeWord;
+
+//#endregion
+//#region node_modules/lodash-es/_unicodeWords.js
+/** Used to compose unicode character classes. */
+var rsAstralRange = "\\ud800-\\udfff", rsComboRange = "\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff", rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+/** Used to compose unicode capture groups. */
+var rsApos = "['’]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsModifier = "(?:" + rsCombo + "|\\ud83c[\\udffb-\\udfff])", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
+/** Used to compose unicode regexes. */
+var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [
+	rsNonAstral,
+	rsRegional,
+	rsSurrPair
+].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [
+	rsDingbat,
+	rsRegional,
+	rsSurrPair
+].join("|") + ")" + rsSeq;
+/** Used to match complex or compound words. */
+var reUnicodeWord = RegExp([
+	rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [
+		rsBreak,
+		rsUpper,
+		"$"
+	].join("|") + ")",
+	rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [
+		rsBreak,
+		rsUpper + rsMiscLower,
+		"$"
+	].join("|") + ")",
+	rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
+	rsUpper + "+" + rsOptContrUpper,
+	rsOrdUpper,
+	rsOrdLower,
+	rsDigits,
+	rsEmoji
+].join("|"), "g");
+/**
+* Splits a Unicode `string` into an array of its words.
+*
+* @private
+* @param {string} The string to inspect.
+* @returns {Array} Returns the words of `string`.
+*/
+function unicodeWords(string) {
+	return string.match(reUnicodeWord) || [];
+}
+var _unicodeWords_default = unicodeWords;
+
+//#endregion
+//#region node_modules/lodash-es/words.js
+/**
+* Splits `string` into an array of its words.
+*
+* @static
+* @memberOf _
+* @since 3.0.0
+* @category String
+* @param {string} [string=''] The string to inspect.
+* @param {RegExp|string} [pattern] The pattern to match words.
+* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+* @returns {Array} Returns the words of `string`.
+* @example
+*
+* _.words('fred, barney, & pebbles');
+* // => ['fred', 'barney', 'pebbles']
+*
+* _.words('fred, barney, & pebbles', /[^, ]+/g);
+* // => ['fred', 'barney', '&', 'pebbles']
+*/
+function words(string, pattern, guard) {
+	string = toString_default(string);
+	pattern = guard ? void 0 : pattern;
+	if (pattern === void 0) return _hasUnicodeWord_default(string) ? _unicodeWords_default(string) : _asciiWords_default(string);
+	return string.match(pattern) || [];
+}
+var words_default = words;
+
+//#endregion
+//#region node_modules/lodash-es/_createCompounder.js
+/** Used to match apostrophes. */
+var reApos = RegExp("['’]", "g");
+/**
+* Creates a function like `_.camelCase`.
+*
+* @private
+* @param {Function} callback The function to combine each word.
+* @returns {Function} Returns the new compounder function.
+*/
+function createCompounder(callback) {
+	return function(string) {
+		return _arrayReduce_default(words_default(deburr_default(string).replace(reApos, "")), callback, "");
+	};
+}
+var _createCompounder_default = createCompounder;
+
+//#endregion
+//#region node_modules/lodash-es/camelCase.js
+/**
+* Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
+*
+* @static
+* @memberOf _
+* @since 3.0.0
+* @category String
+* @param {string} [string=''] The string to convert.
+* @returns {string} Returns the camel cased string.
+* @example
+*
+* _.camelCase('Foo Bar');
+* // => 'fooBar'
+*
+* _.camelCase('--foo-bar--');
+* // => 'fooBar'
+*
+* _.camelCase('__FOO_BAR__');
+* // => 'fooBar'
+*/
+var camelCase$1 = _createCompounder_default(function(result, word, index) {
+	word = word.toLowerCase();
+	return result + (index ? capitalize_default(word) : word);
+});
+var camelCase_default = camelCase$1;
+
+//#endregion
+//#region src/utils.ts
+function camelCase(str) {
+	if (!str) return str;
+	if (str.startsWith("_")) {
+		const leadingChars = str.match(/^_+/);
+		return leadingChars[0] + camelCase_default(str.slice(leadingChars[0].length));
+	}
+	if (str.endsWith("_")) {
+		const leadingChars = str.match(/_+$/);
+		return camelCase_default(str.slice(0, str.length - leadingChars[0].length)) + leadingChars[0];
+	}
+	return camelCase_default(str);
+}
+function capitalize(str) {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+//#region src/helpers/files.ts
+const ensurePath = async (path$2, clear = false) => {
+	if (clear) await rimraf(resolve(...path$2));
+	await mkdir(resolve(...path$2), { recursive: true });
+};
+const writeFileToPath = async (path$2, content) => {
+	await mkdir(resolve(...path$2, ".."), { recursive: true });
+	await writeFile(resolve(...path$2), content, "utf-8");
+};
+/**
+* Remove files/directories matching a glob pattern.
+*
+* @param pattern Glob pattern (e.g. "dist/**")
+* @param cwd Optional working directory
+*/
+async function rimraf(pattern, cwd = process.cwd()) {
+	const matches = glob(pattern, { cwd });
+	for await (const match of matches) await rm(resolve(cwd, match), {
+		force: true,
+		recursive: true
+	});
+}
+
+//#endregion
+//#region src/config.ts
+const RUNTIME_LIB_NAME = "./runtime";
+
+//#endregion
+//#region src/render/requestTypes/requestTypeName.ts
+const requestTypeName = (type) => {
+	if (!type) return "";
+	return `${type.name}GenqlSelection`;
+};
+
+//#endregion
+//#region src/render/client/renderClient.ts
+const renderClientCode = (ctx) => {
+	const url$1 = ctx.config?.endpoint ? `"${ctx.config.endpoint}"` : "undefined";
+	const fetchImport = ctx.config?.fetchImport;
+	return `
+function(options${url$1 ? "?" : ""}: ClientOptions): Client {
+  return createClientOriginal({
+      url: ${url$1},
+      ${fetchImport ? `fetch,` : ""}
+      ...options,
+      queryRoot: typeMap.Query!,
+      mutationRoot: typeMap.Mutation!,
+      subscriptionRoot: typeMap.Subscription!,
+  }) as any
+}`;
+};
+const renderClientEsm = (schema, ctx) => {
+	const queryType = schema.getQueryType();
+	const mutationType = schema.getMutationType();
+	const subscriptionType = schema.getSubscriptionType();
+	const fetchImport = ctx.config?.fetchImport || "";
+	ctx.addCodeBlock(`
+${fetchImport}
+${renderClientTypesImports({
+		mutationType,
+		queryType,
+		subscriptionType
+	})}
+  import {
+      linkTypeMap,
+      createClient as createClientOriginal,
+      generateGraphqlOperation,
+      type FieldsSelection, type GraphqlOperation, type ClientOptions, GenqlError
+  } from '${RUNTIME_LIB_NAME}'
+  export type { FieldsSelection } from '${RUNTIME_LIB_NAME}'
+  export { GenqlError }
+
+  import types from './types'
+  export * from './schema'
+  const typeMap = linkTypeMap(types as any)
+
+  ${renderClientType({
+		mutationType,
+		queryType,
+		subscriptionType
+	})}
+
+  export const createClient = ${renderClientCode(ctx)}
+
+  export const everything = {
+    __scalar: true
+  }
+  `);
+	if (queryType) ctx.addCodeBlock(`
+        export type QueryResult<fields extends ${requestTypeName(queryType)}> = FieldsSelection<${queryType.name}, fields>
+        export const generateQueryOp: (fields: ${requestTypeName(queryType)} & { __name?: string }) => GraphqlOperation = function(fields) {
+        return generateGraphqlOperation('query', typeMap.Query!, fields as any)
+      }
+    `);
+	if (mutationType) ctx.addCodeBlock(`
+        export type MutationResult<fields extends ${requestTypeName(mutationType)}> = FieldsSelection<${mutationType.name}, fields>
+        export const generateMutationOp: (fields: ${requestTypeName(mutationType)} & { __name?: string }) => GraphqlOperation = function(fields) {
+        return generateGraphqlOperation('mutation', typeMap.Mutation!, fields as any)
+      }
+    `);
+	if (subscriptionType) ctx.addCodeBlock(`
+        export type SubscriptionResult<fields extends ${requestTypeName(subscriptionType)}> = FieldsSelection<${subscriptionType.name}, fields>
+        export const generateSubscriptionOp: (fields: ${requestTypeName(subscriptionType)} & { __name?: string }) => GraphqlOperation = function(fields) {
+        return generateGraphqlOperation('subscription', typeMap.Subscription!, fields as any)
+      }
+    `);
+};
+function renderClientTypesImports({ queryType, mutationType, subscriptionType }) {
+	const imports = [];
+	if (queryType) imports.push(requestTypeName(queryType), queryType.name);
+	if (mutationType) imports.push(requestTypeName(mutationType), mutationType.name);
+	if (subscriptionType) imports.push(requestTypeName(subscriptionType), subscriptionType.name);
+	if (imports.length > 0) return `import type {${imports.join(",")}} from './schema'`;
+	return "";
+}
+function renderClientType({ queryType, mutationType, subscriptionType }) {
+	let interfaceContent = "";
+	if (queryType) interfaceContent += `
+      query<R extends ${requestTypeName(queryType)}>(
+          request: R & { __name?: string },
+      ): Promise<FieldsSelection<${queryType.name}, R>>
+      `;
+	if (mutationType) interfaceContent += `
+      mutation<R extends ${requestTypeName(mutationType)}>(
+          request: R & { __name?: string },
+      ): Promise<FieldsSelection<${mutationType.name}, R>>
+      `;
+	return `
+  export interface Client {
+      ${interfaceContent}
+  }
+  `;
+}
+
+//#endregion
+//#region src/render/common/excludedTypes.ts
+const excludedTypes = [
+	"__Schema",
+	"__Type",
+	"__TypeKind",
+	"__Field",
+	"__InputValue",
+	"__EnumValue",
+	"__Directive",
+	"__DirectiveLocation"
+];
+
+//#endregion
+//#region src/helpers/prettify.ts
+function prettify(code, parser) {
+	const hasPrettier = import.meta.resolve("prettier");
+	if (parser === "skip" || !hasPrettier) return code;
+	return new Promise(async (resolve$2, reject) => {
+		try {
+			const prettier = await import("prettier/standalone.js").then(({ default: mod }) => mod);
+			const parserTS = await import("prettier/plugins/typescript.js").then(({ default: mod }) => mod);
+			const parserEstree = await import("prettier/plugins/estree.js").then(({ default: mod }) => mod);
+			const parserGraphQL = await import("prettier/plugins/graphql.js").then(({ default: mod }) => mod);
+			resolve$2(await prettier.format(code, {
+				parser,
+				plugins: [
+					parserGraphQL,
+					parserTS,
+					parserEstree
+				],
+				semi: false,
+				singleQuote: true,
+				trailingComma: "all",
+				printWidth: 80
+			}));
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+//#endregion
+//#region src/render/common/relativeImportPath.ts
+const relativeImportPath = (from, to) => {
+	const fromResolved = path$1.relative(from, to);
+	return fromResolved[0] === "." ? fromResolved : `./${fromResolved}`;
+};
+
+//#endregion
+//#region src/render/common/RenderContext.ts
+var RenderContext = class {
+	codeBlocks = [];
+	imports = {};
+	importAliasCounter = 0;
+	constructor(schema, config) {
+		this.schema = schema;
+		this.config = config;
+	}
+	addCodeBlock(block) {
+		if (block) this.codeBlocks.push(block);
+	}
+	addImport(from, isDefault, module$1, fromAbsolute, noAlias) {
+		if (this.config && this.config.output) from = fromAbsolute ? from : relativeImportPath(this.config.output, from);
+		if (!this.imports[from]) this.imports[from] = [];
+		const imports = this.imports[from];
+		const existing = imports.find((i) => isDefault && i.isDefault || !isDefault && i.module === module$1);
+		if (existing) return existing.alias;
+		this.importAliasCounter++;
+		const alias = noAlias ? void 0 : `a${this.importAliasCounter}`;
+		imports.push({
+			isDefault,
+			module: module$1,
+			alias
+		});
+		return alias;
+	}
+	getImportBlock() {
+		const imports = [];
+		Object.keys(this.imports).forEach((from) => {
+			let defaultImport = this.imports[from].find((i) => i.isDefault);
+			const namedImports = this.imports[from].filter((i) => !i.isDefault);
+			const statements = [];
+			if (defaultImport) statements.push(defaultImport.alias || "");
+			if (namedImports.length > 0) statements.push(`{${namedImports.map((i) => i.alias ? `${i.module} as ${i.alias}` : i.module).join(",")}}`);
+			imports.push(`import ${statements.join(",")} from '${from}'`);
+		});
+		if (imports.length > 0) return imports.join("\n");
+		else return;
+	}
+	toCode(parser, pretty = false) {
+		const blocks = [...this.codeBlocks];
+		if (parser && (parser === "typescript" || parser === "babel")) {
+			const importBlock = this.getImportBlock();
+			if (importBlock) blocks.unshift(importBlock);
+		}
+		if (parser) {
+			const whiteSpaced = blocks.join("\n\n");
+			if (pretty && parser !== "skip") return prettify(whiteSpaced, parser);
+			return whiteSpaced;
+		}
+		return blocks.join("");
+	}
+};
+
+//#endregion
+//#region src/render/common/comment.ts
+const comment = (comment$1) => {
+	const lines = [];
+	if (comment$1.deprecated) lines.push(`@deprecated ${comment$1.deprecated.replace(/\s/g, " ")}`);
+	if (comment$1.text) lines.push(...comment$1.text.split("\n"));
+	return lines.length > 0 ? lines.length === 1 ? `\n/** ${lines[0]} */\n` : `\n/**\n${lines.map((l) => ` * ${l}`).join("\n")}\n */\n` : "";
+};
+const typeComment = (type) => comment({ text: type.description });
+const fieldComment = (field) => comment({
+	deprecated: field.deprecationReason,
+	text: field.description
+});
+const argumentComment = (arg) => comment({ text: arg.description });
+
+//#endregion
+//#region src/render/common/renderTyping.ts
+const renderTyping = (type, nonNull = false, wrap = (x) => x) => {
+	if (isNamedType(type)) {
+		let typeName = type.name;
+		if (isScalarType(type)) typeName = `Scalars['${typeName}']`;
+		const typing = wrap(typeName);
+		return nonNull ? typing : `(${typing} | null)`;
+	}
+	if (isListType(type)) {
+		const typing = `${renderTyping(type.ofType, false, wrap)}[]`;
+		return nonNull ? typing : `(${typing} | null)`;
+	}
+	return renderTyping(type.ofType, true, wrap);
+};
+
+//#endregion
+//#region src/render/common/support.ts
+function sortKeys(obj) {
+	obj = obj || {};
+	const ordered = {};
+	Object.keys(obj).sort().forEach(function(key) {
+		ordered[key] = obj[key];
+	});
+	return ordered;
+}
+
+//#endregion
+//#region src/render/requestTypes/inputObjectType.ts
+const inputObjectType = (type, ctx) => {
+	let fields = type.getFields();
+	if (ctx.config?.sortProperties) fields = sortKeys(fields);
+	const fieldStrings = Object.keys(fields).map((fieldName) => {
+		const field = fields[fieldName];
+		return `${argumentComment(field)}${field.name}${isNonNullType(field.type) && field.defaultValue == null ? ":" : "?:"} ${renderTyping(field.type)}`;
+	});
+	ctx.addCodeBlock(`${typeComment(type)}export interface ${type.name} {${fieldStrings.join(",")}}`);
+};
+
+//#endregion
+//#region src/render/requestTypes/objectType.ts
+const INDENTATION$1 = "    ";
+const objectType$2 = (type, ctx) => {
+	let fields = type.getFields();
+	if (ctx.config?.sortProperties) fields = sortKeys(fields);
+	let fieldStrings = Object.keys(fields).map((fieldName) => {
+		const field = fields[fieldName];
+		const types = [];
+		const resolvedType = getNamedType(field.type);
+		const resolvable = !(isEnumType(resolvedType) || isScalarType(resolvedType));
+		const argsPresent = field.args.length > 0;
+		const argsString = toArgsString(field);
+		const argsOptional = !argsString.match(/[^?]:/);
+		if (argsPresent) if (resolvable) types.push(`(${requestTypeName(resolvedType)} & { __args${argsOptional ? "?" : ""}: ${argsString} })`);
+		else types.push(`{ __args: ${argsString} }`);
+		if (argsOptional && !resolvable) types.push("boolean | number");
+		if (!argsPresent && resolvable) types.push(requestTypeName(resolvedType));
+		return `${fieldComment(field)}${field.name}?: ${types.join(" | ")}`;
+	});
+	if (isInterfaceType(type) && ctx.schema) {
+		let interfaceProperties = ctx.schema.getPossibleTypes(type).map((t) => `on_${t.name}?: ${requestTypeName(t)}`);
+		if (ctx.config?.sortProperties) interfaceProperties = interfaceProperties.sort();
+		fieldStrings = fieldStrings.concat(interfaceProperties);
+	}
+	fieldStrings.push("__typename?: boolean | number");
+	fieldStrings.push("__scalar?: boolean | number");
+	fieldStrings = fieldStrings.map((x) => x.split("\n").filter(Boolean).map((l) => INDENTATION$1 + l).join("\n"));
+	ctx.addCodeBlock(`${typeComment(type)}export interface ${requestTypeName(type)}{\n${fieldStrings.join("\n")}\n}`);
+};
+const toArgsString = (field) => {
+	return `{${field.args.map((a) => `${argumentComment(a)}${a.name}${isNonNullType(a.type) && a.defaultValue == null ? ":" : "?:"} ${renderTyping(a.type)}`).join(", ")}}`;
+};
+
+//#endregion
+//#region node_modules/lodash-es/isObject.js
+/**
+* Checks if `value` is the
+* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+* @example
+*
+* _.isObject({});
+* // => true
+*
+* _.isObject([1, 2, 3]);
+* // => true
+*
+* _.isObject(_.noop);
+* // => true
+*
+* _.isObject(null);
+* // => false
+*/
+function isObject(value) {
+	var type = typeof value;
+	return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+//#endregion
+//#region node_modules/lodash-es/isFunction.js
+/** `Object#toString` result references. */
+var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+/**
+* Checks if `value` is classified as a `Function` object.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+* @example
+*
+* _.isFunction(_);
+* // => true
+*
+* _.isFunction(/abc/);
+* // => false
+*/
+function isFunction(value) {
+	if (!isObject_default(value)) return false;
+	var tag = _baseGetTag_default(value);
+	return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+//#endregion
+//#region node_modules/lodash-es/_coreJsData.js
+/** Used to detect overreaching core-js shims. */
+var coreJsData = _root_default["__core-js_shared__"];
+var _coreJsData_default = coreJsData;
+
+//#endregion
+//#region node_modules/lodash-es/_isMasked.js
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = function() {
+	var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
+	return uid ? "Symbol(src)_1." + uid : "";
+}();
+/**
+* Checks if `func` has its source masked.
+*
+* @private
+* @param {Function} func The function to check.
+* @returns {boolean} Returns `true` if `func` is masked, else `false`.
+*/
+function isMasked(func) {
+	return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked_default = isMasked;
+
+//#endregion
+//#region node_modules/lodash-es/_toSource.js
+/** Used to resolve the decompiled source of functions. */
+var funcToString$1 = Function.prototype.toString;
+/**
+* Converts `func` to its source code.
+*
+* @private
+* @param {Function} func The function to convert.
+* @returns {string} Returns the source code.
+*/
+function toSource(func) {
+	if (func != null) {
+		try {
+			return funcToString$1.call(func);
+		} catch (e) {}
+		try {
+			return func + "";
+		} catch (e) {}
+	}
+	return "";
+}
+var _toSource_default = toSource;
+
+//#endregion
+//#region node_modules/lodash-es/_baseIsNative.js
+/**
+* Used to match `RegExp`
+* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+*/
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+/** Used for built-in method references. */
+var funcProto = Function.prototype, objectProto = Object.prototype;
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = objectProto.hasOwnProperty;
+/** Used to detect if a method is native. */
+var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty$2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+/**
+* The base implementation of `_.isNative` without bad shim checks.
+*
+* @private
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a native function,
+*  else `false`.
+*/
+function baseIsNative(value) {
+	if (!isObject_default(value) || _isMasked_default(value)) return false;
+	return (isFunction_default(value) ? reIsNative : reIsHostCtor).test(_toSource_default(value));
+}
+var _baseIsNative_default = baseIsNative;
+
+//#endregion
+//#region node_modules/lodash-es/_getValue.js
+/**
+* Gets the value at `key` of `object`.
+*
+* @private
+* @param {Object} [object] The object to query.
+* @param {string} key The key of the property to get.
+* @returns {*} Returns the property value.
+*/
+function getValue(object, key) {
+	return object == null ? void 0 : object[key];
+}
+var _getValue_default = getValue;
+
+//#endregion
+//#region node_modules/lodash-es/_getNative.js
+/**
+* Gets the native function at `key` of `object`.
+*
+* @private
+* @param {Object} object The object to query.
+* @param {string} key The key of the method to get.
+* @returns {*} Returns the function if it's native, else `undefined`.
+*/
+function getNative(object, key) {
+	var value = _getValue_default(object, key);
+	return _baseIsNative_default(value) ? value : void 0;
+}
+var _getNative_default = getNative;
+
+//#endregion
+//#region node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = _getNative_default(Object, "create");
+var _nativeCreate_default = nativeCreate;
+
+//#endregion
+//#region node_modules/lodash-es/_hashClear.js
+/**
+* Removes all key-value entries from the hash.
+*
+* @private
+* @name clear
+* @memberOf Hash
+*/
+function hashClear() {
+	this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
+	this.size = 0;
+}
+var _hashClear_default = hashClear;
+
+//#endregion
+//#region node_modules/lodash-es/_hashDelete.js
+/**
+* Removes `key` and its value from the hash.
+*
+* @private
+* @name delete
+* @memberOf Hash
+* @param {Object} hash The hash to modify.
+* @param {string} key The key of the value to remove.
+* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+*/
+function hashDelete(key) {
+	var result = this.has(key) && delete this.__data__[key];
+	this.size -= result ? 1 : 0;
+	return result;
+}
+var _hashDelete_default = hashDelete;
+
+//#endregion
+//#region node_modules/lodash-es/_hashGet.js
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+/**
+* Gets the hash value for `key`.
+*
+* @private
+* @name get
+* @memberOf Hash
+* @param {string} key The key of the value to get.
+* @returns {*} Returns the entry value.
+*/
+function hashGet(key) {
+	var data = this.__data__;
+	if (_nativeCreate_default) {
+		var result = data[key];
+		return result === HASH_UNDEFINED$2 ? void 0 : result;
+	}
+	return hasOwnProperty$1.call(data, key) ? data[key] : void 0;
+}
+var _hashGet_default = hashGet;
+
+//#endregion
+//#region node_modules/lodash-es/_hashHas.js
+/** Used to check objects for own properties. */
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+/**
+* Checks if a hash value for `key` exists.
+*
+* @private
+* @name has
+* @memberOf Hash
+* @param {string} key The key of the entry to check.
+* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+*/
+function hashHas(key) {
+	var data = this.__data__;
+	return _nativeCreate_default ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+}
+var _hashHas_default = hashHas;
+
+//#endregion
+//#region node_modules/lodash-es/_hashSet.js
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+/**
+* Sets the hash `key` to `value`.
+*
+* @private
+* @name set
+* @memberOf Hash
+* @param {string} key The key of the value to set.
+* @param {*} value The value to set.
+* @returns {Object} Returns the hash instance.
+*/
+function hashSet(key, value) {
+	var data = this.__data__;
+	this.size += this.has(key) ? 0 : 1;
+	data[key] = _nativeCreate_default && value === void 0 ? HASH_UNDEFINED$1 : value;
+	return this;
+}
+var _hashSet_default = hashSet;
+
+//#endregion
+//#region node_modules/lodash-es/_Hash.js
+/**
+* Creates a hash object.
+*
+* @private
+* @constructor
+* @param {Array} [entries] The key-value pairs to cache.
+*/
+function Hash(entries) {
+	var index = -1, length = entries == null ? 0 : entries.length;
+	this.clear();
+	while (++index < length) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+Hash.prototype.clear = _hashClear_default;
+Hash.prototype["delete"] = _hashDelete_default;
+Hash.prototype.get = _hashGet_default;
+Hash.prototype.has = _hashHas_default;
+Hash.prototype.set = _hashSet_default;
+var _Hash_default = Hash;
+
+//#endregion
+//#region node_modules/lodash-es/_listCacheClear.js
+/**
+* Removes all key-value entries from the list cache.
+*
+* @private
+* @name clear
+* @memberOf ListCache
+*/
+function listCacheClear() {
+	this.__data__ = [];
+	this.size = 0;
+}
+var _listCacheClear_default = listCacheClear;
+
+//#endregion
+//#region node_modules/lodash-es/eq.js
+/**
+* Performs a
+* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+* comparison between two values to determine if they are equivalent.
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to compare.
+* @param {*} other The other value to compare.
+* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+* @example
+*
+* var object = { 'a': 1 };
+* var other = { 'a': 1 };
+*
+* _.eq(object, object);
+* // => true
+*
+* _.eq(object, other);
+* // => false
+*
+* _.eq('a', 'a');
+* // => true
+*
+* _.eq('a', Object('a'));
+* // => false
+*
+* _.eq(NaN, NaN);
+* // => true
+*/
+function eq(value, other) {
+	return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+//#endregion
+//#region node_modules/lodash-es/_assocIndexOf.js
+/**
+* Gets the index at which the `key` is found in `array` of key-value pairs.
+*
+* @private
+* @param {Array} array The array to inspect.
+* @param {*} key The key to search for.
+* @returns {number} Returns the index of the matched value, else `-1`.
+*/
+function assocIndexOf(array, key) {
+	var length = array.length;
+	while (length--) if (eq_default(array[length][0], key)) return length;
+	return -1;
+}
+var _assocIndexOf_default = assocIndexOf;
+
+//#endregion
+//#region node_modules/lodash-es/_listCacheDelete.js
+/** Built-in value references. */
+var splice = Array.prototype.splice;
+/**
+* Removes `key` and its value from the list cache.
+*
+* @private
+* @name delete
+* @memberOf ListCache
+* @param {string} key The key of the value to remove.
+* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+*/
+function listCacheDelete(key) {
+	var data = this.__data__, index = _assocIndexOf_default(data, key);
+	if (index < 0) return false;
+	if (index == data.length - 1) data.pop();
+	else splice.call(data, index, 1);
+	--this.size;
+	return true;
+}
+var _listCacheDelete_default = listCacheDelete;
+
+//#endregion
+//#region node_modules/lodash-es/_listCacheGet.js
+/**
+* Gets the list cache value for `key`.
+*
+* @private
+* @name get
+* @memberOf ListCache
+* @param {string} key The key of the value to get.
+* @returns {*} Returns the entry value.
+*/
+function listCacheGet(key) {
+	var data = this.__data__, index = _assocIndexOf_default(data, key);
+	return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet_default = listCacheGet;
+
+//#endregion
+//#region node_modules/lodash-es/_listCacheHas.js
+/**
+* Checks if a list cache value for `key` exists.
+*
+* @private
+* @name has
+* @memberOf ListCache
+* @param {string} key The key of the entry to check.
+* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+*/
+function listCacheHas(key) {
+	return _assocIndexOf_default(this.__data__, key) > -1;
+}
+var _listCacheHas_default = listCacheHas;
+
+//#endregion
+//#region node_modules/lodash-es/_listCacheSet.js
+/**
+* Sets the list cache `key` to `value`.
+*
+* @private
+* @name set
+* @memberOf ListCache
+* @param {string} key The key of the value to set.
+* @param {*} value The value to set.
+* @returns {Object} Returns the list cache instance.
+*/
+function listCacheSet(key, value) {
+	var data = this.__data__, index = _assocIndexOf_default(data, key);
+	if (index < 0) {
+		++this.size;
+		data.push([key, value]);
+	} else data[index][1] = value;
+	return this;
+}
+var _listCacheSet_default = listCacheSet;
+
+//#endregion
+//#region node_modules/lodash-es/_ListCache.js
+/**
+* Creates an list cache object.
+*
+* @private
+* @constructor
+* @param {Array} [entries] The key-value pairs to cache.
+*/
+function ListCache(entries) {
+	var index = -1, length = entries == null ? 0 : entries.length;
+	this.clear();
+	while (++index < length) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+ListCache.prototype.clear = _listCacheClear_default;
+ListCache.prototype["delete"] = _listCacheDelete_default;
+ListCache.prototype.get = _listCacheGet_default;
+ListCache.prototype.has = _listCacheHas_default;
+ListCache.prototype.set = _listCacheSet_default;
+var _ListCache_default = ListCache;
+
+//#endregion
+//#region node_modules/lodash-es/_Map.js
+var Map$1 = _getNative_default(_root_default, "Map");
+var _Map_default = Map$1;
+
+//#endregion
+//#region node_modules/lodash-es/_mapCacheClear.js
+/**
+* Removes all key-value entries from the map.
+*
+* @private
+* @name clear
+* @memberOf MapCache
+*/
+function mapCacheClear() {
+	this.size = 0;
+	this.__data__ = {
+		"hash": new _Hash_default(),
+		"map": new (_Map_default || _ListCache_default)(),
+		"string": new _Hash_default()
+	};
+}
+var _mapCacheClear_default = mapCacheClear;
+
+//#endregion
+//#region node_modules/lodash-es/_isKeyable.js
+/**
+* Checks if `value` is suitable for use as unique object key.
+*
+* @private
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+*/
+function isKeyable(value) {
+	var type = typeof value;
+	return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable_default = isKeyable;
+
+//#endregion
+//#region node_modules/lodash-es/_getMapData.js
+/**
+* Gets the data for `map`.
+*
+* @private
+* @param {Object} map The map to query.
+* @param {string} key The reference key.
+* @returns {*} Returns the map data.
+*/
+function getMapData(map, key) {
+	var data = map.__data__;
+	return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData_default = getMapData;
+
+//#endregion
+//#region node_modules/lodash-es/_mapCacheDelete.js
+/**
+* Removes `key` and its value from the map.
+*
+* @private
+* @name delete
+* @memberOf MapCache
+* @param {string} key The key of the value to remove.
+* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+*/
+function mapCacheDelete(key) {
+	var result = _getMapData_default(this, key)["delete"](key);
+	this.size -= result ? 1 : 0;
+	return result;
+}
+var _mapCacheDelete_default = mapCacheDelete;
+
+//#endregion
+//#region node_modules/lodash-es/_mapCacheGet.js
+/**
+* Gets the map value for `key`.
+*
+* @private
+* @name get
+* @memberOf MapCache
+* @param {string} key The key of the value to get.
+* @returns {*} Returns the entry value.
+*/
+function mapCacheGet(key) {
+	return _getMapData_default(this, key).get(key);
+}
+var _mapCacheGet_default = mapCacheGet;
+
+//#endregion
+//#region node_modules/lodash-es/_mapCacheHas.js
+/**
+* Checks if a map value for `key` exists.
+*
+* @private
+* @name has
+* @memberOf MapCache
+* @param {string} key The key of the entry to check.
+* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+*/
+function mapCacheHas(key) {
+	return _getMapData_default(this, key).has(key);
+}
+var _mapCacheHas_default = mapCacheHas;
+
+//#endregion
+//#region node_modules/lodash-es/_mapCacheSet.js
+/**
+* Sets the map `key` to `value`.
+*
+* @private
+* @name set
+* @memberOf MapCache
+* @param {string} key The key of the value to set.
+* @param {*} value The value to set.
+* @returns {Object} Returns the map cache instance.
+*/
+function mapCacheSet(key, value) {
+	var data = _getMapData_default(this, key), size = data.size;
+	data.set(key, value);
+	this.size += data.size == size ? 0 : 1;
+	return this;
+}
+var _mapCacheSet_default = mapCacheSet;
+
+//#endregion
+//#region node_modules/lodash-es/_MapCache.js
+/**
+* Creates a map cache object to store key-value pairs.
+*
+* @private
+* @constructor
+* @param {Array} [entries] The key-value pairs to cache.
+*/
+function MapCache(entries) {
+	var index = -1, length = entries == null ? 0 : entries.length;
+	this.clear();
+	while (++index < length) {
+		var entry = entries[index];
+		this.set(entry[0], entry[1]);
+	}
+}
+MapCache.prototype.clear = _mapCacheClear_default;
+MapCache.prototype["delete"] = _mapCacheDelete_default;
+MapCache.prototype.get = _mapCacheGet_default;
+MapCache.prototype.has = _mapCacheHas_default;
+MapCache.prototype.set = _mapCacheSet_default;
+var _MapCache_default = MapCache;
+
+//#endregion
+//#region node_modules/lodash-es/_setCacheAdd.js
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+/**
+* Adds `value` to the array cache.
+*
+* @private
+* @name add
+* @memberOf SetCache
+* @alias push
+* @param {*} value The value to cache.
+* @returns {Object} Returns the cache instance.
+*/
+function setCacheAdd(value) {
+	this.__data__.set(value, HASH_UNDEFINED);
+	return this;
+}
+var _setCacheAdd_default = setCacheAdd;
+
+//#endregion
+//#region node_modules/lodash-es/_setCacheHas.js
+/**
+* Checks if `value` is in the array cache.
+*
+* @private
+* @name has
+* @memberOf SetCache
+* @param {*} value The value to search for.
+* @returns {number} Returns `true` if `value` is found, else `false`.
+*/
+function setCacheHas(value) {
+	return this.__data__.has(value);
+}
+var _setCacheHas_default = setCacheHas;
+
+//#endregion
+//#region node_modules/lodash-es/_SetCache.js
+/**
+*
+* Creates an array cache object to store unique values.
+*
+* @private
+* @constructor
+* @param {Array} [values] The values to cache.
+*/
+function SetCache(values) {
+	var index = -1, length = values == null ? 0 : values.length;
+	this.__data__ = new _MapCache_default();
+	while (++index < length) this.add(values[index]);
+}
+SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd_default;
+SetCache.prototype.has = _setCacheHas_default;
+var _SetCache_default = SetCache;
+
+//#endregion
+//#region node_modules/lodash-es/_baseFindIndex.js
+/**
+* The base implementation of `_.findIndex` and `_.findLastIndex` without
+* support for iteratee shorthands.
+*
+* @private
+* @param {Array} array The array to inspect.
+* @param {Function} predicate The function invoked per iteration.
+* @param {number} fromIndex The index to search from.
+* @param {boolean} [fromRight] Specify iterating from right to left.
+* @returns {number} Returns the index of the matched value, else `-1`.
+*/
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+	var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+	while (fromRight ? index-- : ++index < length) if (predicate(array[index], index, array)) return index;
+	return -1;
+}
+var _baseFindIndex_default = baseFindIndex;
+
+//#endregion
+//#region node_modules/lodash-es/_baseIsNaN.js
+/**
+* The base implementation of `_.isNaN` without support for number objects.
+*
+* @private
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+*/
+function baseIsNaN(value) {
+	return value !== value;
+}
+var _baseIsNaN_default = baseIsNaN;
+
+//#endregion
+//#region node_modules/lodash-es/_strictIndexOf.js
+/**
+* A specialized version of `_.indexOf` which performs strict equality
+* comparisons of values, i.e. `===`.
+*
+* @private
+* @param {Array} array The array to inspect.
+* @param {*} value The value to search for.
+* @param {number} fromIndex The index to search from.
+* @returns {number} Returns the index of the matched value, else `-1`.
+*/
+function strictIndexOf(array, value, fromIndex) {
+	var index = fromIndex - 1, length = array.length;
+	while (++index < length) if (array[index] === value) return index;
+	return -1;
+}
+var _strictIndexOf_default = strictIndexOf;
+
+//#endregion
+//#region node_modules/lodash-es/_baseIndexOf.js
+/**
+* The base implementation of `_.indexOf` without `fromIndex` bounds checks.
+*
+* @private
+* @param {Array} array The array to inspect.
+* @param {*} value The value to search for.
+* @param {number} fromIndex The index to search from.
+* @returns {number} Returns the index of the matched value, else `-1`.
+*/
+function baseIndexOf(array, value, fromIndex) {
+	return value === value ? _strictIndexOf_default(array, value, fromIndex) : _baseFindIndex_default(array, _baseIsNaN_default, fromIndex);
+}
+var _baseIndexOf_default = baseIndexOf;
+
+//#endregion
+//#region node_modules/lodash-es/_arrayIncludes.js
+/**
+* A specialized version of `_.includes` for arrays without support for
+* specifying an index to search from.
+*
+* @private
+* @param {Array} [array] The array to inspect.
+* @param {*} target The value to search for.
+* @returns {boolean} Returns `true` if `target` is found, else `false`.
+*/
+function arrayIncludes(array, value) {
+	return !!(array == null ? 0 : array.length) && _baseIndexOf_default(array, value, 0) > -1;
+}
+var _arrayIncludes_default = arrayIncludes;
+
+//#endregion
+//#region node_modules/lodash-es/_arrayIncludesWith.js
+/**
+* This function is like `arrayIncludes` except that it accepts a comparator.
+*
+* @private
+* @param {Array} [array] The array to inspect.
+* @param {*} target The value to search for.
+* @param {Function} comparator The comparator invoked per element.
+* @returns {boolean} Returns `true` if `target` is found, else `false`.
+*/
+function arrayIncludesWith(array, value, comparator) {
+	var index = -1, length = array == null ? 0 : array.length;
+	while (++index < length) if (comparator(value, array[index])) return true;
+	return false;
+}
+var _arrayIncludesWith_default = arrayIncludesWith;
+
+//#endregion
+//#region node_modules/lodash-es/_cacheHas.js
+/**
+* Checks if a `cache` value for `key` exists.
+*
+* @private
+* @param {Object} cache The cache to query.
+* @param {string} key The key of the entry to check.
+* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+*/
+function cacheHas(cache, key) {
+	return cache.has(key);
+}
+var _cacheHas_default = cacheHas;
+
+//#endregion
+//#region node_modules/lodash-es/_Set.js
+var Set$1 = _getNative_default(_root_default, "Set");
+var _Set_default = Set$1;
+
+//#endregion
+//#region node_modules/lodash-es/noop.js
+/**
+* This method returns `undefined`.
+*
+* @static
+* @memberOf _
+* @since 2.3.0
+* @category Util
+* @example
+*
+* _.times(2, _.noop);
+* // => [undefined, undefined]
+*/
+function noop() {}
+var noop_default = noop;
+
+//#endregion
+//#region node_modules/lodash-es/_setToArray.js
+/**
+* Converts `set` to an array of its values.
+*
+* @private
+* @param {Object} set The set to convert.
+* @returns {Array} Returns the values.
+*/
+function setToArray(set) {
+	var index = -1, result = Array(set.size);
+	set.forEach(function(value) {
+		result[++index] = value;
+	});
+	return result;
+}
+var _setToArray_default = setToArray;
+
+//#endregion
+//#region node_modules/lodash-es/_createSet.js
+/**
+* Creates a set object of `values`.
+*
+* @private
+* @param {Array} values The values to add to the set.
+* @returns {Object} Returns the new set.
+*/
+var createSet = !(_Set_default && 1 / _setToArray_default(new _Set_default([, -0]))[1] == Infinity) ? noop_default : function(values) {
+	return new _Set_default(values);
+};
+var _createSet_default = createSet;
+
+//#endregion
+//#region node_modules/lodash-es/_baseUniq.js
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+/**
+* The base implementation of `_.uniqBy` without support for iteratee shorthands.
+*
+* @private
+* @param {Array} array The array to inspect.
+* @param {Function} [iteratee] The iteratee invoked per element.
+* @param {Function} [comparator] The comparator invoked per element.
+* @returns {Array} Returns the new duplicate free array.
+*/
+function baseUniq(array, iteratee, comparator) {
+	var index = -1, includes = _arrayIncludes_default, length = array.length, isCommon = true, result = [], seen = result;
+	if (comparator) {
+		isCommon = false;
+		includes = _arrayIncludesWith_default;
+	} else if (length >= LARGE_ARRAY_SIZE) {
+		var set = iteratee ? null : _createSet_default(array);
+		if (set) return _setToArray_default(set);
+		isCommon = false;
+		includes = _cacheHas_default;
+		seen = new _SetCache_default();
+	} else seen = iteratee ? [] : result;
+	outer: while (++index < length) {
+		var value = array[index], computed = iteratee ? iteratee(value) : value;
+		value = comparator || value !== 0 ? value : 0;
+		if (isCommon && computed === computed) {
+			var seenIndex = seen.length;
+			while (seenIndex--) if (seen[seenIndex] === computed) continue outer;
+			if (iteratee) seen.push(computed);
+			result.push(value);
+		} else if (!includes(seen, computed, comparator)) {
+			if (seen !== result) seen.push(computed);
+			result.push(value);
+		}
+	}
+	return result;
+}
+var _baseUniq_default = baseUniq;
+
+//#endregion
+//#region node_modules/lodash-es/uniq.js
+/**
+* Creates a duplicate-free version of an array, using
+* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+* for equality comparisons, in which only the first occurrence of each element
+* is kept. The order of result values is determined by the order they occur
+* in the array.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Array
+* @param {Array} array The array to inspect.
+* @returns {Array} Returns the new duplicate free array.
+* @example
+*
+* _.uniq([2, 1, 2]);
+* // => [2, 1]
+*/
+function uniq(array) {
+	return array && array.length ? _baseUniq_default(array) : [];
+}
+var uniq_default = uniq;
+
+//#endregion
+//#region src/render/requestTypes/unionType.ts
+const unionType$2 = (type, ctx) => {
+	let types = [...type.getTypes()];
+	if (ctx.config?.sortProperties) types = types.sort();
+	const fieldStrings = types.map((t) => `on_${t.name}?:${requestTypeName(t)}`);
+	const commonInterfaces = uniq_default(types.map((x) => x.getInterfaces()).flat());
+	fieldStrings.push(...commonInterfaces.map((type$1) => {
+		return `on_${type$1.name}?: ${requestTypeName(type$1)}`;
+	}));
+	fieldStrings.push("__typename?: boolean | number");
+	ctx.addCodeBlock(`${typeComment(type)}export interface ${requestTypeName(type)}{\n${fieldStrings.map((x) => "    " + x).join(",\n")}\n}`);
+};
+
+//#endregion
+//#region src/render/requestTypes/renderRequestTypes.ts
+const renderRequestTypes = (schema, ctx) => {
+	let typeMap = schema.getTypeMap();
+	if (ctx.config?.sortProperties) typeMap = sortKeys(typeMap);
+	for (const name in typeMap) {
+		if (excludedTypes.includes(name)) continue;
+		const type = typeMap[name];
+		if (isObjectType(type) || isInterfaceType(type)) objectType$2(type, ctx);
+		if (isInputObjectType(type)) inputObjectType(type, ctx);
+		if (isUnionType(type)) unionType$2(type, ctx);
+	}
+	const aliases = [
+		{
+			type: schema.getQueryType(),
+			name: "QueryGenqlSelection"
+		},
+		{
+			type: schema.getMutationType(),
+			name: "MutationGenqlSelection"
+		},
+		{
+			type: schema.getSubscriptionType(),
+			name: "SubscriptionGenqlSelection"
+		}
+	].map(renderAlias$1).filter(Boolean).join("\n");
+	ctx.addCodeBlock(aliases);
+};
+function renderAlias$1({ type, name }) {
+	if (type && requestTypeName(type) !== name) return `export type ${name} = ${requestTypeName(type)}`;
+	return "";
+}
+
+//#endregion
+//#region src/render/responseTypes/enumType.ts
+const enumType = (type, ctx) => {
+	const values = type.getValues().map((v) => `'${v.name}'`);
+	ctx.addCodeBlock(`${typeComment(type)}export type ${type.name} = ${values.join(" | ")}`);
+};
+
+//#endregion
+//#region src/render/responseTypes/objectType.ts
+const INDENTATION = "    ";
+const objectType$1 = (type, ctx) => {
+	let fieldsMap = type.getFields();
+	if (ctx.config?.sortProperties) fieldsMap = sortKeys(fieldsMap);
+	const fields = Object.keys(fieldsMap).map((fieldName) => fieldsMap[fieldName]);
+	if (!ctx.schema) throw new Error("no schema provided");
+	const typeNames = isObjectType(type) ? [type.name] : ctx.schema.getPossibleTypes(type).map((t) => t.name);
+	let fieldStrings = fields.map((f) => {
+		return `${fieldComment(f)}${f.name}: ${renderTyping(f.type)}`;
+	}).concat([`__typename: ${typeNames.length > 0 ? typeNames.map((t) => `'${t}'`).join("|") : "string"}`]);
+	fieldStrings = fieldStrings.map((x) => x.split("\n").filter(Boolean).map((l) => INDENTATION + l).join("\n"));
+	ctx.addCodeBlock(`${typeComment(type)}export interface ${type.name} {\n${fieldStrings.join("\n")}\n}`);
+};
+
+//#endregion
+//#region src/render/responseTypes/typeMappedAlias.ts
+const knownTypes = {
+	Int: "number",
+	Float: "number",
+	String: "string",
+	Boolean: "boolean",
+	ID: "string"
+};
+const getTypeMappedAlias = (type, ctx) => {
+	return {
+		...knownTypes,
+		...ctx?.config?.scalarTypes || {}
+	}?.[type.name] || "any";
+};
+
+//#endregion
+//#region src/render/responseTypes/scalarType.ts
+function renderScalarTypes(ctx, types) {
+	let content = "";
+	types.forEach((type) => {
+		content += `    ${type.name}: ${getTypeMappedAlias(type, ctx)},\n`;
+	});
+	return `export type Scalars = {\n${content}}`;
+}
+
+//#endregion
+//#region src/render/responseTypes/unionType.ts
+const unionType$1 = (type, ctx) => {
+	let typeNames = type.getTypes().map((t) => t.name);
+	if (ctx.config?.sortProperties) typeNames = typeNames.sort();
+	ctx.addCodeBlock(`${typeComment(type)}export type ${type.name} = (${typeNames.join(" | ")}) & { __isUnion?: true }`);
+};
+
+//#endregion
+//#region src/render/responseTypes/interfaceType.ts
+const interfaceType = (type, ctx) => {
+	if (!ctx.schema) throw new Error("schema is required to render unionType");
+	const typeNames = ctx.schema.getPossibleTypes(type).map((t) => t.name);
+	if (!typeNames.length) objectType$1(type, ctx);
+	else ctx.addCodeBlock(`${typeComment(type)}export type ${type.name} = (${typeNames.join(" | ")}) & { __isUnion?: true }`);
+};
+
+//#endregion
+//#region src/render/responseTypes/renderResponseTypes.ts
+const renderResponseTypes = (schema, ctx) => {
+	let typeMap = schema.getTypeMap();
+	if (ctx.config?.sortProperties) typeMap = sortKeys(typeMap);
+	ctx.addCodeBlock(renderScalarTypes(ctx, Object.values(typeMap).filter((type) => isScalarType(type))));
+	for (const name in typeMap) {
+		if (excludedTypes.includes(name)) continue;
+		const type = typeMap[name];
+		if (isEnumType(type)) enumType(type, ctx);
+		if (isUnionType(type)) unionType$1(type, ctx);
+		if (isObjectType(type)) objectType$1(type, ctx);
+		if (isInterfaceType(type)) interfaceType(type, ctx);
+	}
+	const aliases = [
+		{
+			type: schema.getQueryType(),
+			name: "Query"
+		},
+		{
+			type: schema.getMutationType(),
+			name: "Mutation"
+		},
+		{
+			type: schema.getSubscriptionType(),
+			name: "Subscription"
+		}
+	].map(renderAlias).filter(Boolean).join("\n");
+	ctx.addCodeBlock(aliases);
+};
+function renderAlias({ type, name }) {
+	if (type && type.name !== name) return `export type ${name} = ${type.name}`;
+	return "";
+}
+
+//#endregion
+//#region src/render/schema/renderSchema.ts
+const renderSchema = (schema, ctx) => {
+	ctx.addCodeBlock(printSchema(schema));
+};
+
+//#endregion
+//#region src/render/typeGuards/renderTypeGuards.ts
+const renderTypeGuard = (target, possible) => {
+	return `
+    const ${target}_possibleTypes: string[] = [${possible.map((t) => `'${t}'`).join(",")}]
+    export const is${target} = (obj?: { __typename?: any } | null): obj is ${target} => {
+      if (!obj?.__typename) throw new Error('__typename is missing in "is${target}"')
+      return ${target}_possibleTypes.includes(obj.__typename)
+    }
+    `;
+};
+const renderTypeGuards = (schema, ctx) => {
+	const typeMap = schema.getTypeMap();
+	for (const name in typeMap) {
+		if (excludedTypes.includes(name)) continue;
+		const type = typeMap[name];
+		if (isUnionType(type)) {
+			const types = type.getTypes().map((t) => t.name);
+			ctx.addCodeBlock(renderTypeGuard(type.name, types));
+		} else if (isInterfaceType(type)) {
+			const types = schema.getPossibleTypes(type).map((t) => t.name);
+			ctx.addCodeBlock(renderTypeGuard(type.name, types));
+		} else if (isObjectType(type)) ctx.addCodeBlock(renderTypeGuard(type.name, [type.name]));
+	}
+};
+
+//#endregion
+//#region src/render/typeMap/support.ts
+function isEmpty(x) {
+	if (!x) return true;
+	return Object.keys(x).length === 0;
+}
+
+//#endregion
+//#region src/render/typeMap/objectType.ts
+const objectType = (type, ctx) => {
+	const typeObj = Object.keys(type.getFields()).reduce((r, f) => {
+		const field = type.getFields()[f];
+		const fieldObj = { type: getNamedType(field.type).name };
+		r[f] = fieldObj;
+		const args = field.args || [];
+		if (args.length > 0) fieldObj.args = args.reduce((r$1, a) => {
+			const concreteType = a.type.toString();
+			const typename = getNamedType(a.type).name;
+			r$1[a.name] = [typename];
+			if (typename !== concreteType) r$1[a.name]?.push(concreteType);
+			return r$1;
+		}, {});
+		return r;
+	}, {});
+	if (isInterfaceType(type) && ctx.schema) ctx.schema.getPossibleTypes(type).map((t) => {
+		if (!isEmpty(typeObj)) typeObj[`on_${t.name}`] = { type: t.name };
+	});
+	if (!isEmpty(typeObj)) typeObj.__typename = { type: "String" };
+	return typeObj;
+};
+
+//#endregion
+//#region src/render/typeMap/unionType.ts
+const unionType = (type, _) => {
+	const types = type.getTypes();
+	const typeObj = types.reduce((r, t) => {
+		r[`on_${t.name}`] = { type: t.name };
+		return r;
+	}, {});
+	uniq_default(types.map((x) => x.getInterfaces()).flat()).forEach((t) => {
+		typeObj[`on_${t.name}`] = { type: t.name };
+	});
+	typeObj.__typename = { type: "String" };
+	return typeObj;
+};
+
+//#endregion
+//#region src/render/typeMap/renderTypeMap.ts
+const renderTypeMap = (schema, ctx) => {
+	const result = {
+		scalars: [],
+		types: {}
+	};
+	Object.keys(schema.getTypeMap()).filter((t) => !excludedTypes.includes(t)).map((t) => schema.getTypeMap()[t]).map((t) => {
+		if (isObjectType(t) || isInterfaceType(t) || isInputObjectType(t)) result.types[t.name] = objectType(t, ctx);
+		else if (isUnionType(t)) result.types[t.name] = unionType(t, ctx);
+		else if (isScalarType(t) || isEnumType(t)) {
+			result.scalars.push(t.name);
+			result.types[t.name] = {};
+		}
+	});
+	const q = schema.getQueryType();
+	if (q?.name && q?.name !== "Query") {
+		delete result.types[q.name];
+		result.types.Query = objectType(q, ctx);
+	}
+	const m = schema.getMutationType();
+	if (m?.name && m.name !== "Mutation") {
+		delete result.types[m.name];
+		result.types.Mutation = objectType(m, ctx);
+	}
+	const s = schema.getSubscriptionType();
+	if (s?.name && s.name !== "Subscription") {
+		delete result.types[s.name];
+		result.types.Subscription = objectType(s, ctx);
+	}
+	ctx.addCodeBlock(JSON.stringify(replaceTypeNamesWithIndexes(result), null, 4));
+};
+function replaceTypeNamesWithIndexes(typeMap) {
+	const nameToIndex = Object.assign({}, ...Object.keys(typeMap.types).map((k, i) => ({ [k]: i })));
+	return {
+		scalars: typeMap.scalars.map((x) => nameToIndex[x]),
+		types: Object.assign({}, ...Object.keys(typeMap.types || {}).map((k) => {
+			const fieldsMap = typeMap.types[k] || {};
+			const fields = Object.assign({}, ...Object.keys(fieldsMap).map((f) => {
+				const content = fieldsMap[f];
+				if (!content) throw new Error("no content in field " + f);
+				const [typeName, args] = [content.type, content.args];
+				const res = [typeName ? nameToIndex[typeName] : -1];
+				if (args) res[1] = Object.assign({}, ...Object.keys(args || {}).map((k$1) => {
+					const arg = args?.[k$1];
+					if (!arg) throw new Error("replaceTypeNamesWithIndexes: no arg for " + k$1);
+					return { [k$1]: [nameToIndex[arg[0]], ...arg.slice(1)] };
+				}));
+				return { [f]: res };
+			}));
+			return { [k]: { ...fields } };
+		}))
+	};
+}
+
+//#endregion
+//#region src/tasks/clientTasks.ts
+const typeMapFileEsm = "types.ts";
+const schemaTypesFile = "schema.ts";
+const schemaGqlFile = "schema.graphql";
+const cliRoot = path.dirname(url.fileURLToPath(import.meta.url));
+const runtimeFolderPath = path.resolve(cliRoot, "runtime");
+const clientTasks = (config) => {
+	const clientFileEsm = "index.ts";
+	if (!config.output) throw new Error("`output` must be defined in the config");
+	const output = config.output;
+	const tasks = [
+		{
+			title: `writing ${schemaGqlFile}`,
+			async task(ctx) {
+				const renderCtx = new RenderContext(ctx.schema, config);
+				renderSchema(ctx.schema, renderCtx);
+				await writeFileToPath([output, schemaGqlFile], await renderCtx.toCode("graphql"));
+			}
+		},
+		{
+			title: `copy runtime files`,
+			async task() {
+				const files = await fs.readdir(runtimeFolderPath);
+				const target = path.resolve(output, "runtime");
+				if (!await fs.access(target).then(() => true).catch(() => false)) await fs.mkdir(target, { recursive: true });
+				for (const file of files) {
+					const raw = await fs.readFile(path.resolve(runtimeFolderPath, file), "utf-8");
+					await fs.writeFile(path.resolve(output, "runtime", file), `// @ts-nocheck\n${raw};`, "utf-8");
+				}
+			}
+		},
+		{
+			title: `writing ${schemaTypesFile}`,
+			async task(ctx) {
+				const renderCtx = new RenderContext(ctx.schema, config);
+				renderResponseTypes(ctx.schema, renderCtx);
+				renderRequestTypes(ctx.schema, renderCtx);
+				renderTypeGuards(ctx.schema, renderCtx);
+				renderEnumsMaps(ctx.schema, renderCtx);
+				const code = await renderCtx.toCode("typescript");
+				await writeFileToPath([output, schemaTypesFile], "// @ts-nocheck\n/* istanbul ignore file */\n/* tslint:disable */\n/* eslint-disable */\n\n" + code);
+			}
+		},
+		{
+			title: `writing types map`,
+			async task(ctx) {
+				const renderCtx = new RenderContext(ctx.schema, config);
+				renderTypeMap(ctx.schema, renderCtx);
+				const code = await renderCtx.toCode();
+				await writeFileToPath([output, typeMapFileEsm], `export default ${code}`);
+			}
+		},
+		{
+			title: `writing ${clientFileEsm}`,
+			async task(ctx) {
+				const renderCtx = new RenderContext(ctx.schema, config);
+				renderClientEsm(ctx.schema, renderCtx);
+				const code = await renderCtx.toCode("typescript", true);
+				await writeFileToPath([output, clientFileEsm], "// @ts-nocheck\n" + code);
+			}
+		}
+	];
+	return [{
+		title: "preparing client directory",
+		task: () => ensurePath([output], true)
+	}, {
+		title: `writing files`,
+		task() {
+			return new Listr(tasks.filter((x) => Boolean(x)), { concurrent: true });
+		}
+	}];
+};
+function renderEnumsMaps(schema, ctx) {
+	let typeMap = schema.getTypeMap();
+	const enums = [];
+	for (const name in typeMap) {
+		if (excludedTypes.includes(name)) continue;
+		const type = typeMap[name];
+		if (isEnumType(type)) enums.push(type);
+	}
+	if (enums.length === 0) return;
+	ctx.addCodeBlock(enums.map((type) => `export const ${"enum" + capitalize(camelCase(type.name))} = {\n` + type.getValues().map((v) => {
+		if (!v?.name) return "";
+		return `   ${v.name}: '${v.name}' as const`;
+	}).join(",\n") + `\n}\n`).join("\n"));
+}
+
+//#endregion
+//#region src/schema/fetchSchema.ts
+const fetchSchema = async (queryFetchOptions) => {
+	const { headers, endpoint, usePost = true, timeout = 20 * 1e3, options } = queryFetchOptions;
+	const controller = new AbortController();
+	const id = setTimeout(() => controller.abort(), timeout);
+	const query = new URLSearchParams({ query: getIntrospectionQuery() });
+	const fetchOptions = {
+		signal: controller.signal,
+		headers
+	};
+	if (usePost) {
+		fetchOptions.headers = {
+			...headers,
+			"Content-Type": "application/json"
+		};
+		fetchOptions.method = "POST";
+		fetchOptions.body = JSON.stringify({ query: getIntrospectionQuery() });
+	}
+	const res = await fetch(usePost ? endpoint : `${endpoint}?${query.toString()}`, fetchOptions);
+	clearTimeout(id);
+	if (!res.ok) throw new Error(`Introspection for ${endpoint} failed, ${res.status} ${res.statusText}`);
+	const result = await res.json().catch(() => {
+		const contentType = res.headers.get("Content-Type");
+		throw new Error(`Endpoint '${endpoint}' did not return valid json, content type is ${contentType}, check that your endpoint points to a valid graphql API`);
+	});
+	if (!result.data) throw new Error(`introspection for ${endpoint} failed: ${JSON.stringify(result).slice(0, 400)}...`);
+	return buildClientSchema(result.data, options);
+};
+
+//#endregion
+//#region src/tasks/schemaTask.ts
+const schemaTask = (config) => {
+	const processSchema = (schema) => {
+		if (config.sortProperties) return lexicographicSortSchema(schema);
+		return schema;
+	};
+	if (config.endpoint) {
+		const endpoint = config.endpoint;
+		return {
+			title: `fetching schema using ${config.useGet ? "GET" : "POST"} ${endpoint} and headers ${JSON.stringify(config.headers)}`,
+			task: async (ctx) => {
+				ctx.schema = processSchema(await fetchSchema({
+					endpoint,
+					usePost: !config.useGet,
+					headers: config.headers
+				}));
+			}
+		};
+	} else if (config.schema) {
+		const schema = config.schema;
+		return {
+			title: "loading schema",
+			task: async (ctx) => {
+				ctx.schema = processSchema(await loadSchema(schema, { loaders: [new GraphQLFileLoader()] }));
+				try {
+					assertValidSchema(ctx.schema);
+				} catch (e) {
+					if (e["message"] === "Query root type must be provided.") return;
+					throw e;
+				}
+			}
+		};
+	} else throw new Error("either `endpoint`, `fetcher` or `schema` must be defined in the config");
+};
+
+//#endregion
+//#region src/main.ts
+const generate = (config) => {
+	if (!config.output) throw new Error("`output` must be defined in the config");
+	return new Listr([{
+		title: `generating the client in \`${config.output}\``,
+		task: () => new Listr([schemaTask(config), ...clientTasks(config)])
+	}], {
+		renderer: config.verbose ? "verbose" : "default",
+		exitOnError: true
+	}).run().catch((e) => {
+		throw e?.errors?.[0];
+	});
+};
+
+//#endregion
+export { generate as t };