create-awesome-node-app 0.4.23 → 0.4.26

package/dist/index.js

@@ -31,1874 +31,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/commander/index.js
-var require_commander = __commonJS({
-  "../../node_modules/commander/index.js"(exports, module) {
-    var EventEmitter = __require("events").EventEmitter;
-    var childProcess = __require("child_process");
-    var path = __require("path");
-    var fs = __require("fs");
-    var Help = class {
-      constructor() {
-        this.helpWidth = void 0;
-        this.sortSubcommands = false;
-        this.sortOptions = false;
-      }
-      /**
-       * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
-       *
-       * @param {Command} cmd
-       * @returns {Command[]}
-       */
-      visibleCommands(cmd) {
-        const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-        if (cmd._hasImplicitHelpCommand()) {
-          const args = cmd._helpCommandnameAndArgs.split(/ +/);
-          const helpCommand = cmd.createCommand(args.shift()).helpOption(false);
-          helpCommand.description(cmd._helpCommandDescription);
-          helpCommand._parseExpectedArgs(args);
-          visibleCommands.push(helpCommand);
-        }
-        if (this.sortSubcommands) {
-          visibleCommands.sort((a, b) => {
-            return a.name().localeCompare(b.name());
-          });
-        }
-        return visibleCommands;
-      }
-      /**
-       * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
-       *
-       * @param {Command} cmd
-       * @returns {Option[]}
-       */
-      visibleOptions(cmd) {
-        const visibleOptions = cmd.options.filter((option) => !option.hidden);
-        const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
-        const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
-        if (showShortHelpFlag || showLongHelpFlag) {
-          let helpOption;
-          if (!showShortHelpFlag) {
-            helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
-          } else if (!showLongHelpFlag) {
-            helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
-          } else {
-            helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
-          }
-          visibleOptions.push(helpOption);
-        }
-        if (this.sortOptions) {
-          const getSortKey = (option) => {
-            return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-          };
-          visibleOptions.sort((a, b) => {
-            return getSortKey(a).localeCompare(getSortKey(b));
-          });
-        }
-        return visibleOptions;
-      }
-      /**
-       * Get an array of the arguments which have descriptions.
-       *
-       * @param {Command} cmd
-       * @returns {{ term: string, description:string }[]}
-       */
-      visibleArguments(cmd) {
-        if (cmd._argsDescription && cmd._args.length) {
-          return cmd._args.map((argument) => {
-            return { term: argument.name, description: cmd._argsDescription[argument.name] || "" };
-          }, 0);
-        }
-        return [];
-      }
-      /**
-       * Get the command term to show in the list of subcommands.
-       *
-       * @param {Command} cmd
-       * @returns {string}
-       */
-      subcommandTerm(cmd) {
-        const args = cmd._args.map((arg) => humanReadableArgName(arg)).join(" ");
-        return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + // simplistic check for non-help option
-        (args ? " " + args : "");
-      }
-      /**
-       * Get the option term to show in the list of options.
-       *
-       * @param {Option} option
-       * @returns {string}
-       */
-      optionTerm(option) {
-        return option.flags;
-      }
-      /**
-       * Get the longest command term length.
-       *
-       * @param {Command} cmd
-       * @param {Help} helper
-       * @returns {number}
-       */
-      longestSubcommandTermLength(cmd, helper) {
-        return helper.visibleCommands(cmd).reduce((max, command) => {
-          return Math.max(max, helper.subcommandTerm(command).length);
-        }, 0);
-      }
-      /**
-       * Get the longest option term length.
-       *
-       * @param {Command} cmd
-       * @param {Help} helper
-       * @returns {number}
-       */
-      longestOptionTermLength(cmd, helper) {
-        return helper.visibleOptions(cmd).reduce((max, option) => {
-          return Math.max(max, helper.optionTerm(option).length);
-        }, 0);
-      }
-      /**
-       * Get the longest argument term length.
-       *
-       * @param {Command} cmd
-       * @param {Help} helper
-       * @returns {number}
-       */
-      longestArgumentTermLength(cmd, helper) {
-        return helper.visibleArguments(cmd).reduce((max, argument) => {
-          return Math.max(max, argument.term.length);
-        }, 0);
-      }
-      /**
-       * Get the command usage to be displayed at the top of the built-in help.
-       *
-       * @param {Command} cmd
-       * @returns {string}
-       */
-      commandUsage(cmd) {
-        let cmdName = cmd._name;
-        if (cmd._aliases[0]) {
-          cmdName = cmdName + "|" + cmd._aliases[0];
-        }
-        let parentCmdNames = "";
-        for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
-          parentCmdNames = parentCmd.name() + " " + parentCmdNames;
-        }
-        return parentCmdNames + cmdName + " " + cmd.usage();
-      }
-      /**
-       * Get the description for the command.
-       *
-       * @param {Command} cmd
-       * @returns {string}
-       */
-      commandDescription(cmd) {
-        return cmd.description();
-      }
-      /**
-       * Get the command description to show in the list of subcommands.
-       *
-       * @param {Command} cmd
-       * @returns {string}
-       */
-      subcommandDescription(cmd) {
-        return cmd.description();
-      }
-      /**
-       * Get the option description to show in the list of options.
-       *
-       * @param {Option} option
-       * @return {string}
-       */
-      optionDescription(option) {
-        if (option.negate) {
-          return option.description;
-        }
-        const extraInfo = [];
-        if (option.argChoices) {
-          extraInfo.push(
-            // use stringify to match the display of the default value
-            `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
-          );
-        }
-        if (option.defaultValue !== void 0) {
-          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-        }
-        if (extraInfo.length > 0) {
-          return `${option.description} (${extraInfo.join(", ")})`;
-        }
-        return option.description;
-      }
-      /**
-       * Generate the built-in help text.
-       *
-       * @param {Command} cmd
-       * @param {Help} helper
-       * @returns {string}
-       */
-      formatHelp(cmd, helper) {
-        const termWidth = helper.padWidth(cmd, helper);
-        const helpWidth = helper.helpWidth || 80;
-        const itemIndentWidth = 2;
-        const itemSeparatorWidth = 2;
-        function formatItem(term, description) {
-          if (description) {
-            const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-            return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-          }
-          return term;
-        }
-        ;
-        function formatList(textArray) {
-          return textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
-        }
-        let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
-        const commandDescription = helper.commandDescription(cmd);
-        if (commandDescription.length > 0) {
-          output = output.concat([commandDescription, ""]);
-        }
-        const argumentList = helper.visibleArguments(cmd).map((argument) => {
-          return formatItem(argument.term, argument.description);
-        });
-        if (argumentList.length > 0) {
-          output = output.concat(["Arguments:", formatList(argumentList), ""]);
-        }
-        const optionList = helper.visibleOptions(cmd).map((option) => {
-          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
-        });
-        if (optionList.length > 0) {
-          output = output.concat(["Options:", formatList(optionList), ""]);
-        }
-        const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-          return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
-        });
-        if (commandList.length > 0) {
-          output = output.concat(["Commands:", formatList(commandList), ""]);
-        }
-        return output.join("\n");
-      }
-      /**
-       * Calculate the pad width from the maximum term length.
-       *
-       * @param {Command} cmd
-       * @param {Help} helper
-       * @returns {number}
-       */
-      padWidth(cmd, helper) {
-        return Math.max(
-          helper.longestOptionTermLength(cmd, helper),
-          helper.longestSubcommandTermLength(cmd, helper),
-          helper.longestArgumentTermLength(cmd, helper)
-        );
-      }
-      /**
-       * Wrap the given string to width characters per line, with lines after the first indented.
-       * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
-       *
-       * @param {string} str
-       * @param {number} width
-       * @param {number} indent
-       * @param {number} [minColumnWidth=40]
-       * @return {string}
-       *
-       */
-      wrap(str, width, indent, minColumnWidth = 40) {
-        if (str.match(/[\n]\s+/))
-          return str;
-        const columnWidth = width - indent;
-        if (columnWidth < minColumnWidth)
-          return str;
-        const leadingStr = str.substr(0, indent);
-        const columnText = str.substr(indent);
-        const indentString = " ".repeat(indent);
-        const regex = new RegExp(".{1," + (columnWidth - 1) + "}([\\s\u200B]|$)|[^\\s\u200B]+?([\\s\u200B]|$)", "g");
-        const lines = columnText.match(regex) || [];
-        return leadingStr + lines.map((line, i) => {
-          if (line.slice(-1) === "\n") {
-            line = line.slice(0, line.length - 1);
-          }
-          return (i > 0 ? indentString : "") + line.trimRight();
-        }).join("\n");
-      }
-    };
-    var Option = class {
-      /**
-       * Initialize a new `Option` with the given `flags` and `description`.
-       *
-       * @param {string} flags
-       * @param {string} [description]
-       */
-      constructor(flags, description) {
-        this.flags = flags;
-        this.description = description || "";
-        this.required = flags.includes("<");
-        this.optional = flags.includes("[");
-        this.variadic = /\w\.\.\.[>\]]$/.test(flags);
-        this.mandatory = false;
-        const optionFlags = _parseOptionFlags(flags);
-        this.short = optionFlags.shortFlag;
-        this.long = optionFlags.longFlag;
-        this.negate = false;
-        if (this.long) {
-          this.negate = this.long.startsWith("--no-");
-        }
-        this.defaultValue = void 0;
-        this.defaultValueDescription = void 0;
-        this.parseArg = void 0;
-        this.hidden = false;
-        this.argChoices = void 0;
-      }
-      /**
-       * Set the default value, and optionally supply the description to be displayed in the help.
-       *
-       * @param {any} value
-       * @param {string} [description]
-       * @return {Option}
-       */
-      default(value, description) {
-        this.defaultValue = value;
-        this.defaultValueDescription = description;
-        return this;
-      }
-      /**
-       * Set the custom handler for processing CLI option arguments into option values.
-       *
-       * @param {Function} [fn]
-       * @return {Option}
-       */
-      argParser(fn) {
-        this.parseArg = fn;
-        return this;
-      }
-      /**
-       * Whether the option is mandatory and must have a value after parsing.
-       *
-       * @param {boolean} [mandatory=true]
-       * @return {Option}
-       */
-      makeOptionMandatory(mandatory = true) {
-        this.mandatory = !!mandatory;
-        return this;
-      }
-      /**
-       * Hide option in help.
-       *
-       * @param {boolean} [hide=true]
-       * @return {Option}
-       */
-      hideHelp(hide = true) {
-        this.hidden = !!hide;
-        return this;
-      }
-      /**
-       * @api private
-       */
-      _concatValue(value, previous) {
-        if (previous === this.defaultValue || !Array.isArray(previous)) {
-          return [value];
-        }
-        return previous.concat(value);
-      }
-      /**
-       * Only allow option value to be one of choices.
-       *
-       * @param {string[]} values
-       * @return {Option}
-       */
-      choices(values) {
-        this.argChoices = values;
-        this.parseArg = (arg, previous) => {
-          if (!values.includes(arg)) {
-            throw new InvalidOptionArgumentError(`Allowed choices are ${values.join(", ")}.`);
-          }
-          if (this.variadic) {
-            return this._concatValue(arg, previous);
-          }
-          return arg;
-        };
-        return this;
-      }
-      /**
-       * Return option name.
-       *
-       * @return {string}
-       */
-      name() {
-        if (this.long) {
-          return this.long.replace(/^--/, "");
-        }
-        return this.short.replace(/^-/, "");
-      }
-      /**
-       * Return option name, in a camelcase format that can be used
-       * as a object attribute key.
-       *
-       * @return {string}
-       * @api private
-       */
-      attributeName() {
-        return camelcase(this.name().replace(/^no-/, ""));
-      }
-      /**
-       * Check if `arg` matches the short or long flag.
-       *
-       * @param {string} arg
-       * @return {boolean}
-       * @api private
-       */
-      is(arg) {
-        return this.short === arg || this.long === arg;
-      }
-    };
-    var CommanderError = class extends Error {
-      /**
-       * Constructs the CommanderError class
-       * @param {number} exitCode suggested exit code which could be used with process.exit
-       * @param {string} code an id string representing the error
-       * @param {string} message human-readable description of the error
-       * @constructor
-       */
-      constructor(exitCode, code, message) {
-        super(message);
-        Error.captureStackTrace(this, this.constructor);
-        this.name = this.constructor.name;
-        this.code = code;
-        this.exitCode = exitCode;
-        this.nestedError = void 0;
-      }
-    };
-    var InvalidOptionArgumentError = class extends CommanderError {
-      /**
-       * Constructs the InvalidOptionArgumentError class
-       * @param {string} [message] explanation of why argument is invalid
-       * @constructor
-       */
-      constructor(message) {
-        super(1, "commander.invalidOptionArgument", message);
-        Error.captureStackTrace(this, this.constructor);
-        this.name = this.constructor.name;
-      }
-    };
-    var Command = class extends EventEmitter {
-      /**
-       * Initialize a new `Command`.
-       *
-       * @param {string} [name]
-       */
-      constructor(name) {
-        super();
-        this.commands = [];
-        this.options = [];
-        this.parent = null;
-        this._allowUnknownOption = false;
-        this._allowExcessArguments = true;
-        this._args = [];
-        this.rawArgs = null;
-        this._scriptPath = null;
-        this._name = name || "";
-        this._optionValues = {};
-        this._storeOptionsAsProperties = false;
-        this._actionResults = [];
-        this._actionHandler = null;
-        this._executableHandler = false;
-        this._executableFile = null;
-        this._defaultCommandName = null;
-        this._exitCallback = null;
-        this._aliases = [];
-        this._combineFlagAndOptionalValue = true;
-        this._description = "";
-        this._argsDescription = void 0;
-        this._enablePositionalOptions = false;
-        this._passThroughOptions = false;
-        this._outputConfiguration = {
-          writeOut: (str) => process.stdout.write(str),
-          writeErr: (str) => process.stderr.write(str),
-          getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns : void 0,
-          getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns : void 0,
-          outputError: (str, write) => write(str)
-        };
-        this._hidden = false;
-        this._hasHelpOption = true;
-        this._helpFlags = "-h, --help";
-        this._helpDescription = "display help for command";
-        this._helpShortFlag = "-h";
-        this._helpLongFlag = "--help";
-        this._addImplicitHelpCommand = void 0;
-        this._helpCommandName = "help";
-        this._helpCommandnameAndArgs = "help [command]";
-        this._helpCommandDescription = "display help for command";
-        this._helpConfiguration = {};
-      }
-      /**
-       * Define a command.
-       *
-       * There are two styles of command: pay attention to where to put the description.
-       *
-       * Examples:
-       *
-       *      // Command implemented using action handler (description is supplied separately to `.command`)
-       *      program
-       *        .command('clone <source> [destination]')
-       *        .description('clone a repository into a newly created directory')
-       *        .action((source, destination) => {
-       *          console.log('clone command called');
-       *        });
-       *
-       *      // Command implemented using separate executable file (description is second parameter to `.command`)
-       *      program
-       *        .command('start <service>', 'start named service')
-       *        .command('stop [service]', 'stop named service, or all if no name supplied');
-       *
-       * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
-       * @param {Object|string} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
-       * @param {Object} [execOpts] - configuration options (for executable)
-       * @return {Command} returns new command for action handler, or `this` for executable command
-       */
-      command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
-        let desc = actionOptsOrExecDesc;
-        let opts = execOpts;
-        if (typeof desc === "object" && desc !== null) {
-          opts = desc;
-          desc = null;
-        }
-        opts = opts || {};
-        const args = nameAndArgs.split(/ +/);
-        const cmd = this.createCommand(args.shift());
-        if (desc) {
-          cmd.description(desc);
-          cmd._executableHandler = true;
-        }
-        if (opts.isDefault)
-          this._defaultCommandName = cmd._name;
-        cmd._outputConfiguration = this._outputConfiguration;
-        cmd._hidden = !!(opts.noHelp || opts.hidden);
-        cmd._hasHelpOption = this._hasHelpOption;
-        cmd._helpFlags = this._helpFlags;
-        cmd._helpDescription = this._helpDescription;
-        cmd._helpShortFlag = this._helpShortFlag;
-        cmd._helpLongFlag = this._helpLongFlag;
-        cmd._helpCommandName = this._helpCommandName;
-        cmd._helpCommandnameAndArgs = this._helpCommandnameAndArgs;
-        cmd._helpCommandDescription = this._helpCommandDescription;
-        cmd._helpConfiguration = this._helpConfiguration;
-        cmd._exitCallback = this._exitCallback;
-        cmd._storeOptionsAsProperties = this._storeOptionsAsProperties;
-        cmd._combineFlagAndOptionalValue = this._combineFlagAndOptionalValue;
-        cmd._allowExcessArguments = this._allowExcessArguments;
-        cmd._enablePositionalOptions = this._enablePositionalOptions;
-        cmd._executableFile = opts.executableFile || null;
-        this.commands.push(cmd);
-        cmd._parseExpectedArgs(args);
-        cmd.parent = this;
-        if (desc)
-          return this;
-        return cmd;
-      }
-      /**
-       * Factory routine to create a new unattached command.
-       *
-       * See .command() for creating an attached subcommand, which uses this routine to
-       * create the command. You can override createCommand to customise subcommands.
-       *
-       * @param {string} [name]
-       * @return {Command} new command
-       */
-      createCommand(name) {
-        return new Command(name);
-      }
-      /**
-       * You can customise the help with a subclass of Help by overriding createHelp,
-       * or by overriding Help properties using configureHelp().
-       *
-       * @return {Help}
-       */
-      createHelp() {
-        return Object.assign(new Help(), this.configureHelp());
-      }
-      /**
-       * You can customise the help by overriding Help properties using configureHelp(),
-       * or with a subclass of Help by overriding createHelp().
-       *
-       * @param {Object} [configuration] - configuration options
-       * @return {Command|Object} `this` command for chaining, or stored configuration
-       */
-      configureHelp(configuration) {
-        if (configuration === void 0)
-          return this._helpConfiguration;
-        this._helpConfiguration = configuration;
-        return this;
-      }
-      /**
-       * The default output goes to stdout and stderr. You can customise this for special
-       * applications. You can also customise the display of errors by overriding outputError.
-       *
-       * The configuration properties are all functions:
-       *
-       *    // functions to change where being written, stdout and stderr
-       *    writeOut(str)
-       *    writeErr(str)
-       *    // matching functions to specify width for wrapping help
-       *    getOutHelpWidth()
-       *    getErrHelpWidth()
-       *    // functions based on what is being written out
-       *    outputError(str, write) // used for displaying errors, and not used for displaying help
-       *
-       * @param {Object} [configuration] - configuration options
-       * @return {Command|Object} `this` command for chaining, or stored configuration
-       */
-      configureOutput(configuration) {
-        if (configuration === void 0)
-          return this._outputConfiguration;
-        Object.assign(this._outputConfiguration, configuration);
-        return this;
-      }
-      /**
-       * Add a prepared subcommand.
-       *
-       * See .command() for creating an attached subcommand which inherits settings from its parent.
-       *
-       * @param {Command} cmd - new subcommand
-       * @param {Object} [opts] - configuration options
-       * @return {Command} `this` command for chaining
-       */
-      addCommand(cmd, opts) {
-        if (!cmd._name)
-          throw new Error("Command passed to .addCommand() must have a name");
-        function checkExplicitNames(commandArray) {
-          commandArray.forEach((cmd2) => {
-            if (cmd2._executableHandler && !cmd2._executableFile) {
-              throw new Error(`Must specify executableFile for deeply nested executable: ${cmd2.name()}`);
-            }
-            checkExplicitNames(cmd2.commands);
-          });
-        }
-        checkExplicitNames(cmd.commands);
-        opts = opts || {};
-        if (opts.isDefault)
-          this._defaultCommandName = cmd._name;
-        if (opts.noHelp || opts.hidden)
-          cmd._hidden = true;
-        this.commands.push(cmd);
-        cmd.parent = this;
-        return this;
-      }
-      /**
-       * Define argument syntax for the command.
-       */
-      arguments(desc) {
-        return this._parseExpectedArgs(desc.split(/ +/));
-      }
-      /**
-       * Override default decision whether to add implicit help command.
-       *
-       *    addHelpCommand() // force on
-       *    addHelpCommand(false); // force off
-       *    addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
-       *
-       * @return {Command} `this` command for chaining
-       */
-      addHelpCommand(enableOrNameAndArgs, description) {
-        if (enableOrNameAndArgs === false) {
-          this._addImplicitHelpCommand = false;
-        } else {
-          this._addImplicitHelpCommand = true;
-          if (typeof enableOrNameAndArgs === "string") {
-            this._helpCommandName = enableOrNameAndArgs.split(" ")[0];
-            this._helpCommandnameAndArgs = enableOrNameAndArgs;
-          }
-          this._helpCommandDescription = description || this._helpCommandDescription;
-        }
-        return this;
-      }
-      /**
-       * @return {boolean}
-       * @api private
-       */
-      _hasImplicitHelpCommand() {
-        if (this._addImplicitHelpCommand === void 0) {
-          return this.commands.length && !this._actionHandler && !this._findCommand("help");
-        }
-        return this._addImplicitHelpCommand;
-      }
-      /**
-       * Parse expected `args`.
-       *
-       * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
-       *
-       * @param {Array} args
-       * @return {Command} `this` command for chaining
-       * @api private
-       */
-      _parseExpectedArgs(args) {
-        if (!args.length)
-          return;
-        args.forEach((arg) => {
-          const argDetails = {
-            required: false,
-            name: "",
-            variadic: false
-          };
-          switch (arg[0]) {
-            case "<":
-              argDetails.required = true;
-              argDetails.name = arg.slice(1, -1);
-              break;
-            case "[":
-              argDetails.name = arg.slice(1, -1);
-              break;
-          }
-          if (argDetails.name.length > 3 && argDetails.name.slice(-3) === "...") {
-            argDetails.variadic = true;
-            argDetails.name = argDetails.name.slice(0, -3);
-          }
-          if (argDetails.name) {
-            this._args.push(argDetails);
-          }
-        });
-        this._args.forEach((arg, i) => {
-          if (arg.variadic && i < this._args.length - 1) {
-            throw new Error(`only the last argument can be variadic '${arg.name}'`);
-          }
-        });
-        return this;
-      }
-      /**
-       * Register callback to use as replacement for calling process.exit.
-       *
-       * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing
-       * @return {Command} `this` command for chaining
-       */
-      exitOverride(fn) {
-        if (fn) {
-          this._exitCallback = fn;
-        } else {
-          this._exitCallback = (err) => {
-            if (err.code !== "commander.executeSubCommandAsync") {
-              throw err;
-            } else {
-            }
-          };
-        }
-        return this;
-      }
-      /**
-       * Call process.exit, and _exitCallback if defined.
-       *
-       * @param {number} exitCode exit code for using with process.exit
-       * @param {string} code an id string representing the error
-       * @param {string} message human-readable description of the error
-       * @return never
-       * @api private
-       */
-      _exit(exitCode, code, message) {
-        if (this._exitCallback) {
-          this._exitCallback(new CommanderError(exitCode, code, message));
-        }
-        process.exit(exitCode);
-      }
-      /**
-       * Register callback `fn` for the command.
-       *
-       * Examples:
-       *
-       *      program
-       *        .command('help')
-       *        .description('display verbose help')
-       *        .action(function() {
-       *           // output help here
-       *        });
-       *
-       * @param {Function} fn
-       * @return {Command} `this` command for chaining
-       */
-      action(fn) {
-        const listener = (args) => {
-          const expectedArgsCount = this._args.length;
-          const actionArgs = args.slice(0, expectedArgsCount);
-          if (this._storeOptionsAsProperties) {
-            actionArgs[expectedArgsCount] = this;
-          } else {
-            actionArgs[expectedArgsCount] = this.opts();
-          }
-          actionArgs.push(this);
-          const actionResult = fn.apply(this, actionArgs);
-          let rootCommand = this;
-          while (rootCommand.parent) {
-            rootCommand = rootCommand.parent;
-          }
-          rootCommand._actionResults.push(actionResult);
-        };
-        this._actionHandler = listener;
-        return this;
-      }
-      /**
-       * Factory routine to create a new unattached option.
-       *
-       * See .option() for creating an attached option, which uses this routine to
-       * create the option. You can override createOption to return a custom option.
-       *
-       * @param {string} flags
-       * @param {string} [description]
-       * @return {Option} new option
-       */
-      createOption(flags, description) {
-        return new Option(flags, description);
-      }
-      /**
-       * Add an option.
-       *
-       * @param {Option} option
-       * @return {Command} `this` command for chaining
-       */
-      addOption(option) {
-        const oname = option.name();
-        const name = option.attributeName();
-        let defaultValue = option.defaultValue;
-        if (option.negate || option.optional || option.required || typeof defaultValue === "boolean") {
-          if (option.negate) {
-            const positiveLongFlag = option.long.replace(/^--no-/, "--");
-            defaultValue = this._findOption(positiveLongFlag) ? this._getOptionValue(name) : true;
-          }
-          if (defaultValue !== void 0) {
-            this._setOptionValue(name, defaultValue);
-          }
-        }
-        this.options.push(option);
-        this.on("option:" + oname, (val) => {
-          const oldValue = this._getOptionValue(name);
-          if (val !== null && option.parseArg) {
-            try {
-              val = option.parseArg(val, oldValue === void 0 ? defaultValue : oldValue);
-            } catch (err) {
-              if (err.code === "commander.invalidOptionArgument") {
-                const message = `error: option '${option.flags}' argument '${val}' is invalid. ${err.message}`;
-                this._displayError(err.exitCode, err.code, message);
-              }
-              throw err;
-            }
-          } else if (val !== null && option.variadic) {
-            val = option._concatValue(val, oldValue);
-          }
-          if (typeof oldValue === "boolean" || typeof oldValue === "undefined") {
-            if (val == null) {
-              this._setOptionValue(name, option.negate ? false : defaultValue || true);
-            } else {
-              this._setOptionValue(name, val);
-            }
-          } else if (val !== null) {
-            this._setOptionValue(name, option.negate ? false : val);
-          }
-        });
-        return this;
-      }
-      /**
-       * Internal implementation shared by .option() and .requiredOption()
-       *
-       * @api private
-       */
-      _optionEx(config, flags, description, fn, defaultValue) {
-        const option = this.createOption(flags, description);
-        option.makeOptionMandatory(!!config.mandatory);
-        if (typeof fn === "function") {
-          option.default(defaultValue).argParser(fn);
-        } else if (fn instanceof RegExp) {
-          const regex = fn;
-          fn = (val, def) => {
-            const m = regex.exec(val);
-            return m ? m[0] : def;
-          };
-          option.default(defaultValue).argParser(fn);
-        } else {
-          option.default(fn);
-        }
-        return this.addOption(option);
-      }
-      /**
-       * Define option with `flags`, `description` and optional
-       * coercion `fn`.
-       *
-       * The `flags` string contains the short and/or long flags,
-       * separated by comma, a pipe or space. The following are all valid
-       * all will output this way when `--help` is used.
-       *
-       *    "-p, --pepper"
-       *    "-p|--pepper"
-       *    "-p --pepper"
-       *
-       * Examples:
-       *
-       *     // simple boolean defaulting to undefined
-       *     program.option('-p, --pepper', 'add pepper');
-       *
-       *     program.pepper
-       *     // => undefined
-       *
-       *     --pepper
-       *     program.pepper
-       *     // => true
-       *
-       *     // simple boolean defaulting to true (unless non-negated option is also defined)
-       *     program.option('-C, --no-cheese', 'remove cheese');
-       *
-       *     program.cheese
-       *     // => true
-       *
-       *     --no-cheese
-       *     program.cheese
-       *     // => false
-       *
-       *     // required argument
-       *     program.option('-C, --chdir <path>', 'change the working directory');
-       *
-       *     --chdir /tmp
-       *     program.chdir
-       *     // => "/tmp"
-       *
-       *     // optional argument
-       *     program.option('-c, --cheese [type]', 'add cheese [marble]');
-       *
-       * @param {string} flags
-       * @param {string} [description]
-       * @param {Function|*} [fn] - custom option processing function or default value
-       * @param {*} [defaultValue]
-       * @return {Command} `this` command for chaining
-       */
-      option(flags, description, fn, defaultValue) {
-        return this._optionEx({}, flags, description, fn, defaultValue);
-      }
-      /**
-      * Add a required option which must have a value after parsing. This usually means
-      * the option must be specified on the command line. (Otherwise the same as .option().)
-      *
-      * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
-      *
-      * @param {string} flags
-      * @param {string} [description]
-      * @param {Function|*} [fn] - custom option processing function or default value
-      * @param {*} [defaultValue]
-      * @return {Command} `this` command for chaining
-      */
-      requiredOption(flags, description, fn, defaultValue) {
-        return this._optionEx({ mandatory: true }, flags, description, fn, defaultValue);
-      }
-      /**
-       * Alter parsing of short flags with optional values.
-       *
-       * Examples:
-       *
-       *    // for `.option('-f,--flag [value]'):
-       *    .combineFlagAndOptionalValue(true)  // `-f80` is treated like `--flag=80`, this is the default behaviour
-       *    .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
-       *
-       * @param {Boolean} [combine=true] - if `true` or omitted, an optional value can be specified directly after the flag.
-       */
-      combineFlagAndOptionalValue(combine = true) {
-        this._combineFlagAndOptionalValue = !!combine;
-        return this;
-      }
-      /**
-       * Allow unknown options on the command line.
-       *
-       * @param {Boolean} [allowUnknown=true] - if `true` or omitted, no error will be thrown
-       * for unknown options.
-       */
-      allowUnknownOption(allowUnknown = true) {
-        this._allowUnknownOption = !!allowUnknown;
-        return this;
-      }
-      /**
-       * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
-       *
-       * @param {Boolean} [allowExcess=true] - if `true` or omitted, no error will be thrown
-       * for excess arguments.
-       */
-      allowExcessArguments(allowExcess = true) {
-        this._allowExcessArguments = !!allowExcess;
-        return this;
-      }
-      /**
-       * Enable positional options. Positional means global options are specified before subcommands which lets
-       * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
-       * The default behaviour is non-positional and global options may appear anywhere on the command line.
-       *
-       * @param {Boolean} [positional=true]
-       */
-      enablePositionalOptions(positional = true) {
-        this._enablePositionalOptions = !!positional;
-        return this;
-      }
-      /**
-       * Pass through options that come after command-arguments rather than treat them as command-options,
-       * so actual command-options come before command-arguments. Turning this on for a subcommand requires
-       * positional options to have been enabled on the program (parent commands).
-       * The default behaviour is non-positional and options may appear before or after command-arguments.
-       *
-       * @param {Boolean} [passThrough=true]
-       * for unknown options.
-       */
-      passThroughOptions(passThrough = true) {
-        this._passThroughOptions = !!passThrough;
-        if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
-          throw new Error("passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)");
-        }
-        return this;
-      }
-      /**
-        * Whether to store option values as properties on command object,
-        * or store separately (specify false). In both cases the option values can be accessed using .opts().
-        *
-        * @param {boolean} [storeAsProperties=true]
-        * @return {Command} `this` command for chaining
-        */
-      storeOptionsAsProperties(storeAsProperties = true) {
-        this._storeOptionsAsProperties = !!storeAsProperties;
-        if (this.options.length) {
-          throw new Error("call .storeOptionsAsProperties() before adding options");
-        }
-        return this;
-      }
-      /**
-       * Store option value
-       *
-       * @param {string} key
-       * @param {Object} value
-       * @api private
-       */
-      _setOptionValue(key, value) {
-        if (this._storeOptionsAsProperties) {
-          this[key] = value;
-        } else {
-          this._optionValues[key] = value;
-        }
-      }
-      /**
-       * Retrieve option value
-       *
-       * @param {string} key
-       * @return {Object} value
-       * @api private
-       */
-      _getOptionValue(key) {
-        if (this._storeOptionsAsProperties) {
-          return this[key];
-        }
-        return this._optionValues[key];
-      }
-      /**
-       * Parse `argv`, setting options and invoking commands when defined.
-       *
-       * The default expectation is that the arguments are from node and have the application as argv[0]
-       * and the script being run in argv[1], with user parameters after that.
-       *
-       * Examples:
-       *
-       *      program.parse(process.argv);
-       *      program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
-       *      program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
-       *
-       * @param {string[]} [argv] - optional, defaults to process.argv
-       * @param {Object} [parseOptions] - optionally specify style of options with from: node/user/electron
-       * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
-       * @return {Command} `this` command for chaining
-       */
-      parse(argv, parseOptions) {
-        if (argv !== void 0 && !Array.isArray(argv)) {
-          throw new Error("first parameter to parse must be array or undefined");
-        }
-        parseOptions = parseOptions || {};
-        if (argv === void 0) {
-          argv = process.argv;
-          if (process.versions && process.versions.electron) {
-            parseOptions.from = "electron";
-          }
-        }
-        this.rawArgs = argv.slice();
-        let userArgs;
-        switch (parseOptions.from) {
-          case void 0:
-          case "node":
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
-            break;
-          case "electron":
-            if (process.defaultApp) {
-              this._scriptPath = argv[1];
-              userArgs = argv.slice(2);
-            } else {
-              userArgs = argv.slice(1);
-            }
-            break;
-          case "user":
-            userArgs = argv.slice(0);
-            break;
-          default:
-            throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
-        }
-        if (!this._scriptPath && __require.main) {
-          this._scriptPath = __require.main.filename;
-        }
-        this._name = this._name || this._scriptPath && path.basename(this._scriptPath, path.extname(this._scriptPath));
-        this._parseCommand([], userArgs);
-        return this;
-      }
-      /**
-       * Parse `argv`, setting options and invoking commands when defined.
-       *
-       * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
-       *
-       * The default expectation is that the arguments are from node and have the application as argv[0]
-       * and the script being run in argv[1], with user parameters after that.
-       *
-       * Examples:
-       *
-       *      program.parseAsync(process.argv);
-       *      program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
-       *      program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
-       *
-       * @param {string[]} [argv]
-       * @param {Object} [parseOptions]
-       * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
-       * @return {Promise}
-       */
-      parseAsync(argv, parseOptions) {
-        this.parse(argv, parseOptions);
-        return Promise.all(this._actionResults).then(() => this);
-      }
-      /**
-       * Execute a sub-command executable.
-       *
-       * @api private
-       */
-      _executeSubCommand(subcommand, args) {
-        args = args.slice();
-        let launchWithNode = false;
-        const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
-        this._checkForMissingMandatoryOptions();
-        let scriptPath = this._scriptPath;
-        if (!scriptPath && __require.main) {
-          scriptPath = __require.main.filename;
-        }
-        let baseDir;
-        try {
-          const resolvedLink = fs.realpathSync(scriptPath);
-          baseDir = path.dirname(resolvedLink);
-        } catch (e) {
-          baseDir = ".";
-        }
-        let bin = path.basename(scriptPath, path.extname(scriptPath)) + "-" + subcommand._name;
-        if (subcommand._executableFile) {
-          bin = subcommand._executableFile;
-        }
-        const localBin = path.join(baseDir, bin);
-        if (fs.existsSync(localBin)) {
-          bin = localBin;
-        } else {
-          sourceExt.forEach((ext) => {
-            if (fs.existsSync(`${localBin}${ext}`)) {
-              bin = `${localBin}${ext}`;
-            }
-          });
-        }
-        launchWithNode = sourceExt.includes(path.extname(bin));
-        let proc;
-        if (process.platform !== "win32") {
-          if (launchWithNode) {
-            args.unshift(bin);
-            args = incrementNodeInspectorPort(process.execArgv).concat(args);
-            proc = childProcess.spawn(process.argv[0], args, { stdio: "inherit" });
-          } else {
-            proc = childProcess.spawn(bin, args, { stdio: "inherit" });
-          }
-        } else {
-          args.unshift(bin);
-          args = incrementNodeInspectorPort(process.execArgv).concat(args);
-          proc = childProcess.spawn(process.execPath, args, { stdio: "inherit" });
-        }
-        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-        signals.forEach((signal) => {
-          process.on(signal, () => {
-            if (proc.killed === false && proc.exitCode === null) {
-              proc.kill(signal);
-            }
-          });
-        });
-        const exitCallback = this._exitCallback;
-        if (!exitCallback) {
-          proc.on("close", process.exit.bind(process));
-        } else {
-          proc.on("close", () => {
-            exitCallback(new CommanderError(process.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
-          });
-        }
-        proc.on("error", (err) => {
-          if (err.code === "ENOENT") {
-            const executableMissing = `'${bin}' does not exist
- - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name`;
-            throw new Error(executableMissing);
-          } else if (err.code === "EACCES") {
-            throw new Error(`'${bin}' not executable`);
-          }
-          if (!exitCallback) {
-            process.exit(1);
-          } else {
-            const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
-            wrappedError.nestedError = err;
-            exitCallback(wrappedError);
-          }
-        });
-        this.runningCommand = proc;
-      }
-      /**
-       * @api private
-       */
-      _dispatchSubcommand(commandName, operands, unknown) {
-        const subCommand = this._findCommand(commandName);
-        if (!subCommand)
-          this.help({ error: true });
-        if (subCommand._executableHandler) {
-          this._executeSubCommand(subCommand, operands.concat(unknown));
-        } else {
-          subCommand._parseCommand(operands, unknown);
-        }
-      }
-      /**
-       * Process arguments in context of this command.
-       *
-       * @api private
-       */
-      _parseCommand(operands, unknown) {
-        const parsed = this.parseOptions(unknown);
-        operands = operands.concat(parsed.operands);
-        unknown = parsed.unknown;
-        this.args = operands.concat(unknown);
-        if (operands && this._findCommand(operands[0])) {
-          this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
-        } else if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
-          if (operands.length === 1) {
-            this.help();
-          } else {
-            this._dispatchSubcommand(operands[1], [], [this._helpLongFlag]);
-          }
-        } else if (this._defaultCommandName) {
-          outputHelpIfRequested(this, unknown);
-          this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
-        } else {
-          if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
-            this.help({ error: true });
-          }
-          outputHelpIfRequested(this, parsed.unknown);
-          this._checkForMissingMandatoryOptions();
-          const checkForUnknownOptions = () => {
-            if (parsed.unknown.length > 0) {
-              this.unknownOption(parsed.unknown[0]);
-            }
-          };
-          const commandEvent = `command:${this.name()}`;
-          if (this._actionHandler) {
-            checkForUnknownOptions();
-            const args = this.args.slice();
-            this._args.forEach((arg, i) => {
-              if (arg.required && args[i] == null) {
-                this.missingArgument(arg.name);
-              } else if (arg.variadic) {
-                args[i] = args.splice(i);
-                args.length = Math.min(i + 1, args.length);
-              }
-            });
-            if (args.length > this._args.length) {
-              this._excessArguments(args);
-            }
-            this._actionHandler(args);
-            if (this.parent)
-              this.parent.emit(commandEvent, operands, unknown);
-          } else if (this.parent && this.parent.listenerCount(commandEvent)) {
-            checkForUnknownOptions();
-            this.parent.emit(commandEvent, operands, unknown);
-          } else if (operands.length) {
-            if (this._findCommand("*")) {
-              this._dispatchSubcommand("*", operands, unknown);
-            } else if (this.listenerCount("command:*")) {
-              this.emit("command:*", operands, unknown);
-            } else if (this.commands.length) {
-              this.unknownCommand();
-            } else {
-              checkForUnknownOptions();
-            }
-          } else if (this.commands.length) {
-            this.help({ error: true });
-          } else {
-            checkForUnknownOptions();
-          }
-        }
-      }
-      /**
-       * Find matching command.
-       *
-       * @api private
-       */
-      _findCommand(name) {
-        if (!name)
-          return void 0;
-        return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
-      }
-      /**
-       * Return an option matching `arg` if any.
-       *
-       * @param {string} arg
-       * @return {Option}
-       * @api private
-       */
-      _findOption(arg) {
-        return this.options.find((option) => option.is(arg));
-      }
-      /**
-       * Display an error message if a mandatory option does not have a value.
-       * Lazy calling after checking for help flags from leaf subcommand.
-       *
-       * @api private
-       */
-      _checkForMissingMandatoryOptions() {
-        for (let cmd = this; cmd; cmd = cmd.parent) {
-          cmd.options.forEach((anOption) => {
-            if (anOption.mandatory && cmd._getOptionValue(anOption.attributeName()) === void 0) {
-              cmd.missingMandatoryOptionValue(anOption);
-            }
-          });
-        }
-      }
-      /**
-       * Parse options from `argv` removing known options,
-       * and return argv split into operands and unknown arguments.
-       *
-       * Examples:
-       *
-       *    argv => operands, unknown
-       *    --known kkk op => [op], []
-       *    op --known kkk => [op], []
-       *    sub --unknown uuu op => [sub], [--unknown uuu op]
-       *    sub -- --unknown uuu op => [sub --unknown uuu op], []
-       *
-       * @param {String[]} argv
-       * @return {{operands: String[], unknown: String[]}}
-       */
-      parseOptions(argv) {
-        const operands = [];
-        const unknown = [];
-        let dest = operands;
-        const args = argv.slice();
-        function maybeOption(arg) {
-          return arg.length > 1 && arg[0] === "-";
-        }
-        let activeVariadicOption = null;
-        while (args.length) {
-          const arg = args.shift();
-          if (arg === "--") {
-            if (dest === unknown)
-              dest.push(arg);
-            dest.push(...args);
-            break;
-          }
-          if (activeVariadicOption && !maybeOption(arg)) {
-            this.emit(`option:${activeVariadicOption.name()}`, arg);
-            continue;
-          }
-          activeVariadicOption = null;
-          if (maybeOption(arg)) {
-            const option = this._findOption(arg);
-            if (option) {
-              if (option.required) {
-                const value = args.shift();
-                if (value === void 0)
-                  this.optionMissingArgument(option);
-                this.emit(`option:${option.name()}`, value);
-              } else if (option.optional) {
-                let value = null;
-                if (args.length > 0 && !maybeOption(args[0])) {
-                  value = args.shift();
-                }
-                this.emit(`option:${option.name()}`, value);
-              } else {
-                this.emit(`option:${option.name()}`);
-              }
-              activeVariadicOption = option.variadic ? option : null;
-              continue;
-            }
-          }
-          if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
-            const option = this._findOption(`-${arg[1]}`);
-            if (option) {
-              if (option.required || option.optional && this._combineFlagAndOptionalValue) {
-                this.emit(`option:${option.name()}`, arg.slice(2));
-              } else {
-                this.emit(`option:${option.name()}`);
-                args.unshift(`-${arg.slice(2)}`);
-              }
-              continue;
-            }
-          }
-          if (/^--[^=]+=/.test(arg)) {
-            const index = arg.indexOf("=");
-            const option = this._findOption(arg.slice(0, index));
-            if (option && (option.required || option.optional)) {
-              this.emit(`option:${option.name()}`, arg.slice(index + 1));
-              continue;
-            }
-          }
-          if (maybeOption(arg)) {
-            dest = unknown;
-          }
-          if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
-            if (this._findCommand(arg)) {
-              operands.push(arg);
-              if (args.length > 0)
-                unknown.push(...args);
-              break;
-            } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
-              operands.push(arg);
-              if (args.length > 0)
-                operands.push(...args);
-              break;
-            } else if (this._defaultCommandName) {
-              unknown.push(arg);
-              if (args.length > 0)
-                unknown.push(...args);
-              break;
-            }
-          }
-          if (this._passThroughOptions) {
-            dest.push(arg);
-            if (args.length > 0)
-              dest.push(...args);
-            break;
-          }
-          dest.push(arg);
-        }
-        return { operands, unknown };
-      }
-      /**
-       * Return an object containing options as key-value pairs
-       *
-       * @return {Object}
-       */
-      opts() {
-        if (this._storeOptionsAsProperties) {
-          const result = {};
-          const len = this.options.length;
-          for (let i = 0; i < len; i++) {
-            const key = this.options[i].attributeName();
-            result[key] = key === this._versionOptionName ? this._version : this[key];
-          }
-          return result;
-        }
-        return this._optionValues;
-      }
-      /**
-       * Internal bottleneck for handling of parsing errors.
-       *
-       * @api private
-       */
-      _displayError(exitCode, code, message) {
-        this._outputConfiguration.outputError(`${message}
-`, this._outputConfiguration.writeErr);
-        this._exit(exitCode, code, message);
-      }
-      /**
-       * Argument `name` is missing.
-       *
-       * @param {string} name
-       * @api private
-       */
-      missingArgument(name) {
-        const message = `error: missing required argument '${name}'`;
-        this._displayError(1, "commander.missingArgument", message);
-      }
-      /**
-       * `Option` is missing an argument.
-       *
-       * @param {Option} option
-       * @api private
-       */
-      optionMissingArgument(option) {
-        const message = `error: option '${option.flags}' argument missing`;
-        this._displayError(1, "commander.optionMissingArgument", message);
-      }
-      /**
-       * `Option` does not have a value, and is a mandatory option.
-       *
-       * @param {Option} option
-       * @api private
-       */
-      missingMandatoryOptionValue(option) {
-        const message = `error: required option '${option.flags}' not specified`;
-        this._displayError(1, "commander.missingMandatoryOptionValue", message);
-      }
-      /**
-       * Unknown option `flag`.
-       *
-       * @param {string} flag
-       * @api private
-       */
-      unknownOption(flag) {
-        if (this._allowUnknownOption)
-          return;
-        const message = `error: unknown option '${flag}'`;
-        this._displayError(1, "commander.unknownOption", message);
-      }
-      /**
-       * Excess arguments, more than expected.
-       *
-       * @param {string[]} receivedArgs
-       * @api private
-       */
-      _excessArguments(receivedArgs) {
-        if (this._allowExcessArguments)
-          return;
-        const expected = this._args.length;
-        const s = expected === 1 ? "" : "s";
-        const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
-        const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
-        this._displayError(1, "commander.excessArguments", message);
-      }
-      /**
-       * Unknown command.
-       *
-       * @api private
-       */
-      unknownCommand() {
-        const partCommands = [this.name()];
-        for (let parentCmd = this.parent; parentCmd; parentCmd = parentCmd.parent) {
-          partCommands.unshift(parentCmd.name());
-        }
-        const fullCommand = partCommands.join(" ");
-        const message = `error: unknown command '${this.args[0]}'.` + (this._hasHelpOption ? ` See '${fullCommand} ${this._helpLongFlag}'.` : "");
-        this._displayError(1, "commander.unknownCommand", message);
-      }
-      /**
-       * Set the program version to `str`.
-       *
-       * This method auto-registers the "-V, --version" flag
-       * which will print the version number when passed.
-       *
-       * You can optionally supply the  flags and description to override the defaults.
-       *
-       * @param {string} str
-       * @param {string} [flags]
-       * @param {string} [description]
-       * @return {this | string} `this` command for chaining, or version string if no arguments
-       */
-      version(str, flags, description) {
-        if (str === void 0)
-          return this._version;
-        this._version = str;
-        flags = flags || "-V, --version";
-        description = description || "output the version number";
-        const versionOption = this.createOption(flags, description);
-        this._versionOptionName = versionOption.attributeName();
-        this.options.push(versionOption);
-        this.on("option:" + versionOption.name(), () => {
-          this._outputConfiguration.writeOut(`${str}
-`);
-          this._exit(0, "commander.version", str);
-        });
-        return this;
-      }
-      /**
-       * Set the description to `str`.
-       *
-       * @param {string} [str]
-       * @param {Object} [argsDescription]
-       * @return {string|Command}
-       */
-      description(str, argsDescription) {
-        if (str === void 0 && argsDescription === void 0)
-          return this._description;
-        this._description = str;
-        this._argsDescription = argsDescription;
-        return this;
-      }
-      /**
-       * Set an alias for the command.
-       *
-       * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
-       *
-       * @param {string} [alias]
-       * @return {string|Command}
-       */
-      alias(alias) {
-        if (alias === void 0)
-          return this._aliases[0];
-        let command = this;
-        if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-          command = this.commands[this.commands.length - 1];
-        }
-        if (alias === command._name)
-          throw new Error("Command alias can't be the same as its name");
-        command._aliases.push(alias);
-        return this;
-      }
-      /**
-       * Set aliases for the command.
-       *
-       * Only the first alias is shown in the auto-generated help.
-       *
-       * @param {string[]} [aliases]
-       * @return {string[]|Command}
-       */
-      aliases(aliases) {
-        if (aliases === void 0)
-          return this._aliases;
-        aliases.forEach((alias) => this.alias(alias));
-        return this;
-      }
-      /**
-       * Set / get the command usage `str`.
-       *
-       * @param {string} [str]
-       * @return {String|Command}
-       */
-      usage(str) {
-        if (str === void 0) {
-          if (this._usage)
-            return this._usage;
-          const args = this._args.map((arg) => {
-            return humanReadableArgName(arg);
-          });
-          return [].concat(
-            this.options.length || this._hasHelpOption ? "[options]" : [],
-            this.commands.length ? "[command]" : [],
-            this._args.length ? args : []
-          ).join(" ");
-        }
-        this._usage = str;
-        return this;
-      }
-      /**
-       * Get or set the name of the command
-       *
-       * @param {string} [str]
-       * @return {string|Command}
-       */
-      name(str) {
-        if (str === void 0)
-          return this._name;
-        this._name = str;
-        return this;
-      }
-      /**
-       * Return program help documentation.
-       *
-       * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout
-       * @return {string}
-       */
-      helpInformation(contextOptions) {
-        const helper = this.createHelp();
-        if (helper.helpWidth === void 0) {
-          helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-        }
-        return helper.formatHelp(this, helper);
-      }
-      /**
-       * @api private
-       */
-      _getHelpContext(contextOptions) {
-        contextOptions = contextOptions || {};
-        const context = { error: !!contextOptions.error };
-        let write;
-        if (context.error) {
-          write = (arg) => this._outputConfiguration.writeErr(arg);
-        } else {
-          write = (arg) => this._outputConfiguration.writeOut(arg);
-        }
-        context.write = contextOptions.write || write;
-        context.command = this;
-        return context;
-      }
-      /**
-       * Output help information for this command.
-       *
-       * Outputs built-in help, and custom text added using `.addHelpText()`.
-       *
-       * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout
-       */
-      outputHelp(contextOptions) {
-        let deprecatedCallback;
-        if (typeof contextOptions === "function") {
-          deprecatedCallback = contextOptions;
-          contextOptions = void 0;
-        }
-        const context = this._getHelpContext(contextOptions);
-        const groupListeners = [];
-        let command = this;
-        while (command) {
-          groupListeners.push(command);
-          command = command.parent;
-        }
-        groupListeners.slice().reverse().forEach((command2) => command2.emit("beforeAllHelp", context));
-        this.emit("beforeHelp", context);
-        let helpInformation = this.helpInformation(context);
-        if (deprecatedCallback) {
-          helpInformation = deprecatedCallback(helpInformation);
-          if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
-            throw new Error("outputHelp callback must return a string or a Buffer");
-          }
-        }
-        context.write(helpInformation);
-        this.emit(this._helpLongFlag);
-        this.emit("afterHelp", context);
-        groupListeners.forEach((command2) => command2.emit("afterAllHelp", context));
-      }
-      /**
-       * You can pass in flags and a description to override the help
-       * flags and help description for your command. Pass in false to
-       * disable the built-in help option.
-       *
-       * @param {string | boolean} [flags]
-       * @param {string} [description]
-       * @return {Command} `this` command for chaining
-       */
-      helpOption(flags, description) {
-        if (typeof flags === "boolean") {
-          this._hasHelpOption = flags;
-          return this;
-        }
-        this._helpFlags = flags || this._helpFlags;
-        this._helpDescription = description || this._helpDescription;
-        const helpFlags = _parseOptionFlags(this._helpFlags);
-        this._helpShortFlag = helpFlags.shortFlag;
-        this._helpLongFlag = helpFlags.longFlag;
-        return this;
-      }
-      /**
-       * Output help information and exit.
-       *
-       * Outputs built-in help, and custom text added using `.addHelpText()`.
-       *
-       * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout
-       */
-      help(contextOptions) {
-        this.outputHelp(contextOptions);
-        let exitCode = process.exitCode || 0;
-        if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-          exitCode = 1;
-        }
-        this._exit(exitCode, "commander.help", "(outputHelp)");
-      }
-      /**
-       * Add additional text to be displayed with the built-in help.
-       *
-       * Position is 'before' or 'after' to affect just this command,
-       * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
-       *
-       * @param {string} position - before or after built-in help
-       * @param {string | Function} text - string to add, or a function returning a string
-       * @return {Command} `this` command for chaining
-       */
-      addHelpText(position, text) {
-        const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-        if (!allowedValues.includes(position)) {
-          throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-        }
-        const helpEvent = `${position}Help`;
-        this.on(helpEvent, (context) => {
-          let helpStr;
-          if (typeof text === "function") {
-            helpStr = text({ error: context.error, command: context.command });
-          } else {
-            helpStr = text;
-          }
-          if (helpStr) {
-            context.write(`${helpStr}
-`);
-          }
-        });
-        return this;
-      }
-    };
-    exports = module.exports = new Command();
-    exports.program = exports;
-    exports.Command = Command;
-    exports.Option = Option;
-    exports.CommanderError = CommanderError;
-    exports.InvalidOptionArgumentError = InvalidOptionArgumentError;
-    exports.Help = Help;
-    function camelcase(flag) {
-      return flag.split("-").reduce((str, word) => {
-        return str + word[0].toUpperCase() + word.slice(1);
-      });
-    }
-    function outputHelpIfRequested(cmd, args) {
-      const helpOption = cmd._hasHelpOption && args.find((arg) => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
-      if (helpOption) {
-        cmd.outputHelp();
-        cmd._exit(0, "commander.helpDisplayed", "(outputHelp)");
-      }
-    }
-    function humanReadableArgName(arg) {
-      const nameOutput = arg.name + (arg.variadic === true ? "..." : "");
-      return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-    }
-    function _parseOptionFlags(flags) {
-      let shortFlag;
-      let longFlag;
-      const flagParts = flags.split(/[ |,]+/);
-      if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
-        shortFlag = flagParts.shift();
-      longFlag = flagParts.shift();
-      if (!shortFlag && /^-[^-]$/.test(longFlag)) {
-        shortFlag = longFlag;
-        longFlag = void 0;
-      }
-      return { shortFlag, longFlag };
-    }
-    function incrementNodeInspectorPort(args) {
-      return args.map((arg) => {
-        if (!arg.startsWith("--inspect")) {
-          return arg;
-        }
-        let debugOption;
-        let debugHost = "127.0.0.1";
-        let debugPort = "9229";
-        let match;
-        if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-          debugOption = match[1];
-        } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-          debugOption = match[1];
-          if (/^\d+$/.test(match[3])) {
-            debugPort = match[3];
-          } else {
-            debugHost = match[3];
-          }
-        } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-          debugOption = match[1];
-          debugHost = match[3];
-          debugPort = match[4];
-        }
-        if (debugOption && debugPort !== "0") {
-          return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-        }
-        return arg;
-      });
-    }
-  }
-});
-
-// ../../node_modules/escape-string-regexp/index.js
-var require_escape_string_regexp = __commonJS({
-  "../../node_modules/escape-string-regexp/index.js"(exports, module) {
-    "use strict";
-    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
-    module.exports = function(str) {
-      if (typeof str !== "string") {
-        throw new TypeError("Expected a string");
-      }
-      return str.replace(matchOperatorsRe, "\\$&");
-    };
-  }
-});
-
-// ../../node_modules/color-name/index.js
+// node_modules/color-name/index.js
 var require_color_name = __commonJS({
-  "../../node_modules/color-name/index.js"(exports, module) {
+  "node_modules/color-name/index.js"(exports, module) {
     "use strict";
     module.exports = {
       "aliceblue": [240, 248, 255],
@@ -2053,18 +188,15 @@ var require_color_name = __commonJS({
   }
 });
 
-// ../../node_modules/color-convert/conversions.js
+// node_modules/color-convert/conversions.js
 var require_conversions = __commonJS({
-  "../../node_modules/color-convert/conversions.js"(exports, module) {
+  "node_modules/color-convert/conversions.js"(exports, module) {
     var cssKeywords = require_color_name();
     var reverseKeywords = {};
-    for (key in cssKeywords) {
-      if (cssKeywords.hasOwnProperty(key)) {
-        reverseKeywords[cssKeywords[key]] = key;
-      }
+    for (const key of Object.keys(cssKeywords)) {
+      reverseKeywords[cssKeywords[key]] = key;
     }
-    var key;
-    var convert = module.exports = {
+    var convert = {
       rgb: { channels: 3, labels: "rgb" },
       hsl: { channels: 3, labels: "hsl" },
       hsv: { channels: 3, labels: "hsv" },
@@ -2081,38 +213,32 @@ var require_conversions = __commonJS({
       apple: { channels: 3, labels: ["r16", "g16", "b16"] },
       gray: { channels: 1, labels: ["gray"] }
     };
-    for (model in convert) {
-      if (convert.hasOwnProperty(model)) {
-        if (!("channels" in convert[model])) {
-          throw new Error("missing channels property: " + model);
-        }
-        if (!("labels" in convert[model])) {
-          throw new Error("missing channel labels property: " + model);
-        }
-        if (convert[model].labels.length !== convert[model].channels) {
-          throw new Error("channel and label counts mismatch: " + model);
-        }
-        channels = convert[model].channels;
-        labels = convert[model].labels;
-        delete convert[model].channels;
-        delete convert[model].labels;
-        Object.defineProperty(convert[model], "channels", { value: channels });
-        Object.defineProperty(convert[model], "labels", { value: labels });
+    module.exports = convert;
+    for (const model of Object.keys(convert)) {
+      if (!("channels" in convert[model])) {
+        throw new Error("missing channels property: " + model);
       }
+      if (!("labels" in convert[model])) {
+        throw new Error("missing channel labels property: " + model);
+      }
+      if (convert[model].labels.length !== convert[model].channels) {
+        throw new Error("channel and label counts mismatch: " + model);
+      }
+      const { channels, labels } = convert[model];
+      delete convert[model].channels;
+      delete convert[model].labels;
+      Object.defineProperty(convert[model], "channels", { value: channels });
+      Object.defineProperty(convert[model], "labels", { value: labels });
     }
-    var channels;
-    var labels;
-    var model;
     convert.rgb.hsl = function(rgb) {
-      var r = rgb[0] / 255;
-      var g = rgb[1] / 255;
-      var b = rgb[2] / 255;
-      var min = Math.min(r, g, b);
-      var max = Math.max(r, g, b);
-      var delta = max - min;
-      var h;
-      var s;
-      var l;
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const min = Math.min(r, g, b);
+      const max = Math.max(r, g, b);
+      const delta = max - min;
+      let h;
+      let s;
       if (max === min) {
         h = 0;
       } else if (r === max) {
@@ -2126,7 +252,7 @@ var require_conversions = __commonJS({
       if (h < 0) {
         h += 360;
       }
-      l = (min + max) / 2;
+      const l = (min + max) / 2;
       if (max === min) {
         s = 0;
       } else if (l <= 0.5) {
@@ -2137,21 +263,22 @@ var require_conversions = __commonJS({
       return [h, s * 100, l * 100];
     };
     convert.rgb.hsv = function(rgb) {
-      var rdif;
-      var gdif;
-      var bdif;
-      var h;
-      var s;
-      var r = rgb[0] / 255;
-      var g = rgb[1] / 255;
-      var b = rgb[2] / 255;
-      var v = Math.max(r, g, b);
-      var diff = v - Math.min(r, g, b);
-      var diffc = function(c) {
+      let rdif;
+      let gdif;
+      let bdif;
+      let h;
+      let s;
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const v = Math.max(r, g, b);
+      const diff = v - Math.min(r, g, b);
+      const diffc = function(c) {
         return (v - c) / 6 / diff + 1 / 2;
       };
       if (diff === 0) {
-        h = s = 0;
+        h = 0;
+        s = 0;
       } else {
         s = diff / v;
         rdif = diffc(r);
@@ -2177,46 +304,40 @@ var require_conversions = __commonJS({
       ];
     };
     convert.rgb.hwb = function(rgb) {
-      var r = rgb[0];
-      var g = rgb[1];
-      var b = rgb[2];
-      var h = convert.rgb.hsl(rgb)[0];
-      var w = 1 / 255 * Math.min(r, Math.min(g, b));
+      const r = rgb[0];
+      const g = rgb[1];
+      let b = rgb[2];
+      const h = convert.rgb.hsl(rgb)[0];
+      const w = 1 / 255 * Math.min(r, Math.min(g, b));
       b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
       return [h, w * 100, b * 100];
     };
     convert.rgb.cmyk = function(rgb) {
-      var r = rgb[0] / 255;
-      var g = rgb[1] / 255;
-      var b = rgb[2] / 255;
-      var c;
-      var m;
-      var y;
-      var k;
-      k = Math.min(1 - r, 1 - g, 1 - b);
-      c = (1 - r - k) / (1 - k) || 0;
-      m = (1 - g - k) / (1 - k) || 0;
-      y = (1 - b - k) / (1 - k) || 0;
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const k = Math.min(1 - r, 1 - g, 1 - b);
+      const c = (1 - r - k) / (1 - k) || 0;
+      const m = (1 - g - k) / (1 - k) || 0;
+      const y = (1 - b - k) / (1 - k) || 0;
       return [c * 100, m * 100, y * 100, k * 100];
     };
     function comparativeDistance(x, y) {
-      return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
+      return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
     }
     convert.rgb.keyword = function(rgb) {
-      var reversed = reverseKeywords[rgb];
+      const reversed = reverseKeywords[rgb];
       if (reversed) {
         return reversed;
       }
-      var currentClosestDistance = Infinity;
-      var currentClosestKeyword;
-      for (var keyword in cssKeywords) {
-        if (cssKeywords.hasOwnProperty(keyword)) {
-          var value = cssKeywords[keyword];
-          var distance = comparativeDistance(rgb, value);
-          if (distance < currentClosestDistance) {
-            currentClosestDistance = distance;
-            currentClosestKeyword = keyword;
-          }
+      let currentClosestDistance = Infinity;
+      let currentClosestKeyword;
+      for (const keyword of Object.keys(cssKeywords)) {
+        const value = cssKeywords[keyword];
+        const distance = comparativeDistance(rgb, value);
+        if (distance < currentClosestDistance) {
+          currentClosestDistance = distance;
+          currentClosestKeyword = keyword;
         }
       }
       return currentClosestKeyword;
@@ -2225,45 +346,40 @@ var require_conversions = __commonJS({
       return cssKeywords[keyword];
     };
     convert.rgb.xyz = function(rgb) {
-      var r = rgb[0] / 255;
-      var g = rgb[1] / 255;
-      var b = rgb[2] / 255;
-      r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
-      g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
-      b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
-      var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
-      var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
-      var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+      let r = rgb[0] / 255;
+      let g = rgb[1] / 255;
+      let b = rgb[2] / 255;
+      r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;
+      g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;
+      b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+      const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+      const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+      const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
       return [x * 100, y * 100, z * 100];
     };
     convert.rgb.lab = function(rgb) {
-      var xyz = convert.rgb.xyz(rgb);
-      var x = xyz[0];
-      var y = xyz[1];
-      var z = xyz[2];
-      var l;
-      var a;
-      var b;
+      const xyz = convert.rgb.xyz(rgb);
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
       x /= 95.047;
       y /= 100;
       z /= 108.883;
-      x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
-      y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
-      z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
-      l = 116 * y - 16;
-      a = 500 * (x - y);
-      b = 200 * (y - z);
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
       return [l, a, b];
     };
     convert.hsl.rgb = function(hsl) {
-      var h = hsl[0] / 360;
-      var s = hsl[1] / 100;
-      var l = hsl[2] / 100;
-      var t1;
-      var t2;
-      var t3;
-      var rgb;
-      var val;
+      const h = hsl[0] / 360;
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      let t2;
+      let t3;
+      let val;
       if (s === 0) {
         val = l * 255;
         return [val, val, val];
@@ -2273,9 +389,9 @@ var require_conversions = __commonJS({
       } else {
         t2 = l + s - l * s;
       }
-      t1 = 2 * l - t2;
-      rgb = [0, 0, 0];
-      for (var i = 0; i < 3; i++) {
+      const t1 = 2 * l - t2;
+      const rgb = [0, 0, 0];
+      for (let i = 0; i < 3; i++) {
         t3 = h + 1 / 3 * -(i - 1);
         if (t3 < 0) {
           t3++;
@@ -2297,29 +413,27 @@ var require_conversions = __commonJS({
       return rgb;
     };
     convert.hsl.hsv = function(hsl) {
-      var h = hsl[0];
-      var s = hsl[1] / 100;
-      var l = hsl[2] / 100;
-      var smin = s;
-      var lmin = Math.max(l, 0.01);
-      var sv;
-      var v;
+      const h = hsl[0];
+      let s = hsl[1] / 100;
+      let l = hsl[2] / 100;
+      let smin = s;
+      const lmin = Math.max(l, 0.01);
       l *= 2;
       s *= l <= 1 ? l : 2 - l;
       smin *= lmin <= 1 ? lmin : 2 - lmin;
-      v = (l + s) / 2;
-      sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+      const v = (l + s) / 2;
+      const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
       return [h, sv * 100, v * 100];
     };
     convert.hsv.rgb = function(hsv) {
-      var h = hsv[0] / 60;
-      var s = hsv[1] / 100;
-      var v = hsv[2] / 100;
-      var hi = Math.floor(h) % 6;
-      var f = h - Math.floor(h);
-      var p = 255 * v * (1 - s);
-      var q = 255 * v * (1 - s * f);
-      var t = 255 * v * (1 - s * (1 - f));
+      const h = hsv[0] / 60;
+      const s = hsv[1] / 100;
+      let v = hsv[2] / 100;
+      const hi = Math.floor(h) % 6;
+      const f = h - Math.floor(h);
+      const p = 255 * v * (1 - s);
+      const q = 255 * v * (1 - s * f);
+      const t = 255 * v * (1 - s * (1 - f));
       v *= 255;
       switch (hi) {
         case 0:
@@ -2337,15 +451,14 @@ var require_conversions = __commonJS({
       }
     };
     convert.hsv.hsl = function(hsv) {
-      var h = hsv[0];
-      var s = hsv[1] / 100;
-      var v = hsv[2] / 100;
-      var vmin = Math.max(v, 0.01);
-      var lmin;
-      var sl;
-      var l;
+      const h = hsv[0];
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const vmin = Math.max(v, 0.01);
+      let sl;
+      let l;
       l = (2 - s) * v;
-      lmin = (2 - s) * vmin;
+      const lmin = (2 - s) * vmin;
       sl = s * vmin;
       sl /= lmin <= 1 ? lmin : 2 - lmin;
       sl = sl || 0;
@@ -2353,28 +466,25 @@ var require_conversions = __commonJS({
       return [h, sl * 100, l * 100];
     };
     convert.hwb.rgb = function(hwb) {
-      var h = hwb[0] / 360;
-      var wh = hwb[1] / 100;
-      var bl = hwb[2] / 100;
-      var ratio = wh + bl;
-      var i;
-      var v;
-      var f;
-      var n;
+      const h = hwb[0] / 360;
+      let wh = hwb[1] / 100;
+      let bl = hwb[2] / 100;
+      const ratio = wh + bl;
+      let f;
       if (ratio > 1) {
         wh /= ratio;
         bl /= ratio;
       }
-      i = Math.floor(6 * h);
-      v = 1 - bl;
+      const i = Math.floor(6 * h);
+      const v = 1 - bl;
       f = 6 * h - i;
       if ((i & 1) !== 0) {
         f = 1 - f;
       }
-      n = wh + f * (v - wh);
-      var r;
-      var g;
-      var b;
+      const n = wh + f * (v - wh);
+      let r;
+      let g;
+      let b;
       switch (i) {
         default:
         case 6:
@@ -2412,67 +522,61 @@ var require_conversions = __commonJS({
       return [r * 255, g * 255, b * 255];
     };
     convert.cmyk.rgb = function(cmyk) {
-      var c = cmyk[0] / 100;
-      var m = cmyk[1] / 100;
-      var y = cmyk[2] / 100;
-      var k = cmyk[3] / 100;
-      var r;
-      var g;
-      var b;
-      r = 1 - Math.min(1, c * (1 - k) + k);
-      g = 1 - Math.min(1, m * (1 - k) + k);
-      b = 1 - Math.min(1, y * (1 - k) + k);
+      const c = cmyk[0] / 100;
+      const m = cmyk[1] / 100;
+      const y = cmyk[2] / 100;
+      const k = cmyk[3] / 100;
+      const r = 1 - Math.min(1, c * (1 - k) + k);
+      const g = 1 - Math.min(1, m * (1 - k) + k);
+      const b = 1 - Math.min(1, y * (1 - k) + k);
       return [r * 255, g * 255, b * 255];
     };
     convert.xyz.rgb = function(xyz) {
-      var x = xyz[0] / 100;
-      var y = xyz[1] / 100;
-      var z = xyz[2] / 100;
-      var r;
-      var g;
-      var b;
+      const x = xyz[0] / 100;
+      const y = xyz[1] / 100;
+      const z = xyz[2] / 100;
+      let r;
+      let g;
+      let b;
       r = x * 3.2406 + y * -1.5372 + z * -0.4986;
       g = x * -0.9689 + y * 1.8758 + z * 0.0415;
       b = x * 0.0557 + y * -0.204 + z * 1.057;
-      r = r > 31308e-7 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : r * 12.92;
-      g = g > 31308e-7 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : g * 12.92;
-      b = b > 31308e-7 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : b * 12.92;
+      r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
+      g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
+      b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
       r = Math.min(Math.max(0, r), 1);
       g = Math.min(Math.max(0, g), 1);
       b = Math.min(Math.max(0, b), 1);
       return [r * 255, g * 255, b * 255];
     };
     convert.xyz.lab = function(xyz) {
-      var x = xyz[0];
-      var y = xyz[1];
-      var z = xyz[2];
-      var l;
-      var a;
-      var b;
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
       x /= 95.047;
       y /= 100;
       z /= 108.883;
-      x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
-      y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
-      z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
-      l = 116 * y - 16;
-      a = 500 * (x - y);
-      b = 200 * (y - z);
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
       return [l, a, b];
     };
     convert.lab.xyz = function(lab) {
-      var l = lab[0];
-      var a = lab[1];
-      var b = lab[2];
-      var x;
-      var y;
-      var z;
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let x;
+      let y;
+      let z;
       y = (l + 16) / 116;
       x = a / 500 + y;
       z = y - b / 200;
-      var y2 = Math.pow(y, 3);
-      var x2 = Math.pow(x, 3);
-      var z2 = Math.pow(z, 3);
+      const y2 = y ** 3;
+      const x2 = x ** 3;
+      const z2 = z ** 3;
       y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
       x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
       z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
@@ -2482,42 +586,35 @@ var require_conversions = __commonJS({
       return [x, y, z];
     };
     convert.lab.lch = function(lab) {
-      var l = lab[0];
-      var a = lab[1];
-      var b = lab[2];
-      var hr;
-      var h;
-      var c;
-      hr = Math.atan2(b, a);
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let h;
+      const hr = Math.atan2(b, a);
       h = hr * 360 / 2 / Math.PI;
       if (h < 0) {
         h += 360;
       }
-      c = Math.sqrt(a * a + b * b);
+      const c = Math.sqrt(a * a + b * b);
       return [l, c, h];
     };
     convert.lch.lab = function(lch) {
-      var l = lch[0];
-      var c = lch[1];
-      var h = lch[2];
-      var a;
-      var b;
-      var hr;
-      hr = h / 360 * 2 * Math.PI;
-      a = c * Math.cos(hr);
-      b = c * Math.sin(hr);
+      const l = lch[0];
+      const c = lch[1];
+      const h = lch[2];
+      const hr = h / 360 * 2 * Math.PI;
+      const a = c * Math.cos(hr);
+      const b = c * Math.sin(hr);
       return [l, a, b];
     };
-    convert.rgb.ansi16 = function(args) {
-      var r = args[0];
-      var g = args[1];
-      var b = args[2];
-      var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2];
+    convert.rgb.ansi16 = function(args, saturation = null) {
+      const [r, g, b] = args;
+      let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
       value = Math.round(value / 50);
       if (value === 0) {
         return 30;
       }
-      var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+      let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
       if (value === 2) {
         ansi += 60;
       }
@@ -2527,9 +624,9 @@ var require_conversions = __commonJS({
       return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
     };
     convert.rgb.ansi256 = function(args) {
-      var r = args[0];
-      var g = args[1];
-      var b = args[2];
+      const r = args[0];
+      const g = args[1];
+      const b = args[2];
       if (r === g && g === b) {
         if (r < 8) {
           return 16;
@@ -2539,11 +636,11 @@ var require_conversions = __commonJS({
         }
         return Math.round((r - 8) / 247 * 24) + 232;
       }
-      var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+      const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
       return ansi;
     };
     convert.ansi16.rgb = function(args) {
-      var color = args % 10;
+      let color = args % 10;
       if (color === 0 || color === 7) {
         if (args > 50) {
           color += 3.5;
@@ -2551,55 +648,55 @@ var require_conversions = __commonJS({
         color = color / 10.5 * 255;
         return [color, color, color];
       }
-      var mult = (~~(args > 50) + 1) * 0.5;
-      var r = (color & 1) * mult * 255;
-      var g = (color >> 1 & 1) * mult * 255;
-      var b = (color >> 2 & 1) * mult * 255;
+      const mult = (~~(args > 50) + 1) * 0.5;
+      const r = (color & 1) * mult * 255;
+      const g = (color >> 1 & 1) * mult * 255;
+      const b = (color >> 2 & 1) * mult * 255;
       return [r, g, b];
     };
     convert.ansi256.rgb = function(args) {
       if (args >= 232) {
-        var c = (args - 232) * 10 + 8;
+        const c = (args - 232) * 10 + 8;
         return [c, c, c];
       }
       args -= 16;
-      var rem;
-      var r = Math.floor(args / 36) / 5 * 255;
-      var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
-      var b = rem % 6 / 5 * 255;
+      let rem;
+      const r = Math.floor(args / 36) / 5 * 255;
+      const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+      const b = rem % 6 / 5 * 255;
       return [r, g, b];
     };
     convert.rgb.hex = function(args) {
-      var integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
-      var string = integer.toString(16).toUpperCase();
+      const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+      const string = integer.toString(16).toUpperCase();
       return "000000".substring(string.length) + string;
     };
     convert.hex.rgb = function(args) {
-      var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+      const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
       if (!match) {
         return [0, 0, 0];
       }
-      var colorString = match[0];
+      let colorString = match[0];
       if (match[0].length === 3) {
-        colorString = colorString.split("").map(function(char) {
+        colorString = colorString.split("").map((char) => {
           return char + char;
         }).join("");
       }
-      var integer = parseInt(colorString, 16);
-      var r = integer >> 16 & 255;
-      var g = integer >> 8 & 255;
-      var b = integer & 255;
+      const integer = parseInt(colorString, 16);
+      const r = integer >> 16 & 255;
+      const g = integer >> 8 & 255;
+      const b = integer & 255;
       return [r, g, b];
     };
     convert.rgb.hcg = function(rgb) {
-      var r = rgb[0] / 255;
-      var g = rgb[1] / 255;
-      var b = rgb[2] / 255;
-      var max = Math.max(Math.max(r, g), b);
-      var min = Math.min(Math.min(r, g), b);
-      var chroma = max - min;
-      var grayscale;
-      var hue;
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const max = Math.max(Math.max(r, g), b);
+      const min = Math.min(Math.min(r, g), b);
+      const chroma = max - min;
+      let grayscale;
+      let hue;
       if (chroma < 1) {
         grayscale = min / (1 - chroma);
       } else {
@@ -2612,49 +709,44 @@ var require_conversions = __commonJS({
       } else if (max === g) {
         hue = 2 + (b - r) / chroma;
       } else {
-        hue = 4 + (r - g) / chroma + 4;
+        hue = 4 + (r - g) / chroma;
       }
       hue /= 6;
       hue %= 1;
       return [hue * 360, chroma * 100, grayscale * 100];
     };
     convert.hsl.hcg = function(hsl) {
-      var s = hsl[1] / 100;
-      var l = hsl[2] / 100;
-      var c = 1;
-      var f = 0;
-      if (l < 0.5) {
-        c = 2 * s * l;
-      } else {
-        c = 2 * s * (1 - l);
-      }
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
+      let f = 0;
       if (c < 1) {
         f = (l - 0.5 * c) / (1 - c);
       }
       return [hsl[0], c * 100, f * 100];
     };
     convert.hsv.hcg = function(hsv) {
-      var s = hsv[1] / 100;
-      var v = hsv[2] / 100;
-      var c = s * v;
-      var f = 0;
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const c = s * v;
+      let f = 0;
       if (c < 1) {
         f = (v - c) / (1 - c);
       }
       return [hsv[0], c * 100, f * 100];
     };
     convert.hcg.rgb = function(hcg) {
-      var h = hcg[0] / 360;
-      var c = hcg[1] / 100;
-      var g = hcg[2] / 100;
+      const h = hcg[0] / 360;
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
       if (c === 0) {
         return [g * 255, g * 255, g * 255];
       }
-      var pure = [0, 0, 0];
-      var hi = h % 1 * 6;
-      var v = hi % 1;
-      var w = 1 - v;
-      var mg = 0;
+      const pure = [0, 0, 0];
+      const hi = h % 1 * 6;
+      const v = hi % 1;
+      const w = 1 - v;
+      let mg = 0;
       switch (Math.floor(hi)) {
         case 0:
           pure[0] = 1;
@@ -2694,20 +786,20 @@ var require_conversions = __commonJS({
       ];
     };
     convert.hcg.hsv = function(hcg) {
-      var c = hcg[1] / 100;
-      var g = hcg[2] / 100;
-      var v = c + g * (1 - c);
-      var f = 0;
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
+      let f = 0;
       if (v > 0) {
         f = c / v;
       }
       return [hcg[0], f * 100, v * 100];
     };
     convert.hcg.hsl = function(hcg) {
-      var c = hcg[1] / 100;
-      var g = hcg[2] / 100;
-      var l = g * (1 - c) + 0.5 * c;
-      var s = 0;
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const l = g * (1 - c) + 0.5 * c;
+      let s = 0;
       if (l > 0 && l < 0.5) {
         s = c / (2 * l);
       } else if (l >= 0.5 && l < 1) {
@@ -2716,17 +808,17 @@ var require_conversions = __commonJS({
       return [hcg[0], s * 100, l * 100];
     };
     convert.hcg.hwb = function(hcg) {
-      var c = hcg[1] / 100;
-      var g = hcg[2] / 100;
-      var v = c + g * (1 - c);
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
       return [hcg[0], (v - c) * 100, (1 - v) * 100];
     };
     convert.hwb.hcg = function(hwb) {
-      var w = hwb[1] / 100;
-      var b = hwb[2] / 100;
-      var v = 1 - b;
-      var c = v - w;
-      var g = 0;
+      const w = hwb[1] / 100;
+      const b = hwb[2] / 100;
+      const v = 1 - b;
+      const c = v - w;
+      let g = 0;
       if (c < 1) {
         g = (v - c) / (1 - c);
       }
@@ -2741,9 +833,10 @@ var require_conversions = __commonJS({
     convert.gray.rgb = function(args) {
       return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
     };
-    convert.gray.hsl = convert.gray.hsv = function(args) {
+    convert.gray.hsl = function(args) {
       return [0, 0, args[0]];
     };
+    convert.gray.hsv = convert.gray.hsl;
     convert.gray.hwb = function(gray) {
       return [0, 100, gray[0]];
     };
@@ -2754,26 +847,26 @@ var require_conversions = __commonJS({
       return [gray[0], 0, 0];
     };
     convert.gray.hex = function(gray) {
-      var val = Math.round(gray[0] / 100 * 255) & 255;
-      var integer = (val << 16) + (val << 8) + val;
-      var string = integer.toString(16).toUpperCase();
+      const val = Math.round(gray[0] / 100 * 255) & 255;
+      const integer = (val << 16) + (val << 8) + val;
+      const string = integer.toString(16).toUpperCase();
       return "000000".substring(string.length) + string;
     };
     convert.rgb.gray = function(rgb) {
-      var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+      const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
       return [val / 255 * 100];
     };
   }
 });
 
-// ../../node_modules/color-convert/route.js
+// node_modules/color-convert/route.js
 var require_route = __commonJS({
-  "../../node_modules/color-convert/route.js"(exports, module) {
+  "node_modules/color-convert/route.js"(exports, module) {
     var conversions = require_conversions();
     function buildGraph() {
-      var graph = {};
-      var models = Object.keys(conversions);
-      for (var len = models.length, i = 0; i < len; i++) {
+      const graph = {};
+      const models = Object.keys(conversions);
+      for (let len = models.length, i = 0; i < len; i++) {
         graph[models[i]] = {
           // http://jsperf.com/1-vs-infinity
           // micro-opt, but this is simple.
@@ -2784,15 +877,15 @@ var require_route = __commonJS({
       return graph;
     }
     function deriveBFS(fromModel) {
-      var graph = buildGraph();
-      var queue = [fromModel];
+      const graph = buildGraph();
+      const queue = [fromModel];
       graph[fromModel].distance = 0;
       while (queue.length) {
-        var current = queue.pop();
-        var adjacents = Object.keys(conversions[current]);
-        for (var len = adjacents.length, i = 0; i < len; i++) {
-          var adjacent = adjacents[i];
-          var node = graph[adjacent];
+        const current = queue.pop();
+        const adjacents = Object.keys(conversions[current]);
+        for (let len = adjacents.length, i = 0; i < len; i++) {
+          const adjacent = adjacents[i];
+          const node = graph[adjacent];
           if (node.distance === -1) {
             node.distance = graph[current].distance + 1;
             node.parent = current;
@@ -2808,9 +901,9 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      var path = [graph[toModel].parent, toModel];
-      var fn = conversions[graph[toModel].parent][toModel];
-      var cur = graph[toModel].parent;
+      const path = [graph[toModel].parent, toModel];
+      let fn = conversions[graph[toModel].parent][toModel];
+      let cur = graph[toModel].parent;
       while (graph[cur].parent) {
         path.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
@@ -2820,12 +913,12 @@ var require_route = __commonJS({
       return fn;
     }
     module.exports = function(fromModel) {
-      var graph = deriveBFS(fromModel);
-      var conversion = {};
-      var models = Object.keys(graph);
-      for (var len = models.length, i = 0; i < len; i++) {
-        var toModel = models[i];
-        var node = graph[toModel];
+      const graph = deriveBFS(fromModel);
+      const conversion = {};
+      const models = Object.keys(graph);
+      for (let len = models.length, i = 0; i < len; i++) {
+        const toModel = models[i];
+        const node = graph[toModel];
         if (node.parent === null) {
           continue;
         }
@@ -2836,20 +929,21 @@ var require_route = __commonJS({
   }
 });
 
-// ../../node_modules/color-convert/index.js
+// node_modules/color-convert/index.js
 var require_color_convert = __commonJS({
-  "../../node_modules/color-convert/index.js"(exports, module) {
+  "node_modules/color-convert/index.js"(exports, module) {
     var conversions = require_conversions();
     var route = require_route();
     var convert = {};
     var models = Object.keys(conversions);
     function wrapRaw(fn) {
-      var wrappedFn = function(args) {
-        if (args === void 0 || args === null) {
-          return args;
+      const wrappedFn = function(...args) {
+        const arg0 = args[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
         }
-        if (arguments.length > 1) {
-          args = Array.prototype.slice.call(arguments);
+        if (arg0.length > 1) {
+          args = arg0;
         }
         return fn(args);
       };
@@ -2859,16 +953,17 @@ var require_color_convert = __commonJS({
       return wrappedFn;
     }
     function wrapRounded(fn) {
-      var wrappedFn = function(args) {
-        if (args === void 0 || args === null) {
-          return args;
+      const wrappedFn = function(...args) {
+        const arg0 = args[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
         }
-        if (arguments.length > 1) {
-          args = Array.prototype.slice.call(arguments);
+        if (arg0.length > 1) {
+          args = arg0;
         }
-        var result = fn(args);
+        const result = fn(args);
         if (typeof result === "object") {
-          for (var len = result.length, i = 0; i < len; i++) {
+          for (let len = result.length, i = 0; i < len; i++) {
             result[i] = Math.round(result[i]);
           }
         }
@@ -2879,14 +974,14 @@ var require_color_convert = __commonJS({
       }
       return wrappedFn;
     }
-    models.forEach(function(fromModel) {
+    models.forEach((fromModel) => {
       convert[fromModel] = {};
       Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
       Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
-      var routes = route(fromModel);
-      var routeModels = Object.keys(routes);
-      routeModels.forEach(function(toModel) {
-        var fn = routes[toModel];
+      const routes = route(fromModel);
+      const routeModels = Object.keys(routes);
+      routeModels.forEach((toModel) => {
+        const fn = routes[toModel];
         convert[fromModel][toModel] = wrapRounded(fn);
         convert[fromModel][toModel].raw = wrapRaw(fn);
       });
@@ -2895,23 +990,56 @@ var require_color_convert = __commonJS({
   }
 });
 
-// ../../node_modules/ansi-styles/index.js
+// node_modules/ansi-styles/index.js
 var require_ansi_styles = __commonJS({
-  "../../node_modules/ansi-styles/index.js"(exports, module) {
+  "node_modules/ansi-styles/index.js"(exports, module) {
     "use strict";
-    var colorConvert = require_color_convert();
-    var wrapAnsi16 = (fn, offset) => function() {
-      const code = fn.apply(colorConvert, arguments);
+    var wrapAnsi16 = (fn, offset) => (...args) => {
+      const code = fn(...args);
       return `\x1B[${code + offset}m`;
     };
-    var wrapAnsi256 = (fn, offset) => function() {
-      const code = fn.apply(colorConvert, arguments);
+    var wrapAnsi256 = (fn, offset) => (...args) => {
+      const code = fn(...args);
       return `\x1B[${38 + offset};5;${code}m`;
     };
-    var wrapAnsi16m = (fn, offset) => function() {
-      const rgb = fn.apply(colorConvert, arguments);
+    var wrapAnsi16m = (fn, offset) => (...args) => {
+      const rgb = fn(...args);
       return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
     };
+    var ansi2ansi = (n) => n;
+    var rgb2rgb = (r, g, b) => [r, g, b];
+    var setLazyProperty = (object, property, get) => {
+      Object.defineProperty(object, property, {
+        get: () => {
+          const value = get();
+          Object.defineProperty(object, property, {
+            value,
+            enumerable: true,
+            configurable: true
+          });
+          return value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
+    var colorConvert;
+    var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+      if (colorConvert === void 0) {
+        colorConvert = require_color_convert();
+      }
+      const offset = isBackground ? 10 : 0;
+      const styles = {};
+      for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+        const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+        if (sourceSpace === targetSpace) {
+          styles[name] = wrap(identity, offset);
+        } else if (typeof suite === "object") {
+          styles[name] = wrap(suite[targetSpace], offset);
+        }
+      }
+      return styles;
+    };
     function assembleStyles() {
       const codes = /* @__PURE__ */ new Map();
       const styles = {
@@ -2935,8 +1063,8 @@ var require_ansi_styles = __commonJS({
           magenta: [35, 39],
           cyan: [36, 39],
           white: [37, 39],
-          gray: [90, 39],
           // Bright color
+          blackBright: [90, 39],
           redBright: [91, 39],
           greenBright: [92, 39],
           yellowBright: [93, 39],
@@ -2965,11 +1093,12 @@ var require_ansi_styles = __commonJS({
           bgWhiteBright: [107, 49]
         }
       };
-      styles.color.grey = styles.color.gray;
-      for (const groupName of Object.keys(styles)) {
-        const group = styles[groupName];
-        for (const styleName of Object.keys(group)) {
-          const style = group[styleName];
+      styles.color.gray = styles.color.blackBright;
+      styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+      styles.color.grey = styles.color.blackBright;
+      styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+      for (const [groupName, group] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group)) {
           styles[styleName] = {
             open: `\x1B[${style[0]}m`,
             close: `\x1B[${style[1]}m`
@@ -2981,54 +1110,19 @@ var require_ansi_styles = __commonJS({
           value: group,
           enumerable: false
         });
-        Object.defineProperty(styles, "codes", {
-          value: codes,
-          enumerable: false
-        });
       }
-      const ansi2ansi = (n) => n;
-      const rgb2rgb = (r, g, b) => [r, g, b];
+      Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false
+      });
       styles.color.close = "\x1B[39m";
       styles.bgColor.close = "\x1B[49m";
-      styles.color.ansi = {
-        ansi: wrapAnsi16(ansi2ansi, 0)
-      };
-      styles.color.ansi256 = {
-        ansi256: wrapAnsi256(ansi2ansi, 0)
-      };
-      styles.color.ansi16m = {
-        rgb: wrapAnsi16m(rgb2rgb, 0)
-      };
-      styles.bgColor.ansi = {
-        ansi: wrapAnsi16(ansi2ansi, 10)
-      };
-      styles.bgColor.ansi256 = {
-        ansi256: wrapAnsi256(ansi2ansi, 10)
-      };
-      styles.bgColor.ansi16m = {
-        rgb: wrapAnsi16m(rgb2rgb, 10)
-      };
-      for (let key of Object.keys(colorConvert)) {
-        if (typeof colorConvert[key] !== "object") {
-          continue;
-        }
-        const suite = colorConvert[key];
-        if (key === "ansi16") {
-          key = "ansi";
-        }
-        if ("ansi16" in suite) {
-          styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
-          styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
-        }
-        if ("ansi256" in suite) {
-          styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
-          styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
-        }
-        if ("rgb" in suite) {
-          styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
-          styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
-        }
-      }
+      setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+      setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+      setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+      setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
       return styles;
     }
     Object.defineProperty(module, "exports", {
@@ -3038,35 +1132,41 @@ var require_ansi_styles = __commonJS({
   }
 });
 
-// ../../node_modules/has-flag/index.js
+// node_modules/has-flag/index.js
 var require_has_flag = __commonJS({
-  "../../node_modules/has-flag/index.js"(exports, module) {
+  "node_modules/has-flag/index.js"(exports, module) {
     "use strict";
-    module.exports = (flag, argv) => {
-      argv = argv || process.argv;
+    module.exports = (flag, argv = process.argv) => {
       const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-      const pos = argv.indexOf(prefix + flag);
-      const terminatorPos = argv.indexOf("--");
-      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
     };
   }
 });
 
-// ../../node_modules/supports-color/index.js
+// node_modules/supports-color/index.js
 var require_supports_color = __commonJS({
-  "../../node_modules/supports-color/index.js"(exports, module) {
+  "node_modules/supports-color/index.js"(exports, module) {
     "use strict";
     var os = __require("os");
+    var tty = __require("tty");
     var hasFlag = require_has_flag();
-    var env = process.env;
+    var { env } = process;
     var forceColor;
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
-      forceColor = false;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
     } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      forceColor = true;
+      forceColor = 1;
     }
     if ("FORCE_COLOR" in env) {
-      forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
     }
     function translateLevel(level) {
       if (level === 0) {
@@ -3079,8 +1179,8 @@ var require_supports_color = __commonJS({
         has16m: level >= 3
       };
     }
-    function supportsColor(stream) {
-      if (forceColor === false) {
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
         return 0;
       }
       if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
@@ -3089,19 +1189,22 @@ var require_supports_color = __commonJS({
       if (hasFlag("color=256")) {
         return 2;
       }
-      if (stream && !stream.isTTY && forceColor !== true) {
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
         return 0;
       }
-      const min = forceColor ? 1 : 0;
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
       if (process.platform === "win32") {
         const osRelease = os.release().split(".");
-        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
         return 1;
       }
       if ("CI" in env) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -3130,31 +1233,67 @@ var require_supports_color = __commonJS({
       if ("COLORTERM" in env) {
         return 1;
       }
-      if (env.TERM === "dumb") {
-        return min;
-      }
       return min;
     }
     function getSupportLevel(stream) {
-      const level = supportsColor(stream);
+      const level = supportsColor(stream, stream && stream.isTTY);
       return translateLevel(level);
     }
     module.exports = {
       supportsColor: getSupportLevel,
-      stdout: getSupportLevel(process.stdout),
-      stderr: getSupportLevel(process.stderr)
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// node_modules/chalk/source/util.js
+var require_util = __commonJS({
+  "node_modules/chalk/source/util.js"(exports, module) {
+    "use strict";
+    var stringReplaceAll = (string, substring, replacer) => {
+      let index = string.indexOf(substring);
+      if (index === -1) {
+        return string;
+      }
+      const substringLength = substring.length;
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+        endIndex = index + substringLength;
+        index = string.indexOf(substring, endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    var stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        const gotCR = string[index - 1] === "\r";
+        returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+        endIndex = index + 1;
+        index = string.indexOf("\n", endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    module.exports = {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
     };
   }
 });
 
-// ../../node_modules/chalk/templates.js
+// node_modules/chalk/source/templates.js
 var require_templates = __commonJS({
-  "../../node_modules/chalk/templates.js"(exports, module) {
+  "node_modules/chalk/source/templates.js"(exports, module) {
     "use strict";
-    var TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+    var TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
     var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
     var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-    var ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+    var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
     var ESCAPES = /* @__PURE__ */ new Map([
       ["n", "\n"],
       ["r", "\r"],
@@ -3168,20 +1307,26 @@ var require_templates = __commonJS({
       ["a", "\x07"]
     ]);
     function unescape(c) {
-      if (c[0] === "u" && c.length === 5 || c[0] === "x" && c.length === 3) {
+      const u = c[0] === "u";
+      const bracket = c[1] === "{";
+      if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
         return String.fromCharCode(parseInt(c.slice(1), 16));
       }
+      if (u && bracket) {
+        return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+      }
       return ESCAPES.get(c) || c;
     }
-    function parseArguments(name, args) {
+    function parseArguments(name, arguments_) {
       const results = [];
-      const chunks = args.trim().split(/\s*,\s*/g);
+      const chunks = arguments_.trim().split(/\s*,\s*/g);
       let matches;
       for (const chunk of chunks) {
-        if (!isNaN(chunk)) {
-          results.push(Number(chunk));
+        const number = Number(chunk);
+        if (!Number.isNaN(number)) {
+          results.push(number);
         } else if (matches = chunk.match(STRING_REGEX)) {
-          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
         } else {
           throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
         }
@@ -3211,31 +1356,28 @@ var require_templates = __commonJS({
         }
       }
       let current = chalk2;
-      for (const styleName of Object.keys(enabled)) {
-        if (Array.isArray(enabled[styleName])) {
-          if (!(styleName in current)) {
-            throw new Error(`Unknown Chalk style: ${styleName}`);
-          }
-          if (enabled[styleName].length > 0) {
-            current = current[styleName].apply(current, enabled[styleName]);
-          } else {
-            current = current[styleName];
-          }
+      for (const [styleName, styles2] of Object.entries(enabled)) {
+        if (!Array.isArray(styles2)) {
+          continue;
+        }
+        if (!(styleName in current)) {
+          throw new Error(`Unknown Chalk style: ${styleName}`);
         }
+        current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];
       }
       return current;
     }
-    module.exports = (chalk2, tmp) => {
+    module.exports = (chalk2, temporary) => {
       const styles = [];
       const chunks = [];
       let chunk = [];
-      tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
-        if (escapeChar) {
-          chunk.push(unescape(escapeChar));
+      temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+        if (escapeCharacter) {
+          chunk.push(unescape(escapeCharacter));
         } else if (style) {
-          const str = chunk.join("");
+          const string = chunk.join("");
           chunk = [];
-          chunks.push(styles.length === 0 ? str : buildStyle(chalk2, styles)(str));
+          chunks.push(styles.length === 0 ? string : buildStyle(chalk2, styles)(string));
           styles.push({ inverse, styles: parseStyle(style) });
         } else if (close) {
           if (styles.length === 0) {
@@ -3245,189 +1387,200 @@ var require_templates = __commonJS({
           chunk = [];
           styles.pop();
         } else {
-          chunk.push(chr);
+          chunk.push(character);
         }
       });
       chunks.push(chunk.join(""));
       if (styles.length > 0) {
-        const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
-        throw new Error(errMsg);
+        const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+        throw new Error(errMessage);
       }
       return chunks.join("");
     };
   }
 });
 
-// ../../node_modules/chalk/index.js
-var require_chalk = __commonJS({
-  "../../node_modules/chalk/index.js"(exports, module) {
+// node_modules/chalk/source/index.js
+var require_source = __commonJS({
+  "node_modules/chalk/source/index.js"(exports, module) {
     "use strict";
-    var escapeStringRegexp = require_escape_string_regexp();
     var ansiStyles = require_ansi_styles();
-    var stdoutColor = require_supports_color().stdout;
-    var template = require_templates();
-    var isSimpleWindowsTerm = process.platform === "win32" && !(process.env.TERM || "").toLowerCase().startsWith("xterm");
-    var levelMapping = ["ansi", "ansi", "ansi256", "ansi16m"];
-    var skipModels = /* @__PURE__ */ new Set(["gray"]);
+    var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
+    var {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
+    } = require_util();
+    var { isArray } = Array;
+    var levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
     var styles = /* @__PURE__ */ Object.create(null);
-    function applyOptions(obj, options) {
-      options = options || {};
-      const scLevel = stdoutColor ? stdoutColor.level : 0;
-      obj.level = options.level === void 0 ? scLevel : options.level;
-      obj.enabled = "enabled" in options ? options.enabled : obj.level > 0;
-    }
-    function Chalk(options) {
-      if (!this || !(this instanceof Chalk) || this.template) {
-        const chalk2 = {};
-        applyOptions(chalk2, options);
-        chalk2.template = function() {
-          const args = [].slice.call(arguments);
-          return chalkTag.apply(null, [chalk2.template].concat(args));
-        };
-        Object.setPrototypeOf(chalk2, Chalk.prototype);
-        Object.setPrototypeOf(chalk2.template, chalk2);
-        chalk2.template.constructor = Chalk;
-        return chalk2.template;
+    var applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
       }
-      applyOptions(this, options);
-    }
-    if (isSimpleWindowsTerm) {
-      ansiStyles.blue.open = "\x1B[94m";
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    var ChalkClass = class {
+      constructor(options) {
+        return chalkFactory(options);
+      }
+    };
+    var chalkFactory = (options) => {
+      const chalk3 = {};
+      applyOptions(chalk3, options);
+      chalk3.template = (...arguments_) => chalkTag(chalk3.template, ...arguments_);
+      Object.setPrototypeOf(chalk3, Chalk.prototype);
+      Object.setPrototypeOf(chalk3.template, chalk3);
+      chalk3.template.constructor = () => {
+        throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+      };
+      chalk3.template.Instance = ChalkClass;
+      return chalk3.template;
+    };
+    function Chalk(options) {
+      return chalkFactory(options);
     }
-    for (const key of Object.keys(ansiStyles)) {
-      ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), "g");
-      styles[key] = {
+    for (const [styleName, style] of Object.entries(ansiStyles)) {
+      styles[styleName] = {
         get() {
-          const codes = ansiStyles[key];
-          return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+          const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
         }
       };
     }
     styles.visible = {
       get() {
-        return build.call(this, this._styles || [], true, "visible");
+        const builder = createBuilder(this, this._styler, true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
       }
     };
-    ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), "g");
-    for (const model of Object.keys(ansiStyles.color.ansi)) {
-      if (skipModels.has(model)) {
-        continue;
-      }
+    var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+    for (const model of usedModels) {
       styles[model] = {
         get() {
-          const level = this.level;
-          return function() {
-            const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
-            const codes = {
-              open,
-              close: ansiStyles.color.close,
-              closeRe: ansiStyles.color.closeRe
-            };
-            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
           };
         }
       };
     }
-    ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), "g");
-    for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
-      if (skipModels.has(model)) {
-        continue;
-      }
+    for (const model of usedModels) {
       const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
       styles[bgModel] = {
         get() {
-          const level = this.level;
-          return function() {
-            const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
-            const codes = {
-              open,
-              close: ansiStyles.bgColor.close,
-              closeRe: ansiStyles.bgColor.closeRe
-            };
-            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
           };
         }
       };
     }
     var proto = Object.defineProperties(() => {
-    }, styles);
-    function build(_styles, _empty, key) {
-      const builder = function() {
-        return applyStyle.apply(builder, arguments);
-      };
-      builder._styles = _styles;
-      builder._empty = _empty;
-      const self = this;
-      Object.defineProperty(builder, "level", {
+    }, {
+      ...styles,
+      level: {
         enumerable: true,
         get() {
-          return self.level;
+          return this._generator.level;
         },
         set(level) {
-          self.level = level;
+          this._generator.level = level;
         }
-      });
-      Object.defineProperty(builder, "enabled", {
-        enumerable: true,
-        get() {
-          return self.enabled;
-        },
-        set(enabled) {
-          self.enabled = enabled;
+      }
+    });
+    var createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    var createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => {
+        if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+          return applyStyle(builder, chalkTag(builder, ...arguments_));
         }
-      });
-      builder.hasGrey = this.hasGrey || key === "gray" || key === "grey";
-      builder.__proto__ = proto;
+        return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      };
+      Object.setPrototypeOf(builder, proto);
+      builder._generator = self;
+      builder._styler = _styler;
+      builder._isEmpty = _isEmpty;
       return builder;
-    }
-    function applyStyle() {
-      const args = arguments;
-      const argsLen = args.length;
-      let str = String(arguments[0]);
-      if (argsLen === 0) {
-        return "";
-      }
-      if (argsLen > 1) {
-        for (let a = 1; a < argsLen; a++) {
-          str += " " + args[a];
-        }
+    };
+    var applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self._isEmpty ? "" : string;
       }
-      if (!this.enabled || this.level <= 0 || !str) {
-        return this._empty ? "" : str;
+      let styler = self._styler;
+      if (styler === void 0) {
+        return string;
       }
-      const originalDim = ansiStyles.dim.open;
-      if (isSimpleWindowsTerm && this.hasGrey) {
-        ansiStyles.dim.open = "";
+      const { openAll, closeAll } = styler;
+      if (string.indexOf("\x1B") !== -1) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
       }
-      for (const code of this._styles.slice().reverse()) {
-        str = code.open + str.replace(code.closeRe, code.open) + code.close;
-        str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
       }
-      ansiStyles.dim.open = originalDim;
-      return str;
-    }
-    function chalkTag(chalk2, strings) {
-      if (!Array.isArray(strings)) {
-        return [].slice.call(arguments, 1).join(" ");
+      return openAll + string + closeAll;
+    };
+    var template;
+    var chalkTag = (chalk3, ...strings) => {
+      const [firstString] = strings;
+      if (!isArray(firstString) || !isArray(firstString.raw)) {
+        return strings.join(" ");
+      }
+      const arguments_ = strings.slice(1);
+      const parts = [firstString.raw[0]];
+      for (let i = 1; i < firstString.length; i++) {
+        parts.push(
+          String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"),
+          String(firstString.raw[i])
+        );
       }
-      const args = [].slice.call(arguments, 2);
-      const parts = [strings.raw[0]];
-      for (let i = 1; i < strings.length; i++) {
-        parts.push(String(args[i - 1]).replace(/[{}\\]/g, "\\$&"));
-        parts.push(String(strings.raw[i]));
+      if (template === void 0) {
+        template = require_templates();
       }
-      return template(chalk2, parts.join(""));
-    }
+      return template(chalk3, parts.join(""));
+    };
     Object.defineProperties(Chalk.prototype, styles);
-    module.exports = Chalk();
-    module.exports.supportsColor = stdoutColor;
-    module.exports.default = module.exports;
+    var chalk2 = Chalk();
+    chalk2.supportsColor = stdoutColor;
+    chalk2.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk2.stderr.supportsColor = stderrColor;
+    module.exports = chalk2;
   }
 });
 
 // src/index.ts
-var import_commander = __toESM(require_commander(), 1);
-var import_chalk = __toESM(require_chalk(), 1);
+var import_chalk = __toESM(require_source(), 1);
+import { Command } from "commander";
 import semver from "semver";
 import {
   createNodeApp,
@@ -3464,7 +1617,10 @@ var getTemplateData = async () => {
   }
   return templateDataCache.data;
 };
-var getTemplateCategories = async () => {
+var getTemplateCategories = async (cliArgs) => {
+  if (cliArgs == null ? void 0 : cliArgs.category) {
+    return [cliArgs.category];
+  }
   const templateData = await getTemplateData();
   const categories = /* @__PURE__ */ new Set();
   templateData.templates.forEach((template) => {
@@ -3472,15 +1628,20 @@ var getTemplateCategories = async () => {
   });
   return Array.from(categories);
 };
-var getTemplatesForCategory = async (category) => {
+var getTemplatesForCategory = async (category, cliArgs) => {
+  const selectedCategory = (cliArgs == null ? void 0 : cliArgs.category) || category;
+  if (!selectedCategory) {
+    throw new Error("Category is required in non-interactive mode.");
+  }
   const templateData = await getTemplateData();
   const templates = templateData.templates.filter(
-    (template) => template.category === category
+    (template) => template.category === selectedCategory
   );
   return templates;
 };
-var getExtensionsGroupedByCategory = async (type) => {
-  const safeType = Array.isArray(type) ? type : [type];
+var getExtensionsGroupedByCategory = async (type, cliArgs) => {
+  const selectedType = (cliArgs == null ? void 0 : cliArgs.type) ? cliArgs.type.split(",") : type;
+  const safeType = Array.isArray(selectedType) ? selectedType : [selectedType];
   const templateData = await getTemplateData();
   const extensions = templateData.extensions.filter((extension) => {
     const safeExtensionType = Array.isArray(extension.type) ? extension.type : [extension.type];
@@ -3502,14 +1663,67 @@ var getExtensionsGroupedByCategory = async (type) => {
 // src/options.ts
 prompts.override(yargs.argv);
 var PACKAGE_MANAGERS = ["npm", "yarn", "pnpm"];
+var isValidUrl = (url) => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
 var getCnaOptions = async (options) => {
-  if (isCI) {
+  const categories = await getTemplateCategories();
+  if (isCI || !options.interactive) {
+    let matchedTemplate;
+    if (options.template && !isValidUrl(options.template)) {
+      const allTemplates = (await Promise.all(
+        categories.map((category) => getTemplatesForCategory(category))
+      )).flat();
+      matchedTemplate = allTemplates.find(
+        (template) => template.slug === options.template
+      );
+      if (matchedTemplate) {
+        options.template = matchedTemplate.url;
+        if (matchedTemplate.customOptions) {
+          matchedTemplate.customOptions.forEach((customOption) => {
+            if (customOption.name && customOption.initial !== void 0) {
+              options[customOption.name] = customOption.initial;
+            }
+          });
+        }
+      } else {
+        throw new Error(
+          `Invalid template slug: '${options.template}'. Please provide a valid template slug.`
+        );
+      }
+    }
+    if (options.addons && Array.isArray(options.addons)) {
+      const extensionsGroupedByCategory2 = await getExtensionsGroupedByCategory([
+        (matchedTemplate == null ? void 0 : matchedTemplate.type) || "custom",
+        "all"
+      ]);
+      options.addons = options.addons.map((addon) => {
+        if (!isValidUrl(addon)) {
+          for (const extensions of Object.values(extensionsGroupedByCategory2)) {
+            const matchedExtension = extensions.find(
+              (extension) => extension.slug === addon
+            );
+            if (matchedExtension) {
+              return matchedExtension.url;
+            }
+          }
+          throw new Error(
+            `Invalid extension slug: '${addon}'. Please provide a valid extension slug.`
+          );
+        }
+        return addon;
+      });
+    }
     if (options.verbose) {
       console.log(JSON.stringify(options, null, 2));
     }
     return options;
   }
-  const categories = await getTemplateCategories();
   const categoriesOptions = [
     ...categories.map((category) => ({
       title: category,
@@ -3668,7 +1882,7 @@ var getCnaOptions = async (options) => {
 // package.json
 var package_default = {
   name: "create-awesome-node-app",
-  version: "0.4.23",
+  version: "0.4.26",
   type: "module",
   description: "Command line tool to create Node apps with a lot of different templates and extensions.",
   license: "MIT",
@@ -3715,36 +1929,42 @@ var package_default = {
   dependencies: {
     "@create-node-app/core": "*",
     axios: "^1.6.0",
-    "ci-info": "^3.8.0",
+    "ci-info": "^4.0.0",
+    commander: "^13.1.0",
     prompts: "^2.4.1",
-    semver: "^5.7.2",
+    semver: "^7.5.2",
     yargs: "^17.0.1"
   },
   devDependencies: {
     "@create-node-app/eslint-config-ts": "*",
     "@types/node": "^18.14.6",
-    "@types/prompts": "^2.4.2",
+    "@types/prompts": "^2.4.9",
     "@types/yargs": "^17.0.22",
-    eslint: "^7.9.0",
-    tsup: "^6.2.3"
+    eslint: "^7.23.0",
+    "eslint-config-turbo": "^0.0.4",
+    tsup: "^6.2.3",
+    "eslint-plugin-turbo": "^0.0.4"
   }
 };
 
 // src/index.ts
+var program = new Command();
 var main = async () => {
   let projectName = "my-project";
-  import_commander.default.version(package_default.version).arguments("[project-directory]").usage(`${import_chalk.default.green("[project-directory]")} [options]`).action((name) => {
-    projectName = name || projectName;
-  }).option("--verbose", "print additional logs").option("--info", "print environment debug info").option(
+  program.version(package_default.version).arguments("[project-directory]").usage(`${import_chalk.default.green("[project-directory]")} [options]`).option("-v, --verbose", "print additional logs").option("-i, --info", "print environment debug info").option(
     "--no-install",
     "Generate package.json without installing dependencies"
   ).option(
-    "--template <template>",
+    "-t, --template <template>",
     "specify a template for the created project"
   ).option(
-    "--extend [extensions...]",
+    "--addons [extensions...]",
     "specify extensions to apply for the boilerplate generation"
-  ).option("--use-yarn", "use yarn instead of npm or pnpm").option("--use-pnpm", "use pnpm instead of yarn or npm").parse(process.argv);
+  ).option("--use-yarn", "use yarn instead of npm or pnpm").option("--use-pnpm", "use pnpm instead of yarn or npm").option("--interactive", "run in interactive mode to select options", false).action((providedProjectName) => {
+    projectName = providedProjectName || projectName;
+  });
+  program.parse(process.argv);
+  const opts = program.opts();
   checkNodeVersion(package_default.engines.node, package_default.name);
   const latest = await checkForLatestVersion("create-awesome-node-app");
   if (latest && semver.lt(package_default.version, latest)) {
@@ -3758,14 +1978,20 @@ We recommend always using the latest version of create-awesome-node-app if possi
     );
     return;
   }
-  const { useYarn, usePnpm, ...opts } = import_commander.default.opts();
+  const options = await getCnaOptions({ ...opts, projectName });
+  const { useYarn, usePnpm, ...restOptions } = options;
   const packageManager = useYarn ? "yarn" : usePnpm ? "pnpm" : "npm";
-  const templatesOrExtensions = [opts.template].concat(opts.extend || []).filter(Boolean).map((templateOrExtension) => ({
-    url: templateOrExtension
-  }));
+  const templatesOrExtensions = [restOptions.template].concat(Array.isArray(restOptions.addons) ? restOptions.addons : []).concat(Array.isArray(restOptions.extend) ? restOptions.extend : []).reduce((acc, templateOrExtension) => {
+    if (!templateOrExtension) {
+      return acc;
+    }
+    return acc.concat({
+      url: templateOrExtension
+    });
+  }, []);
   return createNodeApp(
     projectName,
-    { ...opts, packageManager, templatesOrExtensions, projectName },
+    { ...restOptions, packageManager, templatesOrExtensions, projectName },
     getCnaOptions
   );
 };