publish-microfrontend 1.3.1-beta.6128 → 1.3.1-beta.6133

package/lib/index.js

@@ -1215,8 +1215,8 @@ var require_yargs_parser = __commonJS({
         }
       }
       aliasArrays.forEach(function(aliasArray) {
-        aliasArray = aliasArray.filter(function(v, i, self) {
-          return self.indexOf(v) === i;
+        aliasArray = aliasArray.filter(function(v, i, self2) {
+          return self2.indexOf(v) === i;
         });
         combined[aliasArray.pop()] = aliasArray;
       });
@@ -1259,11 +1259,11 @@ var require_command = __commonJS({
     var Parser = require_yargs_parser();
     var DEFAULT_MARKER = /(^\*)|(^\$0)/;
     function command(yargs2, usage, validation, globalMiddleware = []) {
-      const self = {};
+      const self2 = {};
       let handlers = {};
       let aliasMap = {};
       let defaultCommand;
-      self.addHandler = function addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
+      self2.addHandler = function addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
         let aliases = [];
         const middlewares = middleware_1.commandMiddlewareFactory(commandMiddleware);
         handler = handler || (() => {
@@ -1275,11 +1275,11 @@ var require_command = __commonJS({
           let command2 = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : moduleName(cmd);
           if (cmd.aliases)
             command2 = [].concat(command2).concat(cmd.aliases);
-          self.addHandler(command2, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
+          self2.addHandler(command2, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
           return;
         }
         if (isCommandBuilderDefinition(builder)) {
-          self.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
+          self2.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
           return;
         }
         const parsedCommand = parse_command_1.parseCommand(cmd);
@@ -1318,7 +1318,7 @@ var require_command = __commonJS({
         if (isDefault)
           defaultCommand = handlers[parsedCommand.cmd];
       };
-      self.addDirectory = function addDirectory(dir, context, req, callerFile, opts) {
+      self2.addDirectory = function addDirectory(dir, context, req, callerFile, opts) {
         opts = opts || {};
         if (typeof opts.recurse !== "boolean")
           opts.recurse = false;
@@ -1331,7 +1331,7 @@ var require_command = __commonJS({
             if (~context.files.indexOf(joined))
               return visited;
             context.files.push(joined);
-            self.addHandler(visited);
+            self2.addHandler(visited);
           }
           return visited;
         };
@@ -1354,10 +1354,10 @@ var require_command = __commonJS({
         }
         return false;
       }
-      self.getCommands = () => Object.keys(handlers).concat(Object.keys(aliasMap));
-      self.getCommandHandlers = () => handlers;
-      self.hasDefaultCommand = () => !!defaultCommand;
-      self.runCommand = function runCommand2(command2, yargs3, parsed, commandIndex) {
+      self2.getCommands = () => Object.keys(handlers).concat(Object.keys(aliasMap));
+      self2.getCommandHandlers = () => handlers;
+      self2.hasDefaultCommand = () => !!defaultCommand;
+      self2.runCommand = function runCommand2(command2, yargs3, parsed, commandIndex) {
         let aliases = parsed.aliases;
         const commandHandler = handlers[command2] || handlers[aliasMap[command2]] || defaultCommand;
         const currentContext = yargs3.getContext();
@@ -1450,7 +1450,7 @@ var require_command = __commonJS({
         pc.push(c);
         return `$0 ${pc.join(" ")}`;
       }
-      self.runDefaultBuilderOn = function(yargs3) {
+      self2.runDefaultBuilderOn = function(yargs3) {
         common_types_1.assertNotStrictEqual(defaultCommand, void 0);
         if (shouldUpdateUsage(yargs3)) {
           const commandString = DEFAULT_MARKER.test(defaultCommand.original) ? defaultCommand.original : defaultCommand.original.replace(/^[^[\]<>]*/, "$0 ");
@@ -1480,7 +1480,7 @@ var require_command = __commonJS({
           populatePositional(maybe, argv, positionalMap);
         }
         argv._ = context.commands.concat(argv._);
-        postProcessPositionals(argv, positionalMap, self.cmdToParseOptions(commandHandler.original));
+        postProcessPositionals(argv, positionalMap, self2.cmdToParseOptions(commandHandler.original));
         return positionalMap;
       }
       function populatePositional(positional, argv, positionalMap) {
@@ -1533,7 +1533,7 @@ var require_command = __commonJS({
           });
         }
       }
-      self.cmdToParseOptions = function(cmdString) {
+      self2.cmdToParseOptions = function(cmdString) {
         const parseOptions = {
           array: [],
           default: {},
@@ -1560,21 +1560,21 @@ var require_command = __commonJS({
         });
         return parseOptions;
       };
-      self.reset = () => {
+      self2.reset = () => {
         handlers = {};
         aliasMap = {};
         defaultCommand = void 0;
-        return self;
+        return self2;
       };
       const frozens = [];
-      self.freeze = () => {
+      self2.freeze = () => {
         frozens.push({
           handlers,
           aliasMap,
           defaultCommand
         });
       };
-      self.unfreeze = () => {
+      self2.unfreeze = () => {
         const frozen = frozens.pop();
         common_types_1.assertNotStrictEqual(frozen, void 0);
         ({
@@ -1583,7 +1583,7 @@ var require_command = __commonJS({
           defaultCommand
         } = frozen);
       };
-      return self;
+      return self2;
     }
     exports2.command = command;
     function isCommandHandlerDefinition(cmd) {
@@ -3225,28 +3225,28 @@ var require_usage = __commonJS({
     var stringWidth = require_string_width();
     function usage(yargs2, y18n) {
       const __ = y18n.__;
-      const self = {};
+      const self2 = {};
       const fails = [];
-      self.failFn = function failFn(f) {
+      self2.failFn = function failFn(f) {
         fails.push(f);
       };
       let failMessage = null;
       let showHelpOnFail = true;
-      self.showHelpOnFail = function showHelpOnFailFn(arg1 = true, arg2) {
+      self2.showHelpOnFail = function showHelpOnFailFn(arg1 = true, arg2) {
         function parseFunctionArgs() {
           return typeof arg1 === "string" ? [true, arg1] : [arg1, arg2];
         }
         const [enabled, message] = parseFunctionArgs();
         failMessage = message;
         showHelpOnFail = enabled;
-        return self;
+        return self2;
       };
       let failureOutput = false;
-      self.fail = function fail2(msg, err) {
+      self2.fail = function fail2(msg, err) {
         const logger = yargs2._getLoggerInstance();
         if (fails.length) {
           for (let i = fails.length - 1; i >= 0; --i) {
-            fails[i](msg, err, self);
+            fails[i](msg, err, self2);
           }
         } else {
           if (yargs2.getExitProcess())
@@ -3277,31 +3277,31 @@ var require_usage = __commonJS({
       };
       let usages = [];
       let usageDisabled = false;
-      self.usage = (msg, description) => {
+      self2.usage = (msg, description) => {
         if (msg === null) {
           usageDisabled = true;
           usages = [];
-          return self;
+          return self2;
         }
         usageDisabled = false;
         usages.push([msg, description || ""]);
-        return self;
+        return self2;
       };
-      self.getUsage = () => {
+      self2.getUsage = () => {
         return usages;
       };
-      self.getUsageDisabled = () => {
+      self2.getUsageDisabled = () => {
         return usageDisabled;
       };
-      self.getPositionalGroupName = () => {
+      self2.getPositionalGroupName = () => {
         return __("Positionals:");
       };
       let examples = [];
-      self.example = (cmd, description) => {
+      self2.example = (cmd, description) => {
         examples.push([cmd, description || ""]);
       };
       let commands = [];
-      self.command = function command(cmd, description, isDefault, aliases, deprecated = false) {
+      self2.command = function command(cmd, description, isDefault, aliases, deprecated = false) {
         if (isDefault) {
           commands = commands.map((cmdArray) => {
             cmdArray[2] = false;
@@ -3310,29 +3310,29 @@ var require_usage = __commonJS({
         }
         commands.push([cmd, description || "", isDefault, aliases, deprecated]);
       };
-      self.getCommands = () => commands;
+      self2.getCommands = () => commands;
       let descriptions = {};
-      self.describe = function describe(keyOrKeys, desc) {
+      self2.describe = function describe(keyOrKeys, desc) {
         if (Array.isArray(keyOrKeys)) {
           keyOrKeys.forEach((k) => {
-            self.describe(k, desc);
+            self2.describe(k, desc);
           });
         } else if (typeof keyOrKeys === "object") {
           Object.keys(keyOrKeys).forEach((k) => {
-            self.describe(k, keyOrKeys[k]);
+            self2.describe(k, keyOrKeys[k]);
           });
         } else {
           descriptions[keyOrKeys] = desc;
         }
       };
-      self.getDescriptions = () => descriptions;
+      self2.getDescriptions = () => descriptions;
       let epilogs = [];
-      self.epilog = (msg) => {
+      self2.epilog = (msg) => {
         epilogs.push(msg);
       };
       let wrapSet = false;
       let wrap;
-      self.wrap = (cols) => {
+      self2.wrap = (cols) => {
         wrapSet = true;
         wrap = cols;
       };
@@ -3344,8 +3344,8 @@ var require_usage = __commonJS({
         return wrap;
       }
       const deferY18nLookupPrefix = "__yargsString__:";
-      self.deferY18nLookup = (str) => deferY18nLookupPrefix + str;
-      self.help = function help() {
+      self2.deferY18nLookup = (str) => deferY18nLookupPrefix + str;
+      self2.help = function help() {
         if (cachedHelpMessage)
           return cachedHelpMessage;
         normalizeAliases();
@@ -3450,7 +3450,7 @@ var require_usage = __commonJS({
           ui.div(groupName);
           const switches = normalizedKeys.reduce((acc, key) => {
             acc[key] = [key].concat(options.alias[key] || []).map((sw) => {
-              if (groupName === self.getPositionalGroupName())
+              if (groupName === self2.getPositionalGroupName())
                 return sw;
               else {
                 return (/^[0-9]$/.test(sw) ? ~options.boolean.indexOf(key) ? "-" : "--" : sw.length > 1 ? "--" : "-") + sw;
@@ -3481,7 +3481,7 @@ var require_usage = __commonJS({
               key in deprecatedOptions ? deprecatedExtra(deprecatedOptions[key]) : null,
               type,
               key in demandedOptions ? `[${__("required")}]` : null,
-              options.choices && options.choices[key] ? `[${__("choices:")} ${self.stringifiedValues(options.choices[key])}]` : null,
+              options.choices && options.choices[key] ? `[${__("choices:")} ${self2.stringifiedValues(options.choices[key])}]` : null,
               defaultString(options.default[key], options.defaultDescription[key])
             ].filter(Boolean).join(" ");
             ui.span({ text: kswitch, padding: [0, 2, 0, 2], width: maxWidth(switches, theWrap) + 4 }, desc);
@@ -3540,7 +3540,7 @@ var require_usage = __commonJS({
         (Object.keys(options.alias) || []).forEach((key) => {
           options.alias[key].forEach((alias) => {
             if (descriptions[alias])
-              self.describe(key, descriptions[alias]);
+              self2.describe(key, descriptions[alias]);
             if (alias in demandedOptions)
               yargs2.demandOption(key, demandedOptions[alias]);
             if (~options.boolean.indexOf(alias))
@@ -3559,10 +3559,10 @@ var require_usage = __commonJS({
         });
       }
       let cachedHelpMessage;
-      self.cacheHelpMessage = function() {
+      self2.cacheHelpMessage = function() {
         cachedHelpMessage = this.help();
       };
-      self.clearCachedHelpMessage = function() {
+      self2.clearCachedHelpMessage = function() {
         cachedHelpMessage = void 0;
       };
       function addUngroupedKeys(keys, aliases, groups, defaultGroup) {
@@ -3582,18 +3582,18 @@ var require_usage = __commonJS({
       function filterHiddenOptions(key) {
         return yargs2.getOptions().hiddenOptions.indexOf(key) < 0 || yargs2.parsed.argv[yargs2.getOptions().showHiddenOpt];
       }
-      self.showHelp = (level) => {
+      self2.showHelp = (level) => {
         const logger = yargs2._getLoggerInstance();
         if (!level)
           level = "error";
         const emit = typeof level === "function" ? level : logger[level];
-        emit(self.help());
+        emit(self2.help());
       };
-      self.functionDescription = (fn) => {
+      self2.functionDescription = (fn) => {
         const description = fn.name ? decamelize(fn.name, "-") : __("generated-value");
         return ["(", description, ")"].join("");
       };
-      self.stringifiedValues = function stringifiedValues(values, separator) {
+      self2.stringifiedValues = function stringifiedValues(values, separator) {
         let string2 = "";
         const sep = separator || ", ";
         const array = [].concat(values);
@@ -3635,14 +3635,14 @@ var require_usage = __commonJS({
         }
       }
       let version = null;
-      self.version = (ver) => {
+      self2.version = (ver) => {
         version = ver;
       };
-      self.showVersion = () => {
+      self2.showVersion = () => {
         const logger = yargs2._getLoggerInstance();
         logger.log(version);
       };
-      self.reset = function reset(localLookup) {
+      self2.reset = function reset(localLookup) {
         failMessage = null;
         failureOutput = false;
         usages = [];
@@ -3651,10 +3651,10 @@ var require_usage = __commonJS({
         examples = [];
         commands = [];
         descriptions = obj_filter_1.objFilter(descriptions, (k) => !localLookup[k]);
-        return self;
+        return self2;
       };
       const frozens = [];
-      self.freeze = function freeze() {
+      self2.freeze = function freeze() {
         frozens.push({
           failMessage,
           failureOutput,
@@ -3666,7 +3666,7 @@ var require_usage = __commonJS({
           descriptions
         });
       };
-      self.unfreeze = function unfreeze() {
+      self2.unfreeze = function unfreeze() {
         const frozen = frozens.pop();
         common_types_1.assertNotStrictEqual(frozen, void 0);
         ({
@@ -3680,7 +3680,7 @@ var require_usage = __commonJS({
           descriptions
         } = frozen);
       };
-      return self;
+      return self2;
     }
     exports2.usage = usage;
   }
@@ -3756,15 +3756,15 @@ var require_completion = __commonJS({
     var path = require("path");
     var common_types_1 = require_common_types();
     function completion(yargs2, usage, command) {
-      const self = {
+      const self2 = {
         completionKey: "get-yargs-completions"
       };
       let aliases;
-      self.setParsed = function setParsed(parsed) {
+      self2.setParsed = function setParsed(parsed) {
         aliases = parsed.aliases;
       };
       const zshShell = process.env.SHELL && process.env.SHELL.indexOf("zsh") !== -1 || process.env.ZSH_NAME && process.env.ZSH_NAME.indexOf("zsh") !== -1;
-      self.getCompletion = function getCompletion(args2, done) {
+      self2.getCompletion = function getCompletion(args2, done) {
         const completions = [];
         const current2 = args2.length ? args2[args2.length - 1] : "";
         const argv = yargs2.parse(args2, true);
@@ -3847,7 +3847,7 @@ var require_completion = __commonJS({
         }
         done(completions);
       };
-      self.generateCompletionScript = function generateCompletionScript($0, cmd) {
+      self2.generateCompletionScript = function generateCompletionScript($0, cmd) {
         let script = zshShell ? templates.completionZshTemplate : templates.completionShTemplate;
         const name = path.basename($0);
         if ($0.match(/\.js$/))
@@ -3857,10 +3857,10 @@ var require_completion = __commonJS({
         return script.replace(/{{app_path}}/g, $0);
       };
       let completionFunction = null;
-      self.registerFunction = (fn) => {
+      self2.registerFunction = (fn) => {
         completionFunction = fn;
       };
-      return self;
+      return self2;
     }
     exports2.completion = completion;
     function isSyncCompletionFunction(completionFunction) {
@@ -3918,8 +3918,8 @@ var require_validation = __commonJS({
     function validation(yargs2, usage, y18n) {
       const __ = y18n.__;
       const __n = y18n.__n;
-      const self = {};
-      self.nonOptionCount = function nonOptionCount(argv) {
+      const self2 = {};
+      self2.nonOptionCount = function nonOptionCount(argv) {
         const demandedCommands = yargs2.getDemandedCommands();
         const _s = argv._.length - yargs2.getContext().commands.length;
         if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
@@ -3938,12 +3938,12 @@ var require_validation = __commonJS({
           }
         }
       };
-      self.positionalCount = function positionalCount(required, observed) {
+      self2.positionalCount = function positionalCount(required, observed) {
         if (observed < required) {
           usage.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", observed, observed, required));
         }
       };
-      self.requiredArguments = function requiredArguments(argv) {
+      self2.requiredArguments = function requiredArguments(argv) {
         const demandedOptions = yargs2.getDemandedOptions();
         let missing = null;
         for (const key of Object.keys(demandedOptions)) {
@@ -3965,12 +3965,12 @@ ${customMsgs.join("\n")}` : "";
           usage.fail(__n("Missing required argument: %s", "Missing required arguments: %s", Object.keys(missing).length, Object.keys(missing).join(", ") + customMsg));
         }
       };
-      self.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand) {
+      self2.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand) {
         const commandKeys = yargs2.getCommandInstance().getCommands();
         const unknown = [];
         const currentContext = yargs2.getContext();
         Object.keys(argv).forEach((key) => {
-          if (specialKeys.indexOf(key) === -1 && !Object.prototype.hasOwnProperty.call(positionalMap, key) && !Object.prototype.hasOwnProperty.call(yargs2._getParseContext(), key) && !self.isValidAndSomeAliasIsNotNew(key, aliases)) {
+          if (specialKeys.indexOf(key) === -1 && !Object.prototype.hasOwnProperty.call(positionalMap, key) && !Object.prototype.hasOwnProperty.call(yargs2._getParseContext(), key) && !self2.isValidAndSomeAliasIsNotNew(key, aliases)) {
             unknown.push(key);
           }
         });
@@ -3985,7 +3985,7 @@ ${customMsgs.join("\n")}` : "";
           usage.fail(__n("Unknown argument: %s", "Unknown arguments: %s", unknown.length, unknown.join(", ")));
         }
       };
-      self.unknownCommands = function unknownCommands(argv) {
+      self2.unknownCommands = function unknownCommands(argv) {
         const commandKeys = yargs2.getCommandInstance().getCommands();
         const unknown = [];
         const currentContext = yargs2.getContext();
@@ -4003,7 +4003,7 @@ ${customMsgs.join("\n")}` : "";
           return false;
         }
       };
-      self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {
+      self2.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {
         if (!Object.prototype.hasOwnProperty.call(aliases, key)) {
           return false;
         }
@@ -4015,7 +4015,7 @@ ${customMsgs.join("\n")}` : "";
         }
         return false;
       };
-      self.limitedChoices = function limitedChoices(argv) {
+      self2.limitedChoices = function limitedChoices(argv) {
         const options = yargs2.getOptions();
         const invalid = {};
         if (!Object.keys(options.choices).length)
@@ -4040,13 +4040,13 @@ ${customMsgs.join("\n")}` : "";
         usage.fail(msg);
       };
       let checks = [];
-      self.check = function check(f, global2) {
+      self2.check = function check(f, global2) {
         checks.push({
           func: f,
           global: global2
         });
       };
-      self.customChecks = function customChecks(argv, aliases) {
+      self2.customChecks = function customChecks(argv, aliases) {
         for (let i = 0, f; (f = checks[i]) !== void 0; i++) {
           const func = f.func;
           let result = null;
@@ -4064,11 +4064,11 @@ ${customMsgs.join("\n")}` : "";
         }
       };
       let implied = {};
-      self.implies = function implies(key, value) {
+      self2.implies = function implies(key, value) {
         argsert_1.argsert("<string|object> [array|number|string]", [key, value], arguments.length);
         if (typeof key === "object") {
           Object.keys(key).forEach((k) => {
-            self.implies(k, key[k]);
+            self2.implies(k, key[k]);
           });
         } else {
           yargs2.global(key);
@@ -4076,14 +4076,14 @@ ${customMsgs.join("\n")}` : "";
             implied[key] = [];
           }
           if (Array.isArray(value)) {
-            value.forEach((i) => self.implies(key, i));
+            value.forEach((i) => self2.implies(key, i));
           } else {
             common_types_1.assertNotStrictEqual(value, void 0);
             implied[key].push(value);
           }
         }
       };
-      self.getImplied = function getImplied() {
+      self2.getImplied = function getImplied() {
         return implied;
       };
       function keyExists(argv, val) {
@@ -4099,7 +4099,7 @@ ${customMsgs.join("\n")}` : "";
         }
         return val;
       }
-      self.implications = function implications(argv) {
+      self2.implications = function implications(argv) {
         const implyFail = [];
         Object.keys(implied).forEach((key) => {
           const origKey = key;
@@ -4123,11 +4123,11 @@ ${customMsgs.join("\n")}` : "";
         }
       };
       let conflicting = {};
-      self.conflicts = function conflicts(key, value) {
+      self2.conflicts = function conflicts(key, value) {
         argsert_1.argsert("<string|object> [array|string]", [key, value], arguments.length);
         if (typeof key === "object") {
           Object.keys(key).forEach((k) => {
-            self.conflicts(k, key[k]);
+            self2.conflicts(k, key[k]);
           });
         } else {
           yargs2.global(key);
@@ -4135,14 +4135,14 @@ ${customMsgs.join("\n")}` : "";
             conflicting[key] = [];
           }
           if (Array.isArray(value)) {
-            value.forEach((i) => self.conflicts(key, i));
+            value.forEach((i) => self2.conflicts(key, i));
           } else {
             conflicting[key].push(value);
           }
         }
       };
-      self.getConflicting = () => conflicting;
-      self.conflicting = function conflictingFn(argv) {
+      self2.getConflicting = () => conflicting;
+      self2.conflicting = function conflictingFn(argv) {
         Object.keys(argv).forEach((key) => {
           if (conflicting[key]) {
             conflicting[key].forEach((value) => {
@@ -4153,7 +4153,7 @@ ${customMsgs.join("\n")}` : "";
           }
         });
       };
-      self.recommendCommands = function recommendCommands(cmd, potentialCommands) {
+      self2.recommendCommands = function recommendCommands(cmd, potentialCommands) {
         const threshold = 3;
         potentialCommands = potentialCommands.sort((a, b) => b.length - a.length);
         let recommended = null;
@@ -4168,21 +4168,21 @@ ${customMsgs.join("\n")}` : "";
         if (recommended)
           usage.fail(__("Did you mean %s?", recommended));
       };
-      self.reset = function reset(localLookup) {
+      self2.reset = function reset(localLookup) {
         implied = obj_filter_1.objFilter(implied, (k) => !localLookup[k]);
         conflicting = obj_filter_1.objFilter(conflicting, (k) => !localLookup[k]);
         checks = checks.filter((c) => c.global);
-        return self;
+        return self2;
       };
       const frozens = [];
-      self.freeze = function freeze() {
+      self2.freeze = function freeze() {
         frozens.push({
           implied,
           checks,
           conflicting
         });
       };
-      self.unfreeze = function unfreeze() {
+      self2.unfreeze = function unfreeze() {
         const frozen = frozens.pop();
         common_types_1.assertNotStrictEqual(frozen, void 0);
         ({
@@ -4191,7 +4191,7 @@ ${customMsgs.join("\n")}` : "";
           conflicting
         } = frozen);
       };
-      return self;
+      return self2;
     }
     exports2.validation = validation;
   }
@@ -4781,7 +4781,7 @@ var require_yargs = __commonJS({
     var findUp = require_find_up();
     var requireMainFilename = require_require_main_filename();
     function Yargs(processArgs = [], cwd = process.cwd(), parentRequire = require) {
-      const self = {};
+      const self2 = {};
       let command;
       let completion = null;
       let groups = {};
@@ -4795,11 +4795,11 @@ var require_yargs = __commonJS({
         directory: path.resolve(__dirname, "../../locales"),
         updateFiles: false
       });
-      self.middleware = middleware_1.globalMiddlewareFactory(globalMiddleware, self);
-      self.scriptName = function(scriptName) {
-        self.customScriptName = true;
-        self.$0 = scriptName;
-        return self;
+      self2.middleware = middleware_1.globalMiddlewareFactory(globalMiddleware, self2);
+      self2.scriptName = function(scriptName) {
+        self2.customScriptName = true;
+        self2.$0 = scriptName;
+        return self2;
       };
       let default$0;
       if (/\b(node|iojs|electron)(\.exe)?$/.test(process.argv[0])) {
@@ -4807,17 +4807,17 @@ var require_yargs = __commonJS({
       } else {
         default$0 = process.argv.slice(0, 1);
       }
-      self.$0 = default$0.map((x) => {
+      self2.$0 = default$0.map((x) => {
         const b = rebase(cwd, x);
         return x.match(/^(\/|([a-zA-Z]:)?\\)/) && b.length < x.length ? b : x;
       }).join(" ").trim();
       if (process.env._ !== void 0 && processArgv.getProcessArgvBin() === process.env._) {
-        self.$0 = process.env._.replace(`${path.dirname(process.execPath)}/`, "");
+        self2.$0 = process.env._.replace(`${path.dirname(process.execPath)}/`, "");
       }
       const context = { resets: -1, commands: [], fullCommands: [], files: [] };
-      self.getContext = () => context;
+      self2.getContext = () => context;
       let options;
-      self.resetOptions = self.reset = function resetOptions(aliases = {}) {
+      self2.resetOptions = self2.reset = function resetOptions(aliases = {}) {
         context.resets++;
         options = options || {};
         const tmpOptions = {};
@@ -4869,19 +4869,19 @@ var require_yargs = __commonJS({
         });
         tmpOptions.envPrefix = options.envPrefix;
         options = tmpOptions;
-        usage = usage ? usage.reset(localLookup) : usage_1.usage(self, y18n);
-        validation = validation ? validation.reset(localLookup) : validation_1.validation(self, usage, y18n);
-        command = command ? command.reset() : command_1.command(self, usage, validation, globalMiddleware);
+        usage = usage ? usage.reset(localLookup) : usage_1.usage(self2, y18n);
+        validation = validation ? validation.reset(localLookup) : validation_1.validation(self2, usage, y18n);
+        command = command ? command.reset() : command_1.command(self2, usage, validation, globalMiddleware);
         if (!completion)
-          completion = completion_1.completion(self, usage, command);
+          completion = completion_1.completion(self2, usage, command);
         completionCommand = null;
         output = "";
         exitError = null;
         hasOutput = false;
-        self.parsed = false;
-        return self;
+        self2.parsed = false;
+        return self2;
       };
-      self.resetOptions();
+      self2.resetOptions();
       const frozens = [];
       function freeze() {
         frozens.push({
@@ -4895,7 +4895,7 @@ var require_yargs = __commonJS({
           output,
           exitError,
           hasOutput,
-          parsed: self.parsed,
+          parsed: self2.parsed,
           parseFn,
           parseContext,
           handlerFinishCommand
@@ -4916,7 +4916,7 @@ var require_yargs = __commonJS({
           output,
           exitError,
           hasOutput,
-          parsed: self.parsed,
+          parsed: self2.parsed,
           strict,
           strictCommands,
           completionCommand,
@@ -4929,49 +4929,49 @@ var require_yargs = __commonJS({
         validation.unfreeze();
         command.unfreeze();
       }
-      self.boolean = function(keys) {
+      self2.boolean = function(keys) {
         argsert_1.argsert("<array|string>", [keys], arguments.length);
         populateParserHintArray("boolean", keys);
-        return self;
+        return self2;
       };
-      self.array = function(keys) {
+      self2.array = function(keys) {
         argsert_1.argsert("<array|string>", [keys], arguments.length);
         populateParserHintArray("array", keys);
-        return self;
+        return self2;
       };
-      self.number = function(keys) {
+      self2.number = function(keys) {
         argsert_1.argsert("<array|string>", [keys], arguments.length);
         populateParserHintArray("number", keys);
-        return self;
+        return self2;
       };
-      self.normalize = function(keys) {
+      self2.normalize = function(keys) {
         argsert_1.argsert("<array|string>", [keys], arguments.length);
         populateParserHintArray("normalize", keys);
-        return self;
+        return self2;
       };
-      self.count = function(keys) {
+      self2.count = function(keys) {
         argsert_1.argsert("<array|string>", [keys], arguments.length);
         populateParserHintArray("count", keys);
-        return self;
+        return self2;
       };
-      self.string = function(keys) {
+      self2.string = function(keys) {
         argsert_1.argsert("<array|string>", [keys], arguments.length);
         populateParserHintArray("string", keys);
-        return self;
+        return self2;
       };
-      self.requiresArg = function(keys) {
+      self2.requiresArg = function(keys) {
         argsert_1.argsert("<array|string|object> [number]", [keys], arguments.length);
         if (typeof keys === "string" && options.narg[keys]) {
-          return self;
+          return self2;
         } else {
-          populateParserHintSingleValueDictionary(self.requiresArg, "narg", keys, NaN);
+          populateParserHintSingleValueDictionary(self2.requiresArg, "narg", keys, NaN);
         }
-        return self;
+        return self2;
       };
-      self.skipValidation = function(keys) {
+      self2.skipValidation = function(keys) {
         argsert_1.argsert("<array|string>", [keys], arguments.length);
         populateParserHintArray("skipValidation", keys);
-        return self;
+        return self2;
       };
       function populateParserHintArray(type, keys) {
         keys = [].concat(keys);
@@ -4980,22 +4980,22 @@ var require_yargs = __commonJS({
           options[type].push(key);
         });
       }
-      self.nargs = function(key, value) {
+      self2.nargs = function(key, value) {
         argsert_1.argsert("<string|object|array> [number]", [key, value], arguments.length);
-        populateParserHintSingleValueDictionary(self.nargs, "narg", key, value);
-        return self;
+        populateParserHintSingleValueDictionary(self2.nargs, "narg", key, value);
+        return self2;
       };
-      self.choices = function(key, value) {
+      self2.choices = function(key, value) {
         argsert_1.argsert("<object|string|array> [string|array]", [key, value], arguments.length);
-        populateParserHintArrayDictionary(self.choices, "choices", key, value);
-        return self;
+        populateParserHintArrayDictionary(self2.choices, "choices", key, value);
+        return self2;
       };
-      self.alias = function(key, value) {
+      self2.alias = function(key, value) {
         argsert_1.argsert("<object|string|array> [string|array]", [key, value], arguments.length);
-        populateParserHintArrayDictionary(self.alias, "alias", key, value);
-        return self;
+        populateParserHintArrayDictionary(self2.alias, "alias", key, value);
+        return self2;
       };
-      self.default = self.defaults = function(key, value, defaultDescription) {
+      self2.default = self2.defaults = function(key, value, defaultDescription) {
         argsert_1.argsert("<object|string|array> [*] [string]", [key, value, defaultDescription], arguments.length);
         if (defaultDescription) {
           common_types_1.assertSingleKey(key);
@@ -5007,29 +5007,29 @@ var require_yargs = __commonJS({
             options.defaultDescription[key] = usage.functionDescription(value);
           value = value.call();
         }
-        populateParserHintSingleValueDictionary(self.default, "default", key, value);
-        return self;
+        populateParserHintSingleValueDictionary(self2.default, "default", key, value);
+        return self2;
       };
-      self.describe = function(key, desc) {
+      self2.describe = function(key, desc) {
         argsert_1.argsert("<object|string|array> [string]", [key, desc], arguments.length);
         setKey(key, true);
         usage.describe(key, desc);
-        return self;
+        return self2;
       };
       function setKey(key, set) {
         populateParserHintSingleValueDictionary(setKey, "key", key, set);
-        return self;
+        return self2;
       }
       function demandOption(keys, msg) {
         argsert_1.argsert("<object|string|array> [string]", [keys, msg], arguments.length);
-        populateParserHintSingleValueDictionary(self.demandOption, "demandedOptions", keys, msg);
-        return self;
+        populateParserHintSingleValueDictionary(self2.demandOption, "demandedOptions", keys, msg);
+        return self2;
       }
-      self.demandOption = demandOption;
-      self.coerce = function(keys, value) {
+      self2.demandOption = demandOption;
+      self2.coerce = function(keys, value) {
         argsert_1.argsert("<object|string|array> [function]", [keys, value], arguments.length);
-        populateParserHintSingleValueDictionary(self.coerce, "coerce", keys, value);
-        return self;
+        populateParserHintSingleValueDictionary(self2.coerce, "coerce", keys, value);
+        return self2;
       };
       function populateParserHintSingleValueDictionary(builder, type, key, value) {
         populateParserHintDictionary(builder, type, key, value, (type2, key2, value2) => {
@@ -5073,44 +5073,44 @@ var require_yargs = __commonJS({
         });
         delete usage.getDescriptions()[optionKey];
       }
-      self.config = function config(key = "config", msg, parseFn2) {
+      self2.config = function config(key = "config", msg, parseFn2) {
         argsert_1.argsert("[object|string] [string|function] [function]", [key, msg, parseFn2], arguments.length);
         if (typeof key === "object" && !Array.isArray(key)) {
-          key = apply_extends_1.applyExtends(key, cwd, self.getParserConfiguration()["deep-merge-config"]);
+          key = apply_extends_1.applyExtends(key, cwd, self2.getParserConfiguration()["deep-merge-config"]);
           options.configObjects = (options.configObjects || []).concat(key);
-          return self;
+          return self2;
         }
         if (typeof msg === "function") {
           parseFn2 = msg;
           msg = void 0;
         }
-        self.describe(key, msg || usage.deferY18nLookup("Path to JSON config file"));
+        self2.describe(key, msg || usage.deferY18nLookup("Path to JSON config file"));
         (Array.isArray(key) ? key : [key]).forEach((k) => {
           options.config[k] = parseFn2 || true;
         });
-        return self;
+        return self2;
       };
-      self.example = function(cmd, description) {
+      self2.example = function(cmd, description) {
         argsert_1.argsert("<string|array> [string]", [cmd, description], arguments.length);
         if (Array.isArray(cmd)) {
-          cmd.forEach((exampleParams) => self.example(...exampleParams));
+          cmd.forEach((exampleParams) => self2.example(...exampleParams));
         } else {
           usage.example(cmd, description);
         }
-        return self;
+        return self2;
       };
-      self.command = function(cmd, description, builder, handler, middlewares, deprecated) {
+      self2.command = function(cmd, description, builder, handler, middlewares, deprecated) {
         argsert_1.argsert("<string|array|object> [string|boolean] [function|object] [function] [array] [boolean|string]", [cmd, description, builder, handler, middlewares, deprecated], arguments.length);
         command.addHandler(cmd, description, builder, handler, middlewares, deprecated);
-        return self;
+        return self2;
       };
-      self.commandDir = function(dir, opts) {
+      self2.commandDir = function(dir, opts) {
         argsert_1.argsert("<string> [object]", [dir, opts], arguments.length);
         const req = parentRequire || require;
-        command.addDirectory(dir, self.getContext(), req, require_get_caller_file()(), opts);
-        return self;
+        command.addDirectory(dir, self2.getContext(), req, require_get_caller_file()(), opts);
+        return self2;
       };
-      self.demand = self.required = self.require = function demand(keys, max, msg) {
+      self2.demand = self2.required = self2.require = function demand(keys, max, msg) {
         if (Array.isArray(max)) {
           max.forEach((key) => {
             common_types_1.assertNotStrictEqual(msg, true);
@@ -5123,7 +5123,7 @@ var require_yargs = __commonJS({
         }
         if (typeof keys === "number") {
           common_types_1.assertNotStrictEqual(msg, true);
-          self.demandCommand(keys, max, msg, msg);
+          self2.demandCommand(keys, max, msg, msg);
         } else if (Array.isArray(keys)) {
           keys.forEach((key) => {
             common_types_1.assertNotStrictEqual(msg, true);
@@ -5136,86 +5136,86 @@ var require_yargs = __commonJS({
             demandOption(keys);
           }
         }
-        return self;
+        return self2;
       };
-      self.demandCommand = function demandCommand(min = 1, max, minMsg, maxMsg) {
+      self2.demandCommand = function demandCommand(min = 1, max, minMsg, maxMsg) {
         argsert_1.argsert("[number] [number|string] [string|null|undefined] [string|null|undefined]", [min, max, minMsg, maxMsg], arguments.length);
         if (typeof max !== "number") {
           minMsg = max;
           max = Infinity;
         }
-        self.global("_", false);
+        self2.global("_", false);
         options.demandedCommands._ = {
           min,
           max,
           minMsg,
           maxMsg
         };
-        return self;
+        return self2;
       };
-      self.getDemandedOptions = () => {
+      self2.getDemandedOptions = () => {
         argsert_1.argsert([], 0);
         return options.demandedOptions;
       };
-      self.getDemandedCommands = () => {
+      self2.getDemandedCommands = () => {
         argsert_1.argsert([], 0);
         return options.demandedCommands;
       };
-      self.deprecateOption = function deprecateOption(option, message) {
+      self2.deprecateOption = function deprecateOption(option, message) {
         argsert_1.argsert("<string> [string|boolean]", [option, message], arguments.length);
         options.deprecatedOptions[option] = message;
-        return self;
+        return self2;
       };
-      self.getDeprecatedOptions = () => {
+      self2.getDeprecatedOptions = () => {
         argsert_1.argsert([], 0);
         return options.deprecatedOptions;
       };
-      self.implies = function(key, value) {
+      self2.implies = function(key, value) {
         argsert_1.argsert("<string|object> [number|string|array]", [key, value], arguments.length);
         validation.implies(key, value);
-        return self;
+        return self2;
       };
-      self.conflicts = function(key1, key2) {
+      self2.conflicts = function(key1, key2) {
         argsert_1.argsert("<string|object> [string|array]", [key1, key2], arguments.length);
         validation.conflicts(key1, key2);
-        return self;
+        return self2;
       };
-      self.usage = function(msg, description, builder, handler) {
+      self2.usage = function(msg, description, builder, handler) {
         argsert_1.argsert("<string|null|undefined> [string|boolean] [function|object] [function]", [msg, description, builder, handler], arguments.length);
         if (description !== void 0) {
           common_types_1.assertNotStrictEqual(msg, null);
           if ((msg || "").match(/^\$0( |$)/)) {
-            return self.command(msg, description, builder, handler);
+            return self2.command(msg, description, builder, handler);
           } else {
             throw new yerror_1.YError(".usage() description must start with $0 if being used as alias for .command()");
           }
         } else {
           usage.usage(msg);
-          return self;
+          return self2;
         }
       };
-      self.epilogue = self.epilog = function(msg) {
+      self2.epilogue = self2.epilog = function(msg) {
         argsert_1.argsert("<string>", [msg], arguments.length);
         usage.epilog(msg);
-        return self;
+        return self2;
       };
-      self.fail = function(f) {
+      self2.fail = function(f) {
         argsert_1.argsert("<function>", [f], arguments.length);
         usage.failFn(f);
-        return self;
+        return self2;
       };
-      self.onFinishCommand = function(f) {
+      self2.onFinishCommand = function(f) {
         argsert_1.argsert("<function>", [f], arguments.length);
         handlerFinishCommand = f;
-        return self;
+        return self2;
       };
-      self.getHandlerFinishCommand = () => handlerFinishCommand;
-      self.check = function(f, _global) {
+      self2.getHandlerFinishCommand = () => handlerFinishCommand;
+      self2.check = function(f, _global) {
         argsert_1.argsert("<function> [boolean]", [f, _global], arguments.length);
         validation.check(f, _global !== false);
-        return self;
+        return self2;
       };
-      self.global = function global2(globals, global2) {
+      self2.global = function global2(globals, global2) {
         argsert_1.argsert("<string|array> [boolean]", [globals, global2], arguments.length);
         globals = [].concat(globals);
         if (global2 !== false) {
@@ -5226,17 +5226,17 @@ var require_yargs = __commonJS({
               options.local.push(g);
           });
         }
-        return self;
+        return self2;
       };
-      self.pkgConf = function pkgConf(key, rootPath) {
+      self2.pkgConf = function pkgConf(key, rootPath) {
         argsert_1.argsert("<string> [string]", [key, rootPath], arguments.length);
         let conf = null;
         const obj = pkgUp(rootPath || cwd);
         if (obj[key] && typeof obj[key] === "object") {
-          conf = apply_extends_1.applyExtends(obj[key], rootPath || cwd, self.getParserConfiguration()["deep-merge-config"]);
+          conf = apply_extends_1.applyExtends(obj[key], rootPath || cwd, self2.getParserConfiguration()["deep-merge-config"]);
           options.configObjects = (options.configObjects || []).concat(conf);
         }
-        return self;
+        return self2;
       };
       const pkgs = {};
       function pkgUp(rootPath) {
@@ -5261,14 +5261,14 @@ var require_yargs = __commonJS({
       }
       let parseFn = null;
       let parseContext = null;
-      self.parse = function parse(args2, shortCircuit, _parseFn) {
+      self2.parse = function parse(args2, shortCircuit, _parseFn) {
         argsert_1.argsert("[string|array] [function|boolean|object] [function]", [args2, shortCircuit, _parseFn], arguments.length);
         freeze();
         if (typeof args2 === "undefined") {
-          const argv = self._parseArgs(processArgs);
-          const tmpParsed = self.parsed;
+          const argv = self2._parseArgs(processArgs);
+          const tmpParsed = self2.parsed;
           unfreeze();
-          self.parsed = tmpParsed;
+          self2.parsed = tmpParsed;
           return argv;
         }
         if (typeof shortCircuit === "object") {
@@ -5283,20 +5283,20 @@ var require_yargs = __commonJS({
           processArgs = args2;
         if (parseFn)
           exitProcess = false;
-        const parsed = self._parseArgs(args2, !!shortCircuit);
-        completion.setParsed(self.parsed);
+        const parsed = self2._parseArgs(args2, !!shortCircuit);
+        completion.setParsed(self2.parsed);
         if (parseFn)
           parseFn(exitError, parsed, output);
         unfreeze();
         return parsed;
       };
-      self._getParseContext = () => parseContext || {};
-      self._hasParseCallback = () => !!parseFn;
-      self.option = self.options = function option(key, opt) {
+      self2._getParseContext = () => parseContext || {};
+      self2._hasParseCallback = () => !!parseFn;
+      self2.option = self2.options = function option(key, opt) {
         argsert_1.argsert("<string|object> [object]", [key, opt], arguments.length);
         if (typeof key === "object") {
           Object.keys(key).forEach((k) => {
-            self.options(k, key[k]);
+            self2.options(k, key[k]);
           });
         } else {
           if (typeof opt !== "object") {
@@ -5304,90 +5304,90 @@ var require_yargs = __commonJS({
           }
           options.key[key] = true;
           if (opt.alias)
-            self.alias(key, opt.alias);
+            self2.alias(key, opt.alias);
           const deprecate = opt.deprecate || opt.deprecated;
           if (deprecate) {
-            self.deprecateOption(key, deprecate);
+            self2.deprecateOption(key, deprecate);
           }
           const demand = opt.demand || opt.required || opt.require;
           if (demand) {
-            self.demand(key, demand);
+            self2.demand(key, demand);
           }
           if (opt.demandOption) {
-            self.demandOption(key, typeof opt.demandOption === "string" ? opt.demandOption : void 0);
+            self2.demandOption(key, typeof opt.demandOption === "string" ? opt.demandOption : void 0);
           }
           if (opt.conflicts) {
-            self.conflicts(key, opt.conflicts);
+            self2.conflicts(key, opt.conflicts);
           }
           if ("default" in opt) {
-            self.default(key, opt.default);
+            self2.default(key, opt.default);
           }
           if (opt.implies !== void 0) {
-            self.implies(key, opt.implies);
+            self2.implies(key, opt.implies);
           }
           if (opt.nargs !== void 0) {
-            self.nargs(key, opt.nargs);
+            self2.nargs(key, opt.nargs);
           }
           if (opt.config) {
-            self.config(key, opt.configParser);
+            self2.config(key, opt.configParser);
           }
           if (opt.normalize) {
-            self.normalize(key);
+            self2.normalize(key);
           }
           if (opt.choices) {
-            self.choices(key, opt.choices);
+            self2.choices(key, opt.choices);
           }
           if (opt.coerce) {
-            self.coerce(key, opt.coerce);
+            self2.coerce(key, opt.coerce);
           }
           if (opt.group) {
-            self.group(key, opt.group);
+            self2.group(key, opt.group);
           }
           if (opt.boolean || opt.type === "boolean") {
-            self.boolean(key);
+            self2.boolean(key);
             if (opt.alias)
-              self.boolean(opt.alias);
+              self2.boolean(opt.alias);
           }
           if (opt.array || opt.type === "array") {
-            self.array(key);
+            self2.array(key);
             if (opt.alias)
-              self.array(opt.alias);
+              self2.array(opt.alias);
           }
           if (opt.number || opt.type === "number") {
-            self.number(key);
+            self2.number(key);
             if (opt.alias)
-              self.number(opt.alias);
+              self2.number(opt.alias);
           }
           if (opt.string || opt.type === "string") {
-            self.string(key);
+            self2.string(key);
             if (opt.alias)
-              self.string(opt.alias);
+              self2.string(opt.alias);
           }
           if (opt.count || opt.type === "count") {
-            self.count(key);
+            self2.count(key);
           }
           if (typeof opt.global === "boolean") {
-            self.global(key, opt.global);
+            self2.global(key, opt.global);
           }
           if (opt.defaultDescription) {
             options.defaultDescription[key] = opt.defaultDescription;
           }
           if (opt.skipValidation) {
-            self.skipValidation(key);
+            self2.skipValidation(key);
           }
           const desc = opt.describe || opt.description || opt.desc;
-          self.describe(key, desc);
+          self2.describe(key, desc);
           if (opt.hidden) {
-            self.hide(key);
+            self2.hide(key);
           }
           if (opt.requiresArg) {
-            self.requiresArg(key);
+            self2.requiresArg(key);
           }
         }
-        return self;
+        return self2;
       };
-      self.getOptions = () => options;
-      self.positional = function(key, opts) {
+      self2.getOptions = () => options;
+      self2.positional = function(key, opts) {
         argsert_1.argsert("<string> <object>", [key, opts], arguments.length);
         if (context.resets === 0) {
           throw new yerror_1.YError(".positional() can only be called in a command's builder function");
@@ -5429,10 +5429,10 @@ var require_yargs = __commonJS({
               opts[pk] = parseOption[key];
           }
         });
-        self.group(key, usage.getPositionalGroupName());
-        return self.option(key, opts);
+        self2.group(key, usage.getPositionalGroupName());
+        return self2.option(key, opts);
       };
-      self.group = function group(opts, groupName) {
+      self2.group = function group(opts, groupName) {
         argsert_1.argsert("<string|array> <string>", [opts, groupName], arguments.length);
         const existing = preservedGroups[groupName] || groups[groupName];
         if (preservedGroups[groupName]) {
@@ -5444,56 +5444,56 @@ var require_yargs = __commonJS({
             return false;
           return seen[key] = true;
         });
-        return self;
+        return self2;
       };
-      self.getGroups = () => Object.assign({}, groups, preservedGroups);
-      self.env = function(prefix) {
+      self2.getGroups = () => Object.assign({}, groups, preservedGroups);
+      self2.env = function(prefix) {
         argsert_1.argsert("[string|boolean]", [prefix], arguments.length);
         if (prefix === false)
           delete options.envPrefix;
         else
           options.envPrefix = prefix || "";
-        return self;
+        return self2;
       };
-      self.wrap = function(cols) {
+      self2.wrap = function(cols) {
         argsert_1.argsert("<number|null|undefined>", [cols], arguments.length);
         usage.wrap(cols);
-        return self;
+        return self2;
       };
       let strict = false;
-      self.strict = function(enabled) {
+      self2.strict = function(enabled) {
         argsert_1.argsert("[boolean]", [enabled], arguments.length);
         strict = enabled !== false;
-        return self;
+        return self2;
       };
-      self.getStrict = () => strict;
+      self2.getStrict = () => strict;
       let strictCommands = false;
-      self.strictCommands = function(enabled) {
+      self2.strictCommands = function(enabled) {
         argsert_1.argsert("[boolean]", [enabled], arguments.length);
         strictCommands = enabled !== false;
-        return self;
+        return self2;
       };
-      self.getStrictCommands = () => strictCommands;
+      self2.getStrictCommands = () => strictCommands;
       let parserConfig = {};
-      self.parserConfiguration = function parserConfiguration(config) {
+      self2.parserConfiguration = function parserConfiguration(config) {
         argsert_1.argsert("<object>", [config], arguments.length);
         parserConfig = config;
-        return self;
+        return self2;
       };
-      self.getParserConfiguration = () => parserConfig;
-      self.showHelp = function(level) {
+      self2.getParserConfiguration = () => parserConfig;
+      self2.showHelp = function(level) {
         argsert_1.argsert("[string|function]", [level], arguments.length);
-        if (!self.parsed)
-          self._parseArgs(processArgs);
+        if (!self2.parsed)
+          self2._parseArgs(processArgs);
         if (command.hasDefaultCommand()) {
           context.resets++;
-          command.runDefaultBuilderOn(self);
+          command.runDefaultBuilderOn(self2);
         }
         usage.showHelp(level);
-        return self;
+        return self2;
       };
       let versionOpt = null;
-      self.version = function version(opt, msg, ver) {
+      self2.version = function version(opt, msg, ver) {
         const defaultVersionOpt = "version";
         argsert_1.argsert("[boolean|string] [string] [string]", [opt, msg, ver], arguments.length);
         if (versionOpt) {
@@ -5506,7 +5506,7 @@ var require_yargs = __commonJS({
           opt = defaultVersionOpt;
         } else if (arguments.length === 1) {
           if (opt === false) {
-            return self;
+            return self2;
           }
           ver = opt;
           opt = defaultVersionOpt;
@@ -5517,16 +5517,16 @@ var require_yargs = __commonJS({
         versionOpt = typeof opt === "string" ? opt : defaultVersionOpt;
         msg = msg || usage.deferY18nLookup("Show version number");
         usage.version(ver || void 0);
-        self.boolean(versionOpt);
-        self.describe(versionOpt, msg);
-        return self;
+        self2.boolean(versionOpt);
+        self2.describe(versionOpt, msg);
+        return self2;
       };
       function guessVersion() {
         const obj = pkgUp();
         return obj.version || "unknown";
       }
       let helpOpt = null;
-      self.addHelpOpt = self.help = function addHelpOpt(opt, msg) {
+      self2.addHelpOpt = self2.help = function addHelpOpt(opt, msg) {
         const defaultHelpOpt = "help";
         argsert_1.argsert("[string|boolean] [string]", [opt, msg], arguments.length);
         if (helpOpt) {
@@ -5535,46 +5535,46 @@ var require_yargs = __commonJS({
         }
         if (arguments.length === 1) {
           if (opt === false)
-            return self;
+            return self2;
         }
         helpOpt = typeof opt === "string" ? opt : defaultHelpOpt;
-        self.boolean(helpOpt);
-        self.describe(helpOpt, msg || usage.deferY18nLookup("Show help"));
-        return self;
+        self2.boolean(helpOpt);
+        self2.describe(helpOpt, msg || usage.deferY18nLookup("Show help"));
+        return self2;
       };
       const defaultShowHiddenOpt = "show-hidden";
       options.showHiddenOpt = defaultShowHiddenOpt;
-      self.addShowHiddenOpt = self.showHidden = function addShowHiddenOpt(opt, msg) {
+      self2.addShowHiddenOpt = self2.showHidden = function addShowHiddenOpt(opt, msg) {
         argsert_1.argsert("[string|boolean] [string]", [opt, msg], arguments.length);
         if (arguments.length === 1) {
           if (opt === false)
-            return self;
+            return self2;
         }
         const showHiddenOpt = typeof opt === "string" ? opt : defaultShowHiddenOpt;
-        self.boolean(showHiddenOpt);
-        self.describe(showHiddenOpt, msg || usage.deferY18nLookup("Show hidden options"));
+        self2.boolean(showHiddenOpt);
+        self2.describe(showHiddenOpt, msg || usage.deferY18nLookup("Show hidden options"));
         options.showHiddenOpt = showHiddenOpt;
-        return self;
+        return self2;
       };
-      self.hide = function hide(key) {
+      self2.hide = function hide(key) {
         argsert_1.argsert("<string>", [key], arguments.length);
         options.hiddenOptions.push(key);
-        return self;
+        return self2;
       };
-      self.showHelpOnFail = function showHelpOnFail(enabled, message) {
+      self2.showHelpOnFail = function showHelpOnFail(enabled, message) {
         argsert_1.argsert("[boolean|string] [string]", [enabled, message], arguments.length);
         usage.showHelpOnFail(enabled, message);
-        return self;
+        return self2;
       };
       var exitProcess = true;
-      self.exitProcess = function(enabled = true) {
+      self2.exitProcess = function(enabled = true) {
         argsert_1.argsert("[boolean]", [enabled], arguments.length);
         exitProcess = enabled;
-        return self;
+        return self2;
       };
-      self.getExitProcess = () => exitProcess;
+      self2.getExitProcess = () => exitProcess;
       var completionCommand = null;
-      self.completion = function(cmd, desc, fn) {
+      self2.completion = function(cmd, desc, fn) {
         argsert_1.argsert("[string] [string|boolean|function] [function]", [cmd, desc, fn], arguments.length);
         if (typeof desc === "function") {
           fn = desc;
@@ -5584,22 +5584,22 @@ var require_yargs = __commonJS({
         if (!desc && desc !== false) {
           desc = "generate completion script";
         }
-        self.command(completionCommand, desc);
+        self2.command(completionCommand, desc);
         if (fn)
           completion.registerFunction(fn);
-        return self;
+        return self2;
       };
-      self.showCompletionScript = function($0, cmd) {
+      self2.showCompletionScript = function($0, cmd) {
         argsert_1.argsert("[string] [string]", [$0, cmd], arguments.length);
-        $0 = $0 || self.$0;
+        $0 = $0 || self2.$0;
         _logger.log(completion.generateCompletionScript($0, cmd || completionCommand || "completion"));
-        return self;
+        return self2;
       };
-      self.getCompletion = function(args2, done) {
+      self2.getCompletion = function(args2, done) {
         argsert_1.argsert("<array> <function>", [args2, done], arguments.length);
         completion.getCompletion(args2, done);
       };
-      self.locale = function(locale) {
+      self2.locale = function(locale) {
         argsert_1.argsert("[string]", [locale], arguments.length);
         if (!locale) {
           guessLocale();
@@ -5607,24 +5607,24 @@ var require_yargs = __commonJS({
         }
         detectLocale = false;
         y18n.setLocale(locale);
-        return self;
+        return self2;
       };
-      self.updateStrings = self.updateLocale = function(obj) {
+      self2.updateStrings = self2.updateLocale = function(obj) {
         argsert_1.argsert("<object>", [obj], arguments.length);
         detectLocale = false;
         y18n.updateLocale(obj);
-        return self;
+        return self2;
       };
       let detectLocale = true;
-      self.detectLocale = function(detect) {
+      self2.detectLocale = function(detect) {
         argsert_1.argsert("<boolean>", [detect], arguments.length);
         detectLocale = detect;
-        return self;
+        return self2;
       };
-      self.getDetectLocale = () => detectLocale;
+      self2.getDetectLocale = () => detectLocale;
       var hasOutput = false;
       var exitError = null;
-      self.exit = (code, err) => {
+      self2.exit = (code, err) => {
         hasOutput = true;
         exitError = err;
         if (exitProcess)
@@ -5632,7 +5632,7 @@ var require_yargs = __commonJS({
       };
       const _logger = {
         log(...args2) {
-          if (!self._hasParseCallback())
+          if (!self2._hasParseCallback())
             console.log(...args2);
           hasOutput = true;
           if (output.length)
@@ -5640,7 +5640,7 @@ var require_yargs = __commonJS({
           output += args2.join(" ");
         },
         error(...args2) {
-          if (!self._hasParseCallback())
+          if (!self2._hasParseCallback())
             console.error(...args2);
           hasOutput = true;
           if (output.length)
@@ -5648,33 +5648,33 @@ var require_yargs = __commonJS({
           output += args2.join(" ");
         }
       };
-      self._getLoggerInstance = () => _logger;
-      self._hasOutput = () => hasOutput;
-      self._setHasOutput = () => {
+      self2._getLoggerInstance = () => _logger;
+      self2._hasOutput = () => hasOutput;
+      self2._setHasOutput = () => {
         hasOutput = true;
       };
       let recommendCommands;
-      self.recommendCommands = function(recommend = true) {
+      self2.recommendCommands = function(recommend = true) {
         argsert_1.argsert("[boolean]", [recommend], arguments.length);
         recommendCommands = recommend;
-        return self;
+        return self2;
       };
-      self.getUsageInstance = () => usage;
-      self.getValidationInstance = () => validation;
-      self.getCommandInstance = () => command;
-      self.terminalWidth = () => {
+      self2.getUsageInstance = () => usage;
+      self2.getValidationInstance = () => validation;
+      self2.getCommandInstance = () => command;
+      self2.terminalWidth = () => {
         argsert_1.argsert([], 0);
         return typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null;
       };
-      Object.defineProperty(self, "argv", {
-        get: () => self._parseArgs(processArgs),
+      Object.defineProperty(self2, "argv", {
+        get: () => self2._parseArgs(processArgs),
         enumerable: true
       });
-      self._parseArgs = function parseArgs(args2, shortCircuit, _calledFromCommand, commandIndex) {
+      self2._parseArgs = function parseArgs(args2, shortCircuit, _calledFromCommand, commandIndex) {
         let skipValidation = !!_calledFromCommand;
         args2 = args2 || processArgs;
         options.__ = y18n.__;
-        options.configuration = self.getParserConfiguration();
+        options.configuration = self2.getParserConfiguration();
         const populateDoubleDash = !!options.configuration["populate--"];
         const config = Object.assign({}, options.configuration, {
           "populate--": true
@@ -5686,12 +5686,12 @@ var require_yargs = __commonJS({
         if (parseContext)
           argv = Object.assign({}, argv, parseContext);
         const aliases = parsed.aliases;
-        argv.$0 = self.$0;
-        self.parsed = parsed;
+        argv.$0 = self2.$0;
+        self2.parsed = parsed;
         try {
           guessLocale();
           if (shortCircuit) {
-            return populateDoubleDash || _calledFromCommand ? argv : self._copyDoubleDash(argv);
+            return populateDoubleDash || _calledFromCommand ? argv : self2._copyDoubleDash(argv);
           }
           if (helpOpt) {
             const helpCmds = [helpOpt].concat(aliases[helpOpt] || []).filter((k) => k.length > 1);
@@ -5710,16 +5710,16 @@ var require_yargs = __commonJS({
               for (let i = commandIndex || 0, cmd; argv._[i] !== void 0; i++) {
                 cmd = String(argv._[i]);
                 if (~handlerKeys.indexOf(cmd) && cmd !== completionCommand) {
-                  const innerArgv = command.runCommand(cmd, self, parsed, i + 1);
-                  return populateDoubleDash ? innerArgv : self._copyDoubleDash(innerArgv);
+                  const innerArgv = command.runCommand(cmd, self2, parsed, i + 1);
+                  return populateDoubleDash ? innerArgv : self2._copyDoubleDash(innerArgv);
                 } else if (!firstUnknownCommand && cmd !== completionCommand) {
                   firstUnknownCommand = cmd;
                   break;
                 }
               }
               if (command.hasDefaultCommand() && !skipDefaultCommand) {
-                const innerArgv = command.runCommand(null, self, parsed);
-                return populateDoubleDash ? innerArgv : self._copyDoubleDash(innerArgv);
+                const innerArgv = command.runCommand(null, self2, parsed);
+                return populateDoubleDash ? innerArgv : self2._copyDoubleDash(innerArgv);
               }
               if (recommendCommands && firstUnknownCommand && !skipRecommendation) {
                 validation.recommendCommands(firstUnknownCommand, handlerKeys);
@@ -5728,12 +5728,12 @@ var require_yargs = __commonJS({
             if (completionCommand && ~argv._.indexOf(completionCommand) && !requestCompletions) {
               if (exitProcess)
                 setBlocking(true);
-              self.showCompletionScript();
-              self.exit(0);
+              self2.showCompletionScript();
+              self2.exit(0);
             }
           } else if (command.hasDefaultCommand() && !skipDefaultCommand) {
-            const innerArgv = command.runCommand(null, self, parsed);
-            return populateDoubleDash ? innerArgv : self._copyDoubleDash(innerArgv);
+            const innerArgv = command.runCommand(null, self2, parsed);
+            return populateDoubleDash ? innerArgv : self2._copyDoubleDash(innerArgv);
           }
           if (requestCompletions) {
             if (exitProcess)
@@ -5745,9 +5745,9 @@ var require_yargs = __commonJS({
               (completions || []).forEach((completion2) => {
                 _logger.log(completion2);
               });
-              self.exit(0);
+              self2.exit(0);
             });
-            return populateDoubleDash || _calledFromCommand ? argv : self._copyDoubleDash(argv);
+            return populateDoubleDash || _calledFromCommand ? argv : self2._copyDoubleDash(argv);
           }
           if (!hasOutput) {
             Object.keys(argv).forEach((key) => {
@@ -5755,14 +5755,14 @@ var require_yargs = __commonJS({
                 if (exitProcess)
                   setBlocking(true);
                 skipValidation = true;
-                self.showHelp("log");
-                self.exit(0);
+                self2.showHelp("log");
+                self2.exit(0);
               } else if (key === versionOpt && argv[key]) {
                 if (exitProcess)
                   setBlocking(true);
                 skipValidation = true;
                 usage.showVersion();
-                self.exit(0);
+                self2.exit(0);
               }
             });
           }
@@ -5773,7 +5773,7 @@ var require_yargs = __commonJS({
             if (parsed.error)
               throw new yerror_1.YError(parsed.error.message);
             if (!requestCompletions) {
-              self._runValidation(argv, aliases, {}, parsed.error);
+              self2._runValidation(argv, aliases, {}, parsed.error);
             }
           }
         } catch (err) {
@@ -5782,9 +5782,9 @@ var require_yargs = __commonJS({
           else
             throw err;
         }
-        return populateDoubleDash || _calledFromCommand ? argv : self._copyDoubleDash(argv);
+        return populateDoubleDash || _calledFromCommand ? argv : self2._copyDoubleDash(argv);
       };
-      self._copyDoubleDash = function(argv) {
+      self2._copyDoubleDash = function(argv) {
         if (is_promise_1.isPromise(argv) || !argv._ || !argv["--"])
           return argv;
         argv._.push.apply(argv._, argv["--"]);
@@ -5794,7 +5794,7 @@ var require_yargs = __commonJS({
         }
         return argv;
       };
-      self._runValidation = function runValidation(argv, aliases, positionalMap, parseErrors, isDefaultCommand = false) {
+      self2._runValidation = function runValidation(argv, aliases, positionalMap, parseErrors, isDefaultCommand = false) {
         if (parseErrors)
           throw new yerror_1.YError(parseErrors.message);
         validation.nonOptionCount(argv);
@@ -5815,11 +5815,11 @@ var require_yargs = __commonJS({
         if (!detectLocale)
           return;
         const locale = process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || process.env.LANGUAGE || "en_US";
-        self.locale(locale.replace(/[.:].*/, ""));
+        self2.locale(locale.replace(/[.:].*/, ""));
       }
-      self.help();
-      self.version();
-      return self;
+      self2.help();
+      self2.version();
+      return self2;
     }
     exports2.Yargs = Yargs;
     function rebase(base, dir) {
@@ -6268,21 +6268,52 @@ var require_deep_extend = __commonJS({
 // ../../../node_modules/minimist/index.js
 var require_minimist = __commonJS({
   "../../../node_modules/minimist/index.js"(exports2, module2) {
+    "use strict";
+    function hasKey(obj, keys) {
+      var o = obj;
+      keys.slice(0, -1).forEach(function(key2) {
+        o = o[key2] || {};
+      });
+      var key = keys[keys.length - 1];
+      return key in o;
+    }
+    function isNumber(x) {
+      if (typeof x === "number") {
+        return true;
+      }
+      if (/^0x[0-9a-f]+$/i.test(x)) {
+        return true;
+      }
+      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+    }
+    function isConstructorOrProto(obj, key) {
+      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+    }
     module2.exports = function(args2, opts) {
-      if (!opts)
+      if (!opts) {
         opts = {};
-      var flags = { bools: {}, strings: {}, unknownFn: null };
-      if (typeof opts["unknown"] === "function") {
-        flags.unknownFn = opts["unknown"];
       }
-      if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
+      var flags = {
+        bools: {},
+        strings: {},
+        unknownFn: null
+      };
+      if (typeof opts.unknown === "function") {
+        flags.unknownFn = opts.unknown;
+      }
+      if (typeof opts.boolean === "boolean" && opts.boolean) {
         flags.allBools = true;
       } else {
-        [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
+        [].concat(opts.boolean).filter(Boolean).forEach(function(key2) {
           flags.bools[key2] = true;
         });
       }
       var aliases = {};
+      function aliasIsBoolean(key2) {
+        return aliases[key2].some(function(x) {
+          return flags.bools[x];
+        });
+      }
       Object.keys(opts.alias || {}).forEach(function(key2) {
         aliases[key2] = [].concat(opts.alias[key2]);
         aliases[key2].forEach(function(x) {
@@ -6294,89 +6325,96 @@ var require_minimist = __commonJS({
       [].concat(opts.string).filter(Boolean).forEach(function(key2) {
         flags.strings[key2] = true;
         if (aliases[key2]) {
-          flags.strings[aliases[key2]] = true;
+          [].concat(aliases[key2]).forEach(function(k) {
+            flags.strings[k] = true;
+          });
         }
       });
-      var defaults = opts["default"] || {};
+      var defaults = opts.default || {};
       var argv = { _: [] };
-      Object.keys(flags.bools).forEach(function(key2) {
-        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
-      });
-      var notFlags = [];
-      if (args2.indexOf("--") !== -1) {
-        notFlags = args2.slice(args2.indexOf("--") + 1);
-        args2 = args2.slice(0, args2.indexOf("--"));
-      }
       function argDefined(key2, arg2) {
         return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
       }
-      function setArg(key2, val, arg2) {
-        if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
-          if (flags.unknownFn(arg2) === false)
-            return;
-        }
-        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
-        setKey(argv, key2.split("."), value2);
-        (aliases[key2] || []).forEach(function(x) {
-          setKey(argv, x.split("."), value2);
-        });
-      }
       function setKey(obj, keys, value2) {
         var o = obj;
         for (var i2 = 0; i2 < keys.length - 1; i2++) {
           var key2 = keys[i2];
-          if (isConstructorOrProto(o, key2))
+          if (isConstructorOrProto(o, key2)) {
             return;
-          if (o[key2] === void 0)
+          }
+          if (o[key2] === void 0) {
             o[key2] = {};
-          if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype)
+          }
+          if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype) {
             o[key2] = {};
-          if (o[key2] === Array.prototype)
+          }
+          if (o[key2] === Array.prototype) {
             o[key2] = [];
+          }
           o = o[key2];
         }
-        var key2 = keys[keys.length - 1];
-        if (isConstructorOrProto(o, key2))
+        var lastKey = keys[keys.length - 1];
+        if (isConstructorOrProto(o, lastKey)) {
           return;
-        if (o === Object.prototype || o === Number.prototype || o === String.prototype)
+        }
+        if (o === Object.prototype || o === Number.prototype || o === String.prototype) {
           o = {};
-        if (o === Array.prototype)
+        }
+        if (o === Array.prototype) {
           o = [];
-        if (o[key2] === void 0 || flags.bools[key2] || typeof o[key2] === "boolean") {
-          o[key2] = value2;
-        } else if (Array.isArray(o[key2])) {
-          o[key2].push(value2);
+        }
+        if (o[lastKey] === void 0 || flags.bools[lastKey] || typeof o[lastKey] === "boolean") {
+          o[lastKey] = value2;
+        } else if (Array.isArray(o[lastKey])) {
+          o[lastKey].push(value2);
         } else {
-          o[key2] = [o[key2], value2];
+          o[lastKey] = [o[lastKey], value2];
         }
       }
-      function aliasIsBoolean(key2) {
-        return aliases[key2].some(function(x) {
-          return flags.bools[x];
+      function setArg(key2, val, arg2) {
+        if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+          if (flags.unknownFn(arg2) === false) {
+            return;
+          }
+        }
+        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+        setKey(argv, key2.split("."), value2);
+        (aliases[key2] || []).forEach(function(x) {
+          setKey(argv, x.split("."), value2);
         });
       }
+      Object.keys(flags.bools).forEach(function(key2) {
+        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
+      });
+      var notFlags = [];
+      if (args2.indexOf("--") !== -1) {
+        notFlags = args2.slice(args2.indexOf("--") + 1);
+        args2 = args2.slice(0, args2.indexOf("--"));
+      }
       for (var i = 0; i < args2.length; i++) {
         var arg = args2[i];
+        var key;
+        var next;
         if (/^--.+=/.test(arg)) {
           var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
-          var key = m[1];
+          key = m[1];
           var value = m[2];
           if (flags.bools[key]) {
             value = value !== "false";
           }
           setArg(key, value, arg);
         } else if (/^--no-.+/.test(arg)) {
-          var key = arg.match(/^--no-(.+)/)[1];
+          key = arg.match(/^--no-(.+)/)[1];
           setArg(key, false, arg);
         } else if (/^--.+/.test(arg)) {
-          var key = arg.match(/^--(.+)/)[1];
-          var next = args2[i + 1];
-          if (next !== void 0 && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+          key = arg.match(/^--(.+)/)[1];
+          next = args2[i + 1];
+          if (next !== void 0 && !/^(-|--)[^-]/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
             setArg(key, next, arg);
-            i++;
+            i += 1;
           } else if (/^(true|false)$/.test(next)) {
             setArg(key, next === "true", arg);
-            i++;
+            i += 1;
           } else {
             setArg(key, flags.strings[key] ? "" : true, arg);
           }
@@ -6384,13 +6422,13 @@ var require_minimist = __commonJS({
           var letters = arg.slice(1, -1).split("");
           var broken = false;
           for (var j = 0; j < letters.length; j++) {
-            var next = arg.slice(j + 2);
+            next = arg.slice(j + 2);
             if (next === "-") {
               setArg(letters[j], next, arg);
               continue;
             }
-            if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
-              setArg(letters[j], next.split("=")[1], arg);
+            if (/[A-Za-z]/.test(letters[j]) && next[0] === "=") {
+              setArg(letters[j], next.slice(1), arg);
               broken = true;
               break;
             }
@@ -6407,21 +6445,21 @@ var require_minimist = __commonJS({
               setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
             }
           }
-          var key = arg.slice(-1)[0];
+          key = arg.slice(-1)[0];
           if (!broken && key !== "-") {
             if (args2[i + 1] && !/^(-|--)[^-]/.test(args2[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
               setArg(key, args2[i + 1], arg);
-              i++;
+              i += 1;
             } else if (args2[i + 1] && /^(true|false)$/.test(args2[i + 1])) {
               setArg(key, args2[i + 1] === "true", arg);
-              i++;
+              i += 1;
             } else {
               setArg(key, flags.strings[key] ? "" : true, arg);
             }
           }
         } else {
           if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-            argv._.push(flags.strings["_"] || !isNumber(arg) ? arg : Number(arg));
+            argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
           }
           if (opts.stopEarly) {
             argv._.push.apply(argv._, args2.slice(i + 1));
@@ -6429,44 +6467,23 @@ var require_minimist = __commonJS({
           }
         }
       }
-      Object.keys(defaults).forEach(function(key2) {
-        if (!hasKey(argv, key2.split("."))) {
-          setKey(argv, key2.split("."), defaults[key2]);
-          (aliases[key2] || []).forEach(function(x) {
-            setKey(argv, x.split("."), defaults[key2]);
+      Object.keys(defaults).forEach(function(k) {
+        if (!hasKey(argv, k.split("."))) {
+          setKey(argv, k.split("."), defaults[k]);
+          (aliases[k] || []).forEach(function(x) {
+            setKey(argv, x.split("."), defaults[k]);
           });
         }
       });
       if (opts["--"]) {
-        argv["--"] = new Array();
-        notFlags.forEach(function(key2) {
-          argv["--"].push(key2);
-        });
+        argv["--"] = notFlags.slice();
       } else {
-        notFlags.forEach(function(key2) {
-          argv._.push(key2);
+        notFlags.forEach(function(k) {
+          argv._.push(k);
         });
       }
       return argv;
     };
-    function hasKey(obj, keys) {
-      var o = obj;
-      keys.slice(0, -1).forEach(function(key2) {
-        o = o[key2] || {};
-      });
-      var key = keys[keys.length - 1];
-      return key in o;
-    }
-    function isNumber(x) {
-      if (typeof x === "number")
-        return true;
-      if (/^0x[0-9a-f]+$/i.test(x))
-        return true;
-      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
-    }
-    function isConstructorOrProto(obj, key) {
-      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
-    }
   }
 });
 
@@ -6537,9 +6554,9 @@ var require_has_flag = __commonJS({
   }
 });
 
-// ../../../node_modules/chalk/node_modules/supports-color/index.js
+// ../../../node_modules/supports-color/index.js
 var require_supports_color = __commonJS({
-  "../../../node_modules/chalk/node_modules/supports-color/index.js"(exports2, module2) {
+  "../../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
     var os2 = require("os");
     var tty = require("tty");
@@ -6908,7 +6925,7 @@ var require_source = __commonJS({
         parent
       };
     };
-    var createBuilder = (self, _styler, _isEmpty) => {
+    var createBuilder = (self2, _styler, _isEmpty) => {
       const builder = (...arguments_) => {
         if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
           return applyStyle(builder, chalkTag(builder, ...arguments_));
@@ -6916,16 +6933,16 @@ var require_source = __commonJS({
         return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
       };
       Object.setPrototypeOf(builder, proto);
-      builder._generator = self;
+      builder._generator = self2;
       builder._styler = _styler;
       builder._isEmpty = _isEmpty;
       return builder;
     };
-    var applyStyle = (self, string2) => {
-      if (self.level <= 0 || !string2) {
-        return self._isEmpty ? "" : string2;
+    var applyStyle = (self2, string2) => {
+      if (self2.level <= 0 || !string2) {
+        return self2._isEmpty ? "" : string2;
       }
-      let styler = self._styler;
+      let styler = self2._styler;
       if (styler === void 0) {
         return string2;
       }
@@ -7042,11 +7059,11 @@ var require_signals = __commonJS({
 // ../../../node_modules/signal-exit/index.js
 var require_signal_exit = __commonJS({
   "../../../node_modules/signal-exit/index.js"(exports2, module2) {
-    var process8 = global.process;
-    var processOk = function(process9) {
-      return process9 && typeof process9 === "object" && typeof process9.removeListener === "function" && typeof process9.emit === "function" && typeof process9.reallyExit === "function" && typeof process9.listeners === "function" && typeof process9.kill === "function" && typeof process9.pid === "number" && typeof process9.on === "function";
+    var process7 = global.process;
+    var processOk = function(process8) {
+      return process8 && typeof process8 === "object" && typeof process8.removeListener === "function" && typeof process8.emit === "function" && typeof process8.reallyExit === "function" && typeof process8.listeners === "function" && typeof process8.kill === "function" && typeof process8.pid === "number" && typeof process8.on === "function";
     };
-    if (!processOk(process8)) {
+    if (!processOk(process7)) {
       module2.exports = function() {
         return function() {
         };
@@ -7054,15 +7071,15 @@ var require_signal_exit = __commonJS({
     } else {
       assert = require("assert");
       signals = require_signals();
-      isWin = /^win/i.test(process8.platform);
+      isWin = /^win/i.test(process7.platform);
       EE = require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
       }
-      if (process8.__signal_exit_emitter__) {
-        emitter = process8.__signal_exit_emitter__;
+      if (process7.__signal_exit_emitter__) {
+        emitter = process7.__signal_exit_emitter__;
       } else {
-        emitter = process8.__signal_exit_emitter__ = new EE();
+        emitter = process7.__signal_exit_emitter__ = new EE();
         emitter.count = 0;
         emitter.emitted = {};
       }
@@ -7099,12 +7116,12 @@ var require_signal_exit = __commonJS({
         loaded = false;
         signals.forEach(function(sig) {
           try {
-            process8.removeListener(sig, sigListeners[sig]);
+            process7.removeListener(sig, sigListeners[sig]);
           } catch (er) {
           }
         });
-        process8.emit = originalProcessEmit;
-        process8.reallyExit = originalProcessReallyExit;
+        process7.emit = originalProcessEmit;
+        process7.reallyExit = originalProcessReallyExit;
         emitter.count -= 1;
       };
       module2.exports.unload = unload;
@@ -7121,7 +7138,7 @@ var require_signal_exit = __commonJS({
           if (!processOk(global.process)) {
             return;
           }
-          var listeners = process8.listeners(sig);
+          var listeners = process7.listeners(sig);
           if (listeners.length === emitter.count) {
             unload();
             emit("exit", null, sig);
@@ -7129,7 +7146,7 @@ var require_signal_exit = __commonJS({
             if (isWin && sig === "SIGHUP") {
               sig = "SIGINT";
             }
-            process8.kill(process8.pid, sig);
+            process7.kill(process7.pid, sig);
           }
         };
       });
@@ -7145,35 +7162,35 @@ var require_signal_exit = __commonJS({
         emitter.count += 1;
         signals = signals.filter(function(sig) {
           try {
-            process8.on(sig, sigListeners[sig]);
+            process7.on(sig, sigListeners[sig]);
             return true;
           } catch (er) {
             return false;
           }
         });
-        process8.emit = processEmit;
-        process8.reallyExit = processReallyExit;
+        process7.emit = processEmit;
+        process7.reallyExit = processReallyExit;
       };
       module2.exports.load = load;
-      originalProcessReallyExit = process8.reallyExit;
+      originalProcessReallyExit = process7.reallyExit;
       processReallyExit = function processReallyExit2(code) {
         if (!processOk(global.process)) {
           return;
         }
-        process8.exitCode = code || 0;
-        emit("exit", process8.exitCode, null);
-        emit("afterexit", process8.exitCode, null);
-        originalProcessReallyExit.call(process8, process8.exitCode);
+        process7.exitCode = code || 0;
+        emit("exit", process7.exitCode, null);
+        emit("afterexit", process7.exitCode, null);
+        originalProcessReallyExit.call(process7, process7.exitCode);
       };
-      originalProcessEmit = process8.emit;
+      originalProcessEmit = process7.emit;
       processEmit = function processEmit2(ev, arg) {
         if (ev === "exit" && processOk(global.process)) {
           if (arg !== void 0) {
-            process8.exitCode = arg;
+            process7.exitCode = arg;
           }
           var ret = originalProcessEmit.apply(this, arguments);
-          emit("exit", process8.exitCode, null);
-          emit("afterexit", process8.exitCode, null);
+          emit("exit", process7.exitCode, null);
+          emit("afterexit", process7.exitCode, null);
           return ret;
         } else {
           return originalProcessEmit.apply(this, arguments);
@@ -7987,6 +8004,21 @@ var require_spinners = __commonJS({
           "\u25E5"
         ]
       },
+      binary: {
+        interval: 80,
+        frames: [
+          "010010",
+          "001100",
+          "100101",
+          "111010",
+          "111101",
+          "010111",
+          "101011",
+          "111000",
+          "110011",
+          "110101"
+        ]
+      },
       arc: {
         interval: 100,
         frames: [
@@ -8179,6 +8211,7 @@ var require_spinners = __commonJS({
           "[=   ]",
           "[==  ]",
           "[=== ]",
+          "[====]",
           "[ ===]",
           "[  ==]",
           "[   =]",
@@ -8666,6 +8699,144 @@ var require_spinners = __commonJS({
           "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0",
           "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1"
         ]
+      },
+      dwarfFortress: {
+        interval: 80,
+        frames: [
+          " \u2588\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2588\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2588\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2593\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2593\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2592\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2592\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2591\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A\u2591\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "\u263A \u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2593\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2593\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2592\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2592\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2591\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A\u2591\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u263A \u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2593\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2593\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2592\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2592\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2591\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A\u2591\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u263A \u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2593\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2593\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2592\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2592\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2591\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A\u2591\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u263A \u2588\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2588\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2588\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2593\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2593\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2592\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2592\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2591\u2588\xA3\xA3\xA3  ",
+          "    \u263A\u2591\u2588\xA3\xA3\xA3  ",
+          "    \u263A \u2588\xA3\xA3\xA3  ",
+          "     \u263A\u2588\xA3\xA3\xA3  ",
+          "     \u263A\u2588\xA3\xA3\xA3  ",
+          "     \u263A\u2593\xA3\xA3\xA3  ",
+          "     \u263A\u2593\xA3\xA3\xA3  ",
+          "     \u263A\u2592\xA3\xA3\xA3  ",
+          "     \u263A\u2592\xA3\xA3\xA3  ",
+          "     \u263A\u2591\xA3\xA3\xA3  ",
+          "     \u263A\u2591\xA3\xA3\xA3  ",
+          "     \u263A \xA3\xA3\xA3  ",
+          "      \u263A\xA3\xA3\xA3  ",
+          "      \u263A\xA3\xA3\xA3  ",
+          "      \u263A\u2593\xA3\xA3  ",
+          "      \u263A\u2593\xA3\xA3  ",
+          "      \u263A\u2592\xA3\xA3  ",
+          "      \u263A\u2592\xA3\xA3  ",
+          "      \u263A\u2591\xA3\xA3  ",
+          "      \u263A\u2591\xA3\xA3  ",
+          "      \u263A \xA3\xA3  ",
+          "       \u263A\xA3\xA3  ",
+          "       \u263A\xA3\xA3  ",
+          "       \u263A\u2593\xA3  ",
+          "       \u263A\u2593\xA3  ",
+          "       \u263A\u2592\xA3  ",
+          "       \u263A\u2592\xA3  ",
+          "       \u263A\u2591\xA3  ",
+          "       \u263A\u2591\xA3  ",
+          "       \u263A \xA3  ",
+          "        \u263A\xA3  ",
+          "        \u263A\xA3  ",
+          "        \u263A\u2593  ",
+          "        \u263A\u2593  ",
+          "        \u263A\u2592  ",
+          "        \u263A\u2592  ",
+          "        \u263A\u2591  ",
+          "        \u263A\u2591  ",
+          "        \u263A   ",
+          "        \u263A  &",
+          "        \u263A \u263C&",
+          "       \u263A \u263C &",
+          "       \u263A\u263C  &",
+          "      \u263A\u263C  & ",
+          "      \u203C   & ",
+          "     \u263A   &  ",
+          "    \u203C    &  ",
+          "   \u263A    &   ",
+          "  \u203C     &   ",
+          " \u263A     &    ",
+          "\u203C      &    ",
+          "      &     ",
+          "      &     ",
+          "     &   \u2591  ",
+          "     &   \u2592  ",
+          "    &    \u2593  ",
+          "    &    \xA3  ",
+          "   &    \u2591\xA3  ",
+          "   &    \u2592\xA3  ",
+          "  &     \u2593\xA3  ",
+          "  &     \xA3\xA3  ",
+          " &     \u2591\xA3\xA3  ",
+          " &     \u2592\xA3\xA3  ",
+          "&      \u2593\xA3\xA3  ",
+          "&      \xA3\xA3\xA3  ",
+          "      \u2591\xA3\xA3\xA3  ",
+          "      \u2592\xA3\xA3\xA3  ",
+          "      \u2593\xA3\xA3\xA3  ",
+          "      \u2588\xA3\xA3\xA3  ",
+          "     \u2591\u2588\xA3\xA3\xA3  ",
+          "     \u2592\u2588\xA3\xA3\xA3  ",
+          "     \u2593\u2588\xA3\xA3\xA3  ",
+          "     \u2588\u2588\xA3\xA3\xA3  ",
+          "    \u2591\u2588\u2588\xA3\xA3\xA3  ",
+          "    \u2592\u2588\u2588\xA3\xA3\xA3  ",
+          "    \u2593\u2588\u2588\xA3\xA3\xA3  ",
+          "    \u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u2591\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u2592\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u2593\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "   \u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u2591\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u2592\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u2593\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          "  \u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u2591\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u2592\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u2593\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u2588\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  ",
+          " \u2588\u2588\u2588\u2588\u2588\u2588\xA3\xA3\xA3  "
+        ]
       }
     };
   }
@@ -9054,32 +9225,25 @@ var require_buffer_list = __commonJS({
       var keys = Object.keys(object);
       if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly)
-          symbols = symbols.filter(function(sym) {
-            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-          });
-        keys.push.apply(keys, symbols);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
       }
       return keys;
     }
     function _objectSpread(target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i] != null ? arguments[i] : {};
-        if (i % 2) {
-          ownKeys(Object(source), true).forEach(function(key) {
-            _defineProperty(target, key, source[key]);
-          });
-        } else if (Object.getOwnPropertyDescriptors) {
-          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-        } else {
-          ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-          });
-        }
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
       }
       return target;
     }
     function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
       if (key in obj) {
         Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
       } else {
@@ -9099,7 +9263,7 @@ var require_buffer_list = __commonJS({
         descriptor.configurable = true;
         if ("value" in descriptor)
           descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
+        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
       }
     }
     function _createClass(Constructor, protoProps, staticProps) {
@@ -9107,8 +9271,25 @@ var require_buffer_list = __commonJS({
         _defineProperties(Constructor.prototype, protoProps);
       if (staticProps)
         _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
       return Constructor;
     }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
     var _require = require("buffer");
     var Buffer2 = _require.Buffer;
     var _require2 = require("util");
@@ -9176,9 +9357,8 @@ var require_buffer_list = __commonJS({
             return "";
           var p = this.head;
           var ret = "" + p.data;
-          while (p = p.next) {
+          while (p = p.next)
             ret += s + p.data;
-          }
           return ret;
         }
       }, {
@@ -9282,7 +9462,7 @@ var require_buffer_list = __commonJS({
       }, {
         key: custom,
         value: function value(_, options) {
-          return inspect(this, _objectSpread({}, options, {
+          return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
             depth: 0,
             customInspect: false
           }));
@@ -9339,16 +9519,16 @@ var require_destroy = __commonJS({
       });
       return this;
     }
-    function emitErrorAndCloseNT(self, err) {
-      emitErrorNT(self, err);
-      emitCloseNT(self);
+    function emitErrorAndCloseNT(self2, err) {
+      emitErrorNT(self2, err);
+      emitCloseNT(self2);
     }
-    function emitCloseNT(self) {
-      if (self._writableState && !self._writableState.emitClose)
+    function emitCloseNT(self2) {
+      if (self2._writableState && !self2._writableState.emitClose)
         return;
-      if (self._readableState && !self._readableState.emitClose)
+      if (self2._readableState && !self2._readableState.emitClose)
         return;
-      self.emit("close");
+      self2.emit("close");
     }
     function undestroy() {
       if (this._readableState) {
@@ -9367,8 +9547,8 @@ var require_destroy = __commonJS({
         this._writableState.errorEmitted = false;
       }
     }
-    function emitErrorNT(self, err) {
-      self.emit("error", err);
+    function emitErrorNT(self2, err) {
+      self2.emit("error", err);
     }
     function errorOrDestroy(stream, err) {
       var rState = stream._readableState;
@@ -9585,7 +9765,7 @@ var require_stream_writable = __commonJS({
     };
     var Stream = require_stream();
     var Buffer2 = require("buffer").Buffer;
-    var OurUint8Array = global.Uint8Array || function() {
+    var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
     };
     function _uint8ArrayToBuffer(chunk) {
       return Buffer2.from(chunk);
@@ -10059,9 +10239,8 @@ var require_stream_duplex = __commonJS({
     "use strict";
     var objectKeys = Object.keys || function(obj) {
       var keys2 = [];
-      for (var key in obj) {
+      for (var key in obj)
         keys2.push(key);
-      }
       return keys2;
     };
     module2.exports = Duplex;
@@ -10119,8 +10298,8 @@ var require_stream_duplex = __commonJS({
         return;
       process.nextTick(onEndNT, this);
     }
-    function onEndNT(self) {
-      self.end();
+    function onEndNT(self2) {
+      self2.end();
     }
     Object.defineProperty(Duplex.prototype, "destroyed", {
       enumerable: false,
@@ -10325,14 +10504,14 @@ var require_string_decoder = __commonJS({
         return 4;
       return byte >> 6 === 2 ? -1 : -2;
     }
-    function utf8CheckIncomplete(self, buf, i) {
+    function utf8CheckIncomplete(self2, buf, i) {
       var j = buf.length - 1;
       if (j < i)
         return 0;
       var nb = utf8CheckByte(buf[j]);
       if (nb >= 0) {
         if (nb > 0)
-          self.lastNeed = nb - 1;
+          self2.lastNeed = nb - 1;
         return nb;
       }
       if (--j < i || nb === -2)
@@ -10340,7 +10519,7 @@ var require_string_decoder = __commonJS({
       nb = utf8CheckByte(buf[j]);
       if (nb >= 0) {
         if (nb > 0)
-          self.lastNeed = nb - 2;
+          self2.lastNeed = nb - 2;
         return nb;
       }
       if (--j < i || nb === -2)
@@ -10351,25 +10530,25 @@ var require_string_decoder = __commonJS({
           if (nb === 2)
             nb = 0;
           else
-            self.lastNeed = nb - 3;
+            self2.lastNeed = nb - 3;
         }
         return nb;
       }
       return 0;
     }
-    function utf8CheckExtraBytes(self, buf, p) {
+    function utf8CheckExtraBytes(self2, buf, p) {
       if ((buf[0] & 192) !== 128) {
-        self.lastNeed = 0;
+        self2.lastNeed = 0;
         return "\uFFFD";
       }
-      if (self.lastNeed > 1 && buf.length > 1) {
+      if (self2.lastNeed > 1 && buf.length > 1) {
         if ((buf[1] & 192) !== 128) {
-          self.lastNeed = 1;
+          self2.lastNeed = 1;
           return "\uFFFD";
         }
-        if (self.lastNeed > 2 && buf.length > 2) {
+        if (self2.lastNeed > 2 && buf.length > 2) {
           if ((buf[2] & 192) !== 128) {
-            self.lastNeed = 2;
+            self2.lastNeed = 2;
             return "\uFFFD";
           }
         }
@@ -10566,6 +10745,7 @@ var require_async_iterator = __commonJS({
     "use strict";
     var _Object$setPrototypeO;
     function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
       if (key in obj) {
         Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
       } else {
@@ -10573,6 +10753,22 @@ var require_async_iterator = __commonJS({
       }
       return obj;
     }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
     var finished = require_end_of_stream();
     var kLastResolve = Symbol("lastResolve");
     var kLastReject = Symbol("lastReject");
@@ -10748,9 +10944,9 @@ var require_from = __commonJS({
     }
     function _asyncToGenerator(fn) {
       return function() {
-        var self = this, args2 = arguments;
+        var self2 = this, args2 = arguments;
         return new Promise(function(resolve3, reject) {
-          var gen = fn.apply(self, args2);
+          var gen = fn.apply(self2, args2);
           function _next(value) {
             asyncGeneratorStep(gen, resolve3, reject, _next, _throw, "next", value);
           }
@@ -10765,32 +10961,25 @@ var require_from = __commonJS({
       var keys = Object.keys(object);
       if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly)
-          symbols = symbols.filter(function(sym) {
-            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-          });
-        keys.push.apply(keys, symbols);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
       }
       return keys;
     }
     function _objectSpread(target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i] != null ? arguments[i] : {};
-        if (i % 2) {
-          ownKeys(Object(source), true).forEach(function(key) {
-            _defineProperty(target, key, source[key]);
-          });
-        } else if (Object.getOwnPropertyDescriptors) {
-          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-        } else {
-          ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-          });
-        }
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
       }
       return target;
     }
     function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
       if (key in obj) {
         Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
       } else {
@@ -10798,6 +10987,22 @@ var require_from = __commonJS({
       }
       return obj;
     }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
     var ERR_INVALID_ARG_TYPE = require_errors().codes.ERR_INVALID_ARG_TYPE;
     function from(Readable, iterable, opts) {
       var iterator;
@@ -10825,7 +11030,7 @@ var require_from = __commonJS({
       function _next2() {
         _next2 = _asyncToGenerator(function* () {
           try {
-            var _ref = yield iterator.next(), value = _ref.value, done = _ref.done;
+            var _yield$iterator$next = yield iterator.next(), value = _yield$iterator$next.value, done = _yield$iterator$next.done;
             if (done) {
               readable.push(null);
             } else if (readable.push(yield value)) {
@@ -10858,7 +11063,7 @@ var require_stream_readable = __commonJS({
     };
     var Stream = require_stream();
     var Buffer2 = require("buffer").Buffer;
-    var OurUint8Array = global.Uint8Array || function() {
+    var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
     };
     function _uint8ArrayToBuffer(chunk) {
       return Buffer2.from(chunk);
@@ -11372,11 +11577,10 @@ var require_stream_readable = __commonJS({
         state.pipes = null;
         state.pipesCount = 0;
         state.flowing = false;
-        for (var i = 0; i < len; i++) {
+        for (var i = 0; i < len; i++)
           dests[i].emit("unpipe", this, {
             hasUnpiped: false
           });
-        }
         return this;
       }
       var index = indexOf(state.pipes, dest);
@@ -11426,18 +11630,18 @@ var require_stream_readable = __commonJS({
       }
       return res;
     };
-    function updateReadableListening(self) {
-      var state = self._readableState;
-      state.readableListening = self.listenerCount("readable") > 0;
+    function updateReadableListening(self2) {
+      var state = self2._readableState;
+      state.readableListening = self2.listenerCount("readable") > 0;
       if (state.resumeScheduled && !state.paused) {
         state.flowing = true;
-      } else if (self.listenerCount("data") > 0) {
-        self.resume();
+      } else if (self2.listenerCount("data") > 0) {
+        self2.resume();
       }
     }
-    function nReadingNextTick(self) {
+    function nReadingNextTick(self2) {
       debug("readable nexttick read 0");
-      self.read(0);
+      self2.read(0);
     }
     Readable.prototype.resume = function() {
       var state = this._readableState;
@@ -11479,9 +11683,8 @@ var require_stream_readable = __commonJS({
     function flow(stream) {
       var state = stream._readableState;
       debug("flow", state.flowing);
-      while (state.flowing && stream.read() !== null) {
+      while (state.flowing && stream.read() !== null)
         ;
-      }
     }
     Readable.prototype.wrap = function(stream) {
       var _this = this;
@@ -11875,9 +12078,9 @@ var require_readable = __commonJS({
   }
 });
 
-// ../../../node_modules/ora/node_modules/bl/BufferList.js
+// ../../../node_modules/stdin-discarder/node_modules/bl/BufferList.js
 var require_BufferList = __commonJS({
-  "../../../node_modules/ora/node_modules/bl/BufferList.js"(exports2, module2) {
+  "../../../node_modules/stdin-discarder/node_modules/bl/BufferList.js"(exports2, module2) {
     "use strict";
     var { Buffer: Buffer2 } = require("buffer");
     var symbol = Symbol.for("BufferList");
@@ -12179,9 +12382,9 @@ var require_BufferList = __commonJS({
   }
 });
 
-// ../../../node_modules/ora/node_modules/bl/bl.js
+// ../../../node_modules/stdin-discarder/node_modules/bl/bl.js
 var require_bl = __commonJS({
-  "../../../node_modules/ora/node_modules/bl/bl.js"(exports2, module2) {
+  "../../../node_modules/stdin-discarder/node_modules/bl/bl.js"(exports2, module2) {
     "use strict";
     var DuplexStream = require_readable().Duplex;
     var inherits = require_inherits();
@@ -12601,9 +12804,9 @@ var require_balanced_match = __commonJS({
   }
 });
 
-// ../../../node_modules/brace-expansion/index.js
+// ../../../node_modules/minimatch/node_modules/brace-expansion/index.js
 var require_brace_expansion = __commonJS({
-  "../../../node_modules/brace-expansion/index.js"(exports2, module2) {
+  "../../../node_modules/minimatch/node_modules/brace-expansion/index.js"(exports2, module2) {
     var concatMap = require_concat_map();
     var balanced = require_balanced_match();
     module2.exports = expandTop;
@@ -12965,7 +13168,7 @@ var require_minimatch = __commonJS({
       var reClassStart = -1;
       var classStart = -1;
       var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
-      var self = this;
+      var self2 = this;
       function clearStateChar() {
         if (stateChar) {
           switch (stateChar) {
@@ -12981,7 +13184,7 @@ var require_minimatch = __commonJS({
               re += "\\" + stateChar;
               break;
           }
-          self.debug("clearStateChar %j %j", stateChar, re);
+          self2.debug("clearStateChar %j %j", stateChar, re);
           stateChar = false;
         }
       }
@@ -13013,7 +13216,7 @@ var require_minimatch = __commonJS({
               re += c;
               continue;
             }
-            self.debug("call clearStateChar %j", stateChar);
+            self2.debug("call clearStateChar %j", stateChar);
             clearStateChar();
             stateChar = c;
             if (options.noext)
@@ -13374,12 +13577,12 @@ var require_common = __commonJS({
     function alphasort(a, b) {
       return a.localeCompare(b, "en");
     }
-    function setupIgnores(self, options) {
-      self.ignore = options.ignore || [];
-      if (!Array.isArray(self.ignore))
-        self.ignore = [self.ignore];
-      if (self.ignore.length) {
-        self.ignore = self.ignore.map(ignoreMap);
+    function setupIgnores(self2, options) {
+      self2.ignore = options.ignore || [];
+      if (!Array.isArray(self2.ignore))
+        self2.ignore = [self2.ignore];
+      if (self2.ignore.length) {
+        self2.ignore = self2.ignore.map(ignoreMap);
       }
     }
     function ignoreMap(pattern) {
@@ -13393,7 +13596,7 @@ var require_common = __commonJS({
         gmatcher
       };
     }
-    function setopts(self, pattern, options) {
+    function setopts(self2, pattern, options) {
       if (!options)
         options = {};
       if (options.matchBase && pattern.indexOf("/") === -1) {
@@ -13402,61 +13605,61 @@ var require_common = __commonJS({
         }
         pattern = "**/" + pattern;
       }
-      self.silent = !!options.silent;
-      self.pattern = pattern;
-      self.strict = options.strict !== false;
-      self.realpath = !!options.realpath;
-      self.realpathCache = options.realpathCache || Object.create(null);
-      self.follow = !!options.follow;
-      self.dot = !!options.dot;
-      self.mark = !!options.mark;
-      self.nodir = !!options.nodir;
-      if (self.nodir)
-        self.mark = true;
-      self.sync = !!options.sync;
-      self.nounique = !!options.nounique;
-      self.nonull = !!options.nonull;
-      self.nosort = !!options.nosort;
-      self.nocase = !!options.nocase;
-      self.stat = !!options.stat;
-      self.noprocess = !!options.noprocess;
-      self.absolute = !!options.absolute;
-      self.fs = options.fs || fs;
-      self.maxLength = options.maxLength || Infinity;
-      self.cache = options.cache || Object.create(null);
-      self.statCache = options.statCache || Object.create(null);
-      self.symlinks = options.symlinks || Object.create(null);
-      setupIgnores(self, options);
-      self.changedCwd = false;
+      self2.silent = !!options.silent;
+      self2.pattern = pattern;
+      self2.strict = options.strict !== false;
+      self2.realpath = !!options.realpath;
+      self2.realpathCache = options.realpathCache || Object.create(null);
+      self2.follow = !!options.follow;
+      self2.dot = !!options.dot;
+      self2.mark = !!options.mark;
+      self2.nodir = !!options.nodir;
+      if (self2.nodir)
+        self2.mark = true;
+      self2.sync = !!options.sync;
+      self2.nounique = !!options.nounique;
+      self2.nonull = !!options.nonull;
+      self2.nosort = !!options.nosort;
+      self2.nocase = !!options.nocase;
+      self2.stat = !!options.stat;
+      self2.noprocess = !!options.noprocess;
+      self2.absolute = !!options.absolute;
+      self2.fs = options.fs || fs;
+      self2.maxLength = options.maxLength || Infinity;
+      self2.cache = options.cache || Object.create(null);
+      self2.statCache = options.statCache || Object.create(null);
+      self2.symlinks = options.symlinks || Object.create(null);
+      setupIgnores(self2, options);
+      self2.changedCwd = false;
       var cwd = process.cwd();
       if (!ownProp(options, "cwd"))
-        self.cwd = cwd;
+        self2.cwd = cwd;
       else {
-        self.cwd = path.resolve(options.cwd);
-        self.changedCwd = self.cwd !== cwd;
+        self2.cwd = path.resolve(options.cwd);
+        self2.changedCwd = self2.cwd !== cwd;
       }
-      self.root = options.root || path.resolve(self.cwd, "/");
-      self.root = path.resolve(self.root);
+      self2.root = options.root || path.resolve(self2.cwd, "/");
+      self2.root = path.resolve(self2.root);
       if (process.platform === "win32")
-        self.root = self.root.replace(/\\/g, "/");
-      self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+        self2.root = self2.root.replace(/\\/g, "/");
+      self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
       if (process.platform === "win32")
-        self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
-      self.nomount = !!options.nomount;
+        self2.cwdAbs = self2.cwdAbs.replace(/\\/g, "/");
+      self2.nomount = !!options.nomount;
       options.nonegate = true;
       options.nocomment = true;
       options.allowWindowsEscape = false;
-      self.minimatch = new Minimatch(pattern, options);
-      self.options = self.minimatch.options;
+      self2.minimatch = new Minimatch(pattern, options);
+      self2.options = self2.minimatch.options;
     }
-    function finish(self) {
-      var nou = self.nounique;
+    function finish(self2) {
+      var nou = self2.nounique;
       var all = nou ? [] : Object.create(null);
-      for (var i = 0, l = self.matches.length; i < l; i++) {
-        var matches = self.matches[i];
+      for (var i = 0, l = self2.matches.length; i < l; i++) {
+        var matches = self2.matches[i];
         if (!matches || Object.keys(matches).length === 0) {
-          if (self.nonull) {
-            var literal = self.minimatch.globSet[i];
+          if (self2.nonull) {
+            var literal = self2.minimatch.globSet[i];
             if (nou)
               all.push(literal);
             else
@@ -13474,31 +13677,31 @@ var require_common = __commonJS({
       }
       if (!nou)
         all = Object.keys(all);
-      if (!self.nosort)
+      if (!self2.nosort)
         all = all.sort(alphasort);
-      if (self.mark) {
+      if (self2.mark) {
         for (var i = 0; i < all.length; i++) {
-          all[i] = self._mark(all[i]);
+          all[i] = self2._mark(all[i]);
         }
-        if (self.nodir) {
+        if (self2.nodir) {
           all = all.filter(function(e) {
             var notDir = !/\/$/.test(e);
-            var c = self.cache[e] || self.cache[makeAbs(self, e)];
+            var c = self2.cache[e] || self2.cache[makeAbs(self2, e)];
             if (notDir && c)
               notDir = c !== "DIR" && !Array.isArray(c);
             return notDir;
           });
         }
       }
-      if (self.ignore.length)
+      if (self2.ignore.length)
         all = all.filter(function(m2) {
-          return !isIgnored(self, m2);
+          return !isIgnored(self2, m2);
         });
-      self.found = all;
+      self2.found = all;
     }
-    function mark(self, p) {
-      var abs = makeAbs(self, p);
-      var c = self.cache[abs];
+    function mark(self2, p) {
+      var abs = makeAbs(self2, p);
+      var c = self2.cache[abs];
       var m = p;
       if (c) {
         var isDir = c === "DIR" || Array.isArray(c);
@@ -13508,21 +13711,21 @@ var require_common = __commonJS({
         else if (!isDir && slash)
           m = m.slice(0, -1);
         if (m !== p) {
-          var mabs = makeAbs(self, m);
-          self.statCache[mabs] = self.statCache[abs];
-          self.cache[mabs] = self.cache[abs];
+          var mabs = makeAbs(self2, m);
+          self2.statCache[mabs] = self2.statCache[abs];
+          self2.cache[mabs] = self2.cache[abs];
         }
       }
       return m;
     }
-    function makeAbs(self, f) {
+    function makeAbs(self2, f) {
       var abs = f;
       if (f.charAt(0) === "/") {
-        abs = path.join(self.root, f);
+        abs = path.join(self2.root, f);
       } else if (isAbsolute(f) || f === "") {
         abs = f;
-      } else if (self.changedCwd) {
-        abs = path.resolve(self.cwd, f);
+      } else if (self2.changedCwd) {
+        abs = path.resolve(self2.cwd, f);
       } else {
         abs = path.resolve(f);
       }
@@ -13530,17 +13733,17 @@ var require_common = __commonJS({
         abs = abs.replace(/\\/g, "/");
       return abs;
     }
-    function isIgnored(self, path2) {
-      if (!self.ignore.length)
+    function isIgnored(self2, path2) {
+      if (!self2.ignore.length)
         return false;
-      return self.ignore.some(function(item) {
+      return self2.ignore.some(function(item) {
         return item.matcher.match(path2) || !!(item.gmatcher && item.gmatcher.match(path2));
       });
     }
-    function childrenIgnored(self, path2) {
-      if (!self.ignore.length)
+    function childrenIgnored(self2, path2) {
+      if (!self2.ignore.length)
         return false;
-      return self.ignore.some(function(item) {
+      return self2.ignore.some(function(item) {
         return !!(item.gmatcher && item.gmatcher.match(path2));
       });
     }
@@ -13590,17 +13793,17 @@ var require_sync = __commonJS({
     GlobSync.prototype._finish = function() {
       assert.ok(this instanceof GlobSync);
       if (this.realpath) {
-        var self = this;
+        var self2 = this;
         this.matches.forEach(function(matchset, index) {
-          var set = self.matches[index] = Object.create(null);
+          var set = self2.matches[index] = Object.create(null);
           for (var p in matchset) {
             try {
-              p = self._makeAbs(p);
-              var real = rp.realpathSync(p, self.realpathCache);
+              p = self2._makeAbs(p);
+              var real = rp.realpathSync(p, self2.realpathCache);
               set[real] = true;
             } catch (er) {
               if (er.syscall === "stat")
-                set[self._makeAbs(p)] = true;
+                set[self2._makeAbs(p)] = true;
               else
                 throw er;
             }
@@ -14109,7 +14312,7 @@ var require_glob = __commonJS({
           cb(null, matches);
         });
       }
-      var self = this;
+      var self2 = this;
       this._processing = 0;
       this._emitQueue = [];
       this._processQueue = [];
@@ -14124,14 +14327,14 @@ var require_glob = __commonJS({
       }
       sync = false;
       function done() {
-        --self._processing;
-        if (self._processing <= 0) {
+        --self2._processing;
+        if (self2._processing <= 0) {
           if (sync) {
             process.nextTick(function() {
-              self._finish();
+              self2._finish();
             });
           } else {
-            self._finish();
+            self2._finish();
           }
         }
       }
@@ -14152,12 +14355,12 @@ var require_glob = __commonJS({
       var n = this.matches.length;
       if (n === 0)
         return this._finish();
-      var self = this;
+      var self2 = this;
       for (var i = 0; i < this.matches.length; i++)
         this._realpathSet(i, next);
       function next() {
         if (--n === 0)
-          self._finish();
+          self2._finish();
       }
     };
     Glob.prototype._realpathSet = function(index, cb) {
@@ -14165,22 +14368,22 @@ var require_glob = __commonJS({
       if (!matchset)
         return cb();
       var found = Object.keys(matchset);
-      var self = this;
+      var self2 = this;
       var n = found.length;
       if (n === 0)
         return cb();
       var set = this.matches[index] = Object.create(null);
       found.forEach(function(p, i) {
-        p = self._makeAbs(p);
-        rp.realpath(p, self.realpathCache, function(er, real) {
+        p = self2._makeAbs(p);
+        rp.realpath(p, self2.realpathCache, function(er, real) {
           if (!er)
             set[real] = true;
           else if (er.syscall === "stat")
             set[p] = true;
           else
-            self.emit("error", er);
+            self2.emit("error", er);
           if (--n === 0) {
-            self.matches[index] = set;
+            self2.matches[index] = set;
             cb();
           }
         });
@@ -14273,9 +14476,9 @@ var require_glob = __commonJS({
         this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
     };
     Glob.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
-      var self = this;
+      var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+        return self2._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
       });
     };
     Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
@@ -14367,20 +14570,20 @@ var require_glob = __commonJS({
       if (this.follow)
         return this._readdir(abs, false, cb);
       var lstatkey = "lstat\0" + abs;
-      var self = this;
+      var self2 = this;
       var lstatcb = inflight(lstatkey, lstatcb_);
       if (lstatcb)
-        self.fs.lstat(abs, lstatcb);
+        self2.fs.lstat(abs, lstatcb);
       function lstatcb_(er, lstat) {
         if (er && er.code === "ENOENT")
           return cb();
         var isSym = lstat && lstat.isSymbolicLink();
-        self.symlinks[abs] = isSym;
+        self2.symlinks[abs] = isSym;
         if (!isSym && lstat && !lstat.isDirectory()) {
-          self.cache[abs] = "FILE";
+          self2.cache[abs] = "FILE";
           cb();
         } else
-          self._readdir(abs, false, cb);
+          self2._readdir(abs, false, cb);
       }
     };
     Glob.prototype._readdir = function(abs, inGlobStar, cb) {
@@ -14398,15 +14601,15 @@ var require_glob = __commonJS({
         if (Array.isArray(c))
           return cb(null, c);
       }
-      var self = this;
-      self.fs.readdir(abs, readdirCb(this, abs, cb));
+      var self2 = this;
+      self2.fs.readdir(abs, readdirCb(this, abs, cb));
     };
-    function readdirCb(self, abs, cb) {
+    function readdirCb(self2, abs, cb) {
       return function(er, entries) {
         if (er)
-          self._readdirError(abs, er, cb);
+          self2._readdirError(abs, er, cb);
         else
-          self._readdirEntries(abs, entries, cb);
+          self2._readdirEntries(abs, entries, cb);
       };
     }
     Glob.prototype._readdirEntries = function(abs, entries, cb) {
@@ -14460,9 +14663,9 @@ var require_glob = __commonJS({
       return cb();
     };
     Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
-      var self = this;
+      var self2 = this;
       this._readdir(abs, inGlobStar, function(er, entries) {
-        self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+        self2._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
       });
     };
     Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
@@ -14488,9 +14691,9 @@ var require_glob = __commonJS({
       cb();
     };
     Glob.prototype._processSimple = function(prefix, index, cb) {
-      var self = this;
+      var self2 = this;
       this._stat(prefix, function(er, exists) {
-        self._processSimple2(prefix, index, er, exists, cb);
+        self2._processSimple2(prefix, index, er, exists, cb);
       });
     };
     Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
@@ -14540,20 +14743,20 @@ var require_glob = __commonJS({
             return cb(null, type, stat2);
         }
       }
-      var self = this;
+      var self2 = this;
       var statcb = inflight("stat\0" + abs, lstatcb_);
       if (statcb)
-        self.fs.lstat(abs, statcb);
+        self2.fs.lstat(abs, statcb);
       function lstatcb_(er, lstat) {
         if (lstat && lstat.isSymbolicLink()) {
-          return self.fs.stat(abs, function(er2, stat3) {
+          return self2.fs.stat(abs, function(er2, stat3) {
             if (er2)
-              self._stat2(f, abs, null, lstat, cb);
+              self2._stat2(f, abs, null, lstat, cb);
             else
-              self._stat2(f, abs, er2, stat3, cb);
+              self2._stat2(f, abs, er2, stat3, cb);
           });
         } else {
-          self._stat2(f, abs, er, lstat, cb);
+          self2._stat2(f, abs, er, lstat, cb);
         }
       }
     };
@@ -15209,14 +15412,13 @@ var require_ms = __commonJS({
     var m = s * 60;
     var h = m * 60;
     var d = h * 24;
-    var w = d * 7;
     var y = d * 365.25;
     module2.exports = function(val, options) {
       options = options || {};
       var type = typeof val;
       if (type === "string" && val.length > 0) {
         return parse(val);
-      } else if (type === "number" && isFinite(val)) {
+      } else if (type === "number" && isNaN(val) === false) {
         return options.long ? fmtLong(val) : fmtShort(val);
       }
       throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
@@ -15226,7 +15428,7 @@ var require_ms = __commonJS({
       if (str.length > 100) {
         return;
       }
-      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+      var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
       if (!match) {
         return;
       }
@@ -15239,10 +15441,6 @@ var require_ms = __commonJS({
         case "yr":
         case "y":
           return n * y;
-        case "weeks":
-        case "week":
-        case "w":
-          return n * w;
         case "days":
         case "day":
         case "d":
@@ -15276,324 +15474,187 @@ var require_ms = __commonJS({
       }
     }
     function fmtShort(ms) {
-      var msAbs = Math.abs(ms);
-      if (msAbs >= d) {
+      if (ms >= d) {
         return Math.round(ms / d) + "d";
       }
-      if (msAbs >= h) {
+      if (ms >= h) {
         return Math.round(ms / h) + "h";
       }
-      if (msAbs >= m) {
+      if (ms >= m) {
         return Math.round(ms / m) + "m";
       }
-      if (msAbs >= s) {
+      if (ms >= s) {
         return Math.round(ms / s) + "s";
       }
       return ms + "ms";
     }
     function fmtLong(ms) {
-      var msAbs = Math.abs(ms);
-      if (msAbs >= d) {
-        return plural(ms, msAbs, d, "day");
-      }
-      if (msAbs >= h) {
-        return plural(ms, msAbs, h, "hour");
-      }
-      if (msAbs >= m) {
-        return plural(ms, msAbs, m, "minute");
+      return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
+    }
+    function plural(ms, n, name) {
+      if (ms < n) {
+        return;
       }
-      if (msAbs >= s) {
-        return plural(ms, msAbs, s, "second");
+      if (ms < n * 1.5) {
+        return Math.floor(ms / n) + " " + name;
       }
-      return ms + " ms";
-    }
-    function plural(ms, msAbs, n, name) {
-      var isPlural = msAbs >= n * 1.5;
-      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+      return Math.ceil(ms / n) + " " + name + "s";
     }
   }
 });
 
-// ../../../node_modules/debug/src/common.js
-var require_common2 = __commonJS({
-  "../../../node_modules/debug/src/common.js"(exports2, module2) {
-    function setup(env) {
-      createDebug.debug = createDebug;
-      createDebug.default = createDebug;
-      createDebug.coerce = coerce;
-      createDebug.disable = disable;
-      createDebug.enable = enable;
-      createDebug.enabled = enabled;
-      createDebug.humanize = require_ms();
-      createDebug.destroy = destroy;
-      Object.keys(env).forEach((key) => {
-        createDebug[key] = env[key];
-      });
-      createDebug.names = [];
-      createDebug.skips = [];
-      createDebug.formatters = {};
-      function selectColor(namespace) {
-        let hash = 0;
-        for (let i = 0; i < namespace.length; i++) {
-          hash = (hash << 5) - hash + namespace.charCodeAt(i);
-          hash |= 0;
-        }
-        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
-      }
-      createDebug.selectColor = selectColor;
-      function createDebug(namespace) {
-        let prevTime;
-        let enableOverride = null;
-        let namespacesCache;
-        let enabledCache;
-        function debug(...args2) {
-          if (!debug.enabled) {
-            return;
-          }
-          const self = debug;
-          const curr = Number(new Date());
-          const ms = curr - (prevTime || curr);
-          self.diff = ms;
-          self.prev = prevTime;
-          self.curr = curr;
-          prevTime = curr;
-          args2[0] = createDebug.coerce(args2[0]);
-          if (typeof args2[0] !== "string") {
-            args2.unshift("%O");
-          }
-          let index = 0;
-          args2[0] = args2[0].replace(/%([a-zA-Z%])/g, (match, format2) => {
-            if (match === "%%") {
-              return "%";
-            }
-            index++;
-            const formatter = createDebug.formatters[format2];
-            if (typeof formatter === "function") {
-              const val = args2[index];
-              match = formatter.call(self, val);
-              args2.splice(index, 1);
-              index--;
-            }
+// ../../../node_modules/debug/src/debug.js
+var require_debug = __commonJS({
+  "../../../node_modules/debug/src/debug.js"(exports2, module2) {
+    exports2 = module2.exports = createDebug.debug = createDebug["default"] = createDebug;
+    exports2.coerce = coerce;
+    exports2.disable = disable;
+    exports2.enable = enable;
+    exports2.enabled = enabled;
+    exports2.humanize = require_ms();
+    exports2.names = [];
+    exports2.skips = [];
+    exports2.formatters = {};
+    var prevTime;
+    function selectColor(namespace) {
+      var hash = 0, i;
+      for (i in namespace) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return exports2.colors[Math.abs(hash) % exports2.colors.length];
+    }
+    function createDebug(namespace) {
+      function debug() {
+        if (!debug.enabled)
+          return;
+        var self2 = debug;
+        var curr = +new Date();
+        var ms = curr - (prevTime || curr);
+        self2.diff = ms;
+        self2.prev = prevTime;
+        self2.curr = curr;
+        prevTime = curr;
+        var args2 = new Array(arguments.length);
+        for (var i = 0; i < args2.length; i++) {
+          args2[i] = arguments[i];
+        }
+        args2[0] = exports2.coerce(args2[0]);
+        if (typeof args2[0] !== "string") {
+          args2.unshift("%O");
+        }
+        var index = 0;
+        args2[0] = args2[0].replace(/%([a-zA-Z%])/g, function(match, format2) {
+          if (match === "%%")
             return match;
-          });
-          createDebug.formatArgs.call(self, args2);
-          const logFn = self.log || createDebug.log;
-          logFn.apply(self, args2);
-        }
-        debug.namespace = namespace;
-        debug.useColors = createDebug.useColors();
-        debug.color = createDebug.selectColor(namespace);
-        debug.extend = extend;
-        debug.destroy = createDebug.destroy;
-        Object.defineProperty(debug, "enabled", {
-          enumerable: true,
-          configurable: false,
-          get: () => {
-            if (enableOverride !== null) {
-              return enableOverride;
-            }
-            if (namespacesCache !== createDebug.namespaces) {
-              namespacesCache = createDebug.namespaces;
-              enabledCache = createDebug.enabled(namespace);
-            }
-            return enabledCache;
-          },
-          set: (v) => {
-            enableOverride = v;
+          index++;
+          var formatter = exports2.formatters[format2];
+          if (typeof formatter === "function") {
+            var val = args2[index];
+            match = formatter.call(self2, val);
+            args2.splice(index, 1);
+            index--;
           }
+          return match;
         });
-        if (typeof createDebug.init === "function") {
-          createDebug.init(debug);
-        }
-        return debug;
-      }
-      function extend(namespace, delimiter) {
-        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
-        newDebug.log = this.log;
-        return newDebug;
-      }
-      function enable(namespaces) {
-        createDebug.save(namespaces);
-        createDebug.namespaces = namespaces;
-        createDebug.names = [];
-        createDebug.skips = [];
-        let i;
-        const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
-        const len = split.length;
-        for (i = 0; i < len; i++) {
-          if (!split[i]) {
-            continue;
-          }
-          namespaces = split[i].replace(/\*/g, ".*?");
-          if (namespaces[0] === "-") {
-            createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
-          } else {
-            createDebug.names.push(new RegExp("^" + namespaces + "$"));
-          }
+        exports2.formatArgs.call(self2, args2);
+        var logFn = debug.log || exports2.log || console.log.bind(console);
+        logFn.apply(self2, args2);
+      }
+      debug.namespace = namespace;
+      debug.enabled = exports2.enabled(namespace);
+      debug.useColors = exports2.useColors();
+      debug.color = selectColor(namespace);
+      if (typeof exports2.init === "function") {
+        exports2.init(debug);
+      }
+      return debug;
+    }
+    function enable(namespaces) {
+      exports2.save(namespaces);
+      exports2.names = [];
+      exports2.skips = [];
+      var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+      var len = split.length;
+      for (var i = 0; i < len; i++) {
+        if (!split[i])
+          continue;
+        namespaces = split[i].replace(/\*/g, ".*?");
+        if (namespaces[0] === "-") {
+          exports2.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+        } else {
+          exports2.names.push(new RegExp("^" + namespaces + "$"));
         }
       }
-      function disable() {
-        const namespaces = [
-          ...createDebug.names.map(toNamespace),
-          ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
-        ].join(",");
-        createDebug.enable("");
-        return namespaces;
-      }
-      function enabled(name) {
-        if (name[name.length - 1] === "*") {
-          return true;
-        }
-        let i;
-        let len;
-        for (i = 0, len = createDebug.skips.length; i < len; i++) {
-          if (createDebug.skips[i].test(name)) {
-            return false;
-          }
-        }
-        for (i = 0, len = createDebug.names.length; i < len; i++) {
-          if (createDebug.names[i].test(name)) {
-            return true;
-          }
+    }
+    function disable() {
+      exports2.enable("");
+    }
+    function enabled(name) {
+      var i, len;
+      for (i = 0, len = exports2.skips.length; i < len; i++) {
+        if (exports2.skips[i].test(name)) {
+          return false;
         }
-        return false;
       }
-      function toNamespace(regexp) {
-        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
-      }
-      function coerce(val) {
-        if (val instanceof Error) {
-          return val.stack || val.message;
+      for (i = 0, len = exports2.names.length; i < len; i++) {
+        if (exports2.names[i].test(name)) {
+          return true;
         }
-        return val;
       }
-      function destroy() {
-        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
-      }
-      createDebug.enable(createDebug.load());
-      return createDebug;
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error)
+        return val.stack || val.message;
+      return val;
     }
-    module2.exports = setup;
   }
 });
 
 // ../../../node_modules/debug/src/browser.js
 var require_browser = __commonJS({
   "../../../node_modules/debug/src/browser.js"(exports2, module2) {
+    exports2 = module2.exports = require_debug();
+    exports2.log = log;
     exports2.formatArgs = formatArgs;
     exports2.save = save;
     exports2.load = load;
     exports2.useColors = useColors;
-    exports2.storage = localstorage();
-    exports2.destroy = (() => {
-      let warned = false;
-      return () => {
-        if (!warned) {
-          warned = true;
-          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
-        }
-      };
-    })();
+    exports2.storage = typeof chrome != "undefined" && typeof chrome.storage != "undefined" ? chrome.storage.local : localstorage();
     exports2.colors = [
-      "#0000CC",
-      "#0000FF",
-      "#0033CC",
-      "#0033FF",
-      "#0066CC",
-      "#0066FF",
-      "#0099CC",
-      "#0099FF",
-      "#00CC00",
-      "#00CC33",
-      "#00CC66",
-      "#00CC99",
-      "#00CCCC",
-      "#00CCFF",
-      "#3300CC",
-      "#3300FF",
-      "#3333CC",
-      "#3333FF",
-      "#3366CC",
-      "#3366FF",
-      "#3399CC",
-      "#3399FF",
-      "#33CC00",
-      "#33CC33",
-      "#33CC66",
-      "#33CC99",
-      "#33CCCC",
-      "#33CCFF",
-      "#6600CC",
-      "#6600FF",
-      "#6633CC",
-      "#6633FF",
-      "#66CC00",
-      "#66CC33",
-      "#9900CC",
-      "#9900FF",
-      "#9933CC",
-      "#9933FF",
-      "#99CC00",
-      "#99CC33",
-      "#CC0000",
-      "#CC0033",
-      "#CC0066",
-      "#CC0099",
-      "#CC00CC",
-      "#CC00FF",
-      "#CC3300",
-      "#CC3333",
-      "#CC3366",
-      "#CC3399",
-      "#CC33CC",
-      "#CC33FF",
-      "#CC6600",
-      "#CC6633",
-      "#CC9900",
-      "#CC9933",
-      "#CCCC00",
-      "#CCCC33",
-      "#FF0000",
-      "#FF0033",
-      "#FF0066",
-      "#FF0099",
-      "#FF00CC",
-      "#FF00FF",
-      "#FF3300",
-      "#FF3333",
-      "#FF3366",
-      "#FF3399",
-      "#FF33CC",
-      "#FF33FF",
-      "#FF6600",
-      "#FF6633",
-      "#FF9900",
-      "#FF9933",
-      "#FFCC00",
-      "#FFCC33"
+      "lightseagreen",
+      "forestgreen",
+      "goldenrod",
+      "dodgerblue",
+      "darkorchid",
+      "crimson"
     ];
     function useColors() {
-      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+      if (typeof window !== "undefined" && window.process && window.process.type === "renderer") {
         return true;
       }
-      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-        return false;
-      }
       return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
     }
+    exports2.formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (err) {
+        return "[UnexpectedJSONParseError]: " + err.message;
+      }
+    };
     function formatArgs(args2) {
-      args2[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args2[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
-      if (!this.useColors) {
+      var useColors2 = this.useColors;
+      args2[0] = (useColors2 ? "%c" : "") + this.namespace + (useColors2 ? " %c" : " ") + args2[0] + (useColors2 ? "%c " : " ") + "+" + exports2.humanize(this.diff);
+      if (!useColors2)
         return;
-      }
-      const c = "color: " + this.color;
+      var c = "color: " + this.color;
       args2.splice(1, 0, c, "color: inherit");
-      let index = 0;
-      let lastC = 0;
-      args2[0].replace(/%[a-zA-Z%]/g, (match) => {
-        if (match === "%%") {
+      var index = 0;
+      var lastC = 0;
+      args2[0].replace(/%[a-zA-Z%]/g, function(match) {
+        if (match === "%%")
           return;
-        }
         index++;
         if (match === "%c") {
           lastC = index;
@@ -15601,158 +15662,37 @@ var require_browser = __commonJS({
       });
       args2.splice(lastC, 0, c);
     }
-    exports2.log = console.debug || console.log || (() => {
-    });
+    function log() {
+      return typeof console === "object" && console.log && Function.prototype.apply.call(console.log, console, arguments);
+    }
     function save(namespaces) {
       try {
-        if (namespaces) {
-          exports2.storage.setItem("debug", namespaces);
-        } else {
+        if (namespaces == null) {
           exports2.storage.removeItem("debug");
+        } else {
+          exports2.storage.debug = namespaces;
         }
-      } catch (error) {
+      } catch (e) {
       }
     }
     function load() {
-      let r;
+      var r;
       try {
-        r = exports2.storage.getItem("debug");
-      } catch (error) {
+        r = exports2.storage.debug;
+      } catch (e) {
       }
       if (!r && typeof process !== "undefined" && "env" in process) {
         r = process.env.DEBUG;
       }
       return r;
     }
+    exports2.enable(load());
     function localstorage() {
       try {
-        return localStorage;
-      } catch (error) {
-      }
-    }
-    module2.exports = require_common2()(exports2);
-    var { formatters } = module2.exports;
-    formatters.j = function(v) {
-      try {
-        return JSON.stringify(v);
-      } catch (error) {
-        return "[UnexpectedJSONParseError]: " + error.message;
-      }
-    };
-  }
-});
-
-// ../../../node_modules/supports-color/index.js
-var require_supports_color2 = __commonJS({
-  "../../../node_modules/supports-color/index.js"(exports2, module2) {
-    "use strict";
-    var os2 = require("os");
-    var tty = require("tty");
-    var hasFlag = require_has_flag();
-    var { env } = process;
-    var flagForceColor;
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      flagForceColor = 0;
-    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      flagForceColor = 1;
-    }
-    function envForceColor() {
-      if ("FORCE_COLOR" in env) {
-        if (env.FORCE_COLOR === "true") {
-          return 1;
-        }
-        if (env.FORCE_COLOR === "false") {
-          return 0;
-        }
-        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-      }
-    }
-    function translateLevel(level) {
-      if (level === 0) {
-        return false;
-      }
-      return {
-        level,
-        hasBasic: true,
-        has256: level >= 2,
-        has16m: level >= 3
-      };
-    }
-    function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-      const noFlagForceColor = envForceColor();
-      if (noFlagForceColor !== void 0) {
-        flagForceColor = noFlagForceColor;
-      }
-      const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-      if (forceColor === 0) {
-        return 0;
-      }
-      if (sniffFlags) {
-        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-          return 3;
-        }
-        if (hasFlag("color=256")) {
-          return 2;
-        }
-      }
-      if (haveStream && !streamIsTTY && forceColor === void 0) {
-        return 0;
-      }
-      const min = forceColor || 0;
-      if (env.TERM === "dumb") {
-        return min;
-      }
-      if (process.platform === "win32") {
-        const osRelease = os2.release().split(".");
-        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", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
-          return 1;
-        }
-        return min;
-      }
-      if ("TEAMCITY_VERSION" in env) {
-        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-      }
-      if (env.COLORTERM === "truecolor") {
-        return 3;
-      }
-      if ("TERM_PROGRAM" in env) {
-        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-        switch (env.TERM_PROGRAM) {
-          case "iTerm.app":
-            return version >= 3 ? 3 : 2;
-          case "Apple_Terminal":
-            return 2;
-        }
-      }
-      if (/-256(color)?$/i.test(env.TERM)) {
-        return 2;
-      }
-      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-        return 1;
-      }
-      if ("COLORTERM" in env) {
-        return 1;
+        return window.localStorage;
+      } catch (e) {
       }
-      return min;
     }
-    function getSupportLevel(stream, options = {}) {
-      const level = supportsColor(stream, {
-        streamIsTTY: stream && stream.isTTY,
-        ...options
-      });
-      return translateLevel(level);
-    }
-    module2.exports = {
-      supportsColor: getSupportLevel,
-      stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
-      stderr: getSupportLevel({ isTTY: tty.isatty(2) })
-    };
   }
 });
 
@@ -15761,176 +15701,129 @@ var require_node2 = __commonJS({
   "../../../node_modules/debug/src/node.js"(exports2, module2) {
     var tty = require("tty");
     var util = require("util");
+    exports2 = module2.exports = require_debug();
     exports2.init = init;
     exports2.log = log;
     exports2.formatArgs = formatArgs;
     exports2.save = save;
     exports2.load = load;
     exports2.useColors = useColors;
-    exports2.destroy = util.deprecate(() => {
-    }, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
     exports2.colors = [6, 2, 3, 4, 5, 1];
-    try {
-      const supportsColor = require_supports_color2();
-      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
-        exports2.colors = [
-          20,
-          21,
-          26,
-          27,
-          32,
-          33,
-          38,
-          39,
-          40,
-          41,
-          42,
-          43,
-          44,
-          45,
-          56,
-          57,
-          62,
-          63,
-          68,
-          69,
-          74,
-          75,
-          76,
-          77,
-          78,
-          79,
-          80,
-          81,
-          92,
-          93,
-          98,
-          99,
-          112,
-          113,
-          128,
-          129,
-          134,
-          135,
-          148,
-          149,
-          160,
-          161,
-          162,
-          163,
-          164,
-          165,
-          166,
-          167,
-          168,
-          169,
-          170,
-          171,
-          172,
-          173,
-          178,
-          179,
-          184,
-          185,
-          196,
-          197,
-          198,
-          199,
-          200,
-          201,
-          202,
-          203,
-          204,
-          205,
-          206,
-          207,
-          208,
-          209,
-          214,
-          215,
-          220,
-          221
-        ];
-      }
-    } catch (error) {
-    }
-    exports2.inspectOpts = Object.keys(process.env).filter((key) => {
+    exports2.inspectOpts = Object.keys(process.env).filter(function(key) {
       return /^debug_/i.test(key);
-    }).reduce((obj, key) => {
-      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+    }).reduce(function(obj, key) {
+      var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
         return k.toUpperCase();
       });
-      let val = process.env[key];
-      if (/^(yes|on|true|enabled)$/i.test(val)) {
+      var val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val))
         val = true;
-      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+      else if (/^(no|off|false|disabled)$/i.test(val))
         val = false;
-      } else if (val === "null") {
+      else if (val === "null")
         val = null;
-      } else {
+      else
         val = Number(val);
-      }
       obj[prop] = val;
       return obj;
     }, {});
+    var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
+    if (fd !== 1 && fd !== 2) {
+      util.deprecate(function() {
+      }, "except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)")();
+    }
+    var stream = fd === 1 ? process.stdout : fd === 2 ? process.stderr : createWritableStdioStream(fd);
     function useColors() {
-      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(fd);
     }
+    exports2.formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map(function(str) {
+        return str.trim();
+      }).join(" ");
+    };
+    exports2.formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
     function formatArgs(args2) {
-      const { namespace: name, useColors: useColors2 } = this;
+      var name = this.namespace;
+      var useColors2 = this.useColors;
       if (useColors2) {
-        const c = this.color;
-        const colorCode = "[3" + (c < 8 ? c : "8;5;" + c);
-        const prefix = `  ${colorCode};1m${name} `;
+        var c = this.color;
+        var prefix = "  [3" + c + ";1m" + name + " ";
         args2[0] = prefix + args2[0].split("\n").join("\n" + prefix);
-        args2.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "");
+        args2.push("[3" + c + "m+" + exports2.humanize(this.diff) + "");
       } else {
-        args2[0] = getDate() + name + " " + args2[0];
-      }
-    }
-    function getDate() {
-      if (exports2.inspectOpts.hideDate) {
-        return "";
+        args2[0] = new Date().toUTCString() + " " + name + " " + args2[0];
       }
-      return new Date().toISOString() + " ";
     }
-    function log(...args2) {
-      return process.stderr.write(util.format(...args2) + "\n");
+    function log() {
+      return stream.write(util.format.apply(util, arguments) + "\n");
     }
     function save(namespaces) {
-      if (namespaces) {
-        process.env.DEBUG = namespaces;
-      } else {
+      if (namespaces == null) {
         delete process.env.DEBUG;
+      } else {
+        process.env.DEBUG = namespaces;
       }
     }
     function load() {
       return process.env.DEBUG;
     }
+    function createWritableStdioStream(fd2) {
+      var stream2;
+      var tty_wrap = process.binding("tty_wrap");
+      switch (tty_wrap.guessHandleType(fd2)) {
+        case "TTY":
+          stream2 = new tty.WriteStream(fd2);
+          stream2._type = "tty";
+          if (stream2._handle && stream2._handle.unref) {
+            stream2._handle.unref();
+          }
+          break;
+        case "FILE":
+          var fs = require("fs");
+          stream2 = new fs.SyncWriteStream(fd2, { autoClose: false });
+          stream2._type = "fs";
+          break;
+        case "PIPE":
+        case "TCP":
+          var net = require("net");
+          stream2 = new net.Socket({
+            fd: fd2,
+            readable: false,
+            writable: true
+          });
+          stream2.readable = false;
+          stream2.read = null;
+          stream2._type = "pipe";
+          if (stream2._handle && stream2._handle.unref) {
+            stream2._handle.unref();
+          }
+          break;
+        default:
+          throw new Error("Implement me. Unknown stream file type!");
+      }
+      stream2.fd = fd2;
+      stream2._isStdio = true;
+      return stream2;
+    }
     function init(debug) {
       debug.inspectOpts = {};
-      const keys = Object.keys(exports2.inspectOpts);
-      for (let i = 0; i < keys.length; i++) {
+      var keys = Object.keys(exports2.inspectOpts);
+      for (var i = 0; i < keys.length; i++) {
         debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
       }
     }
-    module2.exports = require_common2()(exports2);
-    var { formatters } = module2.exports;
-    formatters.o = function(v) {
-      this.inspectOpts.colors = this.useColors;
-      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
-    };
-    formatters.O = function(v) {
-      this.inspectOpts.colors = this.useColors;
-      return util.inspect(v, this.inspectOpts);
-    };
+    exports2.enable(load());
   }
 });
 
 // ../../../node_modules/debug/src/index.js
 var require_src = __commonJS({
   "../../../node_modules/debug/src/index.js"(exports2, module2) {
-    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+    if (typeof process !== "undefined" && process.type === "renderer") {
       module2.exports = require_browser();
     } else {
       module2.exports = require_node2();
@@ -15939,7 +15832,7 @@ var require_src = __commonJS({
 });
 
 // ../../../node_modules/follow-redirects/debug.js
-var require_debug = __commonJS({
+var require_debug2 = __commonJS({
   "../../../node_modules/follow-redirects/debug.js"(exports2, module2) {
     var debug;
     module2.exports = function() {
@@ -15967,7 +15860,7 @@ var require_follow_redirects = __commonJS({
     var https = require("https");
     var Writable2 = require("stream").Writable;
     var assert = require("assert");
-    var debug = require_debug();
+    var debug = require_debug2();
     var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
     var eventHandlers = Object.create(null);
     events.forEach(function(event) {
@@ -15975,10 +15868,12 @@ var require_follow_redirects = __commonJS({
         this._redirectable.emit(event, arg1, arg2, arg3);
       };
     });
+    var InvalidUrlError = createErrorType("ERR_INVALID_URL", "Invalid URL", TypeError);
     var RedirectionError = createErrorType("ERR_FR_REDIRECTION_FAILURE", "Redirected request failed");
     var TooManyRedirectsError = createErrorType("ERR_FR_TOO_MANY_REDIRECTS", "Maximum number of redirects exceeded");
     var MaxBodyLengthExceededError = createErrorType("ERR_FR_MAX_BODY_LENGTH_EXCEEDED", "Request body larger than maxBodyLength limit");
     var WriteAfterEndError = createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
+    var destroy = Writable2.prototype.destroy || noop;
     function RedirectableRequest(options, responseCallback) {
       Writable2.call(this);
       this._sanitizeOptions(options);
@@ -15992,25 +15887,31 @@ var require_follow_redirects = __commonJS({
       if (responseCallback) {
         this.on("response", responseCallback);
       }
-      var self = this;
+      var self2 = this;
       this._onNativeResponse = function(response) {
-        self._processResponse(response);
+        self2._processResponse(response);
       };
       this._performRequest();
     }
     RedirectableRequest.prototype = Object.create(Writable2.prototype);
     RedirectableRequest.prototype.abort = function() {
-      abortRequest(this._currentRequest);
+      destroyRequest(this._currentRequest);
+      this._currentRequest.abort();
       this.emit("abort");
     };
+    RedirectableRequest.prototype.destroy = function(error) {
+      destroyRequest(this._currentRequest, error);
+      destroy.call(this, error);
+      return this;
+    };
     RedirectableRequest.prototype.write = function(data, encoding, callback) {
       if (this._ending) {
         throw new WriteAfterEndError();
       }
-      if (!(typeof data === "string" || typeof data === "object" && "length" in data)) {
+      if (!isString(data) && !isBuffer(data)) {
         throw new TypeError("data should be a string, Buffer or Uint8Array");
       }
-      if (typeof encoding === "function") {
+      if (isFunction(encoding)) {
         callback = encoding;
         encoding = null;
       }
@@ -16030,10 +15931,10 @@ var require_follow_redirects = __commonJS({
       }
     };
     RedirectableRequest.prototype.end = function(data, encoding, callback) {
-      if (typeof data === "function") {
+      if (isFunction(data)) {
         callback = data;
         data = encoding = null;
-      } else if (typeof encoding === "function") {
+      } else if (isFunction(encoding)) {
         callback = encoding;
         encoding = null;
       }
@@ -16041,10 +15942,10 @@ var require_follow_redirects = __commonJS({
         this._ended = this._ending = true;
         this._currentRequest.end(null, null, callback);
       } else {
-        var self = this;
+        var self2 = this;
         var currentRequest = this._currentRequest;
         this.write(data, encoding, function() {
-          self._ended = true;
+          self2._ended = true;
           currentRequest.end(null, null, callback);
         });
         this._ending = true;
@@ -16059,35 +15960,36 @@ var require_follow_redirects = __commonJS({
       this._currentRequest.removeHeader(name);
     };
     RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
-      var self = this;
+      var self2 = this;
       function destroyOnTimeout(socket) {
         socket.setTimeout(msecs);
         socket.removeListener("timeout", socket.destroy);
         socket.addListener("timeout", socket.destroy);
       }
       function startTimer(socket) {
-        if (self._timeout) {
-          clearTimeout(self._timeout);
+        if (self2._timeout) {
+          clearTimeout(self2._timeout);
         }
-        self._timeout = setTimeout(function() {
-          self.emit("timeout");
+        self2._timeout = setTimeout(function() {
+          self2.emit("timeout");
           clearTimer();
         }, msecs);
         destroyOnTimeout(socket);
       }
       function clearTimer() {
-        if (self._timeout) {
-          clearTimeout(self._timeout);
-          self._timeout = null;
-        }
-        self.removeListener("abort", clearTimer);
-        self.removeListener("error", clearTimer);
-        self.removeListener("response", clearTimer);
+        if (self2._timeout) {
+          clearTimeout(self2._timeout);
+          self2._timeout = null;
+        }
+        self2.removeListener("abort", clearTimer);
+        self2.removeListener("error", clearTimer);
+        self2.removeListener("response", clearTimer);
+        self2.removeListener("close", clearTimer);
         if (callback) {
-          self.removeListener("timeout", callback);
+          self2.removeListener("timeout", callback);
         }
-        if (!self.socket) {
-          self._currentRequest.removeListener("socket", startTimer);
+        if (!self2.socket) {
+          self2._currentRequest.removeListener("socket", startTimer);
         }
       }
       if (callback) {
@@ -16102,6 +16004,7 @@ var require_follow_redirects = __commonJS({
       this.on("abort", clearTimer);
       this.on("error", clearTimer);
       this.on("response", clearTimer);
+      this.on("close", clearTimer);
       return this;
     };
     [
@@ -16157,21 +16060,21 @@ var require_follow_redirects = __commonJS({
       for (var event of events) {
         request.on(event, eventHandlers[event]);
       }
-      this._currentUrl = /^\//.test(this._options.path) ? url.format(this._options) : this._currentUrl = this._options.path;
+      this._currentUrl = /^\//.test(this._options.path) ? url.format(this._options) : this._options.path;
       if (this._isRedirect) {
         var i = 0;
-        var self = this;
+        var self2 = this;
         var buffers = this._requestBodyBuffers;
         (function writeNext(error) {
-          if (request === self._currentRequest) {
+          if (request === self2._currentRequest) {
             if (error) {
-              self.emit("error", error);
+              self2.emit("error", error);
             } else if (i < buffers.length) {
               var buffer = buffers[i++];
               if (!request.finished) {
                 request.write(buffer.data, buffer.encoding, writeNext);
               }
-            } else if (self._ended) {
+            } else if (self2._ended) {
               request.end();
             }
           }
@@ -16195,7 +16098,7 @@ var require_follow_redirects = __commonJS({
         this._requestBodyBuffers = [];
         return;
       }
-      abortRequest(this._currentRequest);
+      destroyRequest(this._currentRequest);
       response.destroy();
       if (++this._redirectCount > this._options.maxRedirects) {
         this.emit("error", new TooManyRedirectsError());
@@ -16222,7 +16125,7 @@ var require_follow_redirects = __commonJS({
       try {
         redirectUrl = url.resolve(currentUrl, location);
       } catch (cause) {
-        this.emit("error", new RedirectionError(cause));
+        this.emit("error", new RedirectionError({ cause }));
         return;
       }
       debug("redirecting to", redirectUrl);
@@ -16232,7 +16135,7 @@ var require_follow_redirects = __commonJS({
       if (redirectUrlParts.protocol !== currentUrlParts.protocol && redirectUrlParts.protocol !== "https:" || redirectUrlParts.host !== currentHost && !isSubdomain(redirectUrlParts.host, currentHost)) {
         removeMatchingHeaders(/^(?:authorization|cookie)$/i, this._options.headers);
       }
-      if (typeof beforeRedirect === "function") {
+      if (isFunction(beforeRedirect)) {
         var responseDetails = {
           headers: response.headers,
           statusCode
@@ -16253,7 +16156,7 @@ var require_follow_redirects = __commonJS({
       try {
         this._performRequest();
       } catch (cause) {
-        this.emit("error", new RedirectionError(cause));
+        this.emit("error", new RedirectionError({ cause }));
       }
     };
     function wrap(protocols) {
@@ -16267,13 +16170,17 @@ var require_follow_redirects = __commonJS({
         var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
         var wrappedProtocol = exports3[scheme] = Object.create(nativeProtocol);
         function request(input, options, callback) {
-          if (typeof input === "string") {
-            var urlStr = input;
+          if (isString(input)) {
+            var parsed;
             try {
-              input = urlToOptions(new URL(urlStr));
+              parsed = urlToOptions(new URL(input));
             } catch (err) {
-              input = url.parse(urlStr);
+              parsed = url.parse(input);
+            }
+            if (!isString(parsed.protocol)) {
+              throw new InvalidUrlError({ input });
             }
+            input = parsed;
           } else if (URL && input instanceof URL) {
             input = urlToOptions(input);
           } else {
@@ -16281,7 +16188,7 @@ var require_follow_redirects = __commonJS({
             options = input;
             input = { protocol };
           }
-          if (typeof options === "function") {
+          if (isFunction(options)) {
             callback = options;
             options = null;
           }
@@ -16290,6 +16197,9 @@ var require_follow_redirects = __commonJS({
             maxBodyLength: exports3.maxBodyLength
           }, input, options);
           options.nativeProtocols = nativeProtocols;
+          if (!isString(options.host) && !isString(options.hostname)) {
+            options.hostname = "::1";
+          }
           assert.equal(options.protocol, protocol, "protocol mismatch");
           debug("options", options);
           return new RedirectableRequest(options, callback);
@@ -16323,43 +16233,49 @@ var require_follow_redirects = __commonJS({
       }
       return options;
     }
-    function removeMatchingHeaders(regex, headers) {
+    function removeMatchingHeaders(regex2, headers) {
       var lastValue;
       for (var header in headers) {
-        if (regex.test(header)) {
+        if (regex2.test(header)) {
           lastValue = headers[header];
           delete headers[header];
         }
       }
       return lastValue === null || typeof lastValue === "undefined" ? void 0 : String(lastValue).trim();
     }
-    function createErrorType(code, defaultMessage) {
-      function CustomError(cause) {
+    function createErrorType(code, message, baseClass) {
+      function CustomError(properties) {
         Error.captureStackTrace(this, this.constructor);
-        if (!cause) {
-          this.message = defaultMessage;
-        } else {
-          this.message = defaultMessage + ": " + cause.message;
-          this.cause = cause;
-        }
+        Object.assign(this, properties || {});
+        this.code = code;
+        this.message = this.cause ? message + ": " + this.cause.message : message;
       }
-      CustomError.prototype = new Error();
+      CustomError.prototype = new (baseClass || Error)();
       CustomError.prototype.constructor = CustomError;
       CustomError.prototype.name = "Error [" + code + "]";
-      CustomError.prototype.code = code;
       return CustomError;
     }
-    function abortRequest(request) {
+    function destroyRequest(request, error) {
       for (var event of events) {
         request.removeListener(event, eventHandlers[event]);
       }
       request.on("error", noop);
-      request.abort();
+      request.destroy(error);
     }
     function isSubdomain(subdomain, domain) {
-      const dot = subdomain.length - domain.length - 1;
+      assert(isString(subdomain) && isString(domain));
+      var dot = subdomain.length - domain.length - 1;
       return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
     }
+    function isString(value) {
+      return typeof value === "string" || value instanceof String;
+    }
+    function isFunction(value) {
+      return typeof value === "function";
+    }
+    function isBuffer(value) {
+      return typeof value === "object" && "length" in value;
+    }
     module2.exports = wrap({ http, https });
     module2.exports.wrap = wrap;
   }
@@ -17451,9 +17367,9 @@ var require_combined_stream = __commonJS({
       this._getNext();
     };
     CombinedStream.prototype._handleErrors = function(stream) {
-      var self = this;
+      var self2 = this;
       stream.on("error", function(err) {
-        self._emitError(err);
+        self2._emitError(err);
       });
     };
     CombinedStream.prototype.write = function(data) {
@@ -17500,12 +17416,12 @@ var require_combined_stream = __commonJS({
     };
     CombinedStream.prototype._updateDataSize = function() {
       this.dataSize = 0;
-      var self = this;
+      var self2 = this;
       this._streams.forEach(function(stream) {
         if (!stream.dataSize) {
           return;
         }
-        self.dataSize += stream.dataSize;
+        self2.dataSize += stream.dataSize;
       });
       if (this._currentStream && this._currentStream.dataSize) {
         this.dataSize += this._currentStream.dataSize;
@@ -26909,14 +26825,14 @@ var forceOverwriteKeys = Object.keys(ForceOverwrite).filter((m) => typeof ForceO
 var import_path4 = __toModule(require("path"));
 var import_promises2 = __toModule(require("fs/promises"));
 
-// ../../../node_modules/ora/index.js
-var import_node_process6 = __toModule(require("node:process"));
+// node_modules/ora/index.js
+var import_node_process5 = __toModule(require("node:process"));
 var import_chalk2 = __toModule(require_source());
 
-// ../../../node_modules/ora/node_modules/cli-cursor/index.js
+// node_modules/cli-cursor/index.js
 var import_node_process2 = __toModule(require("node:process"));
 
-// ../../../node_modules/ora/node_modules/restore-cursor/index.js
+// node_modules/restore-cursor/index.js
 var import_node_process = __toModule(require("node:process"));
 var import_onetime = __toModule(require_onetime());
 var import_signal_exit = __toModule(require_signal_exit());
@@ -26927,7 +26843,7 @@ var restoreCursor = (0, import_onetime.default)(() => {
 });
 var restore_cursor_default = restoreCursor;
 
-// ../../../node_modules/ora/node_modules/cli-cursor/index.js
+// node_modules/cli-cursor/index.js
 var isHidden = false;
 var cliCursor = {};
 cliCursor.show = (writableStream = import_node_process2.default.stderr) => {
@@ -26957,13 +26873,13 @@ cliCursor.toggle = (force, writableStream) => {
 };
 var cli_cursor_default = cliCursor;
 
-// ../../../node_modules/ora/index.js
+// node_modules/ora/index.js
 var import_cli_spinners = __toModule(require_cli_spinners());
 
-// ../../../node_modules/log-symbols/index.js
+// node_modules/log-symbols/index.js
 var import_chalk = __toModule(require_source());
 
-// ../../../node_modules/log-symbols/node_modules/is-unicode-supported/index.js
+// node_modules/is-unicode-supported/index.js
 var import_node_process3 = __toModule(require("node:process"));
 function isUnicodeSupported() {
   if (import_node_process3.default.platform !== "win32") {
@@ -26972,7 +26888,7 @@ function isUnicodeSupported() {
   return Boolean(import_node_process3.default.env.CI) || Boolean(import_node_process3.default.env.WT_SESSION) || Boolean(import_node_process3.default.env.TERMINUS_SUBLIME) || import_node_process3.default.env.ConEmuTask === "{cmd::Cmder}" || import_node_process3.default.env.TERM_PROGRAM === "Terminus-Sublime" || import_node_process3.default.env.TERM_PROGRAM === "vscode" || import_node_process3.default.env.TERM === "xterm-256color" || import_node_process3.default.env.TERM === "alacritty" || import_node_process3.default.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 
-// ../../../node_modules/log-symbols/index.js
+// node_modules/log-symbols/index.js
 var main = {
   info: import_chalk.default.blue("\u2139"),
   success: import_chalk.default.green("\u2714"),
@@ -26988,16 +26904,17 @@ var fallback = {
 var logSymbols = isUnicodeSupported() ? main : fallback;
 var log_symbols_default = logSymbols;
 
-// ../../../node_modules/ora/node_modules/strip-ansi/index.js
+// node_modules/strip-ansi/index.js
 var import_ansi_regex = __toModule(require_ansi_regex());
+var regex = (0, import_ansi_regex.default)();
 function stripAnsi(string2) {
   if (typeof string2 !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string2}\``);
   }
-  return string2.replace((0, import_ansi_regex.default)(), "");
+  return string2.replace(regex, "");
 }
 
-// ../../../node_modules/ora/index.js
+// node_modules/ora/index.js
 var import_wcwidth = __toModule(require_wcwidth());
 
 // ../../../node_modules/is-interactive/index.js
@@ -27005,17 +26922,8 @@ function isInteractive({ stream = process.stdout } = {}) {
   return Boolean(stream && stream.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env));
 }
 
-// ../../../node_modules/ora/node_modules/is-unicode-supported/index.js
+// ../../../node_modules/stdin-discarder/index.js
 var import_node_process4 = __toModule(require("node:process"));
-function isUnicodeSupported2() {
-  if (import_node_process4.default.platform !== "win32") {
-    return import_node_process4.default.env.TERM !== "linux";
-  }
-  return Boolean(import_node_process4.default.env.CI) || Boolean(import_node_process4.default.env.WT_SESSION) || Boolean(import_node_process4.default.env.TERMINUS_SUBLIME) || import_node_process4.default.env.ConEmuTask === "{cmd::Cmder}" || import_node_process4.default.env.TERM_PROGRAM === "Terminus-Sublime" || import_node_process4.default.env.TERM_PROGRAM === "vscode" || import_node_process4.default.env.TERM === "xterm-256color" || import_node_process4.default.env.TERM === "alacritty" || import_node_process4.default.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
-}
-
-// ../../../node_modules/ora/utilities.js
-var import_node_process5 = __toModule(require("node:process"));
 var import_node_readline = __toModule(require("node:readline"));
 var import_bl = __toModule(require_bl());
 var ASCII_ETX_CODE = 3;
@@ -27025,20 +26933,20 @@ var StdinDiscarder = class {
   #ourEmit;
   #rl;
   constructor() {
-    this.#mutedStream.pipe(import_node_process5.default.stdout);
-    const self = this;
-    this.#ourEmit = function(event, data, ...args2) {
-      const { stdin } = import_node_process5.default;
-      if (self.#requests > 0 || stdin.emit === self.#ourEmit) {
+    this.#mutedStream.pipe(import_node_process4.default.stdout);
+    const self2 = this;
+    this.#ourEmit = function(event, data, ...arguments_) {
+      const { stdin } = import_node_process4.default;
+      if (self2.#requests > 0 || stdin.emit === self2.#ourEmit) {
         if (event === "keypress") {
           return;
         }
         if (event === "data" && data.includes(ASCII_ETX_CODE)) {
-          import_node_process5.default.emit("SIGINT");
+          import_node_process4.default.emit("SIGINT");
         }
-        Reflect.apply(self.#ourEmit, this, [event, data, ...args2]);
+        Reflect.apply(self2.#ourEmit, this, [event, data, ...arguments_]);
       } else {
-        Reflect.apply(import_node_process5.default.stdin.emit, this, [event, data, ...args2]);
+        Reflect.apply(import_node_process4.default.stdin.emit, this, [event, data, ...arguments_]);
       }
     };
   }
@@ -27058,33 +26966,35 @@ var StdinDiscarder = class {
     }
   }
   _realStart() {
-    if (import_node_process5.default.platform === "win32") {
+    if (import_node_process4.default.platform === "win32") {
       return;
     }
     this.#rl = import_node_readline.default.createInterface({
-      input: import_node_process5.default.stdin,
+      input: import_node_process4.default.stdin,
       output: this.#mutedStream
     });
     this.#rl.on("SIGINT", () => {
-      if (import_node_process5.default.listenerCount("SIGINT") === 0) {
-        import_node_process5.default.emit("SIGINT");
+      if (import_node_process4.default.listenerCount("SIGINT") === 0) {
+        import_node_process4.default.emit("SIGINT");
       } else {
         this.#rl.close();
-        import_node_process5.default.kill(import_node_process5.default.pid, "SIGINT");
+        import_node_process4.default.kill(import_node_process4.default.pid, "SIGINT");
       }
     });
   }
   _realStop() {
-    if (import_node_process5.default.platform === "win32") {
+    if (import_node_process4.default.platform === "win32") {
       return;
     }
     this.#rl.close();
     this.#rl = void 0;
   }
 };
+var stdinDiscarder = new StdinDiscarder();
+var stdin_discarder_default = stdinDiscarder;
 
-// ../../../node_modules/ora/index.js
-var stdinDiscarder;
+// node_modules/ora/index.js
+var import_cli_spinners2 = __toModule(require_cli_spinners());
 var Ora = class {
   #linesToClear = 0;
   #isDiscardingStdin = false;
@@ -27100,11 +27010,9 @@ var Ora = class {
   #indent;
   #text;
   #prefixText;
+  #suffixText;
   color;
   constructor(options) {
-    if (!stdinDiscarder) {
-      stdinDiscarder = new StdinDiscarder();
-    }
     if (typeof options === "string") {
       options = {
         text: options
@@ -27112,7 +27020,7 @@ var Ora = class {
     }
     this.#options = {
       color: "cyan",
-      stream: import_node_process6.default.stderr,
+      stream: import_node_process5.default.stderr,
       discardStdin: true,
       hideCursor: true,
       ...options
@@ -27125,8 +27033,9 @@ var Ora = class {
     this.#isSilent = typeof this.#options.isSilent === "boolean" ? this.#options.isSilent : false;
     this.text = this.#options.text;
     this.prefixText = this.#options.prefixText;
+    this.suffixText = this.#options.suffixText;
     this.indent = this.#options.indent;
-    if (import_node_process6.default.env.NODE_ENV === "test") {
+    if (import_node_process5.default.env.NODE_ENV === "test") {
       this._stream = this.#stream;
       this._isEnabled = this.#isEnabled;
       Object.defineProperty(this, "_linesToClear", {
@@ -27173,7 +27082,7 @@ var Ora = class {
         throw new Error("The given spinner must have a `frames` property");
       }
       this.#spinner = spinner;
-    } else if (!isUnicodeSupported2()) {
+    } else if (!isUnicodeSupported()) {
       this.#spinner = import_cli_spinners.default.line;
     } else if (spinner === void 0) {
       this.#spinner = import_cli_spinners.default.dots;
@@ -27197,6 +27106,13 @@ var Ora = class {
     this.#prefixText = value || "";
     this.updateLineCount();
   }
+  get suffixText() {
+    return this.#suffixText;
+  }
+  set suffixText(value) {
+    this.#suffixText = value || "";
+    this.updateLineCount();
+  }
   get isSpinning() {
     return this.#id !== void 0;
   }
@@ -27209,11 +27125,22 @@ var Ora = class {
     }
     return "";
   }
+  getFullSuffixText(suffixText = this.#suffixText, prefix = " ") {
+    if (typeof suffixText === "string" && suffixText !== "") {
+      return prefix + suffixText;
+    }
+    if (typeof suffixText === "function") {
+      return prefix + suffixText();
+    }
+    return "";
+  }
   updateLineCount() {
     const columns = this.#stream.columns || 80;
     const fullPrefixText = this.getFullPrefixText(this.#prefixText, "-");
+    const fullSuffixText = this.getFullSuffixText(this.#suffixText, "-");
+    const fullText = " ".repeat(this.#indent) + fullPrefixText + "--" + this.#text + "--" + fullSuffixText;
     this.#lineCount = 0;
-    for (const line of stripAnsi(" ".repeat(this.#indent) + fullPrefixText + "--" + this.#text).split("\n")) {
+    for (const line of stripAnsi(fullText).split("\n")) {
       this.#lineCount += Math.max(1, Math.ceil((0, import_wcwidth.default)(line) / columns));
     }
   }
@@ -27244,7 +27171,8 @@ var Ora = class {
     this.#frameIndex = ++this.#frameIndex % frames.length;
     const fullPrefixText = typeof this.#prefixText === "string" && this.#prefixText !== "" ? this.#prefixText + " " : "";
     const fullText = typeof this.text === "string" ? " " + this.text : "";
-    return fullPrefixText + frame + fullText;
+    const fullSuffixText = typeof this.#suffixText === "string" && this.#suffixText !== "" ? " " + this.#suffixText : "";
+    return fullPrefixText + frame + fullText + fullSuffixText;
   }
   clear() {
     if (!this.#isEnabled || !this.#stream.isTTY) {
@@ -27293,9 +27221,9 @@ var Ora = class {
     if (this.#options.hideCursor) {
       cli_cursor_default.hide(this.#stream);
     }
-    if (this.#options.discardStdin && import_node_process6.default.stdin.isTTY) {
+    if (this.#options.discardStdin && import_node_process5.default.stdin.isTTY) {
       this.#isDiscardingStdin = true;
-      stdinDiscarder.start();
+      stdin_discarder_default.start();
     }
     this.render();
     this.#id = setInterval(this.render.bind(this), this.interval);
@@ -27312,8 +27240,8 @@ var Ora = class {
     if (this.#options.hideCursor) {
       cli_cursor_default.show(this.#stream);
     }
-    if (this.#options.discardStdin && import_node_process6.default.stdin.isTTY && this.#isDiscardingStdin) {
-      stdinDiscarder.stop();
+    if (this.#options.discardStdin && import_node_process5.default.stdin.isTTY && this.#isDiscardingStdin) {
+      stdin_discarder_default.stop();
       this.#isDiscardingStdin = false;
     }
     return this;
@@ -27335,11 +27263,15 @@ var Ora = class {
       return this;
     }
     const prefixText = options.prefixText || this.#prefixText;
+    const fullPrefixText = this.getFullPrefixText(prefixText, " ");
+    const symbolText = options.symbol || " ";
     const text = options.text || this.text;
     const fullText = typeof text === "string" ? " " + text : "";
+    const suffixText = options.suffixText !== void 0 ? options.suffixText : this.#suffixText;
+    const fullSuffixText = this.getFullSuffixText(suffixText, " ");
+    const textToWrite = fullPrefixText + symbolText + fullText + fullSuffixText + "\n";
     this.stop();
-    this.#stream.write(`${this.getFullPrefixText(prefixText, " ")}${options.symbol || " "}${fullText}
-`);
+    this.#stream.write(textToWrite);
     return this;
   }
 };
@@ -27701,8 +27633,8 @@ function createPackage(target = ".", ...flags) {
     return ms.value;
   });
 }
-function onlyUnique(value, index, self) {
-  return self.indexOf(value) === index;
+function onlyUnique(value, index, self2) {
+  return self2.indexOf(value) === index;
 }
 function isFile(item) {
   if (!item || typeof item !== "string") {