git-remote-ops 0.1.0

package/esm/deps/jsr.io/@cliffy/command/1.1.0/command.js

@@ -0,0 +1,1861 @@
+// deno-lint-ignore-file no-explicit-any
+import { parseFlags, UnknownTypeError, ValidationError as FlagsValidationError, } from "../../flags/1.1.0/mod.js";
+import { bold, brightBlue, red } from "../../../@std/fmt/1.0.10/colors.js";
+import { CommandNotFoundError, DefaultCommandNotFoundError, DuplicateCommandAliasError, DuplicateCommandNameError, DuplicateCompletionError, DuplicateEnvVarError, DuplicateExampleError, DuplicateOptionNameError, DuplicateTypeError, MissingCommandNameError, MissingRequiredEnvVarError, NoArgumentsAllowedError, TooManyArgumentsError, TooManyEnvVarValuesError, UnexpectedOptionalEnvVarValueError, UnexpectedVariadicEnvVarValueError, UnknownCommandError, ValidationError, } from "./_errors.js";
+import { exit } from "../../internal/1.1.0/runtime/exit.js";
+import { getArgs } from "../../internal/1.1.0/runtime/get_args.js";
+import { getEnv } from "../../internal/1.1.0/runtime/get_env.js";
+import { getDescription, parseArgumentsDefinition, splitArguments, underscoreToCamelCase, } from "./_utils.js";
+import { HelpGenerator } from "./help/_help_generator.js";
+import { Type } from "./type.js";
+import { BooleanType } from "./types/boolean.js";
+import { FileType } from "./types/file.js";
+import { IntegerType } from "./types/integer.js";
+import { NumberType } from "./types/number.js";
+import { SecretType } from "./types/secret.js";
+import { StringType } from "./types/string.js";
+import { checkVersion } from "./upgrade/_check_version.js";
+/**
+ * Chainable command factory class.
+ *
+ * The command class can be used to create main and sub commands. All methods
+ * from the command class are chainable. Options, arguments, types, etc. that
+ * belong to the main command, should be registered before the first sub-command
+ * is registered. All options, arguments, etc. that are registered after calling
+ * the `.command()` method will be registered to that child-command.
+ *
+ * When calling the `.reset()` method, options, arguments, etc. will be
+ * registered again to the main command.
+ *
+ * @example Todo cli
+ *
+ * ```ts
+ * import { Command } from "./mod.ts";
+ *
+ * export const cli = new Command()
+ *   .name("todo")
+ *   .description("Todo cli.")
+ *   .globalOption("--verbose", "Enable verbose output.")
+ *   .globalEnv("VERBOSE=<value>", "Enable verbose output.")
+ *   .command("add <todo>", "Add todo.")
+ *   .action(({ verbose }, todo: string) => {
+ *     if (verbose) {
+ *       console.log("Add todo '%s'.", todo);
+ *     }
+ *   })
+ *   .command("delete <id>", "Delete todo.")
+ *   .action(({ verbose }, id: string) => {
+ *     if (verbose) {
+ *       console.log("Delete todo with id '%s'.", id);
+ *     }
+ *   });
+ *
+ * if (import.meta.main) {
+ *   await cli.parse();
+ * }
+ * ```
+ *
+ * @example Use command instance as child command
+ *
+ * ```ts
+ * import { Command } from "./mod.ts";
+ *
+ * export const addCommand = new Command<{ verbose?: boolean }>()
+ *   .description("Add todo.")
+ *   .arguments("<todo>")
+ *   .action(({ verbose }, todo: string) => {
+ *     if (verbose) {
+ *       console.log("Add todo '%s'.", todo);
+ *     }
+ *   });
+ *
+ * export const deleteCommand = new Command<{ verbose?: boolean }>()
+ *   .description("Delete todo.")
+ *   .arguments("<id>")
+ *   .action(({ verbose }, id: string) => {
+ *     if (verbose) {
+ *       console.log("Delete todo with id '%s'.", id);
+ *     }
+ *   });
+ *
+ * export const cli = new Command()
+ *   .name("todo")
+ *   .description("Todo cli.")
+ *   .globalOption("--verbose", "Enable verbose output.")
+ *   .globalEnv("VERBOSE=<value:boolean>", "Enable verbose output.")
+ *   .command("add", addCommand)
+ *   .command("delete", deleteCommand);
+ *
+ * if (import.meta.main) {
+ *   await cli.parse();
+ * }
+ * ```
+ */
+export class Command {
+    cmd = this;
+    parent;
+    props = {
+        rawArgs: [],
+        literalArgs: [],
+        args: [],
+    };
+    settings = {
+        name: "COMMAND",
+        description: "",
+        examples: [],
+        aliases: [],
+        meta: {},
+        commands: new Map(),
+    };
+    builder = {
+        groupName: null,
+        types: new Map(),
+        options: [],
+        envVars: [],
+        completions: new Map(),
+    };
+    versionOption(flags, desc, opts) {
+        this.settings.versionOptions = flags === false ? flags : {
+            flags,
+            desc,
+            opts: typeof opts === "function" ? { action: opts } : opts,
+        };
+        return this;
+    }
+    helpOption(flags, desc, opts) {
+        this.settings.helpOptions = flags === false ? flags : {
+            flags,
+            desc,
+            opts: typeof opts === "function" ? { action: opts } : opts,
+        };
+        return this;
+    }
+    /**
+     * Add new sub-command.
+     * @param nameAndArguments  Command definition. E.g: `my-command <input-file:string> <output-file:string>`
+     * @param cmdOrDescription  The description of the new child command.
+     * @param options           Sub-command options.
+     */
+    command(nameAndArguments, cmdOrDescription, { override } = {}) {
+        this.reset();
+        const result = splitArguments(nameAndArguments);
+        const name = result.flags.shift();
+        const aliases = result.flags;
+        if (!name) {
+            throw new MissingCommandNameError();
+        }
+        if (this.getBaseCommand(name, true)) {
+            if (!override) {
+                throw new DuplicateCommandNameError(name);
+            }
+            this.removeCommand(name);
+        }
+        let description;
+        let cmd;
+        if (typeof cmdOrDescription === "string") {
+            description = cmdOrDescription;
+        }
+        if (cmdOrDescription instanceof Command) {
+            cmd = cmdOrDescription.reset();
+        }
+        else {
+            cmd = new Command();
+        }
+        cmd.settings.name = name;
+        cmd.parent = this;
+        if (description) {
+            cmd.description(description);
+        }
+        if (result.typeDefinition) {
+            cmd.arguments(result.typeDefinition);
+        }
+        aliases.forEach((alias) => cmd.alias(alias));
+        this.settings.commands.set(name, cmd);
+        this.select(name);
+        return this;
+    }
+    /**
+     * Add new command alias.
+     *
+     * @param alias Tha name of the alias.
+     */
+    alias(alias) {
+        if (this.cmd.settings.name === alias ||
+            this.cmd.settings.aliases.includes(alias)) {
+            throw new DuplicateCommandAliasError(alias);
+        }
+        this.cmd.settings.aliases.push(alias);
+        return this;
+    }
+    /** Reset internal command reference to main command. */
+    reset() {
+        this.builder.groupName = null;
+        this.cmd = this;
+        return this;
+    }
+    /**
+     * Set internal command pointer to child command with given name.
+     * @param name The name of the command to select.
+     */
+    select(name) {
+        const cmd = this.getBaseCommand(name, true);
+        if (!cmd) {
+            throw new CommandNotFoundError(name, this.getBaseCommands(true));
+        }
+        this.cmd = cmd;
+        return this;
+    }
+    /*****************************************************************************
+     **** SUB HANDLER ************************************************************
+     *****************************************************************************/
+    /**
+     * Set command name.
+     *
+     * This method is usually used to set the command name for the main command.
+     * The name should match the name of your program. It is displayed in the auto
+     * generated help and used for shell completions by default.
+     *
+     * When used on child command, the name will be overridden by the command name
+     * passed to the parent command when the command is registered with the
+     * {@linkcode Command.command}.
+     *
+     * @param name The name for the command.
+     */
+    name(name) {
+        this.cmd.settings.name = name;
+        return this;
+    }
+    /**
+     * Set command version.
+     *
+     * Set the version of your cli. The version is displayed in the auto generated
+     * help and the output from the [version](./help.md#version-option) option.
+     *
+     * @param version Semantic version string string or method that returns the version string.
+     */
+    version(version) {
+        if (typeof version === "string") {
+            this.cmd.settings.version = () => version;
+        }
+        else if (typeof version === "function") {
+            this.cmd.settings.version = version;
+        }
+        return this;
+    }
+    /**
+     * Add meta data. Will be displayed in the auto generated help and in the
+     * output of the long version.
+     *
+     * @param name  The name/label of the metadata.
+     * @param value The value of the metadata.
+     */
+    meta(name, value) {
+        this.cmd.settings.meta[name] = value;
+        return this;
+    }
+    getMeta(name) {
+        return typeof name === "undefined"
+            ? this.settings.meta
+            : this.settings.meta[name];
+    }
+    /**
+     * Set help options or define a custom help handler or help string.
+     *
+     * @param help Options for the build-in help generator or a custom help string
+     * or function that generates the help string. If the help is a function, it
+     * receives the command instance and the help options as parameters and should
+     * return the help string. If the help is a string, it is returned as is when
+     * the help is called.
+     * @param customHelpOptions Custom help options. If the first parameter is an
+     * object, it is treated as custom help options and the default help generator
+     * will be used to generate the help text based on these options.
+     *
+     * @example Help options
+     *
+     * ```ts
+     * import { Command } from "@cliffy/command";
+     *
+     * await new Command()
+     *   .name("demo")
+     *   .help({ auto: true })
+     *   .parse();
+     * ```
+     *
+     * @example Custom help string
+     *
+     * ```ts
+     * import { Command } from "@cliffy/command";
+     *
+     * await new Command()
+     *   .name("demo")
+     *   .help("This is a custom help string.")
+     *   .parse();
+     * ```
+     *
+     * @example Custom help handler
+     *
+     * ```ts
+     * import { Command } from "@cliffy/command";
+     *
+     * await new Command()
+     *   .name("demo")
+     *   .help((cmd) => {
+     *     return `This is a custom help string for command ${cmd.getName()}.`;
+     *   })
+     *   .parse();
+     * ```
+     *
+     * @example Help help handler with options
+     *
+     * ```ts
+     * import { Command } from "@cliffy/command";
+     *
+     * await new Command()
+     *   .name("demo")
+     *   .help(
+     *     (cmd, options) => {
+     *       return `This is a custom help string for command ${cmd.getName()} with options: ${JSON.stringify(options)}.`;
+     *     },
+     *     { auto: true },
+     *   )
+     *   .parse();
+     * ```
+     */
+    help(help, customHelpOptions) {
+        if (typeof help === "string") {
+            this.cmd.settings.help = () => help;
+        }
+        else if (typeof help === "function") {
+            this.cmd.settings.help = help;
+        }
+        else {
+            customHelpOptions = help;
+            this.cmd.settings.help = (cmd, options) => HelpGenerator.generate(cmd, { ...help, ...options });
+        }
+        this.cmd.settings.autoHelp = customHelpOptions?.auto;
+        return this;
+    }
+    /**
+     * Set the command description.
+     *
+     * The description will be displayed in the auto generated help. If the help
+     * option is called with the short flag `-h`, only the first line is
+     * displayed. If called with the long name `--help`, the full description is
+     * displayed.
+     *
+     * For better multiline formatting, unnecessary indentations and empty leading
+     * and trailing lines will be automatically removed.
+     *
+     * @example Multiline formatting
+     *
+     * For example, following description:
+     *
+     * ```ts
+     * import { Command } from "https://deno.land/x/cliffy/command/mod.ts";
+     *
+     * new Command()
+     *   .description(`
+     *     This is a multiline description.
+     *       The indentation of this line will be preserved.
+     *   `);
+     * ```
+     *
+     * is formatted as follows:
+     *
+     * ```console
+     * This is a multiline description.
+     *   The indentation of this line will be preserved.
+     * ```
+     *
+     * @param description The command description.
+     */
+    description(description) {
+        this.cmd.settings.description = description;
+        return this;
+    }
+    /**
+     * Set the command usage. Defaults to arguments.
+     *
+     * With the `.usage()` method you can override the usage text that is
+     * displayed at the top of the auto generated help. By default the command
+     * arguments are used. The usage is always prefixed with the command name.
+     *
+     * @example Set custom usage
+     *
+     * ```ts
+     * import { Command } from "https://deno.land/x/cliffy/command/mod.ts";
+     *
+     * await new Command()
+     *   .name("script-runner")
+     *   .description("Simple script runner.")
+     *   .usage("[options] [script] [script options]")
+     *   // ...
+     *   .parse(Deno.args);
+     * ```
+     *
+     * @param usage The command usage.
+     */
+    usage(usage) {
+        this.cmd.settings.usage = usage;
+        return this;
+    }
+    /** Hide command from help, completions, etc. */
+    hidden() {
+        this.cmd.settings.isHidden = true;
+        return this;
+    }
+    /** Make command globally available. */
+    global() {
+        this.cmd.settings.isGlobal = true;
+        return this;
+    }
+    /**
+     * Set command arguments.
+     *
+     * You can use the {@linkcode Command.arguments} method to specify the
+     * arguments for the command.
+     *
+     * This method will override any previously defined arguments.
+     *
+     * Angled brackets (e.g. `<required>`) indicate required input and
+     * square brackets (e.g. `[optional]`) indicate optional input. A required
+     * input cannot be defined after an optional input.
+     *
+     * Arguments can be also defined with the {@linkcode Command.command} method.
+     *
+     * Optionally you can define [types](./types.md) and
+     * [completions](./shell_completions.md) for your arguments after the argument
+     * name separated by colon. If no type is specified the type defaults to
+     * `string`.
+     *
+     * @example Define arguments
+     *
+     * ```ts
+     * import { Command } from "@cliffy/command";
+     *
+     * const cmd = new Command()
+     *   .name("example")
+     *   .arguments("<input-file:string> [output-file:string] [...tags:string]", [
+     *     "The input file.",
+     *     "The output file.",
+     *     "Tags for the file."
+     *   ]);
+     *
+     * // Parsing arguments
+     * const { args } = await cmd.parse(["input.txt", "result.txt", "tag1", "tag2"]);
+     *
+     * console.log(args); // Output: ['input.txt', 'result.txt', 'tag1', 'tag2']
+     * ```
+     *
+     * @example Use custom types in arguments
+     *
+     * ```typescript
+     * import { Command, EnumType } from "@cliffy/command";
+     *
+     * await new Command()
+     *   .type("color", new EnumType(["red", "blue"]))
+     *   .arguments("<color:color>")
+     *   .action((_, color: "red" | "blue") => {
+     *     console.log("color:", color);
+     *   })
+     *   .parse(Deno.args);
+     * ```
+     *
+     * @example Variadic arguments
+     *
+     * The last argument of a command can be variadic. To make an argument
+     * variadic you can append or prepend `...` to the argument name (`<...NAME>`
+     * or `<NAME...>`).
+     *
+     * Required rest arguments `<...args>` requires at least one argument, optional
+     * rest args `[...args]` are completely optional.
+     *
+     * ```typescript
+     * import { Command } from "https://deno.land/x/cliffy/command/mod.ts";
+     *
+     * await new Command()
+     *   .description("Remove directories.")
+     *   .arguments("<dirs...>")
+     *   .action((_, ...dirs: Array<string>) => {
+     *     for (const dir of dirs) {
+     *       console.log("rmdir %s", dir);
+     *     }
+     *   })
+     *   .parse(Deno.args);
+     * ```
+     *
+     * ```console
+     * $ deno run example.ts dir1 dir2 dir3
+     * rmdir dir1
+     * rmdir dir2
+     * rmdir dir3
+     * ```
+     *
+     * @param args         The arguments definition string.
+     * @param descriptions The argument descriptions.
+     * @returns            The command instance.
+     */
+    arguments(args, descriptions) {
+        this.cmd.settings.arguments = args.split(" ").map((arg, index) => ({
+            arg,
+            description: descriptions?.[index],
+        }));
+        return this;
+    }
+    /**
+     * Add a new command argument.
+     *
+     * - When called multiple times, arguments are appended in the order of calls.
+     * - When called after `arguments()`, the new argument is appended after the previously
+     *   defined arguments.
+     * - When called before `arguments()`, the new argument is overwritten by the later
+     *   defined arguments.
+     *
+     * @example
+     * ```ts
+     * import { Command } from "@cliffy/command";
+     *
+     * const cmd = new Command()
+     *   .name("example")
+     *   .argument("<input-file:string>", "The input file.")
+     *   .argument("[output-file:string]", "The output file.", { default: "out.txt" })
+     *   .argument("[...tags:string]", "Tags for the file.");
+     *
+     * // Parsing arguments
+     * const { args } = await cmd.parse(["input.txt", "result.txt", "tag1", "tag2"]);
+     *
+     * console.log(args); // Output: ['input.txt', 'result.txt', 'tag1', 'tag2']
+     * ```
+     *
+     * @param arg         The argument definition. E.g: `<input-file:string>`
+     * @param description The argument description.
+     * @param opts        Argument options.
+     * @returns           The command instance.
+     */
+    argument(arg, description, opts) {
+        this.cmd.settings.arguments ??= [];
+        this.cmd.settings.arguments.push({ arg, description, ...opts });
+        return this;
+    }
+    /**
+     * Set command callback method.
+     *
+     * @param fn Command action handler.
+     */
+    action(fn) {
+        this.cmd.settings.actionHandler = fn;
+        return this;
+    }
+    /**
+     * Set command callback method.
+     *
+     * @param fn Command action handler.
+     */
+    globalAction(fn) {
+        this.cmd.settings.globalActionHandler = fn;
+        return this;
+    }
+    /**
+     * Don't throw an error if the command was called without arguments.
+     *
+     * @param allowEmpty Enable/disable allow empty.
+     */
+    allowEmpty(allowEmpty) {
+        this.cmd.settings.allowEmpty = allowEmpty !== false;
+        return this;
+    }
+    /**
+     * Enable stop early. If enabled, all arguments starting from the first non
+     * option argument will be passed as arguments with type string to the command
+     * action handler.
+     *
+     * For example:
+     *     `command --debug-level warning server --port 80`
+     *
+     * Will result in:
+     *     - options: `{ debugLevel: 'warning' }`
+     *     - args: `['server', '--port', '80']`
+     *
+     * @param stopEarly Enable/disable stop early.
+     */
+    stopEarly(stopEarly = true) {
+        this.cmd.settings.stopEarly = stopEarly;
+        return this;
+    }
+    /**
+     * Disable parsing arguments. If enabled the raw arguments will be passed to
+     * the action handler. This has no effect for parent or child commands. Only
+     * for the command on which this method was called.
+     *
+     * @param useRawArgs Enable/disable raw arguments.
+     */
+    useRawArgs(useRawArgs = true) {
+        this.cmd.settings.useRawArgs = useRawArgs;
+        return this;
+    }
+    /**
+     * Set default command.
+     *
+     * The default command is executed when the command was called without any
+     * additional arguments.
+     *
+     * @param name Name of the default command.
+     */
+    default(name) {
+        this.cmd.settings.defaultCommand = name;
+        return this;
+    }
+    globalType(name, handler, options) {
+        return this.type(name, handler, { ...options, global: true });
+    }
+    /**
+     * Register custom type.
+     *
+     * @param name    The name of the type.
+     * @param handler The callback method to parse the type.
+     * @param options Type options.
+     */
+    type(name, handler, options) {
+        if (this.cmd.builder.types.get(name) && !options?.override) {
+            throw new DuplicateTypeError(name);
+        }
+        this.cmd.builder.types.set(name, {
+            ...options,
+            name,
+            handler: handler,
+        });
+        if (handler instanceof Type &&
+            (typeof handler.complete !== "undefined" ||
+                typeof handler.values !== "undefined")) {
+            const completeHandler = (cmd, parent) => handler.complete?.(cmd, parent) || [];
+            this.complete(name, completeHandler, options);
+        }
+        return this;
+    }
+    /**
+     * Register global complete handler.
+     *
+     * @param name      The name of the completion.
+     * @param complete  The callback method to complete the type.
+     * @param options   Complete options.
+     */
+    globalComplete(name, complete, options) {
+        return this.complete(name, complete, { ...options, global: true });
+    }
+    complete(name, complete, options) {
+        if (this.cmd.builder.completions.has(name) && !options?.override) {
+            throw new DuplicateCompletionError(name);
+        }
+        this.cmd.builder.completions.set(name, {
+            name,
+            complete,
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Throw validation errors instead of calling `exit()` to handle
+     * validation errors manually.
+     *
+     * A validation error is thrown when the command is wrongly used by the user.
+     * For example: If the user passes some invalid options or arguments to the
+     * command.
+     *
+     * This has no effect for parent commands. Only for the command on which this
+     * method was called and all child commands.
+     *
+     * **Example:**
+     *
+     * ```ts
+     * import { Command, ValidationError } from "./mod.ts";
+     *
+     * const cmd = new Command();
+     * // ...
+     *
+     * try {
+     *   cmd.parse();
+     * } catch(error) {
+     *   if (error instanceof ValidationError) {
+     *     cmd.showHelp();
+     *     Deno.exit(1);
+     *   }
+     *   throw error;
+     * }
+     * ```
+     *
+     * @see ValidationError
+     */
+    throwErrors() {
+        this.cmd.settings.throwOnError = true;
+        return this;
+    }
+    /**
+     * Set custom error handler.
+     *
+     * @param handler Error handler callback function.
+     */
+    error(handler) {
+        this.cmd.settings.errorHandler = handler;
+        return this;
+    }
+    /** Get error handler callback function. */
+    getErrorHandler() {
+        return this.settings.errorHandler ??
+            (this.parent && this.parent.settings.errorHandler);
+    }
+    /**
+     * Same as `.throwErrors()` but also prevents calling `exit()` after
+     * printing help or version with the --help and --version option.
+     */
+    noExit() {
+        this.cmd.settings.shouldExit = false;
+        this.throwErrors();
+        return this;
+    }
+    /**
+     * Disable inheriting global commands, options and environment variables from
+     * parent commands.
+     */
+    noGlobals() {
+        this.cmd.settings.noGlobals = true;
+        return this;
+    }
+    /** Check whether the command should throw errors or exit. */
+    shouldThrowErrors() {
+        return this.settings.throwOnError || !!this.parent?.shouldThrowErrors();
+    }
+    /** Check whether the command should exit after printing help or version. */
+    shouldExit() {
+        return this.settings.shouldExit ?? this.parent?.shouldExit() ?? true;
+    }
+    /**
+     * Enable grouping of options and set the name of the group.
+     * All option which are added after calling the `.group()` method will be
+     * grouped in the help output. If the `.group()` method can be use multiple
+     * times to create more groups.
+     *
+     * @param name The name of the option group.
+     */
+    group(name) {
+        this.cmd.builder.groupName = name;
+        return this;
+    }
+    /**
+     * Register a global option.
+     *
+     * @param flags Flags string e.g: -h, --help, --manual <requiredArg:string> [optionalArg:number] [...restArgs:string]
+     * @param desc Flag description.
+     * @param opts Flag options or custom handler for processing flag value.
+     */
+    globalOption(flags, desc, opts) {
+        if (typeof opts === "function") {
+            return this.option(flags, desc, { value: opts, global: true });
+        }
+        return this.option(flags, desc, { ...opts, global: true });
+    }
+    option(flags, desc, opts) {
+        if (typeof opts === "function") {
+            opts = { value: opts };
+        }
+        const result = splitArguments(flags);
+        const args = result.typeDefinition
+            ? parseArgumentsDefinition(result.typeDefinition)
+            : [];
+        const option = {
+            ...opts,
+            name: "",
+            description: desc,
+            args,
+            flags: result.flags,
+            equalsSign: result.equalsSign,
+            typeDefinition: result.typeDefinition,
+            groupName: this.builder.groupName ?? undefined,
+        };
+        if (option.separator) {
+            for (const arg of args) {
+                if (arg.list) {
+                    arg.separator = option.separator;
+                }
+            }
+        }
+        for (const part of option.flags) {
+            const arg = part.trim();
+            const isLong = /^--/.test(arg);
+            const name = isLong ? arg.slice(2) : arg.slice(1);
+            if (this.cmd.getBaseOption(name, true)) {
+                if (opts?.override) {
+                    this.removeOption(name);
+                }
+                else {
+                    throw new DuplicateOptionNameError(name, this.getPath());
+                }
+            }
+            if (!option.name && isLong) {
+                option.name = name;
+            }
+            else if (!option.aliases) {
+                option.aliases = [name];
+            }
+            else {
+                option.aliases.push(name);
+            }
+        }
+        if (option.prepend) {
+            this.cmd.builder.options.unshift(option);
+        }
+        else {
+            this.cmd.builder.options.push(option);
+        }
+        return this;
+    }
+    /**
+     * Register command example.
+     *
+     * @param name          Name of the example.
+     * @param description   The content of the example.
+     */
+    example(name, description) {
+        if (this.cmd.hasExample(name)) {
+            throw new DuplicateExampleError(name);
+        }
+        this.cmd.settings.examples.push({ name, description });
+        return this;
+    }
+    /**
+     * @param flags Flags string e.g: -h, --help, --manual <requiredArg:string> [optionalArg:number] [...restArgs:string]
+     * @param desc Flag description.
+     * @param opts Flag options or custom handler for processing flag value.
+     */
+    /**
+     * Register a global environment variable.
+     *
+     * @param name        Name of the environment variable.
+     * @param description The description of the environment variable.
+     * @param options     Environment variable options.
+     */
+    globalEnv(name, description, options) {
+        return this.env(name, description, { ...options, global: true });
+    }
+    env(name, description, options) {
+        const result = splitArguments(name);
+        if (!result.typeDefinition) {
+            result.typeDefinition = "<value:boolean>";
+        }
+        if (result.flags.some((envName) => this.cmd.getBaseEnvVar(envName, true))) {
+            throw new DuplicateEnvVarError(name);
+        }
+        const details = parseArgumentsDefinition(result.typeDefinition);
+        if (details.length > 1) {
+            throw new TooManyEnvVarValuesError(name);
+        }
+        else if (details.length && details[0].optional) {
+            throw new UnexpectedOptionalEnvVarValueError(name);
+        }
+        else if (details.length && details[0].variadic) {
+            throw new UnexpectedVariadicEnvVarValueError(name);
+        }
+        this.cmd.builder.envVars.push({
+            name: result.flags[0],
+            names: result.flags,
+            description,
+            type: details[0].type,
+            details: details.shift(),
+            ...options,
+        });
+        return this;
+    }
+    /*****************************************************************************
+     **** MAIN HANDLER ***********************************************************
+     *****************************************************************************/
+    /**
+     * Parse command line arguments and execute matched command.
+     *
+     * @param args Command line args to parse. Ex: `cmd.parse( Deno.args )`
+     */
+    parse(args = getArgs()) {
+        this.props.isRoot = true;
+        const ctx = {
+            unknown: args.slice(),
+            flags: {},
+            env: {},
+            literal: [],
+            stopEarly: false,
+            stopOnUnknown: false,
+            defaults: {},
+            actions: [],
+            parsedFlags: [],
+        };
+        return this.parseCommand(ctx);
+    }
+    async parseCommand(ctx) {
+        try {
+            this.reset();
+            this.registerDefaults();
+            this.props.rawArgs = ctx.unknown.slice();
+            if (this.settings.defaultCommand && !ctx.parsedFlags.length &&
+                !ctx.unknown.length) {
+                const defaultCommand = this.getCommand(this.settings.defaultCommand, true);
+                if (!defaultCommand) {
+                    throw new DefaultCommandNotFoundError(this.settings.defaultCommand, this.getCommands());
+                }
+                defaultCommand.props.globalParent = this;
+                return defaultCommand.parseCommand(ctx);
+            }
+            if (this.settings.useRawArgs) {
+                await this.parseEnvVars(ctx, this.builder.envVars);
+                return await this.execute(ctx.env, ctx.unknown, ctx);
+            }
+            let preParseGlobals = false;
+            let subCommand;
+            // Pre parse globals to support: cmd --global-option sub-command --option
+            if (ctx.unknown.length > 0) {
+                // Detect sub command.
+                subCommand = this.getSubCommand(ctx);
+                if (!subCommand) {
+                    // Only pre parse globals if first arg ist a global option.
+                    const optionName = ctx.unknown[0].replace(/^-+/, "").split("=")[0];
+                    const option = this.getOption(optionName, true);
+                    if (option?.global && !option.standalone) {
+                        preParseGlobals = true;
+                        await this.parseGlobalOptionsAndEnvVars(ctx);
+                    }
+                }
+            }
+            if (subCommand || ctx.unknown.length > 0) {
+                subCommand ??= this.getSubCommand(ctx);
+                if (subCommand) {
+                    subCommand.props.globalParent = this;
+                    return subCommand.parseCommand(ctx);
+                }
+            }
+            // Parse rest options & env vars.
+            await this.parseOptionsAndEnvVars(ctx, preParseGlobals);
+            const options = { ...ctx.env, ...ctx.flags };
+            this.props.parsedOptions = options;
+            // Process arguments.
+            await this.processArguments(ctx);
+            const args = ctx.args ?? [];
+            this.props.parsedArgs = args;
+            this.props.literalArgs = ctx.literal;
+            // Execute option action.
+            if (ctx.actions.length) {
+                await Promise.all(ctx.actions.map((action) => action.call(this, options, ...args)));
+                if (ctx.standalone) {
+                    return {
+                        options,
+                        args,
+                        cmd: this,
+                        literal: this.props.literalArgs,
+                    };
+                }
+            }
+            return await this.execute(options, args, ctx);
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    getSubCommand(ctx) {
+        const subCommand = this.getCommand(ctx.unknown[0], true);
+        if (subCommand) {
+            ctx.unknown.shift();
+        }
+        return subCommand;
+    }
+    async parseGlobalOptionsAndEnvVars(ctx) {
+        const isHelpOption = this.getHelpOption()?.flags.includes(ctx.unknown[0]);
+        // Parse global env vars.
+        const envVars = [
+            ...this.builder.envVars.filter((envVar) => envVar.global),
+            ...this.getGlobalEnvVars(true),
+        ];
+        await this.parseEnvVars(ctx, envVars, !isHelpOption);
+        // Parse global options.
+        const options = [
+            ...this.builder.options.filter((option) => option.global),
+            ...this.getGlobalOptions(true),
+        ];
+        this.parseOptions(ctx, options, {
+            stopEarly: true,
+            stopOnUnknown: true,
+            dotted: false,
+        });
+    }
+    async parseOptionsAndEnvVars(ctx, preParseGlobals) {
+        const helpOption = this.getHelpOption();
+        const isVersionOption = this.props.versionOption?.flags.includes(ctx.unknown[0]);
+        const isHelpOption = helpOption &&
+            (preParseGlobals
+                ? ctx.flags?.[helpOption.name] === true
+                : ctx.unknown.some((unknown) => helpOption.flags.includes(unknown)));
+        // Parse env vars.
+        const envVars = preParseGlobals
+            ? this.builder.envVars.filter((envVar) => !envVar.global)
+            : this.getEnvVars(true);
+        await this.parseEnvVars(ctx, envVars, !isHelpOption && !isVersionOption);
+        // Parse options.
+        const options = this.getOptions(true);
+        this.parseOptions(ctx, options, {
+            args: this.getArguments(),
+        });
+    }
+    /** Register default options like `--version` and `--help`. */
+    registerDefaults() {
+        if (this.props.hasDefaults) {
+            return this;
+        }
+        if (this.parent) {
+            if (this.props.isRoot) {
+                this.getMainCommand().registerDefaults();
+            }
+            return this;
+        }
+        this.props.hasDefaults = true;
+        this.reset();
+        !this.builder.types.has("string") &&
+            this.type("string", new StringType(), { global: true });
+        !this.builder.types.has("number") &&
+            this.type("number", new NumberType(), { global: true });
+        !this.builder.types.has("integer") &&
+            this.type("integer", new IntegerType(), { global: true });
+        !this.builder.types.has("boolean") &&
+            this.type("boolean", new BooleanType(), { global: true });
+        !this.builder.types.has("file") &&
+            this.type("file", new FileType(), { global: true });
+        !this.builder.types.has("secret") &&
+            this.type("secret", new SecretType(), { global: true });
+        if (!this.settings.help) {
+            this.help({});
+        }
+        if (this.settings.versionOptions !== false &&
+            (this.settings.versionOptions || this.settings.version)) {
+            this.option(this.settings.versionOptions?.flags || "-V, --version", this.settings.versionOptions?.desc ||
+                "Show the version number for this program.", {
+                standalone: true,
+                prepend: true,
+                action: async function () {
+                    const long = this.getRawArgs().includes(`--${this.props.versionOption?.name}`);
+                    if (long) {
+                        await checkVersion(this);
+                        this.showLongVersion();
+                    }
+                    else {
+                        this.showVersion();
+                    }
+                    this.exit();
+                },
+                ...(this.settings.versionOptions?.opts ?? {}),
+            });
+            this.props.versionOption = this.builder.options[0];
+        }
+        if (this.settings.helpOptions !== false) {
+            this.option(this.settings.helpOptions?.flags || "-h, --help", this.settings.helpOptions?.desc || "Show this help.", {
+                standalone: true,
+                global: true,
+                prepend: true,
+                action: async function () {
+                    const long = this.getRawArgs().includes(`--${this.getHelpOption()?.name}`);
+                    await checkVersion(this);
+                    this.showHelp({ long });
+                    this.exit();
+                },
+                ...(this.settings.helpOptions?.opts ?? {}),
+            });
+            this.props.helpOption = this.builder.options[0];
+        }
+        return this;
+    }
+    /**
+     * Execute command.
+     * @param options A map of all options and environment variables. This also
+     * includes global options and environment variables. The options are parsed
+     * and processed by the command before passed to the action handler.
+     * @param args Positional arguments array.
+     * @param ctx Parse context.
+     */
+    async execute(options, args, ctx) {
+        // Show help if auto help is enabled, the command has sub commands, was
+        // called without any arguments or options and has no action handler.
+        if (this.settings.commands.size && !ctx.unknown.length &&
+            !ctx.parsedFlags.length && !this.settings.actionHandler &&
+            this.isAutoHelpEnabled()) {
+            this.showHelp();
+            this.exit();
+        }
+        await this.executeGlobalAction(options, args);
+        await this.settings.actionHandler?.call(this, options, ...args);
+        return {
+            options,
+            args,
+            cmd: this,
+            literal: this.props.literalArgs,
+        };
+    }
+    async executeGlobalAction(options, args) {
+        if (!this.settings.noGlobals) {
+            await this.parent?.executeGlobalAction(options, args);
+        }
+        await this.settings.globalActionHandler?.call(this, options, ...args);
+    }
+    /** Parse raw command line arguments. */
+    parseOptions(ctx, options, { stopEarly = this.settings.stopEarly, stopOnUnknown = false, dotted = true, args = [], } = {}) {
+        parseFlags(ctx, {
+            stopEarly,
+            stopOnUnknown,
+            dotted,
+            allowEmpty: this.settings.allowEmpty,
+            flags: options,
+            args,
+            ignoreDefaults: ctx.env,
+            parse: (type) => this.parseType(type),
+            option: (option) => {
+                if (option.action) {
+                    ctx.actions.push(option.action);
+                }
+            },
+        });
+    }
+    /** Parse argument type. */
+    parseType(type) {
+        const typeSettings = this.getType(type.type);
+        if (!typeSettings) {
+            throw new UnknownTypeError(type.type, this.getTypes().map((type) => type.name));
+        }
+        return typeSettings.handler instanceof Type
+            ? typeSettings.handler.parse(type)
+            : typeSettings.handler(type);
+    }
+    /**
+     * Read and validate environment variables.
+     * @param ctx Parse context.
+     * @param envVars env vars defined by the command.
+     * @param validate when true, throws an error if a required env var is missing.
+     */
+    async parseEnvVars(ctx, envVars, validate = true) {
+        await Promise.all(envVars.map(async (envVar) => {
+            const env = await this.findEnvVar(envVar.names);
+            if (env) {
+                const parseType = (value) => {
+                    return this.parseType({
+                        label: "Environment variable",
+                        type: envVar.type,
+                        name: env.name,
+                        value,
+                    });
+                };
+                const propertyName = underscoreToCamelCase(envVar.prefix
+                    ? envVar.names[0].replace(new RegExp(`^${envVar.prefix}`), "")
+                    : envVar.names[0]);
+                if (envVar.details.list) {
+                    ctx.env[propertyName] = env.value
+                        .split(envVar.details.separator ?? ",")
+                        .map(parseType);
+                }
+                else {
+                    ctx.env[propertyName] = parseType(env.value);
+                }
+                if (envVar.value && typeof ctx.env[propertyName] !== "undefined") {
+                    ctx.env[propertyName] = envVar.value(ctx.env[propertyName]);
+                }
+            }
+            else if (envVar.required && validate) {
+                throw new MissingRequiredEnvVarError(envVar);
+            }
+        }));
+    }
+    async findEnvVar(names) {
+        const statuses = await Promise.all(names.map(async (name) => {
+            // dnt-shim-ignore
+            const status = await globalThis.Deno?.permissions
+                .query({ name: "env", variable: name });
+            return { name, status };
+        }));
+        for (const { name, status } of statuses) {
+            if (!status || status.state === "granted") {
+                const value = getEnv(name);
+                if (value) {
+                    return { name, value };
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Processes command-line arguments.
+     *
+     * @param ctx Parse context.
+     */
+    async processArguments(ctx) {
+        if (!this.hasArguments() && ctx.unknown.length) {
+            if (this.hasCommands(true)) {
+                if (this.hasCommand(ctx.unknown[0], true)) {
+                    // e.g: command --global-foo --foo sub-command
+                    throw new TooManyArgumentsError(ctx.unknown);
+                }
+                else {
+                    throw new UnknownCommandError(ctx.unknown[0], this.getCommands());
+                }
+            }
+            else {
+                throw new NoArgumentsAllowedError(this.getPath());
+            }
+        }
+        if (ctx.args?.length) {
+            ctx.args = await Promise.all(ctx.args ?? []);
+        }
+        else if (ctx.stopEarly || ctx.stopOnUnknown) {
+            ctx.args = ctx.unknown;
+        }
+    }
+    handleError(error) {
+        this.throw(error instanceof FlagsValidationError
+            ? new ValidationError(error.message, { cause: error })
+            : error instanceof Error
+                ? error
+                : new Error(`[non-error-thrown] ${error}`));
+    }
+    /**
+     * Handle error. If `throwErrors` is enabled the error will be thrown,
+     * otherwise a formatted error message will be printed and `exit(1)`
+     * will be called. This will also trigger registered error handlers.
+     *
+     * @param error The error to handle.
+     */
+    throw(error) {
+        if (error instanceof ValidationError) {
+            error.cmd = this;
+        }
+        this.getErrorHandler()?.(error, this, {
+            options: this.props.parsedOptions ?? {},
+            args: this.props.parsedArgs ?? [],
+        });
+        if (this.shouldThrowErrors() || !(error instanceof ValidationError)) {
+            throw error;
+        }
+        this.showHelp();
+        console.error(red(`  ${bold("error")}: ${error.message}\n`));
+        exit(error instanceof ValidationError ? error.exitCode : 1);
+    }
+    /*****************************************************************************
+     **** GETTER *****************************************************************
+     *****************************************************************************/
+    /** Get command name. */
+    getName() {
+        return this.settings.name;
+    }
+    /** Get parent command. */
+    getParent() {
+        return this.parent;
+    }
+    /**
+     * Get parent command from global executed command.
+     * Be sure, to call this method only inside an action handler. Unless this or any child command was executed,
+     * this method returns always undefined.
+     */
+    getGlobalParent() {
+        return this.props.globalParent;
+    }
+    /** Get main command. */
+    getMainCommand() {
+        return this.parent?.getMainCommand() ?? this;
+    }
+    /** Get command name aliases. */
+    getAliases() {
+        return this.settings.aliases;
+    }
+    /**
+     * Get full command path.
+     *
+     * @param name Override the main command name.
+     */
+    getPath(name) {
+        return this.parent && !this.props.isRoot
+            ? this.parent.getPath(name) + " " + this.settings.name
+            : name || this.settings.name;
+    }
+    /** Get arguments definition. E.g: <input-file:string> <output-file:string> */
+    getArgsDefinition() {
+        return this.settings.arguments?.map(({ arg }) => arg).join(" ");
+    }
+    /**
+     * Get argument by name.
+     *
+     * @param name Name of the argument.
+     */
+    getArgument(name) {
+        return this.getArguments().find((arg) => arg.name === name);
+    }
+    /** Get arguments. */
+    getArguments() {
+        if (!this.props.args.length && this.settings.arguments) {
+            this.props.args = parseArgumentsDefinition(this.settings.arguments);
+        }
+        return this.props.args;
+    }
+    /** Check if command has arguments. */
+    hasArguments() {
+        return !!this.settings.arguments?.length;
+    }
+    /** Get command version. */
+    getVersion() {
+        return this.getVersionHandler()?.call(this, this);
+    }
+    /** Get help handler method. */
+    getVersionHandler() {
+        return this.settings.version ?? this.parent?.getVersionHandler();
+    }
+    /** Get command description. */
+    getDescription() {
+        // call description method only once
+        return typeof this.settings.description === "function"
+            ? this.settings.description = this.settings.description.call(this)
+            : this.settings.description;
+    }
+    /** Get auto generated command usage. */
+    getUsage() {
+        return this.settings.usage ??
+            [this.getArgsDefinition(), this.getRequiredOptionsDefinition()]
+                .join(" ")
+                .trim();
+    }
+    getRequiredOptionsDefinition() {
+        return this.getOptions()
+            .filter((option) => option.required)
+            .map((option) => [findFlag(option.flags), option.typeDefinition].filter((v) => v)
+            .join(" ")
+            .trim())
+            .join(" ");
+    }
+    /** Get short command description. This is the first line of the description. */
+    getShortDescription() {
+        return getDescription(this.getDescription(), true);
+    }
+    /** Get original command-line arguments. */
+    getRawArgs() {
+        return this.props.rawArgs;
+    }
+    /** Get all arguments defined after the double dash. */
+    getLiteralArgs() {
+        return this.props.literalArgs;
+    }
+    /** Output generated help without exiting. */
+    showVersion() {
+        console.log(this.getVersion());
+    }
+    /** Returns command name, version and meta data. */
+    getLongVersion() {
+        return `${bold(this.getMainCommand().getName())} ${brightBlue(this.getVersion() ?? "")}` +
+            Object.entries(this.getMeta()).map(([k, v]) => `\n${bold(k)} ${brightBlue(v)}`).join("");
+    }
+    /** Outputs command name, version and meta data. */
+    showLongVersion() {
+        console.log(this.getLongVersion());
+    }
+    /** Output generated help without exiting. */
+    showHelp(options) {
+        console.log(this.getHelp(options));
+    }
+    /** Get generated help. */
+    getHelp(options) {
+        this.registerDefaults();
+        return this.getHelpHandler().call(this, this, options ?? {});
+    }
+    /** Get help handler method. */
+    getHelpHandler() {
+        return this.settings.help ?? this.parent?.getHelpHandler();
+    }
+    exit(code = 0) {
+        if (this.shouldExit()) {
+            exit(code);
+        }
+    }
+    /*****************************************************************************
+     **** Options GETTER *********************************************************
+     *****************************************************************************/
+    /**
+     * Checks whether the command has options or not.
+     *
+     * @param hidden Include hidden options.
+     */
+    hasOptions(hidden) {
+        return this.getOptions(hidden).length > 0;
+    }
+    /**
+     * Get options.
+     *
+     * @param hidden Include hidden options.
+     */
+    getOptions(hidden) {
+        return this.getGlobalOptions(hidden).concat(this.getBaseOptions(hidden));
+    }
+    /**
+     * Get base options.
+     *
+     * @param hidden Include hidden options.
+     */
+    getBaseOptions(hidden) {
+        if (!this.builder.options.length) {
+            return [];
+        }
+        return hidden
+            ? this.builder.options.slice(0)
+            : this.builder.options.filter((opt) => !opt.hidden);
+    }
+    /**
+     * Get global options.
+     *
+     * @param hidden Include hidden options.
+     */
+    getGlobalOptions(hidden) {
+        const helpOption = this.getHelpOption();
+        const getGlobals = (cmd, noGlobals, options = [], names = []) => {
+            if (cmd.builder.options.length) {
+                for (const option of cmd.builder.options) {
+                    if (option.global &&
+                        !this.builder.options.find((opt) => opt.name === option.name) &&
+                        names.indexOf(option.name) === -1 &&
+                        (hidden || !option.hidden)) {
+                        if (noGlobals && option !== helpOption) {
+                            continue;
+                        }
+                        names.push(option.name);
+                        options.push(option);
+                    }
+                }
+            }
+            return cmd.parent
+                ? getGlobals(cmd.parent, noGlobals || cmd.settings.noGlobals, options, names)
+                : options;
+        };
+        return this.parent ? getGlobals(this.parent, this.settings.noGlobals) : [];
+    }
+    /**
+     * Checks whether the command has an option with given name or not.
+     *
+     * @param name Name of the option. Must be in param-case.
+     * @param hidden Include hidden options.
+     */
+    hasOption(name, hidden) {
+        return !!this.getOption(name, hidden);
+    }
+    /**
+     * Get option by name.
+     *
+     * @param name Name of the option. Must be in param-case.
+     * @param hidden Include hidden options.
+     */
+    getOption(name, hidden) {
+        return this.getBaseOption(name, hidden) ??
+            this.getGlobalOption(name, hidden);
+    }
+    /**
+     * Get base option by name.
+     *
+     * @param name Name of the option. Must be in param-case.
+     * @param hidden Include hidden options.
+     */
+    getBaseOption(name, hidden) {
+        const option = this.builder.options.find((option) => option.name === name || option.aliases?.includes(name));
+        return option && (hidden || !option.hidden) ? option : undefined;
+    }
+    /**
+     * Get global option from parent commands by name.
+     *
+     * @param name Name of the option. Must be in param-case.
+     * @param hidden Include hidden options.
+     */
+    getGlobalOption(name, hidden) {
+        const helpOption = this.getHelpOption();
+        const getGlobalOption = (parent, noGlobals) => {
+            const option = parent.getBaseOption(name, hidden);
+            if (!option?.global) {
+                return parent.parent && getGlobalOption(parent.parent, noGlobals || parent.settings.noGlobals);
+            }
+            if (noGlobals && option !== helpOption) {
+                return;
+            }
+            return option;
+        };
+        return this.parent && getGlobalOption(this.parent, this.settings.noGlobals);
+    }
+    /**
+     * Remove option by name.
+     *
+     * @param name Name of the option. Must be in param-case.
+     */
+    removeOption(name) {
+        const index = this.builder.options.findIndex((option) => option.name === name);
+        if (index === -1) {
+            return;
+        }
+        return this.builder.options.splice(index, 1)[0];
+    }
+    /**
+     * Checks whether the command has sub-commands or not.
+     *
+     * @param hidden Include hidden commands.
+     */
+    hasCommands(hidden) {
+        return this.getCommands(hidden).length > 0;
+    }
+    /**
+     * Get commands.
+     *
+     * @param hidden Include hidden commands.
+     */
+    getCommands(hidden) {
+        return this.getGlobalCommands(hidden).concat(this.getBaseCommands(hidden));
+    }
+    /**
+     * Get base commands.
+     *
+     * @param hidden Include hidden commands.
+     */
+    getBaseCommands(hidden) {
+        const commands = Array.from(this.settings.commands.values());
+        return hidden ? commands : commands.filter((cmd) => !cmd.settings.isHidden);
+    }
+    /**
+     * Get global commands.
+     *
+     * @param hidden Include hidden commands.
+     */
+    getGlobalCommands(hidden) {
+        const getCommands = (command, noGlobals, commands = [], names = []) => {
+            if (command.settings.commands.size) {
+                for (const [_, cmd] of command.settings.commands) {
+                    if (cmd.settings.isGlobal &&
+                        this !== cmd &&
+                        !this.settings.commands.has(cmd.settings.name) &&
+                        names.indexOf(cmd.settings.name) === -1 &&
+                        (hidden || !cmd.settings.isHidden)) {
+                        if (noGlobals && cmd?.getName() !== "help") {
+                            continue;
+                        }
+                        names.push(cmd.settings.name);
+                        commands.push(cmd);
+                    }
+                }
+            }
+            return command.parent
+                ? getCommands(command.parent, noGlobals || command.settings.noGlobals, commands, names)
+                : commands;
+        };
+        return this.parent ? getCommands(this.parent, this.settings.noGlobals) : [];
+    }
+    /**
+     * Checks whether a child command exists by given name or alias.
+     *
+     * @param name Name or alias of the command.
+     * @param hidden Include hidden commands.
+     */
+    hasCommand(name, hidden) {
+        return !!this.getCommand(name, hidden);
+    }
+    /**
+     * Get command by name or alias.
+     *
+     * @param name Name or alias of the command.
+     * @param hidden Include hidden commands.
+     */
+    getCommand(name, hidden) {
+        return this.getBaseCommand(name, hidden) ??
+            this.getGlobalCommand(name, hidden);
+    }
+    /**
+     * Get base command by name or alias.
+     *
+     * @param name Name or alias of the command.
+     * @param hidden Include hidden commands.
+     */
+    getBaseCommand(name, hidden) {
+        for (const cmd of this.settings.commands.values()) {
+            if (cmd.settings.name === name || cmd.settings.aliases.includes(name)) {
+                return (cmd && (hidden || !cmd.settings.isHidden) ? cmd : undefined);
+            }
+        }
+    }
+    /**
+     * Get global command by name or alias.
+     *
+     * @param name Name or alias of the command.
+     * @param hidden Include hidden commands.
+     */
+    getGlobalCommand(name, hidden) {
+        const getGlobalCommand = (parent, noGlobals) => {
+            const cmd = parent.getBaseCommand(name, hidden);
+            if (!cmd || !cmd.settings.isGlobal) {
+                return parent.parent &&
+                    getGlobalCommand(parent.parent, noGlobals || parent.settings.noGlobals);
+            }
+            if (noGlobals && cmd.getName() !== "help") {
+                return;
+            }
+            return cmd;
+        };
+        return this.parent &&
+            getGlobalCommand(this.parent, this.settings.noGlobals);
+    }
+    /**
+     * Remove sub-command by name or alias.
+     *
+     * @param name Name or alias of the command.
+     */
+    removeCommand(name) {
+        const command = this.getBaseCommand(name, true);
+        if (command) {
+            this.settings.commands.delete(command.settings.name);
+        }
+        return command;
+    }
+    /** Get types. */
+    getTypes() {
+        return this.getGlobalTypes().concat(this.getBaseTypes());
+    }
+    /** Get base types. */
+    getBaseTypes() {
+        return Array.from(this.builder.types.values());
+    }
+    /** Get global types. */
+    getGlobalTypes() {
+        const getTypes = (cmd, types = [], names = []) => {
+            if (cmd) {
+                if (cmd.builder.types.size) {
+                    cmd.builder.types.forEach((type) => {
+                        if (type.global &&
+                            !this.builder.types.has(type.name) &&
+                            names.indexOf(type.name) === -1) {
+                            names.push(type.name);
+                            types.push(type);
+                        }
+                    });
+                }
+                return getTypes(cmd.parent, types, names);
+            }
+            return types;
+        };
+        return getTypes(this.parent);
+    }
+    /**
+     * Get type by name.
+     *
+     * @param name Name of the type.
+     */
+    getType(name) {
+        return this.getBaseType(name) ?? this.getGlobalType(name);
+    }
+    /**
+     * Get base type by name.
+     *
+     * @param name Name of the type.
+     */
+    getBaseType(name) {
+        return this.builder.types.get(name);
+    }
+    /**
+     * Get global type by name.
+     *
+     * @param name Name of the type.
+     */
+    getGlobalType(name) {
+        if (!this.parent) {
+            return;
+        }
+        const cmd = this.parent.getBaseType(name);
+        if (!cmd?.global) {
+            return this.parent.getGlobalType(name);
+        }
+        return cmd;
+    }
+    /** Get completions. */
+    getCompletions() {
+        return this.getGlobalCompletions().concat(this.getBaseCompletions());
+    }
+    /** Get base completions. */
+    getBaseCompletions() {
+        return Array.from(this.builder.completions.values());
+    }
+    /** Get global completions. */
+    getGlobalCompletions() {
+        const getCompletions = (cmd, completions = [], names = []) => {
+            if (cmd) {
+                if (cmd.builder.completions.size) {
+                    cmd.builder.completions.forEach((completion) => {
+                        if (completion.global &&
+                            !this.builder.completions.has(completion.name) &&
+                            names.indexOf(completion.name) === -1) {
+                            names.push(completion.name);
+                            completions.push(completion);
+                        }
+                    });
+                }
+                return getCompletions(cmd.parent, completions, names);
+            }
+            return completions;
+        };
+        return getCompletions(this.parent);
+    }
+    /**
+     * Get completion by name.
+     *
+     * @param name Name of the completion.
+     */
+    getCompletion(name) {
+        return this.getBaseCompletion(name) ?? this.getGlobalCompletion(name);
+    }
+    /**
+     * Get base completion by name.
+     *
+     * @param name Name of the completion.
+     */
+    getBaseCompletion(name) {
+        return this.builder.completions.get(name);
+    }
+    /**
+     * Get global completions by name.
+     *
+     * @param name Name of the completion.
+     */
+    getGlobalCompletion(name) {
+        if (!this.parent) {
+            return;
+        }
+        const completion = this.parent.getBaseCompletion(name);
+        if (!completion?.global) {
+            return this.parent.getGlobalCompletion(name);
+        }
+        return completion;
+    }
+    /**
+     * Checks whether the command has environment variables or not.
+     *
+     * @param hidden Include hidden environment variable.
+     */
+    hasEnvVars(hidden) {
+        return this.getEnvVars(hidden).length > 0;
+    }
+    /**
+     * Get environment variables.
+     *
+     * @param hidden Include hidden environment variable.
+     */
+    getEnvVars(hidden) {
+        return this.getGlobalEnvVars(hidden).concat(this.getBaseEnvVars(hidden));
+    }
+    /**
+     * Get base environment variables.
+     *
+     * @param hidden Include hidden environment variable.
+     */
+    getBaseEnvVars(hidden) {
+        if (!this.builder.envVars.length) {
+            return [];
+        }
+        return hidden
+            ? this.builder.envVars.slice(0)
+            : this.builder.envVars.filter((env) => !env.hidden);
+    }
+    /**
+     * Get global environment variables.
+     *
+     * @param hidden Include hidden environment variable.
+     */
+    getGlobalEnvVars(hidden) {
+        if (this.settings.noGlobals) {
+            return [];
+        }
+        const getEnvVars = (cmd, envVars = [], names = []) => {
+            if (cmd) {
+                if (cmd.builder.envVars.length) {
+                    cmd.builder.envVars.forEach((envVar) => {
+                        if (envVar.global &&
+                            !this.builder.envVars.find((env) => env.names[0] === envVar.names[0]) &&
+                            names.indexOf(envVar.names[0]) === -1 &&
+                            (hidden || !envVar.hidden)) {
+                            names.push(envVar.names[0]);
+                            envVars.push(envVar);
+                        }
+                    });
+                }
+                return getEnvVars(cmd.parent, envVars, names);
+            }
+            return envVars;
+        };
+        return getEnvVars(this.parent);
+    }
+    /**
+     * Checks whether the command has an environment variable with given name or not.
+     *
+     * @param name Name of the environment variable.
+     * @param hidden Include hidden environment variable.
+     */
+    hasEnvVar(name, hidden) {
+        return !!this.getEnvVar(name, hidden);
+    }
+    /**
+     * Get environment variable by name.
+     *
+     * @param name Name of the environment variable.
+     * @param hidden Include hidden environment variable.
+     */
+    getEnvVar(name, hidden) {
+        return this.getBaseEnvVar(name, hidden) ??
+            this.getGlobalEnvVar(name, hidden);
+    }
+    /**
+     * Get base environment variable by name.
+     *
+     * @param name Name of the environment variable.
+     * @param hidden Include hidden environment variable.
+     */
+    getBaseEnvVar(name, hidden) {
+        const envVar = this.builder.envVars.find((env) => env.names.indexOf(name) !== -1);
+        return envVar && (hidden || !envVar.hidden) ? envVar : undefined;
+    }
+    /**
+     * Get global environment variable by name.
+     *
+     * @param name Name of the environment variable.
+     * @param hidden Include hidden environment variable.
+     */
+    getGlobalEnvVar(name, hidden) {
+        if (!this.parent || this.settings.noGlobals) {
+            return;
+        }
+        const envVar = this.parent.getBaseEnvVar(name, hidden);
+        if (!envVar?.global) {
+            return this.parent.getGlobalEnvVar(name, hidden);
+        }
+        return envVar;
+    }
+    /** Checks whether the command has examples or not. */
+    hasExamples() {
+        return this.settings.examples.length > 0;
+    }
+    /** Get all examples. */
+    getExamples() {
+        return this.settings.examples;
+    }
+    /** Checks whether the command has an example with given name or not. */
+    hasExample(name) {
+        return !!this.getExample(name);
+    }
+    /** Get example with given name. */
+    getExample(name) {
+        return this.settings.examples.find((example) => example.name === name);
+    }
+    getHelpOption() {
+        return this.props.helpOption ?? this.parent?.getHelpOption();
+    }
+    isAutoHelpEnabled() {
+        return this.settings.autoHelp ?? this.parent?.isAutoHelpEnabled() ?? true;
+    }
+}
+function findFlag(flags) {
+    for (const flag of flags) {
+        if (flag.startsWith("--")) {
+            return flag;
+        }
+    }
+    return flags[0];
+}