npm-check-updates/build/cli.js

Find newer versions of dependencies than what your package.json allows

#!/usr/bin/env node
import e, { _ as t, a as n, c as r, d as i, f as a, g as o, h as s, i as c, l, m as u, n as d, o as f, p, r as m, s as h, t as g, u as _, v, y } from "./index.js";
import b from "node:path";
import x from "node:os";
import S from "os";
import C, { env as w } from "node:process";
import { fileURLToPath as T } from "node:url";
import { format as E, promisify as D } from "node:util";
import O from "path";
import k from "node:fs";
import { spawn as ee } from "node:child_process";
//#region node_modules/commander/lib/error.js
var A = /* @__PURE__ */ u(((e) => {
	var t = class extends Error {
		constructor(e, t, n) {
			super(n), Error.captureStackTrace(this, this.constructor), this.name = this.constructor.name, this.code = t, this.exitCode = e, this.nestedError = void 0;
		}
	}, n = class extends t {
		constructor(e) {
			super(1, "commander.invalidArgument", e), Error.captureStackTrace(this, this.constructor), this.name = this.constructor.name;
		}
	};
	e.CommanderError = t, e.InvalidArgumentError = n;
})), te = /* @__PURE__ */ u(((e) => {
	var { InvalidArgumentError: t } = A(), n = class {
		constructor(e, t) {
			switch (this.description = t || "", this.variadic = !1, this.parseArg = void 0, this.defaultValue = void 0, this.defaultValueDescription = void 0, this.argChoices = void 0, e[0]) {
				case "<":
					this.required = !0, this._name = e.slice(1, -1);
					break;
				case "[":
					this.required = !1, this._name = e.slice(1, -1);
					break;
				default:
					this.required = !0, this._name = e;
					break;
			}
			this._name.endsWith("...") && (this.variadic = !0, this._name = this._name.slice(0, -3));
		}
		name() {
			return this._name;
		}
		_collectValue(e, t) {
			return t === this.defaultValue || !Array.isArray(t) ? [e] : (t.push(e), t);
		}
		default(e, t) {
			return this.defaultValue = e, this.defaultValueDescription = t, this;
		}
		argParser(e) {
			return this.parseArg = e, this;
		}
		choices(e) {
			return this.argChoices = e.slice(), this.parseArg = (e, n) => {
				if (!this.argChoices.includes(e)) throw new t(`Allowed choices are ${this.argChoices.join(", ")}.`);
				return this.variadic ? this._collectValue(e, n) : e;
			}, this;
		}
		argRequired() {
			return this.required = !0, this;
		}
		argOptional() {
			return this.required = !1, this;
		}
	};
	function r(e) {
		let t = e.name() + (e.variadic === !0 ? "..." : "");
		return e.required ? "<" + t + ">" : "[" + t + "]";
	}
	e.Argument = n, e.humanReadableArgName = r;
})), ne = /* @__PURE__ */ u(((e) => {
	var { humanReadableArgName: t } = te(), n = class {
		constructor() {
			this.helpWidth = void 0, this.minWidthToWrap = 40, this.sortSubcommands = !1, this.sortOptions = !1, this.showGlobalOptions = !1;
		}
		prepareContext(e) {
			this.helpWidth = this.helpWidth ?? e.helpWidth ?? 80;
		}
		visibleCommands(e) {
			let t = e.commands.filter((e) => !e._hidden), n = e._getHelpCommand();
			return n && !n._hidden && t.push(n), this.sortSubcommands && t.sort((e, t) => e.name().localeCompare(t.name())), t;
		}
		compareOptions(e, t) {
			let n = (e) => e.short ? e.short.replace(/^-/, "") : e.long.replace(/^--/, "");
			return n(e).localeCompare(n(t));
		}
		visibleOptions(e) {
			let t = e.options.filter((e) => !e.hidden), n = e._getHelpOption();
			if (n && !n.hidden) {
				let r = n.short && e._findOption(n.short), i = n.long && e._findOption(n.long);
				!r && !i ? t.push(n) : n.long && !i ? t.push(e.createOption(n.long, n.description)) : n.short && !r && t.push(e.createOption(n.short, n.description));
			}
			return this.sortOptions && t.sort(this.compareOptions), t;
		}
		visibleGlobalOptions(e) {
			if (!this.showGlobalOptions) return [];
			let t = [];
			for (let n = e.parent; n; n = n.parent) {
				let e = n.options.filter((e) => !e.hidden);
				t.push(...e);
			}
			return this.sortOptions && t.sort(this.compareOptions), t;
		}
		visibleArguments(e) {
			return e._argsDescription && e.registeredArguments.forEach((t) => {
				t.description = t.description || e._argsDescription[t.name()] || "";
			}), e.registeredArguments.find((e) => e.description) ? e.registeredArguments : [];
		}
		subcommandTerm(e) {
			let n = e.registeredArguments.map((e) => t(e)).join(" ");
			return e._name + (e._aliases[0] ? "|" + e._aliases[0] : "") + (e.options.length ? " [options]" : "") + (n ? " " + n : "");
		}
		optionTerm(e) {
			return e.flags;
		}
		argumentTerm(e) {
			return e.name();
		}
		longestSubcommandTermLength(e, t) {
			return t.visibleCommands(e).reduce((e, n) => Math.max(e, this.displayWidth(t.styleSubcommandTerm(t.subcommandTerm(n)))), 0);
		}
		longestOptionTermLength(e, t) {
			return t.visibleOptions(e).reduce((e, n) => Math.max(e, this.displayWidth(t.styleOptionTerm(t.optionTerm(n)))), 0);
		}
		longestGlobalOptionTermLength(e, t) {
			return t.visibleGlobalOptions(e).reduce((e, n) => Math.max(e, this.displayWidth(t.styleOptionTerm(t.optionTerm(n)))), 0);
		}
		longestArgumentTermLength(e, t) {
			return t.visibleArguments(e).reduce((e, n) => Math.max(e, this.displayWidth(t.styleArgumentTerm(t.argumentTerm(n)))), 0);
		}
		commandUsage(e) {
			let t = e._name;
			e._aliases[0] && (t = t + "|" + e._aliases[0]);
			let n = "";
			for (let t = e.parent; t; t = t.parent) n = t.name() + " " + n;
			return n + t + " " + e.usage();
		}
		commandDescription(e) {
			return e.description();
		}
		subcommandDescription(e) {
			return e.summary() || e.description();
		}
		optionDescription(e) {
			let t = [];
			if (e.argChoices && t.push(`choices: ${e.argChoices.map((e) => JSON.stringify(e)).join(", ")}`), e.defaultValue !== void 0 && (e.required || e.optional || e.isBoolean() && typeof e.defaultValue == "boolean") && t.push(`default: ${e.defaultValueDescription || JSON.stringify(e.defaultValue)}`), e.presetArg !== void 0 && e.optional && t.push(`preset: ${JSON.stringify(e.presetArg)}`), e.envVar !== void 0 && t.push(`env: ${e.envVar}`), t.length > 0) {
				let n = `(${t.join(", ")})`;
				return e.description ? `${e.description} ${n}` : n;
			}
			return e.description;
		}
		argumentDescription(e) {
			let t = [];
			if (e.argChoices && t.push(`choices: ${e.argChoices.map((e) => JSON.stringify(e)).join(", ")}`), e.defaultValue !== void 0 && t.push(`default: ${e.defaultValueDescription || JSON.stringify(e.defaultValue)}`), t.length > 0) {
				let n = `(${t.join(", ")})`;
				return e.description ? `${e.description} ${n}` : n;
			}
			return e.description;
		}
		formatItemList(e, t, n) {
			return t.length === 0 ? [] : [
				n.styleTitle(e),
				...t,
				""
			];
		}
		groupItems(e, t, n) {
			let r = /* @__PURE__ */ new Map();
			return e.forEach((e) => {
				let t = n(e);
				r.has(t) || r.set(t, []);
			}), t.forEach((e) => {
				let t = n(e);
				r.has(t) || r.set(t, []), r.get(t).push(e);
			}), r;
		}
		formatHelp(e, t) {
			let n = t.padWidth(e, t), r = t.helpWidth ?? 80;
			function i(e, r) {
				return t.formatItem(e, n, r, t);
			}
			let a = [`${t.styleTitle("Usage:")} ${t.styleUsage(t.commandUsage(e))}`, ""], o = t.commandDescription(e);
			o.length > 0 && (a = a.concat([t.boxWrap(t.styleCommandDescription(o), r), ""]));
			let s = t.visibleArguments(e).map((e) => i(t.styleArgumentTerm(t.argumentTerm(e)), t.styleArgumentDescription(t.argumentDescription(e))));
			if (a = a.concat(this.formatItemList("Arguments:", s, t)), this.groupItems(e.options, t.visibleOptions(e), (e) => e.helpGroupHeading ?? "Options:").forEach((e, n) => {
				let r = e.map((e) => i(t.styleOptionTerm(t.optionTerm(e)), t.styleOptionDescription(t.optionDescription(e))));
				a = a.concat(this.formatItemList(n, r, t));
			}), t.showGlobalOptions) {
				let n = t.visibleGlobalOptions(e).map((e) => i(t.styleOptionTerm(t.optionTerm(e)), t.styleOptionDescription(t.optionDescription(e))));
				a = a.concat(this.formatItemList("Global Options:", n, t));
			}
			return this.groupItems(e.commands, t.visibleCommands(e), (e) => e.helpGroup() || "Commands:").forEach((e, n) => {
				let r = e.map((e) => i(t.styleSubcommandTerm(t.subcommandTerm(e)), t.styleSubcommandDescription(t.subcommandDescription(e))));
				a = a.concat(this.formatItemList(n, r, t));
			}), a.join("\n");
		}
		displayWidth(e) {
			return r(e).length;
		}
		styleTitle(e) {
			return e;
		}
		styleUsage(e) {
			return e.split(" ").map((e) => e === "[options]" ? this.styleOptionText(e) : e === "[command]" ? this.styleSubcommandText(e) : e[0] === "[" || e[0] === "<" ? this.styleArgumentText(e) : this.styleCommandText(e)).join(" ");
		}
		styleCommandDescription(e) {
			return this.styleDescriptionText(e);
		}
		styleOptionDescription(e) {
			return this.styleDescriptionText(e);
		}
		styleSubcommandDescription(e) {
			return this.styleDescriptionText(e);
		}
		styleArgumentDescription(e) {
			return this.styleDescriptionText(e);
		}
		styleDescriptionText(e) {
			return e;
		}
		styleOptionTerm(e) {
			return this.styleOptionText(e);
		}
		styleSubcommandTerm(e) {
			return e.split(" ").map((e) => e === "[options]" ? this.styleOptionText(e) : e[0] === "[" || e[0] === "<" ? this.styleArgumentText(e) : this.styleSubcommandText(e)).join(" ");
		}
		styleArgumentTerm(e) {
			return this.styleArgumentText(e);
		}
		styleOptionText(e) {
			return e;
		}
		styleArgumentText(e) {
			return e;
		}
		styleSubcommandText(e) {
			return e;
		}
		styleCommandText(e) {
			return e;
		}
		padWidth(e, t) {
			return Math.max(t.longestOptionTermLength(e, t), t.longestGlobalOptionTermLength(e, t), t.longestSubcommandTermLength(e, t), t.longestArgumentTermLength(e, t));
		}
		preformatted(e) {
			return /\n[^\S\r\n]/.test(e);
		}
		formatItem(e, t, n, r) {
			let i = " ".repeat(2);
			if (!n) return i + e;
			let a = e.padEnd(t + e.length - r.displayWidth(e)), o = (this.helpWidth ?? 80) - t - 2 - 2, s;
			return s = o < this.minWidthToWrap || r.preformatted(n) ? n : r.boxWrap(n, o).replace(/\n/g, "\n" + " ".repeat(t + 2)), i + a + " ".repeat(2) + s.replace(/\n/g, `\n${i}`);
		}
		boxWrap(e, t) {
			if (t < this.minWidthToWrap) return e;
			let n = e.split(/\r\n|\n/), r = /[\s]*[^\s]+/g, i = [];
			return n.forEach((e) => {
				let n = e.match(r);
				if (n === null) {
					i.push("");
					return;
				}
				let a = [n.shift()], o = this.displayWidth(a[0]);
				n.forEach((e) => {
					let n = this.displayWidth(e);
					if (o + n <= t) {
						a.push(e), o += n;
						return;
					}
					i.push(a.join(""));
					let r = e.trimStart();
					a = [r], o = this.displayWidth(r);
				}), i.push(a.join(""));
			}), i.join("\n");
		}
	};
	function r(e) {
		return e.replace(/\x1b\[\d*(;\d*)*m/g, "");
	}
	e.Help = n, e.stripColor = r;
})), re = /* @__PURE__ */ u(((e) => {
	var { InvalidArgumentError: t } = A(), n = class {
		constructor(e, t) {
			this.flags = e, this.description = t || "", this.required = e.includes("<"), this.optional = e.includes("["), this.variadic = /\w\.\.\.[>\]]$/.test(e), this.mandatory = !1;
			let n = a(e);
			this.short = n.shortFlag, this.long = n.longFlag, this.negate = !1, this.long && (this.negate = this.long.startsWith("--no-")), this.defaultValue = void 0, this.defaultValueDescription = void 0, this.presetArg = void 0, this.envVar = void 0, this.parseArg = void 0, this.hidden = !1, this.argChoices = void 0, this.conflictsWith = [], this.implied = void 0, this.helpGroupHeading = void 0;
		}
		default(e, t) {
			return this.defaultValue = e, this.defaultValueDescription = t, this;
		}
		preset(e) {
			return this.presetArg = e, this;
		}
		conflicts(e) {
			return this.conflictsWith = this.conflictsWith.concat(e), this;
		}
		implies(e) {
			let t = e;
			return typeof e == "string" && (t = { [e]: !0 }), this.implied = Object.assign(this.implied || {}, t), this;
		}
		env(e) {
			return this.envVar = e, this;
		}
		argParser(e) {
			return this.parseArg = e, this;
		}
		makeOptionMandatory(e = !0) {
			return this.mandatory = !!e, this;
		}
		hideHelp(e = !0) {
			return this.hidden = !!e, this;
		}
		_collectValue(e, t) {
			return t === this.defaultValue || !Array.isArray(t) ? [e] : (t.push(e), t);
		}
		choices(e) {
			return this.argChoices = e.slice(), this.parseArg = (e, n) => {
				if (!this.argChoices.includes(e)) throw new t(`Allowed choices are ${this.argChoices.join(", ")}.`);
				return this.variadic ? this._collectValue(e, n) : e;
			}, this;
		}
		name() {
			return this.long ? this.long.replace(/^--/, "") : this.short.replace(/^-/, "");
		}
		attributeName() {
			return this.negate ? i(this.name().replace(/^no-/, "")) : i(this.name());
		}
		helpGroup(e) {
			return this.helpGroupHeading = e, this;
		}
		is(e) {
			return this.short === e || this.long === e;
		}
		isBoolean() {
			return !this.required && !this.optional && !this.negate;
		}
	}, r = class {
		constructor(e) {
			this.positiveOptions = /* @__PURE__ */ new Map(), this.negativeOptions = /* @__PURE__ */ new Map(), this.dualOptions = /* @__PURE__ */ new Set(), e.forEach((e) => {
				e.negate ? this.negativeOptions.set(e.attributeName(), e) : this.positiveOptions.set(e.attributeName(), e);
			}), this.negativeOptions.forEach((e, t) => {
				this.positiveOptions.has(t) && this.dualOptions.add(t);
			});
		}
		valueFromOption(e, t) {
			let n = t.attributeName();
			if (!this.dualOptions.has(n)) return !0;
			let r = this.negativeOptions.get(n).presetArg, i = r === void 0 ? !1 : r;
			return t.negate === (i === e);
		}
	};
	function i(e) {
		return e.split("-").reduce((e, t) => e + t[0].toUpperCase() + t.slice(1));
	}
	function a(e) {
		let t, n, r = /^-[^-]$/, i = /^--[^-]/, a = e.split(/[ |,]+/).concat("guard");
		if (r.test(a[0]) && (t = a.shift()), i.test(a[0]) && (n = a.shift()), !t && r.test(a[0]) && (t = a.shift()), !t && i.test(a[0]) && (t = n, n = a.shift()), a[0].startsWith("-")) {
			let t = a[0], n = `option creation failed due to '${t}' in option flags '${e}'`;
			throw /^-[^-][^-]/.test(t) ? Error(`${n}
- a short flag is a single dash and a single character
  - either use a single dash and a single character (for a short flag)
  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`) : r.test(t) ? Error(`${n}
- too many short flags`) : i.test(t) ? Error(`${n}
- too many long flags`) : Error(`${n}
- unrecognised flag format`);
		}
		if (t === void 0 && n === void 0) throw Error(`option creation failed due to no flags found in '${e}'.`);
		return {
			shortFlag: t,
			longFlag: n
		};
	}
	e.Option = n, e.DualOptions = r;
})), ie = /* @__PURE__ */ u(((e) => {
	var t = 3;
	function n(e, n) {
		if (Math.abs(e.length - n.length) > t) return Math.max(e.length, n.length);
		let r = [];
		for (let t = 0; t <= e.length; t++) r[t] = [t];
		for (let e = 0; e <= n.length; e++) r[0][e] = e;
		for (let t = 1; t <= n.length; t++) for (let i = 1; i <= e.length; i++) {
			let a = 1;
			a = e[i - 1] === n[t - 1] ? 0 : 1, r[i][t] = Math.min(r[i - 1][t] + 1, r[i][t - 1] + 1, r[i - 1][t - 1] + a), i > 1 && t > 1 && e[i - 1] === n[t - 2] && e[i - 2] === n[t - 1] && (r[i][t] = Math.min(r[i][t], r[i - 2][t - 2] + 1));
		}
		return r[e.length][n.length];
	}
	function r(e, r) {
		if (!r || r.length === 0) return "";
		r = Array.from(new Set(r));
		let i = e.startsWith("--");
		i && (e = e.slice(2), r = r.map((e) => e.slice(2)));
		let a = [], o = t;
		return r.forEach((t) => {
			if (t.length <= 1) return;
			let r = n(e, t), i = Math.max(e.length, t.length);
			(i - r) / i > .4 && (r < o ? (o = r, a = [t]) : r === o && a.push(t));
		}), a.sort((e, t) => e.localeCompare(t)), i && (a = a.map((e) => `--${e}`)), a.length > 1 ? `\n(Did you mean one of ${a.join(", ")}?)` : a.length === 1 ? `\n(Did you mean ${a[0]}?)` : "";
	}
	e.suggestSimilar = r;
})), ae = /* @__PURE__ */ u(((e) => {
	var n = t("node:events").EventEmitter, r = t("node:child_process"), i = t("node:path"), a = t("node:fs"), o = t("node:process"), { Argument: s, humanReadableArgName: c } = te(), { CommanderError: l } = A(), { Help: u, stripColor: d } = ne(), { Option: f, DualOptions: p } = re(), { suggestSimilar: m } = ie(), h = class e extends n {
		constructor(e) {
			super(), this.commands = [], this.options = [], this.parent = null, this._allowUnknownOption = !1, this._allowExcessArguments = !1, this.registeredArguments = [], this._args = this.registeredArguments, this.args = [], this.rawArgs = [], this.processedArgs = [], this._scriptPath = null, this._name = e || "", this._optionValues = {}, this._optionValueSources = {}, this._storeOptionsAsProperties = !1, this._actionHandler = null, this._executableHandler = !1, this._executableFile = null, this._executableDir = null, this._defaultCommandName = null, this._exitCallback = null, this._aliases = [], this._combineFlagAndOptionalValue = !0, this._description = "", this._summary = "", this._argsDescription = void 0, this._enablePositionalOptions = !1, this._passThroughOptions = !1, this._lifeCycleHooks = {}, this._showHelpAfterError = !1, this._showSuggestionAfterError = !0, this._savedState = null, this._outputConfiguration = {
				writeOut: (e) => o.stdout.write(e),
				writeErr: (e) => o.stderr.write(e),
				outputError: (e, t) => t(e),
				getOutHelpWidth: () => o.stdout.isTTY ? o.stdout.columns : void 0,
				getErrHelpWidth: () => o.stderr.isTTY ? o.stderr.columns : void 0,
				getOutHasColors: () => _() ?? (o.stdout.isTTY && o.stdout.hasColors?.()),
				getErrHasColors: () => _() ?? (o.stderr.isTTY && o.stderr.hasColors?.()),
				stripColor: (e) => d(e)
			}, this._hidden = !1, this._helpOption = void 0, this._addImplicitHelpCommand = void 0, this._helpCommand = void 0, this._helpConfiguration = {}, this._helpGroupHeading = void 0, this._defaultCommandGroup = void 0, this._defaultOptionGroup = void 0;
		}
		copyInheritedSettings(e) {
			return this._outputConfiguration = e._outputConfiguration, this._helpOption = e._helpOption, this._helpCommand = e._helpCommand, this._helpConfiguration = e._helpConfiguration, this._exitCallback = e._exitCallback, this._storeOptionsAsProperties = e._storeOptionsAsProperties, this._combineFlagAndOptionalValue = e._combineFlagAndOptionalValue, this._allowExcessArguments = e._allowExcessArguments, this._enablePositionalOptions = e._enablePositionalOptions, this._showHelpAfterError = e._showHelpAfterError, this._showSuggestionAfterError = e._showSuggestionAfterError, this;
		}
		_getCommandAndAncestors() {
			let e = [];
			for (let t = this; t; t = t.parent) e.push(t);
			return e;
		}
		command(e, t, n) {
			let r = t, i = n;
			typeof r == "object" && r && (i = r, r = null), i ||= {};
			let [, a, o] = e.match(/([^ ]+) *(.*)/), s = this.createCommand(a);
			return r && (s.description(r), s._executableHandler = !0), i.isDefault && (this._defaultCommandName = s._name), s._hidden = !!(i.noHelp || i.hidden), s._executableFile = i.executableFile || null, o && s.arguments(o), this._registerCommand(s), s.parent = this, s.copyInheritedSettings(this), r ? this : s;
		}
		createCommand(t) {
			return new e(t);
		}
		createHelp() {
			return Object.assign(new u(), this.configureHelp());
		}
		configureHelp(e) {
			return e === void 0 ? this._helpConfiguration : (this._helpConfiguration = e, this);
		}
		configureOutput(e) {
			return e === void 0 ? this._outputConfiguration : (this._outputConfiguration = {
				...this._outputConfiguration,
				...e
			}, this);
		}
		showHelpAfterError(e = !0) {
			return typeof e != "string" && (e = !!e), this._showHelpAfterError = e, this;
		}
		showSuggestionAfterError(e = !0) {
			return this._showSuggestionAfterError = !!e, this;
		}
		addCommand(e, t) {
			if (!e._name) throw Error("Command passed to .addCommand() must have a name\n- specify the name in Command constructor or using .name()");
			return t ||= {}, t.isDefault && (this._defaultCommandName = e._name), (t.noHelp || t.hidden) && (e._hidden = !0), this._registerCommand(e), e.parent = this, e._checkForBrokenPassThrough(), this;
		}
		createArgument(e, t) {
			return new s(e, t);
		}
		argument(e, t, n, r) {
			let i = this.createArgument(e, t);
			return typeof n == "function" ? i.default(r).argParser(n) : i.default(n), this.addArgument(i), this;
		}
		arguments(e) {
			return e.trim().split(/ +/).forEach((e) => {
				this.argument(e);
			}), this;
		}
		addArgument(e) {
			let t = this.registeredArguments.slice(-1)[0];
			if (t?.variadic) throw Error(`only the last argument can be variadic '${t.name()}'`);
			if (e.required && e.defaultValue !== void 0 && e.parseArg === void 0) throw Error(`a default value for a required argument is never used: '${e.name()}'`);
			return this.registeredArguments.push(e), this;
		}
		helpCommand(e, t) {
			if (typeof e == "boolean") return this._addImplicitHelpCommand = e, e && this._defaultCommandGroup && this._initCommandGroup(this._getHelpCommand()), this;
			let [, n, r] = (e ?? "help [command]").match(/([^ ]+) *(.*)/), i = t ?? "display help for command", a = this.createCommand(n);
			return a.helpOption(!1), r && a.arguments(r), i && a.description(i), this._addImplicitHelpCommand = !0, this._helpCommand = a, (e || t) && this._initCommandGroup(a), this;
		}
		addHelpCommand(e, t) {
			return typeof e == "object" ? (this._addImplicitHelpCommand = !0, this._helpCommand = e, this._initCommandGroup(e), this) : (this.helpCommand(e, t), this);
		}
		_getHelpCommand() {
			return this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help")) ? (this._helpCommand === void 0 && this.helpCommand(void 0, void 0), this._helpCommand) : null;
		}
		hook(e, t) {
			let n = [
				"preSubcommand",
				"preAction",
				"postAction"
			];
			if (!n.includes(e)) throw Error(`Unexpected value for event passed to hook : '${e}'.
Expecting one of '${n.join("', '")}'`);
			return this._lifeCycleHooks[e] ? this._lifeCycleHooks[e].push(t) : this._lifeCycleHooks[e] = [t], this;
		}
		exitOverride(e) {
			return e ? this._exitCallback = e : this._exitCallback = (e) => {
				if (e.code !== "commander.executeSubCommandAsync") throw e;
			}, this;
		}
		_exit(e, t, n) {
			this._exitCallback && this._exitCallback(new l(e, t, n)), o.exit(e);
		}
		action(e) {
			let t = (t) => {
				let n = this.registeredArguments.length, r = t.slice(0, n);
				return this._storeOptionsAsProperties ? r[n] = this : r[n] = this.opts(), r.push(this), e.apply(this, r);
			};
			return this._actionHandler = t, this;
		}
		createOption(e, t) {
			return new f(e, t);
		}
		_callParseArg(e, t, n, r) {
			try {
				return e.parseArg(t, n);
			} catch (e) {
				if (e.code === "commander.invalidArgument") {
					let t = `${r} ${e.message}`;
					this.error(t, {
						exitCode: e.exitCode,
						code: e.code
					});
				}
				throw e;
			}
		}
		_registerOption(e) {
			let t = e.short && this._findOption(e.short) || e.long && this._findOption(e.long);
			if (t) {
				let n = e.long && this._findOption(e.long) ? e.long : e.short;
				throw Error(`Cannot add option '${e.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${n}'
-  already used by option '${t.flags}'`);
			}
			this._initOptionGroup(e), this.options.push(e);
		}
		_registerCommand(e) {
			let t = (e) => [e.name()].concat(e.aliases()), n = t(e).find((e) => this._findCommand(e));
			if (n) {
				let r = t(this._findCommand(n)).join("|"), i = t(e).join("|");
				throw Error(`cannot add command '${i}' as already have command '${r}'`);
			}
			this._initCommandGroup(e), this.commands.push(e);
		}
		addOption(e) {
			this._registerOption(e);
			let t = e.name(), n = e.attributeName();
			if (e.negate) {
				let t = e.long.replace(/^--no-/, "--");
				this._findOption(t) || this.setOptionValueWithSource(n, e.defaultValue === void 0 ? !0 : e.defaultValue, "default");
			} else e.defaultValue !== void 0 && this.setOptionValueWithSource(n, e.defaultValue, "default");
			let r = (t, r, i) => {
				t == null && e.presetArg !== void 0 && (t = e.presetArg);
				let a = this.getOptionValue(n);
				t !== null && e.parseArg ? t = this._callParseArg(e, t, a, r) : t !== null && e.variadic && (t = e._collectValue(t, a)), t ??= e.negate ? !1 : e.isBoolean() || e.optional ? !0 : "", this.setOptionValueWithSource(n, t, i);
			};
			return this.on("option:" + t, (t) => {
				r(t, `error: option '${e.flags}' argument '${t}' is invalid.`, "cli");
			}), e.envVar && this.on("optionEnv:" + t, (t) => {
				r(t, `error: option '${e.flags}' value '${t}' from env '${e.envVar}' is invalid.`, "env");
			}), this;
		}
		_optionEx(e, t, n, r, i) {
			if (typeof t == "object" && t instanceof f) throw Error("To add an Option object use addOption() instead of option() or requiredOption()");
			let a = this.createOption(t, n);
			if (a.makeOptionMandatory(!!e.mandatory), typeof r == "function") a.default(i).argParser(r);
			else if (r instanceof RegExp) {
				let e = r;
				r = (t, n) => {
					let r = e.exec(t);
					return r ? r[0] : n;
				}, a.default(i).argParser(r);
			} else a.default(r);
			return this.addOption(a);
		}
		option(e, t, n, r) {
			return this._optionEx({}, e, t, n, r);
		}
		requiredOption(e, t, n, r) {
			return this._optionEx({ mandatory: !0 }, e, t, n, r);
		}
		combineFlagAndOptionalValue(e = !0) {
			return this._combineFlagAndOptionalValue = !!e, this;
		}
		allowUnknownOption(e = !0) {
			return this._allowUnknownOption = !!e, this;
		}
		allowExcessArguments(e = !0) {
			return this._allowExcessArguments = !!e, this;
		}
		enablePositionalOptions(e = !0) {
			return this._enablePositionalOptions = !!e, this;
		}
		passThroughOptions(e = !0) {
			return this._passThroughOptions = !!e, this._checkForBrokenPassThrough(), this;
		}
		_checkForBrokenPassThrough() {
			if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) throw Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
		}
		storeOptionsAsProperties(e = !0) {
			if (this.options.length) throw Error("call .storeOptionsAsProperties() before adding options");
			if (Object.keys(this._optionValues).length) throw Error("call .storeOptionsAsProperties() before setting option values");
			return this._storeOptionsAsProperties = !!e, this;
		}
		getOptionValue(e) {
			return this._storeOptionsAsProperties ? this[e] : this._optionValues[e];
		}
		setOptionValue(e, t) {
			return this.setOptionValueWithSource(e, t, void 0);
		}
		setOptionValueWithSource(e, t, n) {
			return this._storeOptionsAsProperties ? this[e] = t : this._optionValues[e] = t, this._optionValueSources[e] = n, this;
		}
		getOptionValueSource(e) {
			return this._optionValueSources[e];
		}
		getOptionValueSourceWithGlobals(e) {
			let t;
			return this._getCommandAndAncestors().forEach((n) => {
				n.getOptionValueSource(e) !== void 0 && (t = n.getOptionValueSource(e));
			}), t;
		}
		_prepareUserArgs(e, t) {
			if (e !== void 0 && !Array.isArray(e)) throw Error("first parameter to parse must be array or undefined");
			if (t ||= {}, e === void 0 && t.from === void 0) {
				o.versions?.electron && (t.from = "electron");
				let e = o.execArgv ?? [];
				(e.includes("-e") || e.includes("--eval") || e.includes("-p") || e.includes("--print")) && (t.from = "eval");
			}
			e === void 0 && (e = o.argv), this.rawArgs = e.slice();
			let n;
			switch (t.from) {
				case void 0:
				case "node":
					this._scriptPath = e[1], n = e.slice(2);
					break;
				case "electron":
					o.defaultApp ? (this._scriptPath = e[1], n = e.slice(2)) : n = e.slice(1);
					break;
				case "user":
					n = e.slice(0);
					break;
				case "eval":
					n = e.slice(1);
					break;
				default: throw Error(`unexpected parse option { from: '${t.from}' }`);
			}
			return !this._name && this._scriptPath && this.nameFromFilename(this._scriptPath), this._name = this._name || "program", n;
		}
		parse(e, t) {
			this._prepareForParse();
			let n = this._prepareUserArgs(e, t);
			return this._parseCommand([], n), this;
		}
		async parseAsync(e, t) {
			this._prepareForParse();
			let n = this._prepareUserArgs(e, t);
			return await this._parseCommand([], n), this;
		}
		_prepareForParse() {
			this._savedState === null ? this.saveStateBeforeParse() : this.restoreStateBeforeParse();
		}
		saveStateBeforeParse() {
			this._savedState = {
				_name: this._name,
				_optionValues: { ...this._optionValues },
				_optionValueSources: { ...this._optionValueSources }
			};
		}
		restoreStateBeforeParse() {
			if (this._storeOptionsAsProperties) throw Error("Can not call parse again when storeOptionsAsProperties is true.\n- either make a new Command for each call to parse, or stop storing options as properties");
			this._name = this._savedState._name, this._scriptPath = null, this.rawArgs = [], this._optionValues = { ...this._savedState._optionValues }, this._optionValueSources = { ...this._savedState._optionValueSources }, this.args = [], this.processedArgs = [];
		}
		_checkForMissingExecutable(e, t, n) {
			if (a.existsSync(e)) return;
			let r = `'${e}' does not exist
 - if '${n}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
 - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
 - ${t ? `searched for local subcommand relative to directory '${t}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory"}`;
			throw Error(r);
		}
		_executeSubCommand(e, t) {
			t = t.slice();
			let n = !1, s = [
				".js",
				".ts",
				".tsx",
				".mjs",
				".cjs"
			];
			function c(e, t) {
				let n = i.resolve(e, t);
				if (a.existsSync(n)) return n;
				if (s.includes(i.extname(t))) return;
				let r = s.find((e) => a.existsSync(`${n}${e}`));
				if (r) return `${n}${r}`;
			}
			this._checkForMissingMandatoryOptions(), this._checkForConflictingOptions();
			let u = e._executableFile || `${this._name}-${e._name}`, d = this._executableDir || "";
			if (this._scriptPath) {
				let e;
				try {
					e = a.realpathSync(this._scriptPath);
				} catch {
					e = this._scriptPath;
				}
				d = i.resolve(i.dirname(e), d);
			}
			if (d) {
				let t = c(d, u);
				if (!t && !e._executableFile && this._scriptPath) {
					let n = i.basename(this._scriptPath, i.extname(this._scriptPath));
					n !== this._name && (t = c(d, `${n}-${e._name}`));
				}
				u = t || u;
			}
			n = s.includes(i.extname(u));
			let f;
			o.platform === "win32" ? (this._checkForMissingExecutable(u, d, e._name), t.unshift(u), t = g(o.execArgv).concat(t), f = r.spawn(o.execPath, t, { stdio: "inherit" })) : n ? (t.unshift(u), t = g(o.execArgv).concat(t), f = r.spawn(o.argv[0], t, { stdio: "inherit" })) : f = r.spawn(u, t, { stdio: "inherit" }), f.killed || [
				"SIGUSR1",
				"SIGUSR2",
				"SIGTERM",
				"SIGINT",
				"SIGHUP"
			].forEach((e) => {
				o.on(e, () => {
					f.killed === !1 && f.exitCode === null && f.kill(e);
				});
			});
			let p = this._exitCallback;
			f.on("close", (e) => {
				e ??= 1, p ? p(new l(e, "commander.executeSubCommandAsync", "(close)")) : o.exit(e);
			}), f.on("error", (t) => {
				if (t.code === "ENOENT") this._checkForMissingExecutable(u, d, e._name);
				else if (t.code === "EACCES") throw Error(`'${u}' not executable`);
				if (!p) o.exit(1);
				else {
					let e = new l(1, "commander.executeSubCommandAsync", "(error)");
					e.nestedError = t, p(e);
				}
			}), this.runningCommand = f;
		}
		_dispatchSubcommand(e, t, n) {
			let r = this._findCommand(e);
			r || this.help({ error: !0 }), r._prepareForParse();
			let i;
			return i = this._chainOrCallSubCommandHook(i, r, "preSubcommand"), i = this._chainOrCall(i, () => {
				if (r._executableHandler) this._executeSubCommand(r, t.concat(n));
				else return r._parseCommand(t, n);
			}), i;
		}
		_dispatchHelpCommand(e) {
			e || this.help();
			let t = this._findCommand(e);
			return t && !t._executableHandler && t.help(), this._dispatchSubcommand(e, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
		}
		_checkNumberOfArguments() {
			this.registeredArguments.forEach((e, t) => {
				e.required && this.args[t] == null && this.missingArgument(e.name());
			}), !(this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) && this.args.length > this.registeredArguments.length && this._excessArguments(this.args);
		}
		_processArguments() {
			let e = (e, t, n) => {
				let r = t;
				if (t !== null && e.parseArg) {
					let i = `error: command-argument value '${t}' is invalid for argument '${e.name()}'.`;
					r = this._callParseArg(e, t, n, i);
				}
				return r;
			};
			this._checkNumberOfArguments();
			let t = [];
			this.registeredArguments.forEach((n, r) => {
				let i = n.defaultValue;
				n.variadic ? r < this.args.length ? (i = this.args.slice(r), n.parseArg && (i = i.reduce((t, r) => e(n, r, t), n.defaultValue))) : i === void 0 && (i = []) : r < this.args.length && (i = this.args[r], n.parseArg && (i = e(n, i, n.defaultValue))), t[r] = i;
			}), this.processedArgs = t;
		}
		_chainOrCall(e, t) {
			return e?.then && typeof e.then == "function" ? e.then(() => t()) : t();
		}
		_chainOrCallHooks(e, t) {
			let n = e, r = [];
			return this._getCommandAndAncestors().reverse().filter((e) => e._lifeCycleHooks[t] !== void 0).forEach((e) => {
				e._lifeCycleHooks[t].forEach((t) => {
					r.push({
						hookedCommand: e,
						callback: t
					});
				});
			}), t === "postAction" && r.reverse(), r.forEach((e) => {
				n = this._chainOrCall(n, () => e.callback(e.hookedCommand, this));
			}), n;
		}
		_chainOrCallSubCommandHook(e, t, n) {
			let r = e;
			return this._lifeCycleHooks[n] !== void 0 && this._lifeCycleHooks[n].forEach((e) => {
				r = this._chainOrCall(r, () => e(this, t));
			}), r;
		}
		_parseCommand(e, t) {
			let n = this.parseOptions(t);
			if (this._parseOptionsEnv(), this._parseOptionsImplied(), e = e.concat(n.operands), t = n.unknown, this.args = e.concat(t), e && this._findCommand(e[0])) return this._dispatchSubcommand(e[0], e.slice(1), t);
			if (this._getHelpCommand() && e[0] === this._getHelpCommand().name()) return this._dispatchHelpCommand(e[1]);
			if (this._defaultCommandName) return this._outputHelpIfRequested(t), this._dispatchSubcommand(this._defaultCommandName, e, t);
			this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName && this.help({ error: !0 }), this._outputHelpIfRequested(n.unknown), this._checkForMissingMandatoryOptions(), this._checkForConflictingOptions();
			let r = () => {
				n.unknown.length > 0 && this.unknownOption(n.unknown[0]);
			}, i = `command:${this.name()}`;
			if (this._actionHandler) {
				r(), this._processArguments();
				let n;
				return n = this._chainOrCallHooks(n, "preAction"), n = this._chainOrCall(n, () => this._actionHandler(this.processedArgs)), this.parent && (n = this._chainOrCall(n, () => {
					this.parent.emit(i, e, t);
				})), n = this._chainOrCallHooks(n, "postAction"), n;
			}
			if (this.parent?.listenerCount(i)) r(), this._processArguments(), this.parent.emit(i, e, t);
			else if (e.length) {
				if (this._findCommand("*")) return this._dispatchSubcommand("*", e, t);
				this.listenerCount("command:*") ? this.emit("command:*", e, t) : this.commands.length ? this.unknownCommand() : (r(), this._processArguments());
			} else this.commands.length ? (r(), this.help({ error: !0 })) : (r(), this._processArguments());
		}
		_findCommand(e) {
			if (e) return this.commands.find((t) => t._name === e || t._aliases.includes(e));
		}
		_findOption(e) {
			return this.options.find((t) => t.is(e));
		}
		_checkForMissingMandatoryOptions() {
			this._getCommandAndAncestors().forEach((e) => {
				e.options.forEach((t) => {
					t.mandatory && e.getOptionValue(t.attributeName()) === void 0 && e.missingMandatoryOptionValue(t);
				});
			});
		}
		_checkForConflictingLocalOptions() {
			let e = this.options.filter((e) => {
				let t = e.attributeName();
				return this.getOptionValue(t) === void 0 ? !1 : this.getOptionValueSource(t) !== "default";
			});
			e.filter((e) => e.conflictsWith.length > 0).forEach((t) => {
				let n = e.find((e) => t.conflictsWith.includes(e.attributeName()));
				n && this._conflictingOption(t, n);
			});
		}
		_checkForConflictingOptions() {
			this._getCommandAndAncestors().forEach((e) => {
				e._checkForConflictingLocalOptions();
			});
		}
		parseOptions(e) {
			let t = [], n = [], r = t;
			function i(e) {
				return e.length > 1 && e[0] === "-";
			}
			let a = (e) => /^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(e) ? !this._getCommandAndAncestors().some((e) => e.options.map((e) => e.short).some((e) => /^-\d$/.test(e))) : !1, o = null, s = null, c = 0;
			for (; c < e.length || s;) {
				let l = s ?? e[c++];
				if (s = null, l === "--") {
					r === n && r.push(l), r.push(...e.slice(c));
					break;
				}
				if (o && (!i(l) || a(l))) {
					this.emit(`option:${o.name()}`, l);
					continue;
				}
				if (o = null, i(l)) {
					let t = this._findOption(l);
					if (t) {
						if (t.required) {
							let n = e[c++];
							n === void 0 && this.optionMissingArgument(t), this.emit(`option:${t.name()}`, n);
						} else if (t.optional) {
							let n = null;
							c < e.length && (!i(e[c]) || a(e[c])) && (n = e[c++]), this.emit(`option:${t.name()}`, n);
						} else this.emit(`option:${t.name()}`);
						o = t.variadic ? t : null;
						continue;
					}
				}
				if (l.length > 2 && l[0] === "-" && l[1] !== "-") {
					let e = this._findOption(`-${l[1]}`);
					if (e) {
						e.required || e.optional && this._combineFlagAndOptionalValue ? this.emit(`option:${e.name()}`, l.slice(2)) : (this.emit(`option:${e.name()}`), s = `-${l.slice(2)}`);
						continue;
					}
				}
				if (/^--[^=]+=/.test(l)) {
					let e = l.indexOf("="), t = this._findOption(l.slice(0, e));
					if (t && (t.required || t.optional)) {
						this.emit(`option:${t.name()}`, l.slice(e + 1));
						continue;
					}
				}
				if (r === t && i(l) && !(this.commands.length === 0 && a(l)) && (r = n), (this._enablePositionalOptions || this._passThroughOptions) && t.length === 0 && n.length === 0) {
					if (this._findCommand(l)) {
						t.push(l), n.push(...e.slice(c));
						break;
					} else if (this._getHelpCommand() && l === this._getHelpCommand().name()) {
						t.push(l, ...e.slice(c));
						break;
					} else if (this._defaultCommandName) {
						n.push(l, ...e.slice(c));
						break;
					}
				}
				if (this._passThroughOptions) {
					r.push(l, ...e.slice(c));
					break;
				}
				r.push(l);
			}
			return {
				operands: t,
				unknown: n
			};
		}
		opts() {
			if (this._storeOptionsAsProperties) {
				let e = {}, t = this.options.length;
				for (let n = 0; n < t; n++) {
					let t = this.options[n].attributeName();
					e[t] = t === this._versionOptionName ? this._version : this[t];
				}
				return e;
			}
			return this._optionValues;
		}
		optsWithGlobals() {
			return this._getCommandAndAncestors().reduce((e, t) => Object.assign(e, t.opts()), {});
		}
		error(e, t) {
			this._outputConfiguration.outputError(`${e}\n`, this._outputConfiguration.writeErr), typeof this._showHelpAfterError == "string" ? this._outputConfiguration.writeErr(`${this._showHelpAfterError}\n`) : this._showHelpAfterError && (this._outputConfiguration.writeErr("\n"), this.outputHelp({ error: !0 }));
			let n = t || {}, r = n.exitCode || 1, i = n.code || "commander.error";
			this._exit(r, i, e);
		}
		_parseOptionsEnv() {
			this.options.forEach((e) => {
				if (e.envVar && e.envVar in o.env) {
					let t = e.attributeName();
					(this.getOptionValue(t) === void 0 || [
						"default",
						"config",
						"env"
					].includes(this.getOptionValueSource(t))) && (e.required || e.optional ? this.emit(`optionEnv:${e.name()}`, o.env[e.envVar]) : this.emit(`optionEnv:${e.name()}`));
				}
			});
		}
		_parseOptionsImplied() {
			let e = new p(this.options), t = (e) => this.getOptionValue(e) !== void 0 && !["default", "implied"].includes(this.getOptionValueSource(e));
			this.options.filter((n) => n.implied !== void 0 && t(n.attributeName()) && e.valueFromOption(this.getOptionValue(n.attributeName()), n)).forEach((e) => {
				Object.keys(e.implied).filter((e) => !t(e)).forEach((t) => {
					this.setOptionValueWithSource(t, e.implied[t], "implied");
				});
			});
		}
		missingArgument(e) {
			let t = `error: missing required argument '${e}'`;
			this.error(t, { code: "commander.missingArgument" });
		}
		optionMissingArgument(e) {
			let t = `error: option '${e.flags}' argument missing`;
			this.error(t, { code: "commander.optionMissingArgument" });
		}
		missingMandatoryOptionValue(e) {
			let t = `error: required option '${e.flags}' not specified`;
			this.error(t, { code: "commander.missingMandatoryOptionValue" });
		}
		_conflictingOption(e, t) {
			let n = (e) => {
				let t = e.attributeName(), n = this.getOptionValue(t), r = this.options.find((e) => e.negate && t === e.attributeName()), i = this.options.find((e) => !e.negate && t === e.attributeName());
				return r && (r.presetArg === void 0 && n === !1 || r.presetArg !== void 0 && n === r.presetArg) ? r : i || e;
			}, r = (e) => {
				let t = n(e), r = t.attributeName();
				return this.getOptionValueSource(r) === "env" ? `environment variable '${t.envVar}'` : `option '${t.flags}'`;
			}, i = `error: ${r(e)} cannot be used with ${r(t)}`;
			this.error(i, { code: "commander.conflictingOption" });
		}
		unknownOption(e) {
			if (this._allowUnknownOption) return;
			let t = "";
			if (e.startsWith("--") && this._showSuggestionAfterError) {
				let n = [], r = this;
				do {
					let e = r.createHelp().visibleOptions(r).filter((e) => e.long).map((e) => e.long);
					n = n.concat(e), r = r.parent;
				} while (r && !r._enablePositionalOptions);
				t = m(e, n);
			}
			let n = `error: unknown option '${e}'${t}`;
			this.error(n, { code: "commander.unknownOption" });
		}
		_excessArguments(e) {
			if (this._allowExcessArguments) return;
			let t = this.registeredArguments.length, n = t === 1 ? "" : "s", r = `error: too many arguments${this.parent ? ` for '${this.name()}'` : ""}. Expected ${t} argument${n} but got ${e.length}.`;
			this.error(r, { code: "commander.excessArguments" });
		}
		unknownCommand() {
			let e = this.args[0], t = "";
			if (this._showSuggestionAfterError) {
				let n = [];
				this.createHelp().visibleCommands(this).forEach((e) => {
					n.push(e.name()), e.alias() && n.push(e.alias());
				}), t = m(e, n);
			}
			let n = `error: unknown command '${e}'${t}`;
			this.error(n, { code: "commander.unknownCommand" });
		}
		version(e, t, n) {
			if (e === void 0) return this._version;
			this._version = e, t ||= "-V, --version", n ||= "output the version number";
			let r = this.createOption(t, n);
			return this._versionOptionName = r.attributeName(), this._registerOption(r), this.on("option:" + r.name(), () => {
				this._outputConfiguration.writeOut(`${e}\n`), this._exit(0, "commander.version", e);
			}), this;
		}
		description(e, t) {
			return e === void 0 && t === void 0 ? this._description : (this._description = e, t && (this._argsDescription = t), this);
		}
		summary(e) {
			return e === void 0 ? this._summary : (this._summary = e, this);
		}
		alias(e) {
			if (e === void 0) return this._aliases[0];
			let t = this;
			if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler && (t = this.commands[this.commands.length - 1]), e === t._name) throw Error("Command alias can't be the same as its name");
			let n = this.parent?._findCommand(e);
			if (n) {
				let t = [n.name()].concat(n.aliases()).join("|");
				throw Error(`cannot add alias '${e}' to command '${this.name()}' as already have command '${t}'`);
			}
			return t._aliases.push(e), this;
		}
		aliases(e) {
			return e === void 0 ? this._aliases : (e.forEach((e) => this.alias(e)), this);
		}
		usage(e) {
			if (e === void 0) {
				if (this._usage) return this._usage;
				let e = this.registeredArguments.map((e) => c(e));
				return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? e : []).join(" ");
			}
			return this._usage = e, this;
		}
		name(e) {
			return e === void 0 ? this._name : (this._name = e, this);
		}
		helpGroup(e) {
			return e === void 0 ? this._helpGroupHeading ?? "" : (this._helpGroupHeading = e, this);
		}
		commandsGroup(e) {
			return e === void 0 ? this._defaultCommandGroup ?? "" : (this._defaultCommandGroup = e, this);
		}
		optionsGroup(e) {
			return e === void 0 ? this._defaultOptionGroup ?? "" : (this._defaultOptionGroup = e, this);
		}
		_initOptionGroup(e) {
			this._defaultOptionGroup && !e.helpGroupHeading && e.helpGroup(this._defaultOptionGroup);
		}
		_initCommandGroup(e) {
			this._defaultCommandGroup && !e.helpGroup() && e.helpGroup(this._defaultCommandGroup);
		}
		nameFromFilename(e) {
			return this._name = i.basename(e, i.extname(e)), this;
		}
		executableDir(e) {
			return e === void 0 ? this._executableDir : (this._executableDir = e, this);
		}
		helpInformation(e) {
			let t = this.createHelp(), n = this._getOutputContext(e);
			t.prepareContext({
				error: n.error,
				helpWidth: n.helpWidth,
				outputHasColors: n.hasColors
			});
			let r = t.formatHelp(this, t);
			return n.hasColors ? r : this._outputConfiguration.stripColor(r);
		}
		_getOutputContext(e) {
			e ||= {};
			let t = !!e.error, n, r, i;
			return t ? (n = (e) => this._outputConfiguration.writeErr(e), r = this._outputConfiguration.getErrHasColors(), i = this._outputConfiguration.getErrHelpWidth()) : (n = (e) => this._outputConfiguration.writeOut(e), r = this._outputConfiguration.getOutHasColors(), i = this._outputConfiguration.getOutHelpWidth()), {
				error: t,
				write: (e) => (r || (e = this._outputConfiguration.stripColor(e)), n(e)),
				hasColors: r,
				helpWidth: i
			};
		}
		outputHelp(e) {
			let t;
			typeof e == "function" && (t = e, e = void 0);
			let n = this._getOutputContext(e), r = {
				error: n.error,
				write: n.write,
				command: this
			};
			this._getCommandAndAncestors().reverse().forEach((e) => e.emit("beforeAllHelp", r)), this.emit("beforeHelp", r);
			let i = this.helpInformation({ error: n.error });
			if (t && (i = t(i), typeof i != "string" && !Buffer.isBuffer(i))) throw Error("outputHelp callback must return a string or a Buffer");
			n.write(i), this._getHelpOption()?.long && this.emit(this._getHelpOption().long), this.emit("afterHelp", r), this._getCommandAndAncestors().forEach((e) => e.emit("afterAllHelp", r));
		}
		helpOption(e, t) {
			return typeof e == "boolean" ? (e ? (this._helpOption === null && (this._helpOption = void 0), this._defaultOptionGroup && this._initOptionGroup(this._getHelpOption())) : this._helpOption = null, this) : (this._helpOption = this.createOption(e ?? "-h, --help", t ?? "display help for command"), (e || t) && this._initOptionGroup(this._helpOption), this);
		}
		_getHelpOption() {
			return this._helpOption === void 0 && this.helpOption(void 0, void 0), this._helpOption;
		}
		addHelpOption(e) {
			return this._helpOption = e, this._initOptionGroup(e), this;
		}
		help(e) {
			this.outputHelp(e);
			let t = Number(o.exitCode ?? 0);
			t === 0 && e && typeof e != "function" && e.error && (t = 1), this._exit(t, "commander.help", "(outputHelp)");
		}
		addHelpText(e, t) {
			let n = [
				"beforeAll",
				"before",
				"after",
				"afterAll"
			];
			if (!n.includes(e)) throw Error(`Unexpected value for position to addHelpText.
Expecting one of '${n.join("', '")}'`);
			let r = `${e}Help`;
			return this.on(r, (e) => {
				let n;
				n = typeof t == "function" ? t({
					error: e.error,
					command: e.command
				}) : t, n && e.write(`${n}\n`);
			}), this;
		}
		_outputHelpIfRequested(e) {
			let t = this._getHelpOption();
			t && e.find((e) => t.is(e)) && (this.outputHelp(), this._exit(0, "commander.helpDisplayed", "(outputHelp)"));
		}
	};
	function g(e) {
		return e.map((e) => {
			if (!e.startsWith("--inspect")) return e;
			let t, n = "127.0.0.1", r = "9229", i;
			return (i = e.match(/^(--inspect(-brk)?)$/)) === null ? (i = e.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) === null ? (i = e.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null && (t = i[1], n = i[3], r = i[4]) : (t = i[1], /^\d+$/.test(i[3]) ? r = i[3] : n = i[3]) : t = i[1], t && r !== "0" ? `${t}=${n}:${parseInt(r) + 1}` : e;
		});
	}
	function _() {
		if (o.env.NO_COLOR || o.env.FORCE_COLOR === "0" || o.env.FORCE_COLOR === "false") return !1;
		if (o.env.FORCE_COLOR || o.env.CLICOLOR_FORCE !== void 0) return !0;
	}
	e.Command = h, e.useColor = _;
})), { program: j, createCommand: oe, createArgument: se, createOption: ce, CommanderError: le, InvalidArgumentError: ue, InvalidOptionArgumentError: de, Command: fe, Argument: pe, Option: me, Help: he } = (/* @__PURE__ */ y((/* @__PURE__ */ u(((e) => {
	var { Argument: t } = te(), { Command: n } = ae(), { CommanderError: r, InvalidArgumentError: i } = A(), { Help: a } = ne(), { Option: o } = re();
	e.program = new n(), e.createCommand = (e) => new n(e), e.createOption = (e, t) => new o(e, t), e.createArgument = (e, n) => new t(e, n), e.Command = n, e.Option = o, e.Argument = t, e.Help = a, e.CommanderError = r, e.InvalidArgumentError = i, e.InvalidOptionArgumentError = i;
})))(), 1)).default, ge = /* @__PURE__ */ u(((e, n) => {
	var r = t("constants"), i = process.cwd, a = null, o = process.env.GRACEFUL_FS_PLATFORM || process.platform;
	process.cwd = function() {
		return a ||= i.call(process), a;
	};
	try {
		process.cwd();
	} catch {}
	if (typeof process.chdir == "function") {
		var s = process.chdir;
		process.chdir = function(e) {
			a = null, s.call(process, e);
		}, Object.setPrototypeOf && Object.setPrototypeOf(process.chdir, s);
	}
	n.exports = c;
	function c(e) {
		r.hasOwnProperty("O_SYMLINK") && process.vers