@bleedingdev/modern-js-utils 3.9.0-ultramodern.9 → 3.9.3-ultramodern.1

package/dist/compiled/commander/index.mjs

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