@requence/task 1.0.0-alpha.5 → 1.0.0-alpha.51

package/build/cli.js

@@ -1,4876 +1,15 @@
 #!/usr/bin/env node
 import {
-  __require,
   deobfuscate
-} from "./chunk-6pjtq0hg.js";
+} from "./chunk-b4h2we9a.js";
 
 // src/cli.ts
 import fs from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-
-// ../../node_modules/yargs/lib/platform-shims/esm.mjs
-import { notStrictEqual, strictEqual } from "assert";
-
-// ../../node_modules/cliui/build/lib/index.js
-var align = {
-  right: alignRight,
-  center: alignCenter
-};
-var top = 0;
-var right = 1;
-var bottom = 2;
-var left = 3;
-
-class UI {
-  constructor(opts) {
-    var _a;
-    this.width = opts.width;
-    this.wrap = (_a = opts.wrap) !== null && _a !== undefined ? _a : true;
-    this.rows = [];
-  }
-  span(...args) {
-    const cols = this.div(...args);
-    cols.span = true;
-  }
-  resetOutput() {
-    this.rows = [];
-  }
-  div(...args) {
-    if (args.length === 0) {
-      this.div("");
-    }
-    if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === "string") {
-      return this.applyLayoutDSL(args[0]);
-    }
-    const cols = args.map((arg) => {
-      if (typeof arg === "string") {
-        return this.colFromString(arg);
-      }
-      return arg;
-    });
-    this.rows.push(cols);
-    return cols;
-  }
-  shouldApplyLayoutDSL(...args) {
-    return args.length === 1 && typeof args[0] === "string" && /[\t\n]/.test(args[0]);
-  }
-  applyLayoutDSL(str) {
-    const rows = str.split(`
-`).map((row) => row.split("\t"));
-    let leftColumnWidth = 0;
-    rows.forEach((columns) => {
-      if (columns.length > 1 && mixin.stringWidth(columns[0]) > leftColumnWidth) {
-        leftColumnWidth = Math.min(Math.floor(this.width * 0.5), mixin.stringWidth(columns[0]));
-      }
-    });
-    rows.forEach((columns) => {
-      this.div(...columns.map((r, i) => {
-        return {
-          text: r.trim(),
-          padding: this.measurePadding(r),
-          width: i === 0 && columns.length > 1 ? leftColumnWidth : undefined
-        };
-      }));
-    });
-    return this.rows[this.rows.length - 1];
-  }
-  colFromString(text) {
-    return {
-      text,
-      padding: this.measurePadding(text)
-    };
-  }
-  measurePadding(str) {
-    const noAnsi = mixin.stripAnsi(str);
-    return [0, noAnsi.match(/\s*$/)[0].length, 0, noAnsi.match(/^\s*/)[0].length];
-  }
-  toString() {
-    const lines = [];
-    this.rows.forEach((row) => {
-      this.rowToString(row, lines);
-    });
-    return lines.filter((line) => !line.hidden).map((line) => line.text).join(`
-`);
-  }
-  rowToString(row, lines) {
-    this.rasterize(row).forEach((rrow, r) => {
-      let str = "";
-      rrow.forEach((col, c) => {
-        const { width } = row[c];
-        const wrapWidth = this.negatePadding(row[c]);
-        let ts = col;
-        if (wrapWidth > mixin.stringWidth(col)) {
-          ts += " ".repeat(wrapWidth - mixin.stringWidth(col));
-        }
-        if (row[c].align && row[c].align !== "left" && this.wrap) {
-          const fn = align[row[c].align];
-          ts = fn(ts, wrapWidth);
-          if (mixin.stringWidth(ts) < wrapWidth) {
-            ts += " ".repeat((width || 0) - mixin.stringWidth(ts) - 1);
-          }
-        }
-        const padding = row[c].padding || [0, 0, 0, 0];
-        if (padding[left]) {
-          str += " ".repeat(padding[left]);
-        }
-        str += addBorder(row[c], ts, "| ");
-        str += ts;
-        str += addBorder(row[c], ts, " |");
-        if (padding[right]) {
-          str += " ".repeat(padding[right]);
-        }
-        if (r === 0 && lines.length > 0) {
-          str = this.renderInline(str, lines[lines.length - 1]);
-        }
-      });
-      lines.push({
-        text: str.replace(/ +$/, ""),
-        span: row.span
-      });
-    });
-    return lines;
-  }
-  renderInline(source, previousLine) {
-    const match = source.match(/^ */);
-    const leadingWhitespace = match ? match[0].length : 0;
-    const target = previousLine.text;
-    const targetTextWidth = mixin.stringWidth(target.trimRight());
-    if (!previousLine.span) {
-      return source;
-    }
-    if (!this.wrap) {
-      previousLine.hidden = true;
-      return target + source;
-    }
-    if (leadingWhitespace < targetTextWidth) {
-      return source;
-    }
-    previousLine.hidden = true;
-    return target.trimRight() + " ".repeat(leadingWhitespace - targetTextWidth) + source.trimLeft();
-  }
-  rasterize(row) {
-    const rrows = [];
-    const widths = this.columnWidths(row);
-    let wrapped;
-    row.forEach((col, c) => {
-      col.width = widths[c];
-      if (this.wrap) {
-        wrapped = mixin.wrap(col.text, this.negatePadding(col), { hard: true }).split(`
-`);
-      } else {
-        wrapped = col.text.split(`
-`);
-      }
-      if (col.border) {
-        wrapped.unshift("." + "-".repeat(this.negatePadding(col) + 2) + ".");
-        wrapped.push("'" + "-".repeat(this.negatePadding(col) + 2) + "'");
-      }
-      if (col.padding) {
-        wrapped.unshift(...new Array(col.padding[top] || 0).fill(""));
-        wrapped.push(...new Array(col.padding[bottom] || 0).fill(""));
-      }
-      wrapped.forEach((str, r) => {
-        if (!rrows[r]) {
-          rrows.push([]);
-        }
-        const rrow = rrows[r];
-        for (let i = 0;i < c; i++) {
-          if (rrow[i] === undefined) {
-            rrow.push("");
-          }
-        }
-        rrow.push(str);
-      });
-    });
-    return rrows;
-  }
-  negatePadding(col) {
-    let wrapWidth = col.width || 0;
-    if (col.padding) {
-      wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);
-    }
-    if (col.border) {
-      wrapWidth -= 4;
-    }
-    return wrapWidth;
-  }
-  columnWidths(row) {
-    if (!this.wrap) {
-      return row.map((col) => {
-        return col.width || mixin.stringWidth(col.text);
-      });
-    }
-    let unset = row.length;
-    let remainingWidth = this.width;
-    const widths = row.map((col) => {
-      if (col.width) {
-        unset--;
-        remainingWidth -= col.width;
-        return col.width;
-      }
-      return;
-    });
-    const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;
-    return widths.map((w, i) => {
-      if (w === undefined) {
-        return Math.max(unsetWidth, _minWidth(row[i]));
-      }
-      return w;
-    });
-  }
-}
-function addBorder(col, ts, style) {
-  if (col.border) {
-    if (/[.']-+[.']/.test(ts)) {
-      return "";
-    }
-    if (ts.trim().length !== 0) {
-      return style;
-    }
-    return "  ";
-  }
-  return "";
-}
-function _minWidth(col) {
-  const padding = col.padding || [];
-  const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);
-  if (col.border) {
-    return minWidth + 4;
-  }
-  return minWidth;
-}
-function getWindowWidth() {
-  if (typeof process === "object" && process.stdout && process.stdout.columns) {
-    return process.stdout.columns;
-  }
-  return 80;
-}
-function alignRight(str, width) {
-  str = str.trim();
-  const strWidth = mixin.stringWidth(str);
-  if (strWidth < width) {
-    return " ".repeat(width - strWidth) + str;
-  }
-  return str;
-}
-function alignCenter(str, width) {
-  str = str.trim();
-  const strWidth = mixin.stringWidth(str);
-  if (strWidth >= width) {
-    return str;
-  }
-  return " ".repeat(width - strWidth >> 1) + str;
-}
-var mixin;
-function cliui(opts, _mixin) {
-  mixin = _mixin;
-  return new UI({
-    width: (opts === null || opts === undefined ? undefined : opts.width) || getWindowWidth(),
-    wrap: opts === null || opts === undefined ? undefined : opts.wrap
-  });
-}
-
-// ../../node_modules/cliui/build/lib/string-utils.js
-var ansi = new RegExp("\x1B(?:\\[(?:\\d+[ABCDEFGJKSTm]|\\d+;\\d+[Hfm]|" + "\\d+;\\d+;\\d+m|6n|s|u|\\?25[lh])|\\w)", "g");
-function stripAnsi(str) {
-  return str.replace(ansi, "");
-}
-function wrap(str, width) {
-  const [start, end] = str.match(ansi) || ["", ""];
-  str = stripAnsi(str);
-  let wrapped = "";
-  for (let i = 0;i < str.length; i++) {
-    if (i !== 0 && i % width === 0) {
-      wrapped += `
-`;
-    }
-    wrapped += str.charAt(i);
-  }
-  if (start && end) {
-    wrapped = `${start}${wrapped}${end}`;
-  }
-  return wrapped;
-}
-
-// ../../node_modules/cliui/index.mjs
-function ui(opts) {
-  return cliui(opts, {
-    stringWidth: (str) => {
-      return [...str].length;
-    },
-    stripAnsi,
-    wrap
-  });
-}
-
-// ../../node_modules/escalade/sync/index.mjs
-import { dirname, resolve } from "path";
-import { readdirSync, statSync } from "fs";
-function sync_default(start, callback) {
-  let dir = resolve(".", start);
-  let tmp, stats = statSync(dir);
-  if (!stats.isDirectory()) {
-    dir = dirname(dir);
-  }
-  while (true) {
-    tmp = callback(dir, readdirSync(dir));
-    if (tmp)
-      return resolve(dir, tmp);
-    dir = dirname(tmp = dir);
-    if (tmp === dir)
-      break;
-  }
-}
-
-// ../../node_modules/yargs/lib/platform-shims/esm.mjs
-import { inspect } from "util";
-import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath } from "url";
-
-// ../../node_modules/yargs-parser/build/lib/index.js
-import { format } from "util";
-import { normalize, resolve as resolve2 } from "path";
-
-// ../../node_modules/yargs-parser/build/lib/string-utils.js
-function camelCase(str) {
-  const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
-  if (!isCamelCase) {
-    str = str.toLowerCase();
-  }
-  if (str.indexOf("-") === -1 && str.indexOf("_") === -1) {
-    return str;
-  } else {
-    let camelcase = "";
-    let nextChrUpper = false;
-    const leadingHyphens = str.match(/^-+/);
-    for (let i = leadingHyphens ? leadingHyphens[0].length : 0;i < str.length; i++) {
-      let chr = str.charAt(i);
-      if (nextChrUpper) {
-        nextChrUpper = false;
-        chr = chr.toUpperCase();
-      }
-      if (i !== 0 && (chr === "-" || chr === "_")) {
-        nextChrUpper = true;
-      } else if (chr !== "-" && chr !== "_") {
-        camelcase += chr;
-      }
-    }
-    return camelcase;
-  }
-}
-function decamelize(str, joinString) {
-  const lowercase = str.toLowerCase();
-  joinString = joinString || "-";
-  let notCamelcase = "";
-  for (let i = 0;i < str.length; i++) {
-    const chrLower = lowercase.charAt(i);
-    const chrString = str.charAt(i);
-    if (chrLower !== chrString && i > 0) {
-      notCamelcase += `${joinString}${lowercase.charAt(i)}`;
-    } else {
-      notCamelcase += chrString;
-    }
-  }
-  return notCamelcase;
-}
-function looksLikeNumber(x) {
-  if (x === null || x === undefined)
-    return false;
-  if (typeof x === "number")
-    return true;
-  if (/^0x[0-9a-f]+$/i.test(x))
-    return true;
-  if (/^0[^.]/.test(x))
-    return false;
-  return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
-}
-
-// ../../node_modules/yargs-parser/build/lib/tokenize-arg-string.js
-function tokenizeArgString(argString) {
-  if (Array.isArray(argString)) {
-    return argString.map((e) => typeof e !== "string" ? e + "" : e);
-  }
-  argString = argString.trim();
-  let i = 0;
-  let prevC = null;
-  let c = null;
-  let opening = null;
-  const args = [];
-  for (let ii = 0;ii < argString.length; ii++) {
-    prevC = c;
-    c = argString.charAt(ii);
-    if (c === " " && !opening) {
-      if (!(prevC === " ")) {
-        i++;
-      }
-      continue;
-    }
-    if (c === opening) {
-      opening = null;
-    } else if ((c === "'" || c === '"') && !opening) {
-      opening = c;
-    }
-    if (!args[i])
-      args[i] = "";
-    args[i] += c;
-  }
-  return args;
-}
-
-// ../../node_modules/yargs-parser/build/lib/yargs-parser-types.js
-var DefaultValuesForTypeKey;
-(function(DefaultValuesForTypeKey2) {
-  DefaultValuesForTypeKey2["BOOLEAN"] = "boolean";
-  DefaultValuesForTypeKey2["STRING"] = "string";
-  DefaultValuesForTypeKey2["NUMBER"] = "number";
-  DefaultValuesForTypeKey2["ARRAY"] = "array";
-})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
-
-// ../../node_modules/yargs-parser/build/lib/yargs-parser.js
-var mixin2;
-
-class YargsParser {
-  constructor(_mixin) {
-    mixin2 = _mixin;
-  }
-  parse(argsInput, options) {
-    const opts = Object.assign({
-      alias: undefined,
-      array: undefined,
-      boolean: undefined,
-      config: undefined,
-      configObjects: undefined,
-      configuration: undefined,
-      coerce: undefined,
-      count: undefined,
-      default: undefined,
-      envPrefix: undefined,
-      narg: undefined,
-      normalize: undefined,
-      string: undefined,
-      number: undefined,
-      __: undefined,
-      key: undefined
-    }, options);
-    const args = tokenizeArgString(argsInput);
-    const inputIsString = typeof argsInput === "string";
-    const aliases = combineAliases(Object.assign(Object.create(null), opts.alias));
-    const configuration = Object.assign({
-      "boolean-negation": true,
-      "camel-case-expansion": true,
-      "combine-arrays": false,
-      "dot-notation": true,
-      "duplicate-arguments-array": true,
-      "flatten-duplicate-arrays": true,
-      "greedy-arrays": true,
-      "halt-at-non-option": false,
-      "nargs-eats-options": false,
-      "negation-prefix": "no-",
-      "parse-numbers": true,
-      "parse-positional-numbers": true,
-      "populate--": false,
-      "set-placeholder-key": false,
-      "short-option-groups": true,
-      "strip-aliased": false,
-      "strip-dashed": false,
-      "unknown-options-as-args": false
-    }, opts.configuration);
-    const defaults = Object.assign(Object.create(null), opts.default);
-    const configObjects = opts.configObjects || [];
-    const envPrefix = opts.envPrefix;
-    const notFlagsOption = configuration["populate--"];
-    const notFlagsArgv = notFlagsOption ? "--" : "_";
-    const newAliases = Object.create(null);
-    const defaulted = Object.create(null);
-    const __ = opts.__ || mixin2.format;
-    const flags = {
-      aliases: Object.create(null),
-      arrays: Object.create(null),
-      bools: Object.create(null),
-      strings: Object.create(null),
-      numbers: Object.create(null),
-      counts: Object.create(null),
-      normalize: Object.create(null),
-      configs: Object.create(null),
-      nargs: Object.create(null),
-      coercions: Object.create(null),
-      keys: []
-    };
-    const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
-    const negatedBoolean = new RegExp("^--" + configuration["negation-prefix"] + "(.+)");
-    [].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
-      const key = typeof opt === "object" ? opt.key : opt;
-      const assignment = Object.keys(opt).map(function(key2) {
-        const arrayFlagKeys = {
-          boolean: "bools",
-          string: "strings",
-          number: "numbers"
-        };
-        return arrayFlagKeys[key2];
-      }).filter(Boolean).pop();
-      if (assignment) {
-        flags[assignment][key] = true;
-      }
-      flags.arrays[key] = true;
-      flags.keys.push(key);
-    });
-    [].concat(opts.boolean || []).filter(Boolean).forEach(function(key) {
-      flags.bools[key] = true;
-      flags.keys.push(key);
-    });
-    [].concat(opts.string || []).filter(Boolean).forEach(function(key) {
-      flags.strings[key] = true;
-      flags.keys.push(key);
-    });
-    [].concat(opts.number || []).filter(Boolean).forEach(function(key) {
-      flags.numbers[key] = true;
-      flags.keys.push(key);
-    });
-    [].concat(opts.count || []).filter(Boolean).forEach(function(key) {
-      flags.counts[key] = true;
-      flags.keys.push(key);
-    });
-    [].concat(opts.normalize || []).filter(Boolean).forEach(function(key) {
-      flags.normalize[key] = true;
-      flags.keys.push(key);
-    });
-    if (typeof opts.narg === "object") {
-      Object.entries(opts.narg).forEach(([key, value]) => {
-        if (typeof value === "number") {
-          flags.nargs[key] = value;
-          flags.keys.push(key);
-        }
-      });
-    }
-    if (typeof opts.coerce === "object") {
-      Object.entries(opts.coerce).forEach(([key, value]) => {
-        if (typeof value === "function") {
-          flags.coercions[key] = value;
-          flags.keys.push(key);
-        }
-      });
-    }
-    if (typeof opts.config !== "undefined") {
-      if (Array.isArray(opts.config) || typeof opts.config === "string") {
-        [].concat(opts.config).filter(Boolean).forEach(function(key) {
-          flags.configs[key] = true;
-        });
-      } else if (typeof opts.config === "object") {
-        Object.entries(opts.config).forEach(([key, value]) => {
-          if (typeof value === "boolean" || typeof value === "function") {
-            flags.configs[key] = value;
-          }
-        });
-      }
-    }
-    extendAliases(opts.key, aliases, opts.default, flags.arrays);
-    Object.keys(defaults).forEach(function(key) {
-      (flags.aliases[key] || []).forEach(function(alias) {
-        defaults[alias] = defaults[key];
-      });
-    });
-    let error = null;
-    checkConfiguration();
-    let notFlags = [];
-    const argv = Object.assign(Object.create(null), { _: [] });
-    const argvReturn = {};
-    for (let i = 0;i < args.length; i++) {
-      const arg = args[i];
-      const truncatedArg = arg.replace(/^-{3,}/, "---");
-      let broken;
-      let key;
-      let letters;
-      let m;
-      let next;
-      let value;
-      if (arg !== "--" && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {
-        pushPositional(arg);
-      } else if (truncatedArg.match(/^---+(=|$)/)) {
-        pushPositional(arg);
-        continue;
-      } else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
-        m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
-        if (m !== null && Array.isArray(m) && m.length >= 3) {
-          if (checkAllAliases(m[1], flags.arrays)) {
-            i = eatArray(i, m[1], args, m[2]);
-          } else if (checkAllAliases(m[1], flags.nargs) !== false) {
-            i = eatNargs(i, m[1], args, m[2]);
-          } else {
-            setArg(m[1], m[2], true);
-          }
-        }
-      } else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
-        m = arg.match(negatedBoolean);
-        if (m !== null && Array.isArray(m) && m.length >= 2) {
-          key = m[1];
-          setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
-        }
-      } else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
-        m = arg.match(/^--?(.+)/);
-        if (m !== null && Array.isArray(m) && m.length >= 2) {
-          key = m[1];
-          if (checkAllAliases(key, flags.arrays)) {
-            i = eatArray(i, key, args);
-          } else if (checkAllAliases(key, flags.nargs) !== false) {
-            i = eatNargs(i, key, args);
-          } else {
-            next = args[i + 1];
-            if (next !== undefined && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
-              setArg(key, next);
-              i++;
-            } else if (/^(true|false)$/.test(next)) {
-              setArg(key, next);
-              i++;
-            } else {
-              setArg(key, defaultValue(key));
-            }
-          }
-        }
-      } else if (arg.match(/^-.\..+=/)) {
-        m = arg.match(/^-([^=]+)=([\s\S]*)$/);
-        if (m !== null && Array.isArray(m) && m.length >= 3) {
-          setArg(m[1], m[2]);
-        }
-      } else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
-        next = args[i + 1];
-        m = arg.match(/^-(.\..+)/);
-        if (m !== null && Array.isArray(m) && m.length >= 2) {
-          key = m[1];
-          if (next !== undefined && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
-            setArg(key, next);
-            i++;
-          } else {
-            setArg(key, defaultValue(key));
-          }
-        }
-      } else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
-        letters = arg.slice(1, -1).split("");
-        broken = false;
-        for (let j = 0;j < letters.length; j++) {
-          next = arg.slice(j + 2);
-          if (letters[j + 1] && letters[j + 1] === "=") {
-            value = arg.slice(j + 3);
-            key = letters[j];
-            if (checkAllAliases(key, flags.arrays)) {
-              i = eatArray(i, key, args, value);
-            } else if (checkAllAliases(key, flags.nargs) !== false) {
-              i = eatNargs(i, key, args, value);
-            } else {
-              setArg(key, value);
-            }
-            broken = true;
-            break;
-          }
-          if (next === "-") {
-            setArg(letters[j], next);
-            continue;
-          }
-          if (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags.bools) === false) {
-            setArg(letters[j], next);
-            broken = true;
-            break;
-          }
-          if (letters[j + 1] && letters[j + 1].match(/\W/)) {
-            setArg(letters[j], next);
-            broken = true;
-            break;
-          } else {
-            setArg(letters[j], defaultValue(letters[j]));
-          }
-        }
-        key = arg.slice(-1)[0];
-        if (!broken && key !== "-") {
-          if (checkAllAliases(key, flags.arrays)) {
-            i = eatArray(i, key, args);
-          } else if (checkAllAliases(key, flags.nargs) !== false) {
-            i = eatNargs(i, key, args);
-          } else {
-            next = args[i + 1];
-            if (next !== undefined && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
-              setArg(key, next);
-              i++;
-            } else if (/^(true|false)$/.test(next)) {
-              setArg(key, next);
-              i++;
-            } else {
-              setArg(key, defaultValue(key));
-            }
-          }
-        }
-      } else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
-        key = arg.slice(1);
-        setArg(key, defaultValue(key));
-      } else if (arg === "--") {
-        notFlags = args.slice(i + 1);
-        break;
-      } else if (configuration["halt-at-non-option"]) {
-        notFlags = args.slice(i);
-        break;
-      } else {
-        pushPositional(arg);
-      }
-    }
-    applyEnvVars(argv, true);
-    applyEnvVars(argv, false);
-    setConfig(argv);
-    setConfigObjects();
-    applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
-    applyCoercions(argv);
-    if (configuration["set-placeholder-key"])
-      setPlaceholderKeys(argv);
-    Object.keys(flags.counts).forEach(function(key) {
-      if (!hasKey(argv, key.split(".")))
-        setArg(key, 0);
-    });
-    if (notFlagsOption && notFlags.length)
-      argv[notFlagsArgv] = [];
-    notFlags.forEach(function(key) {
-      argv[notFlagsArgv].push(key);
-    });
-    if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) {
-      Object.keys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
-        delete argv[key];
-      });
-    }
-    if (configuration["strip-aliased"]) {
-      [].concat(...Object.keys(aliases).map((k) => aliases[k])).forEach((alias) => {
-        if (configuration["camel-case-expansion"] && alias.includes("-")) {
-          delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
-        }
-        delete argv[alias];
-      });
-    }
-    function pushPositional(arg) {
-      const maybeCoercedNumber = maybeCoerceNumber("_", arg);
-      if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") {
-        argv._.push(maybeCoercedNumber);
-      }
-    }
-    function eatNargs(i, key, args2, argAfterEqualSign) {
-      let ii;
-      let toEat = checkAllAliases(key, flags.nargs);
-      toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
-      if (toEat === 0) {
-        if (!isUndefined(argAfterEqualSign)) {
-          error = Error(__("Argument unexpected for: %s", key));
-        }
-        setArg(key, defaultValue(key));
-        return i;
-      }
-      let available = isUndefined(argAfterEqualSign) ? 0 : 1;
-      if (configuration["nargs-eats-options"]) {
-        if (args2.length - (i + 1) + available < toEat) {
-          error = Error(__("Not enough arguments following: %s", key));
-        }
-        available = toEat;
-      } else {
-        for (ii = i + 1;ii < args2.length; ii++) {
-          if (!args2[ii].match(/^-[^0-9]/) || args2[ii].match(negative) || isUnknownOptionAsArg(args2[ii]))
-            available++;
-          else
-            break;
-        }
-        if (available < toEat)
-          error = Error(__("Not enough arguments following: %s", key));
-      }
-      let consumed = Math.min(available, toEat);
-      if (!isUndefined(argAfterEqualSign) && consumed > 0) {
-        setArg(key, argAfterEqualSign);
-        consumed--;
-      }
-      for (ii = i + 1;ii < consumed + i + 1; ii++) {
-        setArg(key, args2[ii]);
-      }
-      return i + consumed;
-    }
-    function eatArray(i, key, args2, argAfterEqualSign) {
-      let argsToSet = [];
-      let next = argAfterEqualSign || args2[i + 1];
-      const nargsCount = checkAllAliases(key, flags.nargs);
-      if (checkAllAliases(key, flags.bools) && !/^(true|false)$/.test(next)) {
-        argsToSet.push(true);
-      } else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
-        if (defaults[key] !== undefined) {
-          const defVal = defaults[key];
-          argsToSet = Array.isArray(defVal) ? defVal : [defVal];
-        }
-      } else {
-        if (!isUndefined(argAfterEqualSign)) {
-          argsToSet.push(processValue(key, argAfterEqualSign, true));
-        }
-        for (let ii = i + 1;ii < args2.length; ii++) {
-          if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount)
-            break;
-          next = args2[ii];
-          if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
-            break;
-          i = ii;
-          argsToSet.push(processValue(key, next, inputIsString));
-        }
-      }
-      if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) {
-        error = Error(__("Not enough arguments following: %s", key));
-      }
-      setArg(key, argsToSet);
-      return i;
-    }
-    function setArg(key, val, shouldStripQuotes = inputIsString) {
-      if (/-/.test(key) && configuration["camel-case-expansion"]) {
-        const alias = key.split(".").map(function(prop) {
-          return camelCase(prop);
-        }).join(".");
-        addNewAlias(key, alias);
-      }
-      const value = processValue(key, val, shouldStripQuotes);
-      const splitKey = key.split(".");
-      setKey(argv, splitKey, value);
-      if (flags.aliases[key]) {
-        flags.aliases[key].forEach(function(x) {
-          const keyProperties = x.split(".");
-          setKey(argv, keyProperties, value);
-        });
-      }
-      if (splitKey.length > 1 && configuration["dot-notation"]) {
-        (flags.aliases[splitKey[0]] || []).forEach(function(x) {
-          let keyProperties = x.split(".");
-          const a = [].concat(splitKey);
-          a.shift();
-          keyProperties = keyProperties.concat(a);
-          if (!(flags.aliases[key] || []).includes(keyProperties.join("."))) {
-            setKey(argv, keyProperties, value);
-          }
-        });
-      }
-      if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
-        const keys = [key].concat(flags.aliases[key] || []);
-        keys.forEach(function(key2) {
-          Object.defineProperty(argvReturn, key2, {
-            enumerable: true,
-            get() {
-              return val;
-            },
-            set(value2) {
-              val = typeof value2 === "string" ? mixin2.normalize(value2) : value2;
-            }
-          });
-        });
-      }
-    }
-    function addNewAlias(key, alias) {
-      if (!(flags.aliases[key] && flags.aliases[key].length)) {
-        flags.aliases[key] = [alias];
-        newAliases[alias] = true;
-      }
-      if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
-        addNewAlias(alias, key);
-      }
-    }
-    function processValue(key, val, shouldStripQuotes) {
-      if (shouldStripQuotes) {
-        val = stripQuotes(val);
-      }
-      if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
-        if (typeof val === "string")
-          val = val === "true";
-      }
-      let value = Array.isArray(val) ? val.map(function(v) {
-        return maybeCoerceNumber(key, v);
-      }) : maybeCoerceNumber(key, val);
-      if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) {
-        value = increment();
-      }
-      if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
-        if (Array.isArray(val))
-          value = val.map((val2) => {
-            return mixin2.normalize(val2);
-          });
-        else
-          value = mixin2.normalize(val);
-      }
-      return value;
-    }
-    function maybeCoerceNumber(key, value) {
-      if (!configuration["parse-positional-numbers"] && key === "_")
-        return value;
-      if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
-        const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(parseFloat(`${value}`)));
-        if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags.numbers)) {
-          value = Number(value);
-        }
-      }
-      return value;
-    }
-    function setConfig(argv2) {
-      const configLookup = Object.create(null);
-      applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
-      Object.keys(flags.configs).forEach(function(configKey) {
-        const configPath = argv2[configKey] || configLookup[configKey];
-        if (configPath) {
-          try {
-            let config = null;
-            const resolvedConfigPath = mixin2.resolve(mixin2.cwd(), configPath);
-            const resolveConfig = flags.configs[configKey];
-            if (typeof resolveConfig === "function") {
-              try {
-                config = resolveConfig(resolvedConfigPath);
-              } catch (e) {
-                config = e;
-              }
-              if (config instanceof Error) {
-                error = config;
-                return;
-              }
-            } else {
-              config = mixin2.require(resolvedConfigPath);
-            }
-            setConfigObject(config);
-          } catch (ex) {
-            if (ex.name === "PermissionDenied")
-              error = ex;
-            else if (argv2[configKey])
-              error = Error(__("Invalid JSON config file: %s", configPath));
-          }
-        }
-      });
-    }
-    function setConfigObject(config, prev) {
-      Object.keys(config).forEach(function(key) {
-        const value = config[key];
-        const fullKey = prev ? prev + "." + key : key;
-        if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) {
-          setConfigObject(value, fullKey);
-        } else {
-          if (!hasKey(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) {
-            setArg(fullKey, value);
-          }
-        }
-      });
-    }
-    function setConfigObjects() {
-      if (typeof configObjects !== "undefined") {
-        configObjects.forEach(function(configObject) {
-          setConfigObject(configObject);
-        });
-      }
-    }
-    function applyEnvVars(argv2, configOnly) {
-      if (typeof envPrefix === "undefined")
-        return;
-      const prefix = typeof envPrefix === "string" ? envPrefix : "";
-      const env = mixin2.env();
-      Object.keys(env).forEach(function(envVar) {
-        if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
-          const keys = envVar.split("__").map(function(key, i) {
-            if (i === 0) {
-              key = key.substring(prefix.length);
-            }
-            return camelCase(key);
-          });
-          if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey(argv2, keys)) {
-            setArg(keys.join("."), env[envVar]);
-          }
-        }
-      });
-    }
-    function applyCoercions(argv2) {
-      let coerce;
-      const applied = new Set;
-      Object.keys(argv2).forEach(function(key) {
-        if (!applied.has(key)) {
-          coerce = checkAllAliases(key, flags.coercions);
-          if (typeof coerce === "function") {
-            try {
-              const value = maybeCoerceNumber(key, coerce(argv2[key]));
-              [].concat(flags.aliases[key] || [], key).forEach((ali) => {
-                applied.add(ali);
-                argv2[ali] = value;
-              });
-            } catch (err) {
-              error = err;
-            }
-          }
-        }
-      });
-    }
-    function setPlaceholderKeys(argv2) {
-      flags.keys.forEach((key) => {
-        if (~key.indexOf("."))
-          return;
-        if (typeof argv2[key] === "undefined")
-          argv2[key] = undefined;
-      });
-      return argv2;
-    }
-    function applyDefaultsAndAliases(obj, aliases2, defaults2, canLog = false) {
-      Object.keys(defaults2).forEach(function(key) {
-        if (!hasKey(obj, key.split("."))) {
-          setKey(obj, key.split("."), defaults2[key]);
-          if (canLog)
-            defaulted[key] = true;
-          (aliases2[key] || []).forEach(function(x) {
-            if (hasKey(obj, x.split(".")))
-              return;
-            setKey(obj, x.split("."), defaults2[key]);
-          });
-        }
-      });
-    }
-    function hasKey(obj, keys) {
-      let o = obj;
-      if (!configuration["dot-notation"])
-        keys = [keys.join(".")];
-      keys.slice(0, -1).forEach(function(key2) {
-        o = o[key2] || {};
-      });
-      const key = keys[keys.length - 1];
-      if (typeof o !== "object")
-        return false;
-      else
-        return key in o;
-    }
-    function setKey(obj, keys, value) {
-      let o = obj;
-      if (!configuration["dot-notation"])
-        keys = [keys.join(".")];
-      keys.slice(0, -1).forEach(function(key2) {
-        key2 = sanitizeKey(key2);
-        if (typeof o === "object" && o[key2] === undefined) {
-          o[key2] = {};
-        }
-        if (typeof o[key2] !== "object" || Array.isArray(o[key2])) {
-          if (Array.isArray(o[key2])) {
-            o[key2].push({});
-          } else {
-            o[key2] = [o[key2], {}];
-          }
-          o = o[key2][o[key2].length - 1];
-        } else {
-          o = o[key2];
-        }
-      });
-      const key = sanitizeKey(keys[keys.length - 1]);
-      const isTypeArray = checkAllAliases(keys.join("."), flags.arrays);
-      const isValueArray = Array.isArray(value);
-      let duplicate = configuration["duplicate-arguments-array"];
-      if (!duplicate && checkAllAliases(key, flags.nargs)) {
-        duplicate = true;
-        if (!isUndefined(o[key]) && flags.nargs[key] === 1 || Array.isArray(o[key]) && o[key].length === flags.nargs[key]) {
-          o[key] = undefined;
-        }
-      }
-      if (value === increment()) {
-        o[key] = increment(o[key]);
-      } else if (Array.isArray(o[key])) {
-        if (duplicate && isTypeArray && isValueArray) {
-          o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
-        } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
-          o[key] = value;
-        } else {
-          o[key] = o[key].concat([value]);
-        }
-      } else if (o[key] === undefined && isTypeArray) {
-        o[key] = isValueArray ? value : [value];
-      } else if (duplicate && !(o[key] === undefined || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) {
-        o[key] = [o[key], value];
-      } else {
-        o[key] = value;
-      }
-    }
-    function extendAliases(...args2) {
-      args2.forEach(function(obj) {
-        Object.keys(obj || {}).forEach(function(key) {
-          if (flags.aliases[key])
-            return;
-          flags.aliases[key] = [].concat(aliases[key] || []);
-          flags.aliases[key].concat(key).forEach(function(x) {
-            if (/-/.test(x) && configuration["camel-case-expansion"]) {
-              const c = camelCase(x);
-              if (c !== key && flags.aliases[key].indexOf(c) === -1) {
-                flags.aliases[key].push(c);
-                newAliases[c] = true;
-              }
-            }
-          });
-          flags.aliases[key].concat(key).forEach(function(x) {
-            if (x.length > 1 && /[A-Z]/.test(x) && configuration["camel-case-expansion"]) {
-              const c = decamelize(x, "-");
-              if (c !== key && flags.aliases[key].indexOf(c) === -1) {
-                flags.aliases[key].push(c);
-                newAliases[c] = true;
-              }
-            }
-          });
-          flags.aliases[key].forEach(function(x) {
-            flags.aliases[x] = [key].concat(flags.aliases[key].filter(function(y) {
-              return x !== y;
-            }));
-          });
-        });
-      });
-    }
-    function checkAllAliases(key, flag) {
-      const toCheck = [].concat(flags.aliases[key] || [], key);
-      const keys = Object.keys(flag);
-      const setAlias = toCheck.find((key2) => keys.includes(key2));
-      return setAlias ? flag[setAlias] : false;
-    }
-    function hasAnyFlag(key) {
-      const flagsKeys = Object.keys(flags);
-      const toCheck = [].concat(flagsKeys.map((k) => flags[k]));
-      return toCheck.some(function(flag) {
-        return Array.isArray(flag) ? flag.includes(key) : flag[key];
-      });
-    }
-    function hasFlagsMatching(arg, ...patterns) {
-      const toCheck = [].concat(...patterns);
-      return toCheck.some(function(pattern) {
-        const match = arg.match(pattern);
-        return match && hasAnyFlag(match[1]);
-      });
-    }
-    function hasAllShortFlags(arg) {
-      if (arg.match(negative) || !arg.match(/^-[^-]+/)) {
-        return false;
-      }
-      let hasAllFlags = true;
-      let next;
-      const letters = arg.slice(1).split("");
-      for (let j = 0;j < letters.length; j++) {
-        next = arg.slice(j + 2);
-        if (!hasAnyFlag(letters[j])) {
-          hasAllFlags = false;
-          break;
-        }
-        if (letters[j + 1] && letters[j + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j + 1] && letters[j + 1].match(/\W/)) {
-          break;
-        }
-      }
-      return hasAllFlags;
-    }
-    function isUnknownOptionAsArg(arg) {
-      return configuration["unknown-options-as-args"] && isUnknownOption(arg);
-    }
-    function isUnknownOption(arg) {
-      arg = arg.replace(/^-{3,}/, "--");
-      if (arg.match(negative)) {
-        return false;
-      }
-      if (hasAllShortFlags(arg)) {
-        return false;
-      }
-      const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/;
-      const normalFlag = /^-+([^=]+?)$/;
-      const flagEndingInHyphen = /^-+([^=]+?)-$/;
-      const flagEndingInDigits = /^-+([^=]+?\d+)$/;
-      const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/;
-      return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);
-    }
-    function defaultValue(key) {
-      if (!checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts) && `${key}` in defaults) {
-        return defaults[key];
-      } else {
-        return defaultForType(guessType(key));
-      }
-    }
-    function defaultForType(type) {
-      const def = {
-        [DefaultValuesForTypeKey.BOOLEAN]: true,
-        [DefaultValuesForTypeKey.STRING]: "",
-        [DefaultValuesForTypeKey.NUMBER]: undefined,
-        [DefaultValuesForTypeKey.ARRAY]: []
-      };
-      return def[type];
-    }
-    function guessType(key) {
-      let type = DefaultValuesForTypeKey.BOOLEAN;
-      if (checkAllAliases(key, flags.strings))
-        type = DefaultValuesForTypeKey.STRING;
-      else if (checkAllAliases(key, flags.numbers))
-        type = DefaultValuesForTypeKey.NUMBER;
-      else if (checkAllAliases(key, flags.bools))
-        type = DefaultValuesForTypeKey.BOOLEAN;
-      else if (checkAllAliases(key, flags.arrays))
-        type = DefaultValuesForTypeKey.ARRAY;
-      return type;
-    }
-    function isUndefined(num) {
-      return num === undefined;
-    }
-    function checkConfiguration() {
-      Object.keys(flags.counts).find((key) => {
-        if (checkAllAliases(key, flags.arrays)) {
-          error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
-          return true;
-        } else if (checkAllAliases(key, flags.nargs)) {
-          error = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
-          return true;
-        }
-        return false;
-      });
-    }
-    return {
-      aliases: Object.assign({}, flags.aliases),
-      argv: Object.assign(argvReturn, argv),
-      configuration,
-      defaulted: Object.assign({}, defaulted),
-      error,
-      newAliases: Object.assign({}, newAliases)
-    };
-  }
-}
-function combineAliases(aliases) {
-  const aliasArrays = [];
-  const combined = Object.create(null);
-  let change = true;
-  Object.keys(aliases).forEach(function(key) {
-    aliasArrays.push([].concat(aliases[key], key));
-  });
-  while (change) {
-    change = false;
-    for (let i = 0;i < aliasArrays.length; i++) {
-      for (let ii = i + 1;ii < aliasArrays.length; ii++) {
-        const intersect = aliasArrays[i].filter(function(v) {
-          return aliasArrays[ii].indexOf(v) !== -1;
-        });
-        if (intersect.length) {
-          aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
-          aliasArrays.splice(ii, 1);
-          change = true;
-          break;
-        }
-      }
-    }
-  }
-  aliasArrays.forEach(function(aliasArray) {
-    aliasArray = aliasArray.filter(function(v, i, self) {
-      return self.indexOf(v) === i;
-    });
-    const lastAlias = aliasArray.pop();
-    if (lastAlias !== undefined && typeof lastAlias === "string") {
-      combined[lastAlias] = aliasArray;
-    }
-  });
-  return combined;
-}
-function increment(orig) {
-  return orig !== undefined ? orig + 1 : 1;
-}
-function sanitizeKey(key) {
-  if (key === "__proto__")
-    return "___proto___";
-  return key;
-}
-function stripQuotes(val) {
-  return typeof val === "string" && (val[0] === "'" || val[0] === '"') && val[val.length - 1] === val[0] ? val.substring(1, val.length - 1) : val;
-}
-
-// ../../node_modules/yargs-parser/build/lib/index.js
-var _a;
-var _b;
-var _c;
-var minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 12;
-var nodeVersion = (_b = (_a = process === null || process === undefined ? undefined : process.versions) === null || _a === undefined ? undefined : _a.node) !== null && _b !== undefined ? _b : (_c = process === null || process === undefined ? undefined : process.version) === null || _c === undefined ? undefined : _c.slice(1);
-if (nodeVersion) {
-  const major = Number(nodeVersion.match(/^([^.]+)/)[1]);
-  if (major < minNodeVersion) {
-    throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
-  }
-}
-var env = process ? process.env : {};
-var parser = new YargsParser({
-  cwd: process.cwd,
-  env: () => {
-    return env;
-  },
-  format,
-  normalize,
-  resolve: resolve2,
-  require: (path) => {
-    if (true) {
-      return __require(path);
-    } else
-      ;
-  }
-});
-var yargsParser = function Parser(args, opts) {
-  const result = parser.parse(args.slice(), opts);
-  return result.argv;
-};
-yargsParser.detailed = function(args, opts) {
-  return parser.parse(args.slice(), opts);
-};
-yargsParser.camelCase = camelCase;
-yargsParser.decamelize = decamelize;
-yargsParser.looksLikeNumber = looksLikeNumber;
-var lib_default = yargsParser;
-
-// ../../node_modules/yargs/lib/platform-shims/esm.mjs
-import { basename, dirname as dirname2, extname, relative, resolve as resolve4 } from "path";
-
-// ../../node_modules/yargs/build/lib/utils/process-argv.js
-function getProcessArgvBinIndex() {
-  if (isBundledElectronApp())
-    return 0;
-  return 1;
-}
-function isBundledElectronApp() {
-  return isElectronApp() && !process.defaultApp;
-}
-function isElectronApp() {
-  return !!process.versions.electron;
-}
-function hideBin(argv) {
-  return argv.slice(getProcessArgvBinIndex() + 1);
-}
-function getProcessArgvBin() {
-  return process.argv[getProcessArgvBinIndex()];
-}
-
-// ../../node_modules/yargs/build/lib/yerror.js
-class YError extends Error {
-  constructor(msg) {
-    super(msg || "yargs error");
-    this.name = "YError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, YError);
-    }
-  }
-}
-
-// ../../node_modules/y18n/build/lib/platform-shims/node.js
-import { readFileSync, statSync as statSync2, writeFile } from "fs";
-import { format as format2 } from "util";
-import { resolve as resolve3 } from "path";
-var node_default = {
-  fs: {
-    readFileSync,
-    writeFile
-  },
-  format: format2,
-  resolve: resolve3,
-  exists: (file) => {
-    try {
-      return statSync2(file).isFile();
-    } catch (err) {
-      return false;
-    }
-  }
-};
-
-// ../../node_modules/y18n/build/lib/index.js
-var shim;
-
-class Y18N {
-  constructor(opts) {
-    opts = opts || {};
-    this.directory = opts.directory || "./locales";
-    this.updateFiles = typeof opts.updateFiles === "boolean" ? opts.updateFiles : true;
-    this.locale = opts.locale || "en";
-    this.fallbackToLanguage = typeof opts.fallbackToLanguage === "boolean" ? opts.fallbackToLanguage : true;
-    this.cache = Object.create(null);
-    this.writeQueue = [];
-  }
-  __(...args) {
-    if (typeof arguments[0] !== "string") {
-      return this._taggedLiteral(arguments[0], ...arguments);
-    }
-    const str = args.shift();
-    let cb = function() {
-    };
-    if (typeof args[args.length - 1] === "function")
-      cb = args.pop();
-    cb = cb || function() {
-    };
-    if (!this.cache[this.locale])
-      this._readLocaleFile();
-    if (!this.cache[this.locale][str] && this.updateFiles) {
-      this.cache[this.locale][str] = str;
-      this._enqueueWrite({
-        directory: this.directory,
-        locale: this.locale,
-        cb
-      });
-    } else {
-      cb();
-    }
-    return shim.format.apply(shim.format, [this.cache[this.locale][str] || str].concat(args));
-  }
-  __n() {
-    const args = Array.prototype.slice.call(arguments);
-    const singular = args.shift();
-    const plural = args.shift();
-    const quantity = args.shift();
-    let cb = function() {
-    };
-    if (typeof args[args.length - 1] === "function")
-      cb = args.pop();
-    if (!this.cache[this.locale])
-      this._readLocaleFile();
-    let str = quantity === 1 ? singular : plural;
-    if (this.cache[this.locale][singular]) {
-      const entry = this.cache[this.locale][singular];
-      str = entry[quantity === 1 ? "one" : "other"];
-    }
-    if (!this.cache[this.locale][singular] && this.updateFiles) {
-      this.cache[this.locale][singular] = {
-        one: singular,
-        other: plural
-      };
-      this._enqueueWrite({
-        directory: this.directory,
-        locale: this.locale,
-        cb
-      });
-    } else {
-      cb();
-    }
-    const values = [str];
-    if (~str.indexOf("%d"))
-      values.push(quantity);
-    return shim.format.apply(shim.format, values.concat(args));
-  }
-  setLocale(locale) {
-    this.locale = locale;
-  }
-  getLocale() {
-    return this.locale;
-  }
-  updateLocale(obj) {
-    if (!this.cache[this.locale])
-      this._readLocaleFile();
-    for (const key in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key)) {
-        this.cache[this.locale][key] = obj[key];
-      }
-    }
-  }
-  _taggedLiteral(parts, ...args) {
-    let str = "";
-    parts.forEach(function(part, i) {
-      const arg = args[i + 1];
-      str += part;
-      if (typeof arg !== "undefined") {
-        str += "%s";
-      }
-    });
-    return this.__.apply(this, [str].concat([].slice.call(args, 1)));
-  }
-  _enqueueWrite(work) {
-    this.writeQueue.push(work);
-    if (this.writeQueue.length === 1)
-      this._processWriteQueue();
-  }
-  _processWriteQueue() {
-    const _this = this;
-    const work = this.writeQueue[0];
-    const directory = work.directory;
-    const locale = work.locale;
-    const cb = work.cb;
-    const languageFile = this._resolveLocaleFile(directory, locale);
-    const serializedLocale = JSON.stringify(this.cache[locale], null, 2);
-    shim.fs.writeFile(languageFile, serializedLocale, "utf-8", function(err) {
-      _this.writeQueue.shift();
-      if (_this.writeQueue.length > 0)
-        _this._processWriteQueue();
-      cb(err);
-    });
-  }
-  _readLocaleFile() {
-    let localeLookup = {};
-    const languageFile = this._resolveLocaleFile(this.directory, this.locale);
-    try {
-      if (shim.fs.readFileSync) {
-        localeLookup = JSON.parse(shim.fs.readFileSync(languageFile, "utf-8"));
-      }
-    } catch (err) {
-      if (err instanceof SyntaxError) {
-        err.message = "syntax error in " + languageFile;
-      }
-      if (err.code === "ENOENT")
-        localeLookup = {};
-      else
-        throw err;
-    }
-    this.cache[this.locale] = localeLookup;
-  }
-  _resolveLocaleFile(directory, locale) {
-    let file = shim.resolve(directory, "./", locale + ".json");
-    if (this.fallbackToLanguage && !this._fileExistsSync(file) && ~locale.lastIndexOf("_")) {
-      const languageFile = shim.resolve(directory, "./", locale.split("_")[0] + ".json");
-      if (this._fileExistsSync(languageFile))
-        file = languageFile;
-    }
-    return file;
-  }
-  _fileExistsSync(file) {
-    return shim.exists(file);
-  }
-}
-function y18n(opts, _shim) {
-  shim = _shim;
-  const y18n2 = new Y18N(opts);
-  return {
-    __: y18n2.__.bind(y18n2),
-    __n: y18n2.__n.bind(y18n2),
-    setLocale: y18n2.setLocale.bind(y18n2),
-    getLocale: y18n2.getLocale.bind(y18n2),
-    updateLocale: y18n2.updateLocale.bind(y18n2),
-    locale: y18n2.locale
-  };
-}
-
-// ../../node_modules/y18n/index.mjs
-var y18n2 = (opts) => {
-  return y18n(opts, node_default);
-};
-var y18n_default = y18n2;
-
-// ../../node_modules/yargs/lib/platform-shims/esm.mjs
-var REQUIRE_ERROR = "require is not supported by ESM";
-var REQUIRE_DIRECTORY_ERROR = "loading a directory of commands is not supported yet for ESM";
-var __dirname2;
-try {
-  __dirname2 = fileURLToPath(import.meta.url);
-} catch (e) {
-  __dirname2 = process.cwd();
-}
-var mainFilename = __dirname2.substring(0, __dirname2.lastIndexOf("node_modules"));
-var esm_default = {
-  assert: {
-    notStrictEqual,
-    strictEqual
-  },
-  cliui: ui,
-  findUp: sync_default,
-  getEnv: (key) => {
-    return process.env[key];
-  },
-  inspect,
-  getCallerFile: () => {
-    throw new YError(REQUIRE_DIRECTORY_ERROR);
-  },
-  getProcessArgvBin,
-  mainFilename: mainFilename || process.cwd(),
-  Parser: lib_default,
-  path: {
-    basename,
-    dirname: dirname2,
-    extname,
-    relative,
-    resolve: resolve4
-  },
-  process: {
-    argv: () => process.argv,
-    cwd: process.cwd,
-    emitWarning: (warning, type) => process.emitWarning(warning, type),
-    execPath: () => process.execPath,
-    exit: process.exit,
-    nextTick: process.nextTick,
-    stdColumns: typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null
-  },
-  readFileSync: readFileSync2,
-  require: () => {
-    throw new YError(REQUIRE_ERROR);
-  },
-  requireDirectory: () => {
-    throw new YError(REQUIRE_DIRECTORY_ERROR);
-  },
-  stringWidth: (str) => {
-    return [...str].length;
-  },
-  y18n: y18n_default({
-    directory: resolve4(__dirname2, "../../../locales"),
-    updateFiles: false
-  })
-};
-
-// ../../node_modules/yargs/build/lib/typings/common-types.js
-function assertNotStrictEqual(actual, expected, shim2, message) {
-  shim2.assert.notStrictEqual(actual, expected, message);
-}
-function assertSingleKey(actual, shim2) {
-  shim2.assert.strictEqual(typeof actual, "string");
-}
-function objectKeys(object) {
-  return Object.keys(object);
-}
-
-// ../../node_modules/yargs/build/lib/utils/is-promise.js
-function isPromise(maybePromise) {
-  return !!maybePromise && !!maybePromise.then && typeof maybePromise.then === "function";
-}
-
-// ../../node_modules/yargs/build/lib/parse-command.js
-function parseCommand(cmd) {
-  const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, " ");
-  const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);
-  const bregex = /\.*[\][<>]/g;
-  const firstCommand = splitCommand.shift();
-  if (!firstCommand)
-    throw new Error(`No command found in: ${cmd}`);
-  const parsedCommand = {
-    cmd: firstCommand.replace(bregex, ""),
-    demanded: [],
-    optional: []
-  };
-  splitCommand.forEach((cmd2, i) => {
-    let variadic = false;
-    cmd2 = cmd2.replace(/\s/g, "");
-    if (/\.+[\]>]/.test(cmd2) && i === splitCommand.length - 1)
-      variadic = true;
-    if (/^\[/.test(cmd2)) {
-      parsedCommand.optional.push({
-        cmd: cmd2.replace(bregex, "").split("|"),
-        variadic
-      });
-    } else {
-      parsedCommand.demanded.push({
-        cmd: cmd2.replace(bregex, "").split("|"),
-        variadic
-      });
-    }
-  });
-  return parsedCommand;
-}
-
-// ../../node_modules/yargs/build/lib/argsert.js
-var positionName = ["first", "second", "third", "fourth", "fifth", "sixth"];
-function argsert(arg1, arg2, arg3) {
-  function parseArgs() {
-    return typeof arg1 === "object" ? [{ demanded: [], optional: [] }, arg1, arg2] : [
-      parseCommand(`cmd ${arg1}`),
-      arg2,
-      arg3
-    ];
-  }
-  try {
-    let position = 0;
-    const [parsed, callerArguments, _length] = parseArgs();
-    const args = [].slice.call(callerArguments);
-    while (args.length && args[args.length - 1] === undefined)
-      args.pop();
-    const length = _length || args.length;
-    if (length < parsed.demanded.length) {
-      throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);
-    }
-    const totalCommands = parsed.demanded.length + parsed.optional.length;
-    if (length > totalCommands) {
-      throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);
-    }
-    parsed.demanded.forEach((demanded) => {
-      const arg = args.shift();
-      const observedType = guessType(arg);
-      const matchingTypes = demanded.cmd.filter((type) => type === observedType || type === "*");
-      if (matchingTypes.length === 0)
-        argumentTypeError(observedType, demanded.cmd, position);
-      position += 1;
-    });
-    parsed.optional.forEach((optional) => {
-      if (args.length === 0)
-        return;
-      const arg = args.shift();
-      const observedType = guessType(arg);
-      const matchingTypes = optional.cmd.filter((type) => type === observedType || type === "*");
-      if (matchingTypes.length === 0)
-        argumentTypeError(observedType, optional.cmd, position);
-      position += 1;
-    });
-  } catch (err) {
-    console.warn(err.stack);
-  }
-}
-function guessType(arg) {
-  if (Array.isArray(arg)) {
-    return "array";
-  } else if (arg === null) {
-    return "null";
-  }
-  return typeof arg;
-}
-function argumentTypeError(observedType, allowedTypes, position) {
-  throw new YError(`Invalid ${positionName[position] || "manyith"} argument. Expected ${allowedTypes.join(" or ")} but received ${observedType}.`);
-}
-
-// ../../node_modules/yargs/build/lib/middleware.js
-class GlobalMiddleware {
-  constructor(yargs) {
-    this.globalMiddleware = [];
-    this.frozens = [];
-    this.yargs = yargs;
-  }
-  addMiddleware(callback, applyBeforeValidation, global = true, mutates = false) {
-    argsert("<array|function> [boolean] [boolean] [boolean]", [callback, applyBeforeValidation, global], arguments.length);
-    if (Array.isArray(callback)) {
-      for (let i = 0;i < callback.length; i++) {
-        if (typeof callback[i] !== "function") {
-          throw Error("middleware must be a function");
-        }
-        const m = callback[i];
-        m.applyBeforeValidation = applyBeforeValidation;
-        m.global = global;
-      }
-      Array.prototype.push.apply(this.globalMiddleware, callback);
-    } else if (typeof callback === "function") {
-      const m = callback;
-      m.applyBeforeValidation = applyBeforeValidation;
-      m.global = global;
-      m.mutates = mutates;
-      this.globalMiddleware.push(callback);
-    }
-    return this.yargs;
-  }
-  addCoerceMiddleware(callback, option) {
-    const aliases = this.yargs.getAliases();
-    this.globalMiddleware = this.globalMiddleware.filter((m) => {
-      const toCheck = [...aliases[option] || [], option];
-      if (!m.option)
-        return true;
-      else
-        return !toCheck.includes(m.option);
-    });
-    callback.option = option;
-    return this.addMiddleware(callback, true, true, true);
-  }
-  getMiddleware() {
-    return this.globalMiddleware;
-  }
-  freeze() {
-    this.frozens.push([...this.globalMiddleware]);
-  }
-  unfreeze() {
-    const frozen = this.frozens.pop();
-    if (frozen !== undefined)
-      this.globalMiddleware = frozen;
-  }
-  reset() {
-    this.globalMiddleware = this.globalMiddleware.filter((m) => m.global);
-  }
-}
-function commandMiddlewareFactory(commandMiddleware) {
-  if (!commandMiddleware)
-    return [];
-  return commandMiddleware.map((middleware) => {
-    middleware.applyBeforeValidation = false;
-    return middleware;
-  });
-}
-function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
-  return middlewares.reduce((acc, middleware) => {
-    if (middleware.applyBeforeValidation !== beforeValidation) {
-      return acc;
-    }
-    if (middleware.mutates) {
-      if (middleware.applied)
-        return acc;
-      middleware.applied = true;
-    }
-    if (isPromise(acc)) {
-      return acc.then((initialObj) => Promise.all([initialObj, middleware(initialObj, yargs)])).then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
-    } else {
-      const result = middleware(acc, yargs);
-      return isPromise(result) ? result.then((middlewareObj) => Object.assign(acc, middlewareObj)) : Object.assign(acc, result);
-    }
-  }, argv);
-}
-
-// ../../node_modules/yargs/build/lib/utils/maybe-async-result.js
-function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => {
-  throw err;
-}) {
-  try {
-    const result = isFunction(getResult) ? getResult() : getResult;
-    return isPromise(result) ? result.then((result2) => resultHandler(result2)) : resultHandler(result);
-  } catch (err) {
-    return errorHandler(err);
-  }
-}
-function isFunction(arg) {
-  return typeof arg === "function";
-}
-
-// ../../node_modules/yargs/build/lib/utils/which-module.js
-function whichModule(exported) {
-  if (false)
-    ;
-  for (let i = 0, files = Object.keys(__require.cache), mod;i < files.length; i++) {
-    mod = __require.cache[files[i]];
-    if (mod.exports === exported)
-      return mod;
-  }
-  return null;
-}
-
-// ../../node_modules/yargs/build/lib/command.js
-var DEFAULT_MARKER = /(^\*)|(^\$0)/;
-
-class CommandInstance {
-  constructor(usage, validation, globalMiddleware, shim2) {
-    this.requireCache = new Set;
-    this.handlers = {};
-    this.aliasMap = {};
-    this.frozens = [];
-    this.shim = shim2;
-    this.usage = usage;
-    this.globalMiddleware = globalMiddleware;
-    this.validation = validation;
-  }
-  addDirectory(dir, req, callerFile, opts) {
-    opts = opts || {};
-    if (typeof opts.recurse !== "boolean")
-      opts.recurse = false;
-    if (!Array.isArray(opts.extensions))
-      opts.extensions = ["js"];
-    const parentVisit = typeof opts.visit === "function" ? opts.visit : (o) => o;
-    opts.visit = (obj, joined, filename) => {
-      const visited = parentVisit(obj, joined, filename);
-      if (visited) {
-        if (this.requireCache.has(joined))
-          return visited;
-        else
-          this.requireCache.add(joined);
-        this.addHandler(visited);
-      }
-      return visited;
-    };
-    this.shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);
-  }
-  addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
-    let aliases = [];
-    const middlewares = commandMiddlewareFactory(commandMiddleware);
-    handler = handler || (() => {
-    });
-    if (Array.isArray(cmd)) {
-      if (isCommandAndAliases(cmd)) {
-        [cmd, ...aliases] = cmd;
-      } else {
-        for (const command of cmd) {
-          this.addHandler(command);
-        }
-      }
-    } else if (isCommandHandlerDefinition(cmd)) {
-      let command = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : this.moduleName(cmd);
-      if (cmd.aliases)
-        command = [].concat(command).concat(cmd.aliases);
-      this.addHandler(command, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
-      return;
-    } else if (isCommandBuilderDefinition(builder)) {
-      this.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
-      return;
-    }
-    if (typeof cmd === "string") {
-      const parsedCommand = parseCommand(cmd);
-      aliases = aliases.map((alias) => parseCommand(alias).cmd);
-      let isDefault = false;
-      const parsedAliases = [parsedCommand.cmd].concat(aliases).filter((c) => {
-        if (DEFAULT_MARKER.test(c)) {
-          isDefault = true;
-          return false;
-        }
-        return true;
-      });
-      if (parsedAliases.length === 0 && isDefault)
-        parsedAliases.push("$0");
-      if (isDefault) {
-        parsedCommand.cmd = parsedAliases[0];
-        aliases = parsedAliases.slice(1);
-        cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
-      }
-      aliases.forEach((alias) => {
-        this.aliasMap[alias] = parsedCommand.cmd;
-      });
-      if (description !== false) {
-        this.usage.command(cmd, description, isDefault, aliases, deprecated);
-      }
-      this.handlers[parsedCommand.cmd] = {
-        original: cmd,
-        description,
-        handler,
-        builder: builder || {},
-        middlewares,
-        deprecated,
-        demanded: parsedCommand.demanded,
-        optional: parsedCommand.optional
-      };
-      if (isDefault)
-        this.defaultCommand = this.handlers[parsedCommand.cmd];
-    }
-  }
-  getCommandHandlers() {
-    return this.handlers;
-  }
-  getCommands() {
-    return Object.keys(this.handlers).concat(Object.keys(this.aliasMap));
-  }
-  hasDefaultCommand() {
-    return !!this.defaultCommand;
-  }
-  runCommand(command, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {
-    const commandHandler = this.handlers[command] || this.handlers[this.aliasMap[command]] || this.defaultCommand;
-    const currentContext = yargs.getInternalMethods().getContext();
-    const parentCommands = currentContext.commands.slice();
-    const isDefaultCommand = !command;
-    if (command) {
-      currentContext.commands.push(command);
-      currentContext.fullCommands.push(commandHandler.original);
-    }
-    const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet);
-    return isPromise(builderResult) ? builderResult.then((result) => this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs)) : this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs);
-  }
-  applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet) {
-    const builder = commandHandler.builder;
-    let innerYargs = yargs;
-    if (isCommandBuilderCallback(builder)) {
-      yargs.getInternalMethods().getUsageInstance().freeze();
-      const builderOutput = builder(yargs.getInternalMethods().reset(aliases), helpOrVersionSet);
-      if (isPromise(builderOutput)) {
-        return builderOutput.then((output) => {
-          innerYargs = isYargsInstance(output) ? output : yargs;
-          return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
-        });
-      }
-    } else if (isCommandBuilderOptionDefinitions(builder)) {
-      yargs.getInternalMethods().getUsageInstance().freeze();
-      innerYargs = yargs.getInternalMethods().reset(aliases);
-      Object.keys(commandHandler.builder).forEach((key) => {
-        innerYargs.option(key, builder[key]);
-      });
-    }
-    return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
-  }
-  parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly) {
-    if (isDefaultCommand)
-      innerYargs.getInternalMethods().getUsageInstance().unfreeze(true);
-    if (this.shouldUpdateUsage(innerYargs)) {
-      innerYargs.getInternalMethods().getUsageInstance().usage(this.usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
-    }
-    const innerArgv = innerYargs.getInternalMethods().runYargsParserAndExecuteCommands(null, undefined, true, commandIndex, helpOnly);
-    return isPromise(innerArgv) ? innerArgv.then((argv) => ({
-      aliases: innerYargs.parsed.aliases,
-      innerArgv: argv
-    })) : {
-      aliases: innerYargs.parsed.aliases,
-      innerArgv
-    };
-  }
-  shouldUpdateUsage(yargs) {
-    return !yargs.getInternalMethods().getUsageInstance().getUsageDisabled() && yargs.getInternalMethods().getUsageInstance().getUsage().length === 0;
-  }
-  usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
-    const c = DEFAULT_MARKER.test(commandHandler.original) ? commandHandler.original.replace(DEFAULT_MARKER, "").trim() : commandHandler.original;
-    const pc = parentCommands.filter((c2) => {
-      return !DEFAULT_MARKER.test(c2);
-    });
-    pc.push(c);
-    return `$0 ${pc.join(" ")}`;
-  }
-  handleValidationAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, aliases, yargs, middlewares, positionalMap) {
-    if (!yargs.getInternalMethods().getHasOutput()) {
-      const validation = yargs.getInternalMethods().runValidation(aliases, positionalMap, yargs.parsed.error, isDefaultCommand);
-      innerArgv = maybeAsyncResult(innerArgv, (result) => {
-        validation(result);
-        return result;
-      });
-    }
-    if (commandHandler.handler && !yargs.getInternalMethods().getHasOutput()) {
-      yargs.getInternalMethods().setHasOutput();
-      const populateDoubleDash = !!yargs.getOptions().configuration["populate--"];
-      yargs.getInternalMethods().postProcess(innerArgv, populateDoubleDash, false, false);
-      innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
-      innerArgv = maybeAsyncResult(innerArgv, (result) => {
-        const handlerResult = commandHandler.handler(result);
-        return isPromise(handlerResult) ? handlerResult.then(() => result) : result;
-      });
-      if (!isDefaultCommand) {
-        yargs.getInternalMethods().getUsageInstance().cacheHelpMessage();
-      }
-      if (isPromise(innerArgv) && !yargs.getInternalMethods().hasParseCallback()) {
-        innerArgv.catch((error) => {
-          try {
-            yargs.getInternalMethods().getUsageInstance().fail(null, error);
-          } catch (_err) {
-          }
-        });
-      }
-    }
-    if (!isDefaultCommand) {
-      currentContext.commands.pop();
-      currentContext.fullCommands.pop();
-    }
-    return innerArgv;
-  }
-  applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, helpOnly, aliases, yargs) {
-    let positionalMap = {};
-    if (helpOnly)
-      return innerArgv;
-    if (!yargs.getInternalMethods().getHasOutput()) {
-      positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs);
-    }
-    const middlewares = this.globalMiddleware.getMiddleware().slice(0).concat(commandHandler.middlewares);
-    const maybePromiseArgv = applyMiddleware(innerArgv, yargs, middlewares, true);
-    return isPromise(maybePromiseArgv) ? maybePromiseArgv.then((resolvedInnerArgv) => this.handleValidationAndGetResult(isDefaultCommand, commandHandler, resolvedInnerArgv, currentContext, aliases, yargs, middlewares, positionalMap)) : this.handleValidationAndGetResult(isDefaultCommand, commandHandler, maybePromiseArgv, currentContext, aliases, yargs, middlewares, positionalMap);
-  }
-  populatePositionals(commandHandler, argv, context, yargs) {
-    argv._ = argv._.slice(context.commands.length);
-    const demanded = commandHandler.demanded.slice(0);
-    const optional = commandHandler.optional.slice(0);
-    const positionalMap = {};
-    this.validation.positionalCount(demanded.length, argv._.length);
-    while (demanded.length) {
-      const demand = demanded.shift();
-      this.populatePositional(demand, argv, positionalMap);
-    }
-    while (optional.length) {
-      const maybe = optional.shift();
-      this.populatePositional(maybe, argv, positionalMap);
-    }
-    argv._ = context.commands.concat(argv._.map((a) => "" + a));
-    this.postProcessPositionals(argv, positionalMap, this.cmdToParseOptions(commandHandler.original), yargs);
-    return positionalMap;
-  }
-  populatePositional(positional, argv, positionalMap) {
-    const cmd = positional.cmd[0];
-    if (positional.variadic) {
-      positionalMap[cmd] = argv._.splice(0).map(String);
-    } else {
-      if (argv._.length)
-        positionalMap[cmd] = [String(argv._.shift())];
-    }
-  }
-  cmdToParseOptions(cmdString) {
-    const parseOptions = {
-      array: [],
-      default: {},
-      alias: {},
-      demand: {}
-    };
-    const parsed = parseCommand(cmdString);
-    parsed.demanded.forEach((d) => {
-      const [cmd, ...aliases] = d.cmd;
-      if (d.variadic) {
-        parseOptions.array.push(cmd);
-        parseOptions.default[cmd] = [];
-      }
-      parseOptions.alias[cmd] = aliases;
-      parseOptions.demand[cmd] = true;
-    });
-    parsed.optional.forEach((o) => {
-      const [cmd, ...aliases] = o.cmd;
-      if (o.variadic) {
-        parseOptions.array.push(cmd);
-        parseOptions.default[cmd] = [];
-      }
-      parseOptions.alias[cmd] = aliases;
-    });
-    return parseOptions;
-  }
-  postProcessPositionals(argv, positionalMap, parseOptions, yargs) {
-    const options = Object.assign({}, yargs.getOptions());
-    options.default = Object.assign(parseOptions.default, options.default);
-    for (const key of Object.keys(parseOptions.alias)) {
-      options.alias[key] = (options.alias[key] || []).concat(parseOptions.alias[key]);
-    }
-    options.array = options.array.concat(parseOptions.array);
-    options.config = {};
-    const unparsed = [];
-    Object.keys(positionalMap).forEach((key) => {
-      positionalMap[key].map((value) => {
-        if (options.configuration["unknown-options-as-args"])
-          options.key[key] = true;
-        unparsed.push(`--${key}`);
-        unparsed.push(value);
-      });
-    });
-    if (!unparsed.length)
-      return;
-    const config = Object.assign({}, options.configuration, {
-      "populate--": false
-    });
-    const parsed = this.shim.Parser.detailed(unparsed, Object.assign({}, options, {
-      configuration: config
-    }));
-    if (parsed.error) {
-      yargs.getInternalMethods().getUsageInstance().fail(parsed.error.message, parsed.error);
-    } else {
-      const positionalKeys = Object.keys(positionalMap);
-      Object.keys(positionalMap).forEach((key) => {
-        positionalKeys.push(...parsed.aliases[key]);
-      });
-      Object.keys(parsed.argv).forEach((key) => {
-        if (positionalKeys.includes(key)) {
-          if (!positionalMap[key])
-            positionalMap[key] = parsed.argv[key];
-          if (!this.isInConfigs(yargs, key) && !this.isDefaulted(yargs, key) && Object.prototype.hasOwnProperty.call(argv, key) && Object.prototype.hasOwnProperty.call(parsed.argv, key) && (Array.isArray(argv[key]) || Array.isArray(parsed.argv[key]))) {
-            argv[key] = [].concat(argv[key], parsed.argv[key]);
-          } else {
-            argv[key] = parsed.argv[key];
-          }
-        }
-      });
-    }
-  }
-  isDefaulted(yargs, key) {
-    const { default: defaults } = yargs.getOptions();
-    return Object.prototype.hasOwnProperty.call(defaults, key) || Object.prototype.hasOwnProperty.call(defaults, this.shim.Parser.camelCase(key));
-  }
-  isInConfigs(yargs, key) {
-    const { configObjects } = yargs.getOptions();
-    return configObjects.some((c) => Object.prototype.hasOwnProperty.call(c, key)) || configObjects.some((c) => Object.prototype.hasOwnProperty.call(c, this.shim.Parser.camelCase(key)));
-  }
-  runDefaultBuilderOn(yargs) {
-    if (!this.defaultCommand)
-      return;
-    if (this.shouldUpdateUsage(yargs)) {
-      const commandString = DEFAULT_MARKER.test(this.defaultCommand.original) ? this.defaultCommand.original : this.defaultCommand.original.replace(/^[^[\]<>]*/, "$0 ");
-      yargs.getInternalMethods().getUsageInstance().usage(commandString, this.defaultCommand.description);
-    }
-    const builder = this.defaultCommand.builder;
-    if (isCommandBuilderCallback(builder)) {
-      return builder(yargs, true);
-    } else if (!isCommandBuilderDefinition(builder)) {
-      Object.keys(builder).forEach((key) => {
-        yargs.option(key, builder[key]);
-      });
-    }
-    return;
-  }
-  moduleName(obj) {
-    const mod = whichModule(obj);
-    if (!mod)
-      throw new Error(`No command name given for module: ${this.shim.inspect(obj)}`);
-    return this.commandFromFilename(mod.filename);
-  }
-  commandFromFilename(filename) {
-    return this.shim.path.basename(filename, this.shim.path.extname(filename));
-  }
-  extractDesc({ describe, description, desc }) {
-    for (const test of [describe, description, desc]) {
-      if (typeof test === "string" || test === false)
-        return test;
-      assertNotStrictEqual(test, true, this.shim);
-    }
-    return false;
-  }
-  freeze() {
-    this.frozens.push({
-      handlers: this.handlers,
-      aliasMap: this.aliasMap,
-      defaultCommand: this.defaultCommand
-    });
-  }
-  unfreeze() {
-    const frozen = this.frozens.pop();
-    assertNotStrictEqual(frozen, undefined, this.shim);
-    ({
-      handlers: this.handlers,
-      aliasMap: this.aliasMap,
-      defaultCommand: this.defaultCommand
-    } = frozen);
-  }
-  reset() {
-    this.handlers = {};
-    this.aliasMap = {};
-    this.defaultCommand = undefined;
-    this.requireCache = new Set;
-    return this;
-  }
-}
-function command(usage, validation, globalMiddleware, shim2) {
-  return new CommandInstance(usage, validation, globalMiddleware, shim2);
-}
-function isCommandBuilderDefinition(builder) {
-  return typeof builder === "object" && !!builder.builder && typeof builder.handler === "function";
-}
-function isCommandAndAliases(cmd) {
-  return cmd.every((c) => typeof c === "string");
-}
-function isCommandBuilderCallback(builder) {
-  return typeof builder === "function";
-}
-function isCommandBuilderOptionDefinitions(builder) {
-  return typeof builder === "object";
-}
-function isCommandHandlerDefinition(cmd) {
-  return typeof cmd === "object" && !Array.isArray(cmd);
-}
-
-// ../../node_modules/yargs/build/lib/utils/obj-filter.js
-function objFilter(original = {}, filter = () => true) {
-  const obj = {};
-  objectKeys(original).forEach((key) => {
-    if (filter(key, original[key])) {
-      obj[key] = original[key];
-    }
-  });
-  return obj;
-}
-
-// ../../node_modules/yargs/build/lib/utils/set-blocking.js
-function setBlocking(blocking) {
-  if (typeof process === "undefined")
-    return;
-  [process.stdout, process.stderr].forEach((_stream) => {
-    const stream = _stream;
-    if (stream._handle && stream.isTTY && typeof stream._handle.setBlocking === "function") {
-      stream._handle.setBlocking(blocking);
-    }
-  });
-}
-
-// ../../node_modules/yargs/build/lib/usage.js
-function isBoolean(fail) {
-  return typeof fail === "boolean";
-}
-function usage(yargs, shim2) {
-  const __ = shim2.y18n.__;
-  const self = {};
-  const fails = [];
-  self.failFn = function failFn(f) {
-    fails.push(f);
-  };
-  let failMessage = null;
-  let globalFailMessage = null;
-  let showHelpOnFail = true;
-  self.showHelpOnFail = function showHelpOnFailFn(arg1 = true, arg2) {
-    const [enabled, message] = typeof arg1 === "string" ? [true, arg1] : [arg1, arg2];
-    if (yargs.getInternalMethods().isGlobalContext()) {
-      globalFailMessage = message;
-    }
-    failMessage = message;
-    showHelpOnFail = enabled;
-    return self;
-  };
-  let failureOutput = false;
-  self.fail = function fail(msg, err) {
-    const logger = yargs.getInternalMethods().getLoggerInstance();
-    if (fails.length) {
-      for (let i = fails.length - 1;i >= 0; --i) {
-        const fail = fails[i];
-        if (isBoolean(fail)) {
-          if (err)
-            throw err;
-          else if (msg)
-            throw Error(msg);
-        } else {
-          fail(msg, err, self);
-        }
-      }
-    } else {
-      if (yargs.getExitProcess())
-        setBlocking(true);
-      if (!failureOutput) {
-        failureOutput = true;
-        if (showHelpOnFail) {
-          yargs.showHelp("error");
-          logger.error();
-        }
-        if (msg || err)
-          logger.error(msg || err);
-        const globalOrCommandFailMessage = failMessage || globalFailMessage;
-        if (globalOrCommandFailMessage) {
-          if (msg || err)
-            logger.error("");
-          logger.error(globalOrCommandFailMessage);
-        }
-      }
-      err = err || new YError(msg);
-      if (yargs.getExitProcess()) {
-        return yargs.exit(1);
-      } else if (yargs.getInternalMethods().hasParseCallback()) {
-        return yargs.exit(1, err);
-      } else {
-        throw err;
-      }
-    }
-  };
-  let usages = [];
-  let usageDisabled = false;
-  self.usage = (msg, description) => {
-    if (msg === null) {
-      usageDisabled = true;
-      usages = [];
-      return self;
-    }
-    usageDisabled = false;
-    usages.push([msg, description || ""]);
-    return self;
-  };
-  self.getUsage = () => {
-    return usages;
-  };
-  self.getUsageDisabled = () => {
-    return usageDisabled;
-  };
-  self.getPositionalGroupName = () => {
-    return __("Positionals:");
-  };
-  let examples = [];
-  self.example = (cmd, description) => {
-    examples.push([cmd, description || ""]);
-  };
-  let commands = [];
-  self.command = function command(cmd, description, isDefault, aliases, deprecated = false) {
-    if (isDefault) {
-      commands = commands.map((cmdArray) => {
-        cmdArray[2] = false;
-        return cmdArray;
-      });
-    }
-    commands.push([cmd, description || "", isDefault, aliases, deprecated]);
-  };
-  self.getCommands = () => commands;
-  let descriptions = {};
-  self.describe = function describe(keyOrKeys, desc) {
-    if (Array.isArray(keyOrKeys)) {
-      keyOrKeys.forEach((k) => {
-        self.describe(k, desc);
-      });
-    } else if (typeof keyOrKeys === "object") {
-      Object.keys(keyOrKeys).forEach((k) => {
-        self.describe(k, keyOrKeys[k]);
-      });
-    } else {
-      descriptions[keyOrKeys] = desc;
-    }
-  };
-  self.getDescriptions = () => descriptions;
-  let epilogs = [];
-  self.epilog = (msg) => {
-    epilogs.push(msg);
-  };
-  let wrapSet = false;
-  let wrap2;
-  self.wrap = (cols) => {
-    wrapSet = true;
-    wrap2 = cols;
-  };
-  self.getWrap = () => {
-    if (shim2.getEnv("YARGS_DISABLE_WRAP")) {
-      return null;
-    }
-    if (!wrapSet) {
-      wrap2 = windowWidth();
-      wrapSet = true;
-    }
-    return wrap2;
-  };
-  const deferY18nLookupPrefix = "__yargsString__:";
-  self.deferY18nLookup = (str) => deferY18nLookupPrefix + str;
-  self.help = function help() {
-    if (cachedHelpMessage)
-      return cachedHelpMessage;
-    normalizeAliases();
-    const base$0 = yargs.customScriptName ? yargs.$0 : shim2.path.basename(yargs.$0);
-    const demandedOptions = yargs.getDemandedOptions();
-    const demandedCommands = yargs.getDemandedCommands();
-    const deprecatedOptions = yargs.getDeprecatedOptions();
-    const groups = yargs.getGroups();
-    const options = yargs.getOptions();
-    let keys = [];
-    keys = keys.concat(Object.keys(descriptions));
-    keys = keys.concat(Object.keys(demandedOptions));
-    keys = keys.concat(Object.keys(demandedCommands));
-    keys = keys.concat(Object.keys(options.default));
-    keys = keys.filter(filterHiddenOptions);
-    keys = Object.keys(keys.reduce((acc, key) => {
-      if (key !== "_")
-        acc[key] = true;
-      return acc;
-    }, {}));
-    const theWrap = self.getWrap();
-    const ui2 = shim2.cliui({
-      width: theWrap,
-      wrap: !!theWrap
-    });
-    if (!usageDisabled) {
-      if (usages.length) {
-        usages.forEach((usage2) => {
-          ui2.div({ text: `${usage2[0].replace(/\$0/g, base$0)}` });
-          if (usage2[1]) {
-            ui2.div({ text: `${usage2[1]}`, padding: [1, 0, 0, 0] });
-          }
-        });
-        ui2.div();
-      } else if (commands.length) {
-        let u = null;
-        if (demandedCommands._) {
-          u = `${base$0} <${__("command")}>
-`;
-        } else {
-          u = `${base$0} [${__("command")}]
-`;
-        }
-        ui2.div(`${u}`);
-      }
-    }
-    if (commands.length > 1 || commands.length === 1 && !commands[0][2]) {
-      ui2.div(__("Commands:"));
-      const context = yargs.getInternalMethods().getContext();
-      const parentCommands = context.commands.length ? `${context.commands.join(" ")} ` : "";
-      if (yargs.getInternalMethods().getParserConfiguration()["sort-commands"] === true) {
-        commands = commands.sort((a, b) => a[0].localeCompare(b[0]));
-      }
-      const prefix = base$0 ? `${base$0} ` : "";
-      commands.forEach((command2) => {
-        const commandString = `${prefix}${parentCommands}${command2[0].replace(/^\$0 ?/, "")}`;
-        ui2.span({
-          text: commandString,
-          padding: [0, 2, 0, 2],
-          width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4
-        }, { text: command2[1] });
-        const hints = [];
-        if (command2[2])
-          hints.push(`[${__("default")}]`);
-        if (command2[3] && command2[3].length) {
-          hints.push(`[${__("aliases:")} ${command2[3].join(", ")}]`);
-        }
-        if (command2[4]) {
-          if (typeof command2[4] === "string") {
-            hints.push(`[${__("deprecated: %s", command2[4])}]`);
-          } else {
-            hints.push(`[${__("deprecated")}]`);
-          }
-        }
-        if (hints.length) {
-          ui2.div({
-            text: hints.join(" "),
-            padding: [0, 0, 0, 2],
-            align: "right"
-          });
-        } else {
-          ui2.div();
-        }
-      });
-      ui2.div();
-    }
-    const aliasKeys = (Object.keys(options.alias) || []).concat(Object.keys(yargs.parsed.newAliases) || []);
-    keys = keys.filter((key) => !yargs.parsed.newAliases[key] && aliasKeys.every((alias) => (options.alias[alias] || []).indexOf(key) === -1));
-    const defaultGroup = __("Options:");
-    if (!groups[defaultGroup])
-      groups[defaultGroup] = [];
-    addUngroupedKeys(keys, options.alias, groups, defaultGroup);
-    const isLongSwitch = (sw) => /^--/.test(getText(sw));
-    const displayedGroups = Object.keys(groups).filter((groupName) => groups[groupName].length > 0).map((groupName) => {
-      const normalizedKeys = groups[groupName].filter(filterHiddenOptions).map((key) => {
-        if (aliasKeys.includes(key))
-          return key;
-        for (let i = 0, aliasKey;(aliasKey = aliasKeys[i]) !== undefined; i++) {
-          if ((options.alias[aliasKey] || []).includes(key))
-            return aliasKey;
-        }
-        return key;
-      });
-      return { groupName, normalizedKeys };
-    }).filter(({ normalizedKeys }) => normalizedKeys.length > 0).map(({ groupName, normalizedKeys }) => {
-      const switches = normalizedKeys.reduce((acc, key) => {
-        acc[key] = [key].concat(options.alias[key] || []).map((sw) => {
-          if (groupName === self.getPositionalGroupName())
-            return sw;
-          else {
-            return (/^[0-9]$/.test(sw) ? options.boolean.includes(key) ? "-" : "--" : sw.length > 1 ? "--" : "-") + sw;
-          }
-        }).sort((sw1, sw2) => isLongSwitch(sw1) === isLongSwitch(sw2) ? 0 : isLongSwitch(sw1) ? 1 : -1).join(", ");
-        return acc;
-      }, {});
-      return { groupName, normalizedKeys, switches };
-    });
-    const shortSwitchesUsed = displayedGroups.filter(({ groupName }) => groupName !== self.getPositionalGroupName()).some(({ normalizedKeys, switches }) => !normalizedKeys.every((key) => isLongSwitch(switches[key])));
-    if (shortSwitchesUsed) {
-      displayedGroups.filter(({ groupName }) => groupName !== self.getPositionalGroupName()).forEach(({ normalizedKeys, switches }) => {
-        normalizedKeys.forEach((key) => {
-          if (isLongSwitch(switches[key])) {
-            switches[key] = addIndentation(switches[key], "-x, ".length);
-          }
-        });
-      });
-    }
-    displayedGroups.forEach(({ groupName, normalizedKeys, switches }) => {
-      ui2.div(groupName);
-      normalizedKeys.forEach((key) => {
-        const kswitch = switches[key];
-        let desc = descriptions[key] || "";
-        let type = null;
-        if (desc.includes(deferY18nLookupPrefix))
-          desc = __(desc.substring(deferY18nLookupPrefix.length));
-        if (options.boolean.includes(key))
-          type = `[${__("boolean")}]`;
-        if (options.count.includes(key))
-          type = `[${__("count")}]`;
-        if (options.string.includes(key))
-          type = `[${__("string")}]`;
-        if (options.normalize.includes(key))
-          type = `[${__("string")}]`;
-        if (options.array.includes(key))
-          type = `[${__("array")}]`;
-        if (options.number.includes(key))
-          type = `[${__("number")}]`;
-        const deprecatedExtra = (deprecated) => typeof deprecated === "string" ? `[${__("deprecated: %s", deprecated)}]` : `[${__("deprecated")}]`;
-        const extra = [
-          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,
-          defaultString(options.default[key], options.defaultDescription[key])
-        ].filter(Boolean).join(" ");
-        ui2.span({
-          text: getText(kswitch),
-          padding: [0, 2, 0, 2 + getIndentation(kswitch)],
-          width: maxWidth(switches, theWrap) + 4
-        }, desc);
-        const shouldHideOptionExtras = yargs.getInternalMethods().getUsageConfiguration()["hide-types"] === true;
-        if (extra && !shouldHideOptionExtras)
-          ui2.div({ text: extra, padding: [0, 0, 0, 2], align: "right" });
-        else
-          ui2.div();
-      });
-      ui2.div();
-    });
-    if (examples.length) {
-      ui2.div(__("Examples:"));
-      examples.forEach((example) => {
-        example[0] = example[0].replace(/\$0/g, base$0);
-      });
-      examples.forEach((example) => {
-        if (example[1] === "") {
-          ui2.div({
-            text: example[0],
-            padding: [0, 2, 0, 2]
-          });
-        } else {
-          ui2.div({
-            text: example[0],
-            padding: [0, 2, 0, 2],
-            width: maxWidth(examples, theWrap) + 4
-          }, {
-            text: example[1]
-          });
-        }
-      });
-      ui2.div();
-    }
-    if (epilogs.length > 0) {
-      const e = epilogs.map((epilog) => epilog.replace(/\$0/g, base$0)).join(`
-`);
-      ui2.div(`${e}
-`);
-    }
-    return ui2.toString().replace(/\s*$/, "");
-  };
-  function maxWidth(table, theWrap, modifier) {
-    let width = 0;
-    if (!Array.isArray(table)) {
-      table = Object.values(table).map((v) => [v]);
-    }
-    table.forEach((v) => {
-      width = Math.max(shim2.stringWidth(modifier ? `${modifier} ${getText(v[0])}` : getText(v[0])) + getIndentation(v[0]), width);
-    });
-    if (theWrap)
-      width = Math.min(width, parseInt((theWrap * 0.5).toString(), 10));
-    return width;
-  }
-  function normalizeAliases() {
-    const demandedOptions = yargs.getDemandedOptions();
-    const options = yargs.getOptions();
-    (Object.keys(options.alias) || []).forEach((key) => {
-      options.alias[key].forEach((alias) => {
-        if (descriptions[alias])
-          self.describe(key, descriptions[alias]);
-        if (alias in demandedOptions)
-          yargs.demandOption(key, demandedOptions[alias]);
-        if (options.boolean.includes(alias))
-          yargs.boolean(key);
-        if (options.count.includes(alias))
-          yargs.count(key);
-        if (options.string.includes(alias))
-          yargs.string(key);
-        if (options.normalize.includes(alias))
-          yargs.normalize(key);
-        if (options.array.includes(alias))
-          yargs.array(key);
-        if (options.number.includes(alias))
-          yargs.number(key);
-      });
-    });
-  }
-  let cachedHelpMessage;
-  self.cacheHelpMessage = function() {
-    cachedHelpMessage = this.help();
-  };
-  self.clearCachedHelpMessage = function() {
-    cachedHelpMessage = undefined;
-  };
-  self.hasCachedHelpMessage = function() {
-    return !!cachedHelpMessage;
-  };
-  function addUngroupedKeys(keys, aliases, groups, defaultGroup) {
-    let groupedKeys = [];
-    let toCheck = null;
-    Object.keys(groups).forEach((group) => {
-      groupedKeys = groupedKeys.concat(groups[group]);
-    });
-    keys.forEach((key) => {
-      toCheck = [key].concat(aliases[key]);
-      if (!toCheck.some((k) => groupedKeys.indexOf(k) !== -1)) {
-        groups[defaultGroup].push(key);
-      }
-    });
-    return groupedKeys;
-  }
-  function filterHiddenOptions(key) {
-    return yargs.getOptions().hiddenOptions.indexOf(key) < 0 || yargs.parsed.argv[yargs.getOptions().showHiddenOpt];
-  }
-  self.showHelp = (level) => {
-    const logger = yargs.getInternalMethods().getLoggerInstance();
-    if (!level)
-      level = "error";
-    const emit = typeof level === "function" ? level : logger[level];
-    emit(self.help());
-  };
-  self.functionDescription = (fn) => {
-    const description = fn.name ? shim2.Parser.decamelize(fn.name, "-") : __("generated-value");
-    return ["(", description, ")"].join("");
-  };
-  self.stringifiedValues = function stringifiedValues(values, separator) {
-    let string = "";
-    const sep = separator || ", ";
-    const array = [].concat(values);
-    if (!values || !array.length)
-      return string;
-    array.forEach((value) => {
-      if (string.length)
-        string += sep;
-      string += JSON.stringify(value);
-    });
-    return string;
-  };
-  function defaultString(value, defaultDescription) {
-    let string = `[${__("default:")} `;
-    if (value === undefined && !defaultDescription)
-      return null;
-    if (defaultDescription) {
-      string += defaultDescription;
-    } else {
-      switch (typeof value) {
-        case "string":
-          string += `"${value}"`;
-          break;
-        case "object":
-          string += JSON.stringify(value);
-          break;
-        default:
-          string += value;
-      }
-    }
-    return `${string}]`;
-  }
-  function windowWidth() {
-    const maxWidth2 = 80;
-    if (shim2.process.stdColumns) {
-      return Math.min(maxWidth2, shim2.process.stdColumns);
-    } else {
-      return maxWidth2;
-    }
-  }
-  let version = null;
-  self.version = (ver) => {
-    version = ver;
-  };
-  self.showVersion = (level) => {
-    const logger = yargs.getInternalMethods().getLoggerInstance();
-    if (!level)
-      level = "error";
-    const emit = typeof level === "function" ? level : logger[level];
-    emit(version);
-  };
-  self.reset = function reset(localLookup) {
-    failMessage = null;
-    failureOutput = false;
-    usages = [];
-    usageDisabled = false;
-    epilogs = [];
-    examples = [];
-    commands = [];
-    descriptions = objFilter(descriptions, (k) => !localLookup[k]);
-    return self;
-  };
-  const frozens = [];
-  self.freeze = function freeze() {
-    frozens.push({
-      failMessage,
-      failureOutput,
-      usages,
-      usageDisabled,
-      epilogs,
-      examples,
-      commands,
-      descriptions
-    });
-  };
-  self.unfreeze = function unfreeze(defaultCommand = false) {
-    const frozen = frozens.pop();
-    if (!frozen)
-      return;
-    if (defaultCommand) {
-      descriptions = { ...frozen.descriptions, ...descriptions };
-      commands = [...frozen.commands, ...commands];
-      usages = [...frozen.usages, ...usages];
-      examples = [...frozen.examples, ...examples];
-      epilogs = [...frozen.epilogs, ...epilogs];
-    } else {
-      ({
-        failMessage,
-        failureOutput,
-        usages,
-        usageDisabled,
-        epilogs,
-        examples,
-        commands,
-        descriptions
-      } = frozen);
-    }
-  };
-  return self;
-}
-function isIndentedText(text) {
-  return typeof text === "object";
-}
-function addIndentation(text, indent) {
-  return isIndentedText(text) ? { text: text.text, indentation: text.indentation + indent } : { text, indentation: indent };
-}
-function getIndentation(text) {
-  return isIndentedText(text) ? text.indentation : 0;
-}
-function getText(text) {
-  return isIndentedText(text) ? text.text : text;
-}
-
-// ../../node_modules/yargs/build/lib/completion-templates.js
-var completionShTemplate = `###-begin-{{app_name}}-completions-###
-#
-# yargs command completion script
-#
-# Installation: {{app_path}} {{completion_command}} >> ~/.bashrc
-#    or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX.
-#
-_{{app_name}}_yargs_completions()
-{
-    local cur_word args type_list
-
-    cur_word="\${COMP_WORDS[COMP_CWORD]}"
-    args=("\${COMP_WORDS[@]}")
-
-    # ask yargs to generate completions.
-    type_list=$({{app_path}} --get-yargs-completions "\${args[@]}")
-
-    COMPREPLY=( $(compgen -W "\${type_list}" -- \${cur_word}) )
-
-    # if no match was found, fall back to filename completion
-    if [ \${#COMPREPLY[@]} -eq 0 ]; then
-      COMPREPLY=()
-    fi
-
-    return 0
-}
-complete -o bashdefault -o default -F _{{app_name}}_yargs_completions {{app_name}}
-###-end-{{app_name}}-completions-###
-`;
-var completionZshTemplate = `#compdef {{app_name}}
-###-begin-{{app_name}}-completions-###
-#
-# yargs command completion script
-#
-# Installation: {{app_path}} {{completion_command}} >> ~/.zshrc
-#    or {{app_path}} {{completion_command}} >> ~/.zprofile on OSX.
-#
-_{{app_name}}_yargs_completions()
-{
-  local reply
-  local si=$IFS
-  IFS=$'
-' reply=($(COMP_CWORD="$((CURRENT-1))" COMP_LINE="$BUFFER" COMP_POINT="$CURSOR" {{app_path}} --get-yargs-completions "\${words[@]}"))
-  IFS=$si
-  _describe 'values' reply
-}
-compdef _{{app_name}}_yargs_completions {{app_name}}
-###-end-{{app_name}}-completions-###
-`;
-
-// ../../node_modules/yargs/build/lib/completion.js
-class Completion {
-  constructor(yargs, usage2, command2, shim2) {
-    var _a2, _b2, _c2;
-    this.yargs = yargs;
-    this.usage = usage2;
-    this.command = command2;
-    this.shim = shim2;
-    this.completionKey = "get-yargs-completions";
-    this.aliases = null;
-    this.customCompletionFunction = null;
-    this.indexAfterLastReset = 0;
-    this.zshShell = (_c2 = ((_a2 = this.shim.getEnv("SHELL")) === null || _a2 === undefined ? undefined : _a2.includes("zsh")) || ((_b2 = this.shim.getEnv("ZSH_NAME")) === null || _b2 === undefined ? undefined : _b2.includes("zsh"))) !== null && _c2 !== undefined ? _c2 : false;
-  }
-  defaultCompletion(args, argv, current, done) {
-    const handlers = this.command.getCommandHandlers();
-    for (let i = 0, ii = args.length;i < ii; ++i) {
-      if (handlers[args[i]] && handlers[args[i]].builder) {
-        const builder = handlers[args[i]].builder;
-        if (isCommandBuilderCallback(builder)) {
-          this.indexAfterLastReset = i + 1;
-          const y = this.yargs.getInternalMethods().reset();
-          builder(y, true);
-          return y.argv;
-        }
-      }
-    }
-    const completions = [];
-    this.commandCompletions(completions, args, current);
-    this.optionCompletions(completions, args, argv, current);
-    this.choicesFromOptionsCompletions(completions, args, argv, current);
-    this.choicesFromPositionalsCompletions(completions, args, argv, current);
-    done(null, completions);
-  }
-  commandCompletions(completions, args, current) {
-    const parentCommands = this.yargs.getInternalMethods().getContext().commands;
-    if (!current.match(/^-/) && parentCommands[parentCommands.length - 1] !== current && !this.previousArgHasChoices(args)) {
-      this.usage.getCommands().forEach((usageCommand) => {
-        const commandName = parseCommand(usageCommand[0]).cmd;
-        if (args.indexOf(commandName) === -1) {
-          if (!this.zshShell) {
-            completions.push(commandName);
-          } else {
-            const desc = usageCommand[1] || "";
-            completions.push(commandName.replace(/:/g, "\\:") + ":" + desc);
-          }
-        }
-      });
-    }
-  }
-  optionCompletions(completions, args, argv, current) {
-    if ((current.match(/^-/) || current === "" && completions.length === 0) && !this.previousArgHasChoices(args)) {
-      const options = this.yargs.getOptions();
-      const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
-      Object.keys(options.key).forEach((key) => {
-        const negable = !!options.configuration["boolean-negation"] && options.boolean.includes(key);
-        const isPositionalKey = positionalKeys.includes(key);
-        if (!isPositionalKey && !options.hiddenOptions.includes(key) && !this.argsContainKey(args, key, negable)) {
-          this.completeOptionKey(key, completions, current, negable && !!options.default[key]);
-        }
-      });
-    }
-  }
-  choicesFromOptionsCompletions(completions, args, argv, current) {
-    if (this.previousArgHasChoices(args)) {
-      const choices = this.getPreviousArgChoices(args);
-      if (choices && choices.length > 0) {
-        completions.push(...choices.map((c) => c.replace(/:/g, "\\:")));
-      }
-    }
-  }
-  choicesFromPositionalsCompletions(completions, args, argv, current) {
-    if (current === "" && completions.length > 0 && this.previousArgHasChoices(args)) {
-      return;
-    }
-    const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
-    const offset = Math.max(this.indexAfterLastReset, this.yargs.getInternalMethods().getContext().commands.length + 1);
-    const positionalKey = positionalKeys[argv._.length - offset - 1];
-    if (!positionalKey) {
-      return;
-    }
-    const choices = this.yargs.getOptions().choices[positionalKey] || [];
-    for (const choice of choices) {
-      if (choice.startsWith(current)) {
-        completions.push(choice.replace(/:/g, "\\:"));
-      }
-    }
-  }
-  getPreviousArgChoices(args) {
-    if (args.length < 1)
-      return;
-    let previousArg = args[args.length - 1];
-    let filter = "";
-    if (!previousArg.startsWith("-") && args.length > 1) {
-      filter = previousArg;
-      previousArg = args[args.length - 2];
-    }
-    if (!previousArg.startsWith("-"))
-      return;
-    const previousArgKey = previousArg.replace(/^-+/, "");
-    const options = this.yargs.getOptions();
-    const possibleAliases = [
-      previousArgKey,
-      ...this.yargs.getAliases()[previousArgKey] || []
-    ];
-    let choices;
-    for (const possibleAlias of possibleAliases) {
-      if (Object.prototype.hasOwnProperty.call(options.key, possibleAlias) && Array.isArray(options.choices[possibleAlias])) {
-        choices = options.choices[possibleAlias];
-        break;
-      }
-    }
-    if (choices) {
-      return choices.filter((choice) => !filter || choice.startsWith(filter));
-    }
-  }
-  previousArgHasChoices(args) {
-    const choices = this.getPreviousArgChoices(args);
-    return choices !== undefined && choices.length > 0;
-  }
-  argsContainKey(args, key, negable) {
-    const argsContains = (s) => args.indexOf((/^[^0-9]$/.test(s) ? "-" : "--") + s) !== -1;
-    if (argsContains(key))
-      return true;
-    if (negable && argsContains(`no-${key}`))
-      return true;
-    if (this.aliases) {
-      for (const alias of this.aliases[key]) {
-        if (argsContains(alias))
-          return true;
-      }
-    }
-    return false;
-  }
-  completeOptionKey(key, completions, current, negable) {
-    var _a2, _b2, _c2, _d;
-    let keyWithDesc = key;
-    if (this.zshShell) {
-      const descs = this.usage.getDescriptions();
-      const aliasKey = (_b2 = (_a2 = this === null || this === undefined ? undefined : this.aliases) === null || _a2 === undefined ? undefined : _a2[key]) === null || _b2 === undefined ? undefined : _b2.find((alias) => {
-        const desc2 = descs[alias];
-        return typeof desc2 === "string" && desc2.length > 0;
-      });
-      const descFromAlias = aliasKey ? descs[aliasKey] : undefined;
-      const desc = (_d = (_c2 = descs[key]) !== null && _c2 !== undefined ? _c2 : descFromAlias) !== null && _d !== undefined ? _d : "";
-      keyWithDesc = `${key.replace(/:/g, "\\:")}:${desc.replace("__yargsString__:", "").replace(/(\r\n|\n|\r)/gm, " ")}`;
-    }
-    const startsByTwoDashes = (s) => /^--/.test(s);
-    const isShortOption = (s) => /^[^0-9]$/.test(s);
-    const dashes = !startsByTwoDashes(current) && isShortOption(key) ? "-" : "--";
-    completions.push(dashes + keyWithDesc);
-    if (negable) {
-      completions.push(dashes + "no-" + keyWithDesc);
-    }
-  }
-  customCompletion(args, argv, current, done) {
-    assertNotStrictEqual(this.customCompletionFunction, null, this.shim);
-    if (isSyncCompletionFunction(this.customCompletionFunction)) {
-      const result = this.customCompletionFunction(current, argv);
-      if (isPromise(result)) {
-        return result.then((list) => {
-          this.shim.process.nextTick(() => {
-            done(null, list);
-          });
-        }).catch((err) => {
-          this.shim.process.nextTick(() => {
-            done(err, undefined);
-          });
-        });
-      }
-      return done(null, result);
-    } else if (isFallbackCompletionFunction(this.customCompletionFunction)) {
-      return this.customCompletionFunction(current, argv, (onCompleted = done) => this.defaultCompletion(args, argv, current, onCompleted), (completions) => {
-        done(null, completions);
-      });
-    } else {
-      return this.customCompletionFunction(current, argv, (completions) => {
-        done(null, completions);
-      });
-    }
-  }
-  getCompletion(args, done) {
-    const current = args.length ? args[args.length - 1] : "";
-    const argv = this.yargs.parse(args, true);
-    const completionFunction = this.customCompletionFunction ? (argv2) => this.customCompletion(args, argv2, current, done) : (argv2) => this.defaultCompletion(args, argv2, current, done);
-    return isPromise(argv) ? argv.then(completionFunction) : completionFunction(argv);
-  }
-  generateCompletionScript($0, cmd) {
-    let script = this.zshShell ? completionZshTemplate : completionShTemplate;
-    const name = this.shim.path.basename($0);
-    if ($0.match(/\.js$/))
-      $0 = `./${$0}`;
-    script = script.replace(/{{app_name}}/g, name);
-    script = script.replace(/{{completion_command}}/g, cmd);
-    return script.replace(/{{app_path}}/g, $0);
-  }
-  registerFunction(fn) {
-    this.customCompletionFunction = fn;
-  }
-  setParsed(parsed) {
-    this.aliases = parsed.aliases;
-  }
-}
-function completion(yargs, usage2, command2, shim2) {
-  return new Completion(yargs, usage2, command2, shim2);
-}
-function isSyncCompletionFunction(completionFunction) {
-  return completionFunction.length < 3;
-}
-function isFallbackCompletionFunction(completionFunction) {
-  return completionFunction.length > 3;
-}
-
-// ../../node_modules/yargs/build/lib/utils/levenshtein.js
-function levenshtein(a, b) {
-  if (a.length === 0)
-    return b.length;
-  if (b.length === 0)
-    return a.length;
-  const matrix = [];
-  let i;
-  for (i = 0;i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  let j;
-  for (j = 0;j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-  for (i = 1;i <= b.length; i++) {
-    for (j = 1;j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        if (i > 1 && j > 1 && b.charAt(i - 2) === a.charAt(j - 1) && b.charAt(i - 1) === a.charAt(j - 2)) {
-          matrix[i][j] = matrix[i - 2][j - 2] + 1;
-        } else {
-          matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
-        }
-      }
-    }
-  }
-  return matrix[b.length][a.length];
-}
-
-// ../../node_modules/yargs/build/lib/validation.js
-var specialKeys = ["$0", "--", "_"];
-function validation(yargs, usage2, shim2) {
-  const __ = shim2.y18n.__;
-  const __n = shim2.y18n.__n;
-  const self = {};
-  self.nonOptionCount = function nonOptionCount(argv) {
-    const demandedCommands = yargs.getDemandedCommands();
-    const positionalCount = argv._.length + (argv["--"] ? argv["--"].length : 0);
-    const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length;
-    if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
-      if (_s < demandedCommands._.min) {
-        if (demandedCommands._.minMsg !== undefined) {
-          usage2.fail(demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString()) : null);
-        } else {
-          usage2.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", _s, _s.toString(), demandedCommands._.min.toString()));
-        }
-      } else if (_s > demandedCommands._.max) {
-        if (demandedCommands._.maxMsg !== undefined) {
-          usage2.fail(demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString()) : null);
-        } else {
-          usage2.fail(__n("Too many non-option arguments: got %s, maximum of %s", "Too many non-option arguments: got %s, maximum of %s", _s, _s.toString(), demandedCommands._.max.toString()));
-        }
-      }
-    }
-  };
-  self.positionalCount = function positionalCount(required, observed) {
-    if (observed < required) {
-      usage2.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, demandedOptions) {
-    let missing = null;
-    for (const key of Object.keys(demandedOptions)) {
-      if (!Object.prototype.hasOwnProperty.call(argv, key) || typeof argv[key] === "undefined") {
-        missing = missing || {};
-        missing[key] = demandedOptions[key];
-      }
-    }
-    if (missing) {
-      const customMsgs = [];
-      for (const key of Object.keys(missing)) {
-        const msg = missing[key];
-        if (msg && customMsgs.indexOf(msg) < 0) {
-          customMsgs.push(msg);
-        }
-      }
-      const customMsg = customMsgs.length ? `
-${customMsgs.join(`
-`)}` : "";
-      usage2.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, checkPositionals = true) {
-    var _a2;
-    const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands();
-    const unknown = [];
-    const currentContext = yargs.getInternalMethods().getContext();
-    Object.keys(argv).forEach((key) => {
-      if (!specialKeys.includes(key) && !Object.prototype.hasOwnProperty.call(positionalMap, key) && !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) && !self.isValidAndSomeAliasIsNotNew(key, aliases)) {
-        unknown.push(key);
-      }
-    });
-    if (checkPositionals && (currentContext.commands.length > 0 || commandKeys.length > 0 || isDefaultCommand)) {
-      argv._.slice(currentContext.commands.length).forEach((key) => {
-        if (!commandKeys.includes("" + key)) {
-          unknown.push("" + key);
-        }
-      });
-    }
-    if (checkPositionals) {
-      const demandedCommands = yargs.getDemandedCommands();
-      const maxNonOptDemanded = ((_a2 = demandedCommands._) === null || _a2 === undefined ? undefined : _a2.max) || 0;
-      const expected = currentContext.commands.length + maxNonOptDemanded;
-      if (expected < argv._.length) {
-        argv._.slice(expected).forEach((key) => {
-          key = String(key);
-          if (!currentContext.commands.includes(key) && !unknown.includes(key)) {
-            unknown.push(key);
-          }
-        });
-      }
-    }
-    if (unknown.length) {
-      usage2.fail(__n("Unknown argument: %s", "Unknown arguments: %s", unknown.length, unknown.map((s) => s.trim() ? s : `"${s}"`).join(", ")));
-    }
-  };
-  self.unknownCommands = function unknownCommands(argv) {
-    const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands();
-    const unknown = [];
-    const currentContext = yargs.getInternalMethods().getContext();
-    if (currentContext.commands.length > 0 || commandKeys.length > 0) {
-      argv._.slice(currentContext.commands.length).forEach((key) => {
-        if (!commandKeys.includes("" + key)) {
-          unknown.push("" + key);
-        }
-      });
-    }
-    if (unknown.length > 0) {
-      usage2.fail(__n("Unknown command: %s", "Unknown commands: %s", unknown.length, unknown.join(", ")));
-      return true;
-    } else {
-      return false;
-    }
-  };
-  self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) {
-    if (!Object.prototype.hasOwnProperty.call(aliases, key)) {
-      return false;
-    }
-    const newAliases = yargs.parsed.newAliases;
-    return [key, ...aliases[key]].some((a) => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]);
-  };
-  self.limitedChoices = function limitedChoices(argv) {
-    const options = yargs.getOptions();
-    const invalid = {};
-    if (!Object.keys(options.choices).length)
-      return;
-    Object.keys(argv).forEach((key) => {
-      if (specialKeys.indexOf(key) === -1 && Object.prototype.hasOwnProperty.call(options.choices, key)) {
-        [].concat(argv[key]).forEach((value) => {
-          if (options.choices[key].indexOf(value) === -1 && value !== undefined) {
-            invalid[key] = (invalid[key] || []).concat(value);
-          }
-        });
-      }
-    });
-    const invalidKeys = Object.keys(invalid);
-    if (!invalidKeys.length)
-      return;
-    let msg = __("Invalid values:");
-    invalidKeys.forEach((key) => {
-      msg += `
-  ${__("Argument: %s, Given: %s, Choices: %s", key, usage2.stringifiedValues(invalid[key]), usage2.stringifiedValues(options.choices[key]))}`;
-    });
-    usage2.fail(msg);
-  };
-  let implied = {};
-  self.implies = function implies(key, value) {
-    argsert("<string|object> [array|number|string]", [key, value], arguments.length);
-    if (typeof key === "object") {
-      Object.keys(key).forEach((k) => {
-        self.implies(k, key[k]);
-      });
-    } else {
-      yargs.global(key);
-      if (!implied[key]) {
-        implied[key] = [];
-      }
-      if (Array.isArray(value)) {
-        value.forEach((i) => self.implies(key, i));
-      } else {
-        assertNotStrictEqual(value, undefined, shim2);
-        implied[key].push(value);
-      }
-    }
-  };
-  self.getImplied = function getImplied() {
-    return implied;
-  };
-  function keyExists(argv, val) {
-    const num = Number(val);
-    val = isNaN(num) ? val : num;
-    if (typeof val === "number") {
-      val = argv._.length >= val;
-    } else if (val.match(/^--no-.+/)) {
-      val = val.match(/^--no-(.+)/)[1];
-      val = !Object.prototype.hasOwnProperty.call(argv, val);
-    } else {
-      val = Object.prototype.hasOwnProperty.call(argv, val);
-    }
-    return val;
-  }
-  self.implications = function implications(argv) {
-    const implyFail = [];
-    Object.keys(implied).forEach((key) => {
-      const origKey = key;
-      (implied[key] || []).forEach((value) => {
-        let key2 = origKey;
-        const origValue = value;
-        key2 = keyExists(argv, key2);
-        value = keyExists(argv, value);
-        if (key2 && !value) {
-          implyFail.push(` ${origKey} -> ${origValue}`);
-        }
-      });
-    });
-    if (implyFail.length) {
-      let msg = `${__("Implications failed:")}
-`;
-      implyFail.forEach((value) => {
-        msg += value;
-      });
-      usage2.fail(msg);
-    }
-  };
-  let conflicting = {};
-  self.conflicts = function conflicts(key, value) {
-    argsert("<string|object> [array|string]", [key, value], arguments.length);
-    if (typeof key === "object") {
-      Object.keys(key).forEach((k) => {
-        self.conflicts(k, key[k]);
-      });
-    } else {
-      yargs.global(key);
-      if (!conflicting[key]) {
-        conflicting[key] = [];
-      }
-      if (Array.isArray(value)) {
-        value.forEach((i) => self.conflicts(key, i));
-      } else {
-        conflicting[key].push(value);
-      }
-    }
-  };
-  self.getConflicting = () => conflicting;
-  self.conflicting = function conflictingFn(argv) {
-    Object.keys(argv).forEach((key) => {
-      if (conflicting[key]) {
-        conflicting[key].forEach((value) => {
-          if (value && argv[key] !== undefined && argv[value] !== undefined) {
-            usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value));
-          }
-        });
-      }
-    });
-    if (yargs.getInternalMethods().getParserConfiguration()["strip-dashed"]) {
-      Object.keys(conflicting).forEach((key) => {
-        conflicting[key].forEach((value) => {
-          if (value && argv[shim2.Parser.camelCase(key)] !== undefined && argv[shim2.Parser.camelCase(value)] !== undefined) {
-            usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value));
-          }
-        });
-      });
-    }
-  };
-  self.recommendCommands = function recommendCommands(cmd, potentialCommands) {
-    const threshold = 3;
-    potentialCommands = potentialCommands.sort((a, b) => b.length - a.length);
-    let recommended = null;
-    let bestDistance = Infinity;
-    for (let i = 0, candidate;(candidate = potentialCommands[i]) !== undefined; i++) {
-      const d = levenshtein(cmd, candidate);
-      if (d <= threshold && d < bestDistance) {
-        bestDistance = d;
-        recommended = candidate;
-      }
-    }
-    if (recommended)
-      usage2.fail(__("Did you mean %s?", recommended));
-  };
-  self.reset = function reset(localLookup) {
-    implied = objFilter(implied, (k) => !localLookup[k]);
-    conflicting = objFilter(conflicting, (k) => !localLookup[k]);
-    return self;
-  };
-  const frozens = [];
-  self.freeze = function freeze() {
-    frozens.push({
-      implied,
-      conflicting
-    });
-  };
-  self.unfreeze = function unfreeze() {
-    const frozen = frozens.pop();
-    assertNotStrictEqual(frozen, undefined, shim2);
-    ({ implied, conflicting } = frozen);
-  };
-  return self;
-}
-
-// ../../node_modules/yargs/build/lib/utils/apply-extends.js
-var previouslyVisitedConfigs = [];
-var shim2;
-function applyExtends(config, cwd, mergeExtends, _shim) {
-  shim2 = _shim;
-  let defaultConfig = {};
-  if (Object.prototype.hasOwnProperty.call(config, "extends")) {
-    if (typeof config.extends !== "string")
-      return defaultConfig;
-    const isPath = /\.json|\..*rc$/.test(config.extends);
-    let pathToDefault = null;
-    if (!isPath) {
-      try {
-        pathToDefault = __require.resolve(config.extends);
-      } catch (_err) {
-        return config;
-      }
-    } else {
-      pathToDefault = getPathToDefaultConfig(cwd, config.extends);
-    }
-    checkForCircularExtends(pathToDefault);
-    previouslyVisitedConfigs.push(pathToDefault);
-    defaultConfig = isPath ? JSON.parse(shim2.readFileSync(pathToDefault, "utf8")) : __require(config.extends);
-    delete config.extends;
-    defaultConfig = applyExtends(defaultConfig, shim2.path.dirname(pathToDefault), mergeExtends, shim2);
-  }
-  previouslyVisitedConfigs = [];
-  return mergeExtends ? mergeDeep(defaultConfig, config) : Object.assign({}, defaultConfig, config);
-}
-function checkForCircularExtends(cfgPath) {
-  if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
-    throw new YError(`Circular extended configurations: '${cfgPath}'.`);
-  }
-}
-function getPathToDefaultConfig(cwd, pathToExtend) {
-  return shim2.path.resolve(cwd, pathToExtend);
-}
-function mergeDeep(config1, config2) {
-  const target = {};
-  function isObject(obj) {
-    return obj && typeof obj === "object" && !Array.isArray(obj);
-  }
-  Object.assign(target, config1);
-  for (const key of Object.keys(config2)) {
-    if (isObject(config2[key]) && isObject(target[key])) {
-      target[key] = mergeDeep(config1[key], config2[key]);
-    } else {
-      target[key] = config2[key];
-    }
-  }
-  return target;
-}
-
-// ../../node_modules/yargs/build/lib/yargs-factory.js
-var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
-  if (kind === "m")
-    throw new TypeError("Private method is not writable");
-  if (kind === "a" && !f)
-    throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-    throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
-};
-var __classPrivateFieldGet = function(receiver, state, kind, f) {
-  if (kind === "a" && !f)
-    throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-    throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _YargsInstance_command;
-var _YargsInstance_cwd;
-var _YargsInstance_context;
-var _YargsInstance_completion;
-var _YargsInstance_completionCommand;
-var _YargsInstance_defaultShowHiddenOpt;
-var _YargsInstance_exitError;
-var _YargsInstance_detectLocale;
-var _YargsInstance_emittedWarnings;
-var _YargsInstance_exitProcess;
-var _YargsInstance_frozens;
-var _YargsInstance_globalMiddleware;
-var _YargsInstance_groups;
-var _YargsInstance_hasOutput;
-var _YargsInstance_helpOpt;
-var _YargsInstance_isGlobalContext;
-var _YargsInstance_logger;
-var _YargsInstance_output;
-var _YargsInstance_options;
-var _YargsInstance_parentRequire;
-var _YargsInstance_parserConfig;
-var _YargsInstance_parseFn;
-var _YargsInstance_parseContext;
-var _YargsInstance_pkgs;
-var _YargsInstance_preservedGroups;
-var _YargsInstance_processArgs;
-var _YargsInstance_recommendCommands;
-var _YargsInstance_shim;
-var _YargsInstance_strict;
-var _YargsInstance_strictCommands;
-var _YargsInstance_strictOptions;
-var _YargsInstance_usage;
-var _YargsInstance_usageConfig;
-var _YargsInstance_versionOpt;
-var _YargsInstance_validation;
-function YargsFactory(_shim) {
-  return (processArgs = [], cwd = _shim.process.cwd(), parentRequire) => {
-    const yargs = new YargsInstance(processArgs, cwd, parentRequire, _shim);
-    Object.defineProperty(yargs, "argv", {
-      get: () => {
-        return yargs.parse();
-      },
-      enumerable: true
-    });
-    yargs.help();
-    yargs.version();
-    return yargs;
-  };
-}
-var kCopyDoubleDash = Symbol("copyDoubleDash");
-var kCreateLogger = Symbol("copyDoubleDash");
-var kDeleteFromParserHintObject = Symbol("deleteFromParserHintObject");
-var kEmitWarning = Symbol("emitWarning");
-var kFreeze = Symbol("freeze");
-var kGetDollarZero = Symbol("getDollarZero");
-var kGetParserConfiguration = Symbol("getParserConfiguration");
-var kGetUsageConfiguration = Symbol("getUsageConfiguration");
-var kGuessLocale = Symbol("guessLocale");
-var kGuessVersion = Symbol("guessVersion");
-var kParsePositionalNumbers = Symbol("parsePositionalNumbers");
-var kPkgUp = Symbol("pkgUp");
-var kPopulateParserHintArray = Symbol("populateParserHintArray");
-var kPopulateParserHintSingleValueDictionary = Symbol("populateParserHintSingleValueDictionary");
-var kPopulateParserHintArrayDictionary = Symbol("populateParserHintArrayDictionary");
-var kPopulateParserHintDictionary = Symbol("populateParserHintDictionary");
-var kSanitizeKey = Symbol("sanitizeKey");
-var kSetKey = Symbol("setKey");
-var kUnfreeze = Symbol("unfreeze");
-var kValidateAsync = Symbol("validateAsync");
-var kGetCommandInstance = Symbol("getCommandInstance");
-var kGetContext = Symbol("getContext");
-var kGetHasOutput = Symbol("getHasOutput");
-var kGetLoggerInstance = Symbol("getLoggerInstance");
-var kGetParseContext = Symbol("getParseContext");
-var kGetUsageInstance = Symbol("getUsageInstance");
-var kGetValidationInstance = Symbol("getValidationInstance");
-var kHasParseCallback = Symbol("hasParseCallback");
-var kIsGlobalContext = Symbol("isGlobalContext");
-var kPostProcess = Symbol("postProcess");
-var kRebase = Symbol("rebase");
-var kReset = Symbol("reset");
-var kRunYargsParserAndExecuteCommands = Symbol("runYargsParserAndExecuteCommands");
-var kRunValidation = Symbol("runValidation");
-var kSetHasOutput = Symbol("setHasOutput");
-var kTrackManuallySetKeys = Symbol("kTrackManuallySetKeys");
-
-class YargsInstance {
-  constructor(processArgs = [], cwd, parentRequire, shim3) {
-    this.customScriptName = false;
-    this.parsed = false;
-    _YargsInstance_command.set(this, undefined);
-    _YargsInstance_cwd.set(this, undefined);
-    _YargsInstance_context.set(this, { commands: [], fullCommands: [] });
-    _YargsInstance_completion.set(this, null);
-    _YargsInstance_completionCommand.set(this, null);
-    _YargsInstance_defaultShowHiddenOpt.set(this, "show-hidden");
-    _YargsInstance_exitError.set(this, null);
-    _YargsInstance_detectLocale.set(this, true);
-    _YargsInstance_emittedWarnings.set(this, {});
-    _YargsInstance_exitProcess.set(this, true);
-    _YargsInstance_frozens.set(this, []);
-    _YargsInstance_globalMiddleware.set(this, undefined);
-    _YargsInstance_groups.set(this, {});
-    _YargsInstance_hasOutput.set(this, false);
-    _YargsInstance_helpOpt.set(this, null);
-    _YargsInstance_isGlobalContext.set(this, true);
-    _YargsInstance_logger.set(this, undefined);
-    _YargsInstance_output.set(this, "");
-    _YargsInstance_options.set(this, undefined);
-    _YargsInstance_parentRequire.set(this, undefined);
-    _YargsInstance_parserConfig.set(this, {});
-    _YargsInstance_parseFn.set(this, null);
-    _YargsInstance_parseContext.set(this, null);
-    _YargsInstance_pkgs.set(this, {});
-    _YargsInstance_preservedGroups.set(this, {});
-    _YargsInstance_processArgs.set(this, undefined);
-    _YargsInstance_recommendCommands.set(this, false);
-    _YargsInstance_shim.set(this, undefined);
-    _YargsInstance_strict.set(this, false);
-    _YargsInstance_strictCommands.set(this, false);
-    _YargsInstance_strictOptions.set(this, false);
-    _YargsInstance_usage.set(this, undefined);
-    _YargsInstance_usageConfig.set(this, {});
-    _YargsInstance_versionOpt.set(this, null);
-    _YargsInstance_validation.set(this, undefined);
-    __classPrivateFieldSet(this, _YargsInstance_shim, shim3, "f");
-    __classPrivateFieldSet(this, _YargsInstance_processArgs, processArgs, "f");
-    __classPrivateFieldSet(this, _YargsInstance_cwd, cwd, "f");
-    __classPrivateFieldSet(this, _YargsInstance_parentRequire, parentRequire, "f");
-    __classPrivateFieldSet(this, _YargsInstance_globalMiddleware, new GlobalMiddleware(this), "f");
-    this.$0 = this[kGetDollarZero]();
-    this[kReset]();
-    __classPrivateFieldSet(this, _YargsInstance_command, __classPrivateFieldGet(this, _YargsInstance_command, "f"), "f");
-    __classPrivateFieldSet(this, _YargsInstance_usage, __classPrivateFieldGet(this, _YargsInstance_usage, "f"), "f");
-    __classPrivateFieldSet(this, _YargsInstance_validation, __classPrivateFieldGet(this, _YargsInstance_validation, "f"), "f");
-    __classPrivateFieldSet(this, _YargsInstance_options, __classPrivateFieldGet(this, _YargsInstance_options, "f"), "f");
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").showHiddenOpt = __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, "f");
-    __classPrivateFieldSet(this, _YargsInstance_logger, this[kCreateLogger](), "f");
-  }
-  addHelpOpt(opt, msg) {
-    const defaultHelpOpt = "help";
-    argsert("[string|boolean] [string]", [opt, msg], arguments.length);
-    if (__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")) {
-      this[kDeleteFromParserHintObject](__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"));
-      __classPrivateFieldSet(this, _YargsInstance_helpOpt, null, "f");
-    }
-    if (opt === false && msg === undefined)
-      return this;
-    __classPrivateFieldSet(this, _YargsInstance_helpOpt, typeof opt === "string" ? opt : defaultHelpOpt, "f");
-    this.boolean(__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"));
-    this.describe(__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"), msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show help"));
-    return this;
-  }
-  help(opt, msg) {
-    return this.addHelpOpt(opt, msg);
-  }
-  addShowHiddenOpt(opt, msg) {
-    argsert("[string|boolean] [string]", [opt, msg], arguments.length);
-    if (opt === false && msg === undefined)
-      return this;
-    const showHiddenOpt = typeof opt === "string" ? opt : __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, "f");
-    this.boolean(showHiddenOpt);
-    this.describe(showHiddenOpt, msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show hidden options"));
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").showHiddenOpt = showHiddenOpt;
-    return this;
-  }
-  showHidden(opt, msg) {
-    return this.addShowHiddenOpt(opt, msg);
-  }
-  alias(key, value) {
-    argsert("<object|string|array> [string|array]", [key, value], arguments.length);
-    this[kPopulateParserHintArrayDictionary](this.alias.bind(this), "alias", key, value);
-    return this;
-  }
-  array(keys) {
-    argsert("<array|string>", [keys], arguments.length);
-    this[kPopulateParserHintArray]("array", keys);
-    this[kTrackManuallySetKeys](keys);
-    return this;
-  }
-  boolean(keys) {
-    argsert("<array|string>", [keys], arguments.length);
-    this[kPopulateParserHintArray]("boolean", keys);
-    this[kTrackManuallySetKeys](keys);
-    return this;
-  }
-  check(f, global) {
-    argsert("<function> [boolean]", [f, global], arguments.length);
-    this.middleware((argv, _yargs) => {
-      return maybeAsyncResult(() => {
-        return f(argv, _yargs.getOptions());
-      }, (result) => {
-        if (!result) {
-          __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(__classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.__("Argument check failed: %s", f.toString()));
-        } else if (typeof result === "string" || result instanceof Error) {
-          __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(result.toString(), result);
-        }
-        return argv;
-      }, (err) => {
-        __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(err.message ? err.message : err.toString(), err);
-        return argv;
-      });
-    }, false, global);
-    return this;
-  }
-  choices(key, value) {
-    argsert("<object|string|array> [string|array]", [key, value], arguments.length);
-    this[kPopulateParserHintArrayDictionary](this.choices.bind(this), "choices", key, value);
-    return this;
-  }
-  coerce(keys, value) {
-    argsert("<object|string|array> [function]", [keys, value], arguments.length);
-    if (Array.isArray(keys)) {
-      if (!value) {
-        throw new YError("coerce callback must be provided");
-      }
-      for (const key of keys) {
-        this.coerce(key, value);
-      }
-      return this;
-    } else if (typeof keys === "object") {
-      for (const key of Object.keys(keys)) {
-        this.coerce(key, keys[key]);
-      }
-      return this;
-    }
-    if (!value) {
-      throw new YError("coerce callback must be provided");
-    }
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").key[keys] = true;
-    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").addCoerceMiddleware((argv, yargs) => {
-      let aliases;
-      const shouldCoerce = Object.prototype.hasOwnProperty.call(argv, keys);
-      if (!shouldCoerce) {
-        return argv;
-      }
-      return maybeAsyncResult(() => {
-        aliases = yargs.getAliases();
-        return value(argv[keys]);
-      }, (result) => {
-        argv[keys] = result;
-        const stripAliased = yargs.getInternalMethods().getParserConfiguration()["strip-aliased"];
-        if (aliases[keys] && stripAliased !== true) {
-          for (const alias of aliases[keys]) {
-            argv[alias] = result;
-          }
-        }
-        return argv;
-      }, (err) => {
-        throw new YError(err.message);
-      });
-    }, keys);
-    return this;
-  }
-  conflicts(key1, key2) {
-    argsert("<string|object> [string|array]", [key1, key2], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_validation, "f").conflicts(key1, key2);
-    return this;
-  }
-  config(key = "config", msg, parseFn) {
-    argsert("[object|string] [string|function] [function]", [key, msg, parseFn], arguments.length);
-    if (typeof key === "object" && !Array.isArray(key)) {
-      key = applyExtends(key, __classPrivateFieldGet(this, _YargsInstance_cwd, "f"), this[kGetParserConfiguration]()["deep-merge-config"] || false, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects = (__classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects || []).concat(key);
-      return this;
-    }
-    if (typeof msg === "function") {
-      parseFn = msg;
-      msg = undefined;
-    }
-    this.describe(key, msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Path to JSON config file"));
-    (Array.isArray(key) ? key : [key]).forEach((k) => {
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").config[k] = parseFn || true;
-    });
-    return this;
-  }
-  completion(cmd, desc, fn) {
-    argsert("[string] [string|boolean|function] [function]", [cmd, desc, fn], arguments.length);
-    if (typeof desc === "function") {
-      fn = desc;
-      desc = undefined;
-    }
-    __classPrivateFieldSet(this, _YargsInstance_completionCommand, cmd || __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f") || "completion", "f");
-    if (!desc && desc !== false) {
-      desc = "generate completion script";
-    }
-    this.command(__classPrivateFieldGet(this, _YargsInstance_completionCommand, "f"), desc);
-    if (fn)
-      __classPrivateFieldGet(this, _YargsInstance_completion, "f").registerFunction(fn);
-    return this;
-  }
-  command(cmd, description, builder, handler, middlewares, deprecated) {
-    argsert("<string|array|object> [string|boolean] [function|object] [function] [array] [boolean|string]", [cmd, description, builder, handler, middlewares, deprecated], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_command, "f").addHandler(cmd, description, builder, handler, middlewares, deprecated);
-    return this;
-  }
-  commands(cmd, description, builder, handler, middlewares, deprecated) {
-    return this.command(cmd, description, builder, handler, middlewares, deprecated);
-  }
-  commandDir(dir, opts) {
-    argsert("<string> [object]", [dir, opts], arguments.length);
-    const req = __classPrivateFieldGet(this, _YargsInstance_parentRequire, "f") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").require;
-    __classPrivateFieldGet(this, _YargsInstance_command, "f").addDirectory(dir, req, __classPrivateFieldGet(this, _YargsInstance_shim, "f").getCallerFile(), opts);
-    return this;
-  }
-  count(keys) {
-    argsert("<array|string>", [keys], arguments.length);
-    this[kPopulateParserHintArray]("count", keys);
-    this[kTrackManuallySetKeys](keys);
-    return this;
-  }
-  default(key, value, defaultDescription) {
-    argsert("<object|string|array> [*] [string]", [key, value, defaultDescription], arguments.length);
-    if (defaultDescription) {
-      assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = defaultDescription;
-    }
-    if (typeof value === "function") {
-      assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-      if (!__classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key])
-        __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = __classPrivateFieldGet(this, _YargsInstance_usage, "f").functionDescription(value);
-      value = value.call();
-    }
-    this[kPopulateParserHintSingleValueDictionary](this.default.bind(this), "default", key, value);
-    return this;
-  }
-  defaults(key, value, defaultDescription) {
-    return this.default(key, value, defaultDescription);
-  }
-  demandCommand(min = 1, max, minMsg, maxMsg) {
-    argsert("[number] [number|string] [string|null|undefined] [string|null|undefined]", [min, max, minMsg, maxMsg], arguments.length);
-    if (typeof max !== "number") {
-      minMsg = max;
-      max = Infinity;
-    }
-    this.global("_", false);
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedCommands._ = {
-      min,
-      max,
-      minMsg,
-      maxMsg
-    };
-    return this;
-  }
-  demand(keys, max, msg) {
-    if (Array.isArray(max)) {
-      max.forEach((key) => {
-        assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-        this.demandOption(key, msg);
-      });
-      max = Infinity;
-    } else if (typeof max !== "number") {
-      msg = max;
-      max = Infinity;
-    }
-    if (typeof keys === "number") {
-      assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-      this.demandCommand(keys, max, msg, msg);
-    } else if (Array.isArray(keys)) {
-      keys.forEach((key) => {
-        assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-        this.demandOption(key, msg);
-      });
-    } else {
-      if (typeof msg === "string") {
-        this.demandOption(keys, msg);
-      } else if (msg === true || typeof msg === "undefined") {
-        this.demandOption(keys);
-      }
-    }
-    return this;
-  }
-  demandOption(keys, msg) {
-    argsert("<object|string|array> [string]", [keys, msg], arguments.length);
-    this[kPopulateParserHintSingleValueDictionary](this.demandOption.bind(this), "demandedOptions", keys, msg);
-    return this;
-  }
-  deprecateOption(option, message) {
-    argsert("<string> [string|boolean]", [option, message], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").deprecatedOptions[option] = message;
-    return this;
-  }
-  describe(keys, description) {
-    argsert("<object|string|array> [string]", [keys, description], arguments.length);
-    this[kSetKey](keys, true);
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").describe(keys, description);
-    return this;
-  }
-  detectLocale(detect) {
-    argsert("<boolean>", [detect], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_detectLocale, detect, "f");
-    return this;
-  }
-  env(prefix) {
-    argsert("[string|boolean]", [prefix], arguments.length);
-    if (prefix === false)
-      delete __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix;
-    else
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix = prefix || "";
-    return this;
-  }
-  epilogue(msg) {
-    argsert("<string>", [msg], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").epilog(msg);
-    return this;
-  }
-  epilog(msg) {
-    return this.epilogue(msg);
-  }
-  example(cmd, description) {
-    argsert("<string|array> [string]", [cmd, description], arguments.length);
-    if (Array.isArray(cmd)) {
-      cmd.forEach((exampleParams) => this.example(...exampleParams));
-    } else {
-      __classPrivateFieldGet(this, _YargsInstance_usage, "f").example(cmd, description);
-    }
-    return this;
-  }
-  exit(code, err) {
-    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
-    __classPrivateFieldSet(this, _YargsInstance_exitError, err, "f");
-    if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
-      __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.exit(code);
-  }
-  exitProcess(enabled = true) {
-    argsert("[boolean]", [enabled], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_exitProcess, enabled, "f");
-    return this;
-  }
-  fail(f) {
-    argsert("<function|boolean>", [f], arguments.length);
-    if (typeof f === "boolean" && f !== false) {
-      throw new YError("Invalid first argument. Expected function or boolean 'false'");
-    }
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").failFn(f);
-    return this;
-  }
-  getAliases() {
-    return this.parsed ? this.parsed.aliases : {};
-  }
-  async getCompletion(args, done) {
-    argsert("<array> [function]", [args, done], arguments.length);
-    if (!done) {
-      return new Promise((resolve5, reject) => {
-        __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
-          if (err)
-            reject(err);
-          else
-            resolve5(completions);
-        });
-      });
-    } else {
-      return __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, done);
-    }
-  }
-  getDemandedOptions() {
-    argsert([], 0);
-    return __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedOptions;
-  }
-  getDemandedCommands() {
-    argsert([], 0);
-    return __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedCommands;
-  }
-  getDeprecatedOptions() {
-    argsert([], 0);
-    return __classPrivateFieldGet(this, _YargsInstance_options, "f").deprecatedOptions;
-  }
-  getDetectLocale() {
-    return __classPrivateFieldGet(this, _YargsInstance_detectLocale, "f");
-  }
-  getExitProcess() {
-    return __classPrivateFieldGet(this, _YargsInstance_exitProcess, "f");
-  }
-  getGroups() {
-    return Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_groups, "f"), __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f"));
-  }
-  getHelp() {
-    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
-    if (!__classPrivateFieldGet(this, _YargsInstance_usage, "f").hasCachedHelpMessage()) {
-      if (!this.parsed) {
-        const parse = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet(this, _YargsInstance_processArgs, "f"), undefined, undefined, 0, true);
-        if (isPromise(parse)) {
-          return parse.then(() => {
-            return __classPrivateFieldGet(this, _YargsInstance_usage, "f").help();
-          });
-        }
-      }
-      const builderResponse = __classPrivateFieldGet(this, _YargsInstance_command, "f").runDefaultBuilderOn(this);
-      if (isPromise(builderResponse)) {
-        return builderResponse.then(() => {
-          return __classPrivateFieldGet(this, _YargsInstance_usage, "f").help();
-        });
-      }
-    }
-    return Promise.resolve(__classPrivateFieldGet(this, _YargsInstance_usage, "f").help());
-  }
-  getOptions() {
-    return __classPrivateFieldGet(this, _YargsInstance_options, "f");
-  }
-  getStrict() {
-    return __classPrivateFieldGet(this, _YargsInstance_strict, "f");
-  }
-  getStrictCommands() {
-    return __classPrivateFieldGet(this, _YargsInstance_strictCommands, "f");
-  }
-  getStrictOptions() {
-    return __classPrivateFieldGet(this, _YargsInstance_strictOptions, "f");
-  }
-  global(globals, global) {
-    argsert("<string|array> [boolean]", [globals, global], arguments.length);
-    globals = [].concat(globals);
-    if (global !== false) {
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").local = __classPrivateFieldGet(this, _YargsInstance_options, "f").local.filter((l) => globals.indexOf(l) === -1);
-    } else {
-      globals.forEach((g) => {
-        if (!__classPrivateFieldGet(this, _YargsInstance_options, "f").local.includes(g))
-          __classPrivateFieldGet(this, _YargsInstance_options, "f").local.push(g);
-      });
-    }
-    return this;
-  }
-  group(opts, groupName) {
-    argsert("<string|array> <string>", [opts, groupName], arguments.length);
-    const existing = __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName] || __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName];
-    if (__classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName]) {
-      delete __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName];
-    }
-    const seen = {};
-    __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName] = (existing || []).concat(opts).filter((key) => {
-      if (seen[key])
-        return false;
-      return seen[key] = true;
-    });
-    return this;
-  }
-  hide(key) {
-    argsert("<string>", [key], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").hiddenOptions.push(key);
-    return this;
-  }
-  implies(key, value) {
-    argsert("<string|object> [number|string|array]", [key, value], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_validation, "f").implies(key, value);
-    return this;
-  }
-  locale(locale) {
-    argsert("[string]", [locale], arguments.length);
-    if (locale === undefined) {
-      this[kGuessLocale]();
-      return __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.getLocale();
-    }
-    __classPrivateFieldSet(this, _YargsInstance_detectLocale, false, "f");
-    __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.setLocale(locale);
-    return this;
-  }
-  middleware(callback, applyBeforeValidation, global) {
-    return __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").addMiddleware(callback, !!applyBeforeValidation, global);
-  }
-  nargs(key, value) {
-    argsert("<string|object|array> [number]", [key, value], arguments.length);
-    this[kPopulateParserHintSingleValueDictionary](this.nargs.bind(this), "narg", key, value);
-    return this;
-  }
-  normalize(keys) {
-    argsert("<array|string>", [keys], arguments.length);
-    this[kPopulateParserHintArray]("normalize", keys);
-    return this;
-  }
-  number(keys) {
-    argsert("<array|string>", [keys], arguments.length);
-    this[kPopulateParserHintArray]("number", keys);
-    this[kTrackManuallySetKeys](keys);
-    return this;
-  }
-  option(key, opt) {
-    argsert("<string|object> [object]", [key, opt], arguments.length);
-    if (typeof key === "object") {
-      Object.keys(key).forEach((k) => {
-        this.options(k, key[k]);
-      });
-    } else {
-      if (typeof opt !== "object") {
-        opt = {};
-      }
-      this[kTrackManuallySetKeys](key);
-      if (__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f") && (key === "version" || (opt === null || opt === undefined ? undefined : opt.alias) === "version")) {
-        this[kEmitWarning]([
-          '"version" is a reserved word.',
-          "Please do one of the following:",
-          '- Disable version with `yargs.version(false)` if using "version" as an option',
-          "- Use the built-in `yargs.version` method instead (if applicable)",
-          "- Use a different option key",
-          "https://yargs.js.org/docs/#api-reference-version"
-        ].join(`
-`), undefined, "versionWarning");
-      }
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").key[key] = true;
-      if (opt.alias)
-        this.alias(key, opt.alias);
-      const deprecate = opt.deprecate || opt.deprecated;
-      if (deprecate) {
-        this.deprecateOption(key, deprecate);
-      }
-      const demand = opt.demand || opt.required || opt.require;
-      if (demand) {
-        this.demand(key, demand);
-      }
-      if (opt.demandOption) {
-        this.demandOption(key, typeof opt.demandOption === "string" ? opt.demandOption : undefined);
-      }
-      if (opt.conflicts) {
-        this.conflicts(key, opt.conflicts);
-      }
-      if ("default" in opt) {
-        this.default(key, opt.default);
-      }
-      if (opt.implies !== undefined) {
-        this.implies(key, opt.implies);
-      }
-      if (opt.nargs !== undefined) {
-        this.nargs(key, opt.nargs);
-      }
-      if (opt.config) {
-        this.config(key, opt.configParser);
-      }
-      if (opt.normalize) {
-        this.normalize(key);
-      }
-      if (opt.choices) {
-        this.choices(key, opt.choices);
-      }
-      if (opt.coerce) {
-        this.coerce(key, opt.coerce);
-      }
-      if (opt.group) {
-        this.group(key, opt.group);
-      }
-      if (opt.boolean || opt.type === "boolean") {
-        this.boolean(key);
-        if (opt.alias)
-          this.boolean(opt.alias);
-      }
-      if (opt.array || opt.type === "array") {
-        this.array(key);
-        if (opt.alias)
-          this.array(opt.alias);
-      }
-      if (opt.number || opt.type === "number") {
-        this.number(key);
-        if (opt.alias)
-          this.number(opt.alias);
-      }
-      if (opt.string || opt.type === "string") {
-        this.string(key);
-        if (opt.alias)
-          this.string(opt.alias);
-      }
-      if (opt.count || opt.type === "count") {
-        this.count(key);
-      }
-      if (typeof opt.global === "boolean") {
-        this.global(key, opt.global);
-      }
-      if (opt.defaultDescription) {
-        __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = opt.defaultDescription;
-      }
-      if (opt.skipValidation) {
-        this.skipValidation(key);
-      }
-      const desc = opt.describe || opt.description || opt.desc;
-      const descriptions = __classPrivateFieldGet(this, _YargsInstance_usage, "f").getDescriptions();
-      if (!Object.prototype.hasOwnProperty.call(descriptions, key) || typeof desc === "string") {
-        this.describe(key, desc);
-      }
-      if (opt.hidden) {
-        this.hide(key);
-      }
-      if (opt.requiresArg) {
-        this.requiresArg(key);
-      }
-    }
-    return this;
-  }
-  options(key, opt) {
-    return this.option(key, opt);
-  }
-  parse(args, shortCircuit, _parseFn) {
-    argsert("[string|array] [function|boolean|object] [function]", [args, shortCircuit, _parseFn], arguments.length);
-    this[kFreeze]();
-    if (typeof args === "undefined") {
-      args = __classPrivateFieldGet(this, _YargsInstance_processArgs, "f");
-    }
-    if (typeof shortCircuit === "object") {
-      __classPrivateFieldSet(this, _YargsInstance_parseContext, shortCircuit, "f");
-      shortCircuit = _parseFn;
-    }
-    if (typeof shortCircuit === "function") {
-      __classPrivateFieldSet(this, _YargsInstance_parseFn, shortCircuit, "f");
-      shortCircuit = false;
-    }
-    if (!shortCircuit)
-      __classPrivateFieldSet(this, _YargsInstance_processArgs, args, "f");
-    if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
-      __classPrivateFieldSet(this, _YargsInstance_exitProcess, false, "f");
-    const parsed = this[kRunYargsParserAndExecuteCommands](args, !!shortCircuit);
-    const tmpParsed = this.parsed;
-    __classPrivateFieldGet(this, _YargsInstance_completion, "f").setParsed(this.parsed);
-    if (isPromise(parsed)) {
-      return parsed.then((argv) => {
-        if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
-          __classPrivateFieldGet(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, "f"), argv, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
-        return argv;
-      }).catch((err) => {
-        if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f")) {
-          __classPrivateFieldGet(this, _YargsInstance_parseFn, "f")(err, this.parsed.argv, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
-        }
-        throw err;
-      }).finally(() => {
-        this[kUnfreeze]();
-        this.parsed = tmpParsed;
-      });
-    } else {
-      if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
-        __classPrivateFieldGet(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, "f"), parsed, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
-      this[kUnfreeze]();
-      this.parsed = tmpParsed;
-    }
-    return parsed;
-  }
-  parseAsync(args, shortCircuit, _parseFn) {
-    const maybePromise = this.parse(args, shortCircuit, _parseFn);
-    return !isPromise(maybePromise) ? Promise.resolve(maybePromise) : maybePromise;
-  }
-  parseSync(args, shortCircuit, _parseFn) {
-    const maybePromise = this.parse(args, shortCircuit, _parseFn);
-    if (isPromise(maybePromise)) {
-      throw new YError(".parseSync() must not be used with asynchronous builders, handlers, or middleware");
-    }
-    return maybePromise;
-  }
-  parserConfiguration(config) {
-    argsert("<object>", [config], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_parserConfig, config, "f");
-    return this;
-  }
-  pkgConf(key, rootPath) {
-    argsert("<string> [string]", [key, rootPath], arguments.length);
-    let conf = null;
-    const obj = this[kPkgUp](rootPath || __classPrivateFieldGet(this, _YargsInstance_cwd, "f"));
-    if (obj[key] && typeof obj[key] === "object") {
-      conf = applyExtends(obj[key], rootPath || __classPrivateFieldGet(this, _YargsInstance_cwd, "f"), this[kGetParserConfiguration]()["deep-merge-config"] || false, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects = (__classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects || []).concat(conf);
-    }
-    return this;
-  }
-  positional(key, opts) {
-    argsert("<string> <object>", [key, opts], arguments.length);
-    const supportedOpts = [
-      "default",
-      "defaultDescription",
-      "implies",
-      "normalize",
-      "choices",
-      "conflicts",
-      "coerce",
-      "type",
-      "describe",
-      "desc",
-      "description",
-      "alias"
-    ];
-    opts = objFilter(opts, (k, v) => {
-      if (k === "type" && !["string", "number", "boolean"].includes(v))
-        return false;
-      return supportedOpts.includes(k);
-    });
-    const fullCommand = __classPrivateFieldGet(this, _YargsInstance_context, "f").fullCommands[__classPrivateFieldGet(this, _YargsInstance_context, "f").fullCommands.length - 1];
-    const parseOptions = fullCommand ? __classPrivateFieldGet(this, _YargsInstance_command, "f").cmdToParseOptions(fullCommand) : {
-      array: [],
-      alias: {},
-      default: {},
-      demand: {}
-    };
-    objectKeys(parseOptions).forEach((pk) => {
-      const parseOption = parseOptions[pk];
-      if (Array.isArray(parseOption)) {
-        if (parseOption.indexOf(key) !== -1)
-          opts[pk] = true;
-      } else {
-        if (parseOption[key] && !(pk in opts))
-          opts[pk] = parseOption[key];
-      }
-    });
-    this.group(key, __classPrivateFieldGet(this, _YargsInstance_usage, "f").getPositionalGroupName());
-    return this.option(key, opts);
-  }
-  recommendCommands(recommend = true) {
-    argsert("[boolean]", [recommend], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_recommendCommands, recommend, "f");
-    return this;
-  }
-  required(keys, max, msg) {
-    return this.demand(keys, max, msg);
-  }
-  require(keys, max, msg) {
-    return this.demand(keys, max, msg);
-  }
-  requiresArg(keys) {
-    argsert("<array|string|object> [number]", [keys], arguments.length);
-    if (typeof keys === "string" && __classPrivateFieldGet(this, _YargsInstance_options, "f").narg[keys]) {
-      return this;
-    } else {
-      this[kPopulateParserHintSingleValueDictionary](this.requiresArg.bind(this), "narg", keys, NaN);
-    }
-    return this;
-  }
-  showCompletionScript($0, cmd) {
-    argsert("[string] [string]", [$0, cmd], arguments.length);
-    $0 = $0 || this.$0;
-    __classPrivateFieldGet(this, _YargsInstance_logger, "f").log(__classPrivateFieldGet(this, _YargsInstance_completion, "f").generateCompletionScript($0, cmd || __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f") || "completion"));
-    return this;
-  }
-  showHelp(level) {
-    argsert("[string|function]", [level], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
-    if (!__classPrivateFieldGet(this, _YargsInstance_usage, "f").hasCachedHelpMessage()) {
-      if (!this.parsed) {
-        const parse = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet(this, _YargsInstance_processArgs, "f"), undefined, undefined, 0, true);
-        if (isPromise(parse)) {
-          parse.then(() => {
-            __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelp(level);
-          });
-          return this;
-        }
-      }
-      const builderResponse = __classPrivateFieldGet(this, _YargsInstance_command, "f").runDefaultBuilderOn(this);
-      if (isPromise(builderResponse)) {
-        builderResponse.then(() => {
-          __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelp(level);
-        });
-        return this;
-      }
-    }
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelp(level);
-    return this;
-  }
-  scriptName(scriptName) {
-    this.customScriptName = true;
-    this.$0 = scriptName;
-    return this;
-  }
-  showHelpOnFail(enabled, message) {
-    argsert("[boolean|string] [string]", [enabled, message], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelpOnFail(enabled, message);
-    return this;
-  }
-  showVersion(level) {
-    argsert("[string|function]", [level], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").showVersion(level);
-    return this;
-  }
-  skipValidation(keys) {
-    argsert("<array|string>", [keys], arguments.length);
-    this[kPopulateParserHintArray]("skipValidation", keys);
-    return this;
-  }
-  strict(enabled) {
-    argsert("[boolean]", [enabled], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_strict, enabled !== false, "f");
-    return this;
-  }
-  strictCommands(enabled) {
-    argsert("[boolean]", [enabled], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_strictCommands, enabled !== false, "f");
-    return this;
-  }
-  strictOptions(enabled) {
-    argsert("[boolean]", [enabled], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_strictOptions, enabled !== false, "f");
-    return this;
-  }
-  string(keys) {
-    argsert("<array|string>", [keys], arguments.length);
-    this[kPopulateParserHintArray]("string", keys);
-    this[kTrackManuallySetKeys](keys);
-    return this;
-  }
-  terminalWidth() {
-    argsert([], 0);
-    return __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.stdColumns;
-  }
-  updateLocale(obj) {
-    return this.updateStrings(obj);
-  }
-  updateStrings(obj) {
-    argsert("<object>", [obj], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_detectLocale, false, "f");
-    __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.updateLocale(obj);
-    return this;
-  }
-  usage(msg, description, builder, handler) {
-    argsert("<string|null|undefined> [string|boolean] [function|object] [function]", [msg, description, builder, handler], arguments.length);
-    if (description !== undefined) {
-      assertNotStrictEqual(msg, null, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-      if ((msg || "").match(/^\$0( |$)/)) {
-        return this.command(msg, description, builder, handler);
-      } else {
-        throw new YError(".usage() description must start with $0 if being used as alias for .command()");
-      }
-    } else {
-      __classPrivateFieldGet(this, _YargsInstance_usage, "f").usage(msg);
-      return this;
-    }
-  }
-  usageConfiguration(config) {
-    argsert("<object>", [config], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_usageConfig, config, "f");
-    return this;
-  }
-  version(opt, msg, ver) {
-    const defaultVersionOpt = "version";
-    argsert("[boolean|string] [string] [string]", [opt, msg, ver], arguments.length);
-    if (__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f")) {
-      this[kDeleteFromParserHintObject](__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f"));
-      __classPrivateFieldGet(this, _YargsInstance_usage, "f").version(undefined);
-      __classPrivateFieldSet(this, _YargsInstance_versionOpt, null, "f");
-    }
-    if (arguments.length === 0) {
-      ver = this[kGuessVersion]();
-      opt = defaultVersionOpt;
-    } else if (arguments.length === 1) {
-      if (opt === false) {
-        return this;
-      }
-      ver = opt;
-      opt = defaultVersionOpt;
-    } else if (arguments.length === 2) {
-      ver = msg;
-      msg = undefined;
-    }
-    __classPrivateFieldSet(this, _YargsInstance_versionOpt, typeof opt === "string" ? opt : defaultVersionOpt, "f");
-    msg = msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show version number");
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").version(ver || undefined);
-    this.boolean(__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f"));
-    this.describe(__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f"), msg);
-    return this;
-  }
-  wrap(cols) {
-    argsert("<number|null|undefined>", [cols], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").wrap(cols);
-    return this;
-  }
-  [(_YargsInstance_command = new WeakMap, _YargsInstance_cwd = new WeakMap, _YargsInstance_context = new WeakMap, _YargsInstance_completion = new WeakMap, _YargsInstance_completionCommand = new WeakMap, _YargsInstance_defaultShowHiddenOpt = new WeakMap, _YargsInstance_exitError = new WeakMap, _YargsInstance_detectLocale = new WeakMap, _YargsInstance_emittedWarnings = new WeakMap, _YargsInstance_exitProcess = new WeakMap, _YargsInstance_frozens = new WeakMap, _YargsInstance_globalMiddleware = new WeakMap, _YargsInstance_groups = new WeakMap, _YargsInstance_hasOutput = new WeakMap, _YargsInstance_helpOpt = new WeakMap, _YargsInstance_isGlobalContext = new WeakMap, _YargsInstance_logger = new WeakMap, _YargsInstance_output = new WeakMap, _YargsInstance_options = new WeakMap, _YargsInstance_parentRequire = new WeakMap, _YargsInstance_parserConfig = new WeakMap, _YargsInstance_parseFn = new WeakMap, _YargsInstance_parseContext = new WeakMap, _YargsInstance_pkgs = new WeakMap, _YargsInstance_preservedGroups = new WeakMap, _YargsInstance_processArgs = new WeakMap, _YargsInstance_recommendCommands = new WeakMap, _YargsInstance_shim = new WeakMap, _YargsInstance_strict = new WeakMap, _YargsInstance_strictCommands = new WeakMap, _YargsInstance_strictOptions = new WeakMap, _YargsInstance_usage = new WeakMap, _YargsInstance_usageConfig = new WeakMap, _YargsInstance_versionOpt = new WeakMap, _YargsInstance_validation = new WeakMap, kCopyDoubleDash)](argv) {
-    if (!argv._ || !argv["--"])
-      return argv;
-    argv._.push.apply(argv._, argv["--"]);
-    try {
-      delete argv["--"];
-    } catch (_err) {
-    }
-    return argv;
-  }
-  [kCreateLogger]() {
-    return {
-      log: (...args) => {
-        if (!this[kHasParseCallback]())
-          console.log(...args);
-        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
-        if (__classPrivateFieldGet(this, _YargsInstance_output, "f").length)
-          __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + `
-`, "f");
-        __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + args.join(" "), "f");
-      },
-      error: (...args) => {
-        if (!this[kHasParseCallback]())
-          console.error(...args);
-        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
-        if (__classPrivateFieldGet(this, _YargsInstance_output, "f").length)
-          __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + `
-`, "f");
-        __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + args.join(" "), "f");
-      }
-    };
-  }
-  [kDeleteFromParserHintObject](optionKey) {
-    objectKeys(__classPrivateFieldGet(this, _YargsInstance_options, "f")).forEach((hintKey) => {
-      if (((key) => key === "configObjects")(hintKey))
-        return;
-      const hint = __classPrivateFieldGet(this, _YargsInstance_options, "f")[hintKey];
-      if (Array.isArray(hint)) {
-        if (hint.includes(optionKey))
-          hint.splice(hint.indexOf(optionKey), 1);
-      } else if (typeof hint === "object") {
-        delete hint[optionKey];
-      }
-    });
-    delete __classPrivateFieldGet(this, _YargsInstance_usage, "f").getDescriptions()[optionKey];
-  }
-  [kEmitWarning](warning, type, deduplicationId) {
-    if (!__classPrivateFieldGet(this, _YargsInstance_emittedWarnings, "f")[deduplicationId]) {
-      __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.emitWarning(warning, type);
-      __classPrivateFieldGet(this, _YargsInstance_emittedWarnings, "f")[deduplicationId] = true;
-    }
-  }
-  [kFreeze]() {
-    __classPrivateFieldGet(this, _YargsInstance_frozens, "f").push({
-      options: __classPrivateFieldGet(this, _YargsInstance_options, "f"),
-      configObjects: __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects.slice(0),
-      exitProcess: __classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"),
-      groups: __classPrivateFieldGet(this, _YargsInstance_groups, "f"),
-      strict: __classPrivateFieldGet(this, _YargsInstance_strict, "f"),
-      strictCommands: __classPrivateFieldGet(this, _YargsInstance_strictCommands, "f"),
-      strictOptions: __classPrivateFieldGet(this, _YargsInstance_strictOptions, "f"),
-      completionCommand: __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f"),
-      output: __classPrivateFieldGet(this, _YargsInstance_output, "f"),
-      exitError: __classPrivateFieldGet(this, _YargsInstance_exitError, "f"),
-      hasOutput: __classPrivateFieldGet(this, _YargsInstance_hasOutput, "f"),
-      parsed: this.parsed,
-      parseFn: __classPrivateFieldGet(this, _YargsInstance_parseFn, "f"),
-      parseContext: __classPrivateFieldGet(this, _YargsInstance_parseContext, "f")
-    });
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").freeze();
-    __classPrivateFieldGet(this, _YargsInstance_validation, "f").freeze();
-    __classPrivateFieldGet(this, _YargsInstance_command, "f").freeze();
-    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").freeze();
-  }
-  [kGetDollarZero]() {
-    let $0 = "";
-    let default$0;
-    if (/\b(node|iojs|electron)(\.exe)?$/.test(__classPrivateFieldGet(this, _YargsInstance_shim, "f").process.argv()[0])) {
-      default$0 = __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.argv().slice(1, 2);
-    } else {
-      default$0 = __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.argv().slice(0, 1);
-    }
-    $0 = default$0.map((x) => {
-      const b = this[kRebase](__classPrivateFieldGet(this, _YargsInstance_cwd, "f"), x);
-      return x.match(/^(\/|([a-zA-Z]:)?\\)/) && b.length < x.length ? b : x;
-    }).join(" ").trim();
-    if (__classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("_") && __classPrivateFieldGet(this, _YargsInstance_shim, "f").getProcessArgvBin() === __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("_")) {
-      $0 = __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("_").replace(`${__classPrivateFieldGet(this, _YargsInstance_shim, "f").path.dirname(__classPrivateFieldGet(this, _YargsInstance_shim, "f").process.execPath())}/`, "");
-    }
-    return $0;
-  }
-  [kGetParserConfiguration]() {
-    return __classPrivateFieldGet(this, _YargsInstance_parserConfig, "f");
-  }
-  [kGetUsageConfiguration]() {
-    return __classPrivateFieldGet(this, _YargsInstance_usageConfig, "f");
-  }
-  [kGuessLocale]() {
-    if (!__classPrivateFieldGet(this, _YargsInstance_detectLocale, "f"))
-      return;
-    const locale = __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LC_ALL") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LC_MESSAGES") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LANG") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LANGUAGE") || "en_US";
-    this.locale(locale.replace(/[.:].*/, ""));
-  }
-  [kGuessVersion]() {
-    const obj = this[kPkgUp]();
-    return obj.version || "unknown";
-  }
-  [kParsePositionalNumbers](argv) {
-    const args = argv["--"] ? argv["--"] : argv._;
-    for (let i = 0, arg;(arg = args[i]) !== undefined; i++) {
-      if (__classPrivateFieldGet(this, _YargsInstance_shim, "f").Parser.looksLikeNumber(arg) && Number.isSafeInteger(Math.floor(parseFloat(`${arg}`)))) {
-        args[i] = Number(arg);
-      }
-    }
-    return argv;
-  }
-  [kPkgUp](rootPath) {
-    const npath = rootPath || "*";
-    if (__classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath])
-      return __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath];
-    let obj = {};
-    try {
-      let startDir = rootPath || __classPrivateFieldGet(this, _YargsInstance_shim, "f").mainFilename;
-      if (!rootPath && __classPrivateFieldGet(this, _YargsInstance_shim, "f").path.extname(startDir)) {
-        startDir = __classPrivateFieldGet(this, _YargsInstance_shim, "f").path.dirname(startDir);
-      }
-      const pkgJsonPath = __classPrivateFieldGet(this, _YargsInstance_shim, "f").findUp(startDir, (dir, names) => {
-        if (names.includes("package.json")) {
-          return "package.json";
-        } else {
-          return;
-        }
-      });
-      assertNotStrictEqual(pkgJsonPath, undefined, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-      obj = JSON.parse(__classPrivateFieldGet(this, _YargsInstance_shim, "f").readFileSync(pkgJsonPath, "utf8"));
-    } catch (_noop) {
-    }
-    __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath] = obj || {};
-    return __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath];
-  }
-  [kPopulateParserHintArray](type, keys) {
-    keys = [].concat(keys);
-    keys.forEach((key) => {
-      key = this[kSanitizeKey](key);
-      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type].push(key);
-    });
-  }
-  [kPopulateParserHintSingleValueDictionary](builder, type, key, value) {
-    this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => {
-      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] = value2;
-    });
-  }
-  [kPopulateParserHintArrayDictionary](builder, type, key, value) {
-    this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => {
-      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] = (__classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] || []).concat(value2);
-    });
-  }
-  [kPopulateParserHintDictionary](builder, type, key, value, singleKeyHandler) {
-    if (Array.isArray(key)) {
-      key.forEach((k) => {
-        builder(k, value);
-      });
-    } else if (((key2) => typeof key2 === "object")(key)) {
-      for (const k of objectKeys(key)) {
-        builder(k, key[k]);
-      }
-    } else {
-      singleKeyHandler(type, this[kSanitizeKey](key), value);
-    }
-  }
-  [kSanitizeKey](key) {
-    if (key === "__proto__")
-      return "___proto___";
-    return key;
-  }
-  [kSetKey](key, set) {
-    this[kPopulateParserHintSingleValueDictionary](this[kSetKey].bind(this), "key", key, set);
-    return this;
-  }
-  [kUnfreeze]() {
-    var _a2, _b2, _c2, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-    const frozen = __classPrivateFieldGet(this, _YargsInstance_frozens, "f").pop();
-    assertNotStrictEqual(frozen, undefined, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
-    let configObjects;
-    _a2 = this, _b2 = this, _c2 = this, _d = this, _e = this, _f = this, _g = this, _h = this, _j = this, _k = this, _l = this, _m = this, {
-      options: { set value(_o) {
-        __classPrivateFieldSet(_a2, _YargsInstance_options, _o, "f");
-      } }.value,
-      configObjects,
-      exitProcess: { set value(_o) {
-        __classPrivateFieldSet(_b2, _YargsInstance_exitProcess, _o, "f");
-      } }.value,
-      groups: { set value(_o) {
-        __classPrivateFieldSet(_c2, _YargsInstance_groups, _o, "f");
-      } }.value,
-      output: { set value(_o) {
-        __classPrivateFieldSet(_d, _YargsInstance_output, _o, "f");
-      } }.value,
-      exitError: { set value(_o) {
-        __classPrivateFieldSet(_e, _YargsInstance_exitError, _o, "f");
-      } }.value,
-      hasOutput: { set value(_o) {
-        __classPrivateFieldSet(_f, _YargsInstance_hasOutput, _o, "f");
-      } }.value,
-      parsed: this.parsed,
-      strict: { set value(_o) {
-        __classPrivateFieldSet(_g, _YargsInstance_strict, _o, "f");
-      } }.value,
-      strictCommands: { set value(_o) {
-        __classPrivateFieldSet(_h, _YargsInstance_strictCommands, _o, "f");
-      } }.value,
-      strictOptions: { set value(_o) {
-        __classPrivateFieldSet(_j, _YargsInstance_strictOptions, _o, "f");
-      } }.value,
-      completionCommand: { set value(_o) {
-        __classPrivateFieldSet(_k, _YargsInstance_completionCommand, _o, "f");
-      } }.value,
-      parseFn: { set value(_o) {
-        __classPrivateFieldSet(_l, _YargsInstance_parseFn, _o, "f");
-      } }.value,
-      parseContext: { set value(_o) {
-        __classPrivateFieldSet(_m, _YargsInstance_parseContext, _o, "f");
-      } }.value
-    } = frozen;
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects = configObjects;
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").unfreeze();
-    __classPrivateFieldGet(this, _YargsInstance_validation, "f").unfreeze();
-    __classPrivateFieldGet(this, _YargsInstance_command, "f").unfreeze();
-    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").unfreeze();
-  }
-  [kValidateAsync](validation2, argv) {
-    return maybeAsyncResult(argv, (result) => {
-      validation2(result);
-      return result;
-    });
-  }
-  getInternalMethods() {
-    return {
-      getCommandInstance: this[kGetCommandInstance].bind(this),
-      getContext: this[kGetContext].bind(this),
-      getHasOutput: this[kGetHasOutput].bind(this),
-      getLoggerInstance: this[kGetLoggerInstance].bind(this),
-      getParseContext: this[kGetParseContext].bind(this),
-      getParserConfiguration: this[kGetParserConfiguration].bind(this),
-      getUsageConfiguration: this[kGetUsageConfiguration].bind(this),
-      getUsageInstance: this[kGetUsageInstance].bind(this),
-      getValidationInstance: this[kGetValidationInstance].bind(this),
-      hasParseCallback: this[kHasParseCallback].bind(this),
-      isGlobalContext: this[kIsGlobalContext].bind(this),
-      postProcess: this[kPostProcess].bind(this),
-      reset: this[kReset].bind(this),
-      runValidation: this[kRunValidation].bind(this),
-      runYargsParserAndExecuteCommands: this[kRunYargsParserAndExecuteCommands].bind(this),
-      setHasOutput: this[kSetHasOutput].bind(this)
-    };
-  }
-  [kGetCommandInstance]() {
-    return __classPrivateFieldGet(this, _YargsInstance_command, "f");
-  }
-  [kGetContext]() {
-    return __classPrivateFieldGet(this, _YargsInstance_context, "f");
-  }
-  [kGetHasOutput]() {
-    return __classPrivateFieldGet(this, _YargsInstance_hasOutput, "f");
-  }
-  [kGetLoggerInstance]() {
-    return __classPrivateFieldGet(this, _YargsInstance_logger, "f");
-  }
-  [kGetParseContext]() {
-    return __classPrivateFieldGet(this, _YargsInstance_parseContext, "f") || {};
-  }
-  [kGetUsageInstance]() {
-    return __classPrivateFieldGet(this, _YargsInstance_usage, "f");
-  }
-  [kGetValidationInstance]() {
-    return __classPrivateFieldGet(this, _YargsInstance_validation, "f");
-  }
-  [kHasParseCallback]() {
-    return !!__classPrivateFieldGet(this, _YargsInstance_parseFn, "f");
-  }
-  [kIsGlobalContext]() {
-    return __classPrivateFieldGet(this, _YargsInstance_isGlobalContext, "f");
-  }
-  [kPostProcess](argv, populateDoubleDash, calledFromCommand, runGlobalMiddleware) {
-    if (calledFromCommand)
-      return argv;
-    if (isPromise(argv))
-      return argv;
-    if (!populateDoubleDash) {
-      argv = this[kCopyDoubleDash](argv);
-    }
-    const parsePositionalNumbers = this[kGetParserConfiguration]()["parse-positional-numbers"] || this[kGetParserConfiguration]()["parse-positional-numbers"] === undefined;
-    if (parsePositionalNumbers) {
-      argv = this[kParsePositionalNumbers](argv);
-    }
-    if (runGlobalMiddleware) {
-      argv = applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), false);
-    }
-    return argv;
-  }
-  [kReset](aliases = {}) {
-    __classPrivateFieldSet(this, _YargsInstance_options, __classPrivateFieldGet(this, _YargsInstance_options, "f") || {}, "f");
-    const tmpOptions = {};
-    tmpOptions.local = __classPrivateFieldGet(this, _YargsInstance_options, "f").local || [];
-    tmpOptions.configObjects = __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects || [];
-    const localLookup = {};
-    tmpOptions.local.forEach((l) => {
-      localLookup[l] = true;
-      (aliases[l] || []).forEach((a) => {
-        localLookup[a] = true;
-      });
-    });
-    Object.assign(__classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f"), Object.keys(__classPrivateFieldGet(this, _YargsInstance_groups, "f")).reduce((acc, groupName) => {
-      const keys = __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName].filter((key) => !(key in localLookup));
-      if (keys.length > 0) {
-        acc[groupName] = keys;
-      }
-      return acc;
-    }, {}));
-    __classPrivateFieldSet(this, _YargsInstance_groups, {}, "f");
-    const arrayOptions = [
-      "array",
-      "boolean",
-      "string",
-      "skipValidation",
-      "count",
-      "normalize",
-      "number",
-      "hiddenOptions"
-    ];
-    const objectOptions = [
-      "narg",
-      "key",
-      "alias",
-      "default",
-      "defaultDescription",
-      "config",
-      "choices",
-      "demandedOptions",
-      "demandedCommands",
-      "deprecatedOptions"
-    ];
-    arrayOptions.forEach((k) => {
-      tmpOptions[k] = (__classPrivateFieldGet(this, _YargsInstance_options, "f")[k] || []).filter((k2) => !localLookup[k2]);
-    });
-    objectOptions.forEach((k) => {
-      tmpOptions[k] = objFilter(__classPrivateFieldGet(this, _YargsInstance_options, "f")[k], (k2) => !localLookup[k2]);
-    });
-    tmpOptions.envPrefix = __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix;
-    __classPrivateFieldSet(this, _YargsInstance_options, tmpOptions, "f");
-    __classPrivateFieldSet(this, _YargsInstance_usage, __classPrivateFieldGet(this, _YargsInstance_usage, "f") ? __classPrivateFieldGet(this, _YargsInstance_usage, "f").reset(localLookup) : usage(this, __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
-    __classPrivateFieldSet(this, _YargsInstance_validation, __classPrivateFieldGet(this, _YargsInstance_validation, "f") ? __classPrivateFieldGet(this, _YargsInstance_validation, "f").reset(localLookup) : validation(this, __classPrivateFieldGet(this, _YargsInstance_usage, "f"), __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
-    __classPrivateFieldSet(this, _YargsInstance_command, __classPrivateFieldGet(this, _YargsInstance_command, "f") ? __classPrivateFieldGet(this, _YargsInstance_command, "f").reset() : command(__classPrivateFieldGet(this, _YargsInstance_usage, "f"), __classPrivateFieldGet(this, _YargsInstance_validation, "f"), __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f"), __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
-    if (!__classPrivateFieldGet(this, _YargsInstance_completion, "f"))
-      __classPrivateFieldSet(this, _YargsInstance_completion, completion(this, __classPrivateFieldGet(this, _YargsInstance_usage, "f"), __classPrivateFieldGet(this, _YargsInstance_command, "f"), __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
-    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").reset();
-    __classPrivateFieldSet(this, _YargsInstance_completionCommand, null, "f");
-    __classPrivateFieldSet(this, _YargsInstance_output, "", "f");
-    __classPrivateFieldSet(this, _YargsInstance_exitError, null, "f");
-    __classPrivateFieldSet(this, _YargsInstance_hasOutput, false, "f");
-    this.parsed = false;
-    return this;
-  }
-  [kRebase](base, dir) {
-    return __classPrivateFieldGet(this, _YargsInstance_shim, "f").path.relative(base, dir);
-  }
-  [kRunYargsParserAndExecuteCommands](args, shortCircuit, calledFromCommand, commandIndex = 0, helpOnly = false) {
-    let skipValidation = !!calledFromCommand || helpOnly;
-    args = args || __classPrivateFieldGet(this, _YargsInstance_processArgs, "f");
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").__ = __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.__;
-    __classPrivateFieldGet(this, _YargsInstance_options, "f").configuration = this[kGetParserConfiguration]();
-    const populateDoubleDash = !!__classPrivateFieldGet(this, _YargsInstance_options, "f").configuration["populate--"];
-    const config = Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, "f").configuration, {
-      "populate--": true
-    });
-    const parsed = __classPrivateFieldGet(this, _YargsInstance_shim, "f").Parser.detailed(args, Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, "f"), {
-      configuration: { "parse-positional-numbers": false, ...config }
-    }));
-    const argv = Object.assign(parsed.argv, __classPrivateFieldGet(this, _YargsInstance_parseContext, "f"));
-    let argvPromise = undefined;
-    const aliases = parsed.aliases;
-    let helpOptSet = false;
-    let versionOptSet = false;
-    Object.keys(argv).forEach((key) => {
-      if (key === __classPrivateFieldGet(this, _YargsInstance_helpOpt, "f") && argv[key]) {
-        helpOptSet = true;
-      } else if (key === __classPrivateFieldGet(this, _YargsInstance_versionOpt, "f") && argv[key]) {
-        versionOptSet = true;
-      }
-    });
-    argv.$0 = this.$0;
-    this.parsed = parsed;
-    if (commandIndex === 0) {
-      __classPrivateFieldGet(this, _YargsInstance_usage, "f").clearCachedHelpMessage();
-    }
-    try {
-      this[kGuessLocale]();
-      if (shortCircuit) {
-        return this[kPostProcess](argv, populateDoubleDash, !!calledFromCommand, false);
-      }
-      if (__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")) {
-        const helpCmds = [__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")].concat(aliases[__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")] || []).filter((k) => k.length > 1);
-        if (helpCmds.includes("" + argv._[argv._.length - 1])) {
-          argv._.pop();
-          helpOptSet = true;
-        }
-      }
-      __classPrivateFieldSet(this, _YargsInstance_isGlobalContext, false, "f");
-      const handlerKeys = __classPrivateFieldGet(this, _YargsInstance_command, "f").getCommands();
-      const requestCompletions = __classPrivateFieldGet(this, _YargsInstance_completion, "f").completionKey in argv;
-      const skipRecommendation = helpOptSet || requestCompletions || helpOnly;
-      if (argv._.length) {
-        if (handlerKeys.length) {
-          let firstUnknownCommand;
-          for (let i = commandIndex || 0, cmd;argv._[i] !== undefined; i++) {
-            cmd = String(argv._[i]);
-            if (handlerKeys.includes(cmd) && cmd !== __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f")) {
-              const innerArgv = __classPrivateFieldGet(this, _YargsInstance_command, "f").runCommand(cmd, this, parsed, i + 1, helpOnly, helpOptSet || versionOptSet || helpOnly);
-              return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false);
-            } else if (!firstUnknownCommand && cmd !== __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f")) {
-              firstUnknownCommand = cmd;
-              break;
-            }
-          }
-          if (!__classPrivateFieldGet(this, _YargsInstance_command, "f").hasDefaultCommand() && __classPrivateFieldGet(this, _YargsInstance_recommendCommands, "f") && firstUnknownCommand && !skipRecommendation) {
-            __classPrivateFieldGet(this, _YargsInstance_validation, "f").recommendCommands(firstUnknownCommand, handlerKeys);
-          }
-        }
-        if (__classPrivateFieldGet(this, _YargsInstance_completionCommand, "f") && argv._.includes(__classPrivateFieldGet(this, _YargsInstance_completionCommand, "f")) && !requestCompletions) {
-          if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
-            setBlocking(true);
-          this.showCompletionScript();
-          this.exit(0);
-        }
-      }
-      if (__classPrivateFieldGet(this, _YargsInstance_command, "f").hasDefaultCommand() && !skipRecommendation) {
-        const innerArgv = __classPrivateFieldGet(this, _YargsInstance_command, "f").runCommand(null, this, parsed, 0, helpOnly, helpOptSet || versionOptSet || helpOnly);
-        return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false);
-      }
-      if (requestCompletions) {
-        if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
-          setBlocking(true);
-        args = [].concat(args);
-        const completionArgs = args.slice(args.indexOf(`--${__classPrivateFieldGet(this, _YargsInstance_completion, "f").completionKey}`) + 1);
-        __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(completionArgs, (err, completions) => {
-          if (err)
-            throw new YError(err.message);
-          (completions || []).forEach((completion2) => {
-            __classPrivateFieldGet(this, _YargsInstance_logger, "f").log(completion2);
-          });
-          this.exit(0);
-        });
-        return this[kPostProcess](argv, !populateDoubleDash, !!calledFromCommand, false);
-      }
-      if (!__classPrivateFieldGet(this, _YargsInstance_hasOutput, "f")) {
-        if (helpOptSet) {
-          if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
-            setBlocking(true);
-          skipValidation = true;
-          this.showHelp("log");
-          this.exit(0);
-        } else if (versionOptSet) {
-          if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
-            setBlocking(true);
-          skipValidation = true;
-          __classPrivateFieldGet(this, _YargsInstance_usage, "f").showVersion("log");
-          this.exit(0);
-        }
-      }
-      if (!skipValidation && __classPrivateFieldGet(this, _YargsInstance_options, "f").skipValidation.length > 0) {
-        skipValidation = Object.keys(argv).some((key) => __classPrivateFieldGet(this, _YargsInstance_options, "f").skipValidation.indexOf(key) >= 0 && argv[key] === true);
-      }
-      if (!skipValidation) {
-        if (parsed.error)
-          throw new YError(parsed.error.message);
-        if (!requestCompletions) {
-          const validation2 = this[kRunValidation](aliases, {}, parsed.error);
-          if (!calledFromCommand) {
-            argvPromise = applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), true);
-          }
-          argvPromise = this[kValidateAsync](validation2, argvPromise !== null && argvPromise !== undefined ? argvPromise : argv);
-          if (isPromise(argvPromise) && !calledFromCommand) {
-            argvPromise = argvPromise.then(() => {
-              return applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), false);
-            });
-          }
-        }
-      }
-    } catch (err) {
-      if (err instanceof YError)
-        __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(err.message, err);
-      else
-        throw err;
-    }
-    return this[kPostProcess](argvPromise !== null && argvPromise !== undefined ? argvPromise : argv, populateDoubleDash, !!calledFromCommand, true);
-  }
-  [kRunValidation](aliases, positionalMap, parseErrors, isDefaultCommand) {
-    const demandedOptions = { ...this.getDemandedOptions() };
-    return (argv) => {
-      if (parseErrors)
-        throw new YError(parseErrors.message);
-      __classPrivateFieldGet(this, _YargsInstance_validation, "f").nonOptionCount(argv);
-      __classPrivateFieldGet(this, _YargsInstance_validation, "f").requiredArguments(argv, demandedOptions);
-      let failedStrictCommands = false;
-      if (__classPrivateFieldGet(this, _YargsInstance_strictCommands, "f")) {
-        failedStrictCommands = __classPrivateFieldGet(this, _YargsInstance_validation, "f").unknownCommands(argv);
-      }
-      if (__classPrivateFieldGet(this, _YargsInstance_strict, "f") && !failedStrictCommands) {
-        __classPrivateFieldGet(this, _YargsInstance_validation, "f").unknownArguments(argv, aliases, positionalMap, !!isDefaultCommand);
-      } else if (__classPrivateFieldGet(this, _YargsInstance_strictOptions, "f")) {
-        __classPrivateFieldGet(this, _YargsInstance_validation, "f").unknownArguments(argv, aliases, {}, false, false);
-      }
-      __classPrivateFieldGet(this, _YargsInstance_validation, "f").limitedChoices(argv);
-      __classPrivateFieldGet(this, _YargsInstance_validation, "f").implications(argv);
-      __classPrivateFieldGet(this, _YargsInstance_validation, "f").conflicting(argv);
-    };
-  }
-  [kSetHasOutput]() {
-    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
-  }
-  [kTrackManuallySetKeys](keys) {
-    if (typeof keys === "string") {
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").key[keys] = true;
-    } else {
-      for (const k of keys) {
-        __classPrivateFieldGet(this, _YargsInstance_options, "f").key[k] = true;
-      }
-    }
-  }
-}
-function isYargsInstance(y) {
-  return !!y && typeof y.getInternalMethods === "function";
-}
-
-// ../../node_modules/yargs/index.mjs
-var Yargs = YargsFactory(esm_default);
-var yargs_default = Yargs;
-
-// src/cli.ts
-var y = yargs_default(hideBin(process.argv));
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+var y = yargs(hideBin(process.argv));
 function errorExit(title, text) {
   console.error(chalk.red.bold(title + `
 `));
@@ -4880,14 +19,19 @@ function errorExit(title, text) {
   }
   process.exit(1);
 }
-y.command("generate-types", "generates typescript types", (yargs) => yargs.option("access-token", {
-  describe: "access token"
+y.command("generate-types", "generates typescript types", (yargs2) => yargs2.option("access-token", {
+  describe: "access token",
+  type: "string"
 }).option("outfile", {
   default: "requence-env.d.ts"
 }).option("outdir", {
   default: ""
 }), async (argv) => {
-  const token = argv.accessToken ?? process.env.REQUENCE_ACCESS_TOKEN ?? JSON.parse(fs.readFileSync("package.json", "utf-8")).requence?.accessToken;
+  let token = argv.accessToken ?? process.env.REQUENCE_TASK_ACCESS_TOKEN ?? process.env.REQUENCE_ACCESS_TOKEN;
+  if (!token) {
+    const pkgJson = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+    token = pkgJson.requence?.task?.accessToken ?? pkgJson.requence?.accessToken;
+  }
   console.info();
   if (!token) {
     errorExit("No access token found", `You can provide the access token as argument to ${chalk.bold("createTask")},
@@ -4899,7 +43,7 @@ in your ${chalk.bold("package.json")} in ${chalk.bold("requence.accessToken")}`)
     errorExit("Invalid access token");
   }
   const [, accessToken, serverUrl] = parts;
-  console.info(chalk.gray(`generating typescript definitions…`));
+  console.info(chalk.gray("generating typescript definitions…"));
   const response = await fetch(serverUrl + "/task/types/typescript", {
     method: "GET",
     headers: {
@@ -4911,14 +55,17 @@ in your ${chalk.bold("package.json")} in ${chalk.bold("requence.accessToken")}`)
     errorExit(error);
   }
   const text = await response.text();
-  const data = `/* eslint-disable */
-/* prettier-ignore */
-
-${text}`;
+  const data = [
+    "/* eslint-disable */",
+    "/* oxlint-disable */",
+    "/* prettier-ignore */",
+    text
+  ].join(`
+`);
   const file = path.join(argv.outdir || process.cwd(), argv.outfile);
   fs.writeFileSync(file, data);
   console.info(chalk.green("types saved to", chalk.bold(path.relative(process.cwd(), file))));
 }).scriptName("requence-task").help("h").demandCommand(1, 1).strict().parse();
 
-//# debugId=B7E3681F48E5677864756E2164756E21
+//# debugId=F960044E10AD164964756E2164756E21
 //# sourceMappingURL=cli.js.map