vercel 31.2.3 → 31.3.0

package/dist/index.js

@@ -81,6 +81,781 @@ function getPackageJSON() {
 exports.getPackageJSON = getPackageJSON;
 //# sourceMappingURL=index.js.map
 
+/***/ }),
+
+/***/ 31975:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/*
+
+The MIT License (MIT)
+
+Original Library
+  - Copyright (c) Marak Squires
+
+Additional functionality
+ - Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+var colors = {};
+module['exports'] = colors;
+
+colors.themes = {};
+
+var util = __webpack_require__(31669);
+var ansiStyles = colors.styles = __webpack_require__(79452);
+var defineProps = Object.defineProperties;
+var newLineRegex = new RegExp(/[\r\n]+/g);
+
+colors.supportsColor = __webpack_require__(42274).supportsColor;
+
+if (typeof colors.enabled === 'undefined') {
+  colors.enabled = colors.supportsColor() !== false;
+}
+
+colors.enable = function() {
+  colors.enabled = true;
+};
+
+colors.disable = function() {
+  colors.enabled = false;
+};
+
+colors.stripColors = colors.strip = function(str) {
+  return ('' + str).replace(/\x1B\[\d+m/g, '');
+};
+
+// eslint-disable-next-line no-unused-vars
+var stylize = colors.stylize = function stylize(str, style) {
+  if (!colors.enabled) {
+    return str+'';
+  }
+
+  var styleMap = ansiStyles[style];
+
+  // Stylize should work for non-ANSI styles, too
+  if (!styleMap && style in colors) {
+    // Style maps like trap operate as functions on strings;
+    // they don't have properties like open or close.
+    return colors[style](str);
+  }
+
+  return styleMap.open + str + styleMap.close;
+};
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+var escapeStringRegexp = function(str) {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+  return str.replace(matchOperatorsRe, '\\$&');
+};
+
+function build(_styles) {
+  var builder = function builder() {
+    return applyStyle.apply(builder, arguments);
+  };
+  builder._styles = _styles;
+  // __proto__ is used because we must return a function, but there is
+  // no way to create a function with a different prototype.
+  builder.__proto__ = proto;
+  return builder;
+}
+
+var styles = (function() {
+  var ret = {};
+  ansiStyles.grey = ansiStyles.gray;
+  Object.keys(ansiStyles).forEach(function(key) {
+    ansiStyles[key].closeRe =
+      new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+    ret[key] = {
+      get: function() {
+        return build(this._styles.concat(key));
+      },
+    };
+  });
+  return ret;
+})();
+
+var proto = defineProps(function colors() {}, styles);
+
+function applyStyle() {
+  var args = Array.prototype.slice.call(arguments);
+
+  var str = args.map(function(arg) {
+    // Use weak equality check so we can colorize null/undefined in safe mode
+    if (arg != null && arg.constructor === String) {
+      return arg;
+    } else {
+      return util.inspect(arg);
+    }
+  }).join(' ');
+
+  if (!colors.enabled || !str) {
+    return str;
+  }
+
+  var newLinesPresent = str.indexOf('\n') != -1;
+
+  var nestedStyles = this._styles;
+
+  var i = nestedStyles.length;
+  while (i--) {
+    var code = ansiStyles[nestedStyles[i]];
+    str = code.open + str.replace(code.closeRe, code.open) + code.close;
+    if (newLinesPresent) {
+      str = str.replace(newLineRegex, function(match) {
+        return code.close + match + code.open;
+      });
+    }
+  }
+
+  return str;
+}
+
+colors.setTheme = function(theme) {
+  if (typeof theme === 'string') {
+    console.log('colors.setTheme now only accepts an object, not a string.  ' +
+      'If you are trying to set a theme from a file, it is now your (the ' +
+      'caller\'s) responsibility to require the file.  The old syntax ' +
+      'looked like colors.setTheme(__dirname + ' +
+      '\'/../themes/generic-logging.js\'); The new syntax looks like '+
+      'colors.setTheme(require(__dirname + ' +
+      '\'/../themes/generic-logging.js\'));');
+    return;
+  }
+  for (var style in theme) {
+    (function(style) {
+      colors[style] = function(str) {
+        if (typeof theme[style] === 'object') {
+          var out = str;
+          for (var i in theme[style]) {
+            out = colors[theme[style][i]](out);
+          }
+          return out;
+        }
+        return colors[theme[style]](str);
+      };
+    })(style);
+  }
+};
+
+function init() {
+  var ret = {};
+  Object.keys(styles).forEach(function(name) {
+    ret[name] = {
+      get: function() {
+        return build([name]);
+      },
+    };
+  });
+  return ret;
+}
+
+var sequencer = function sequencer(map, str) {
+  var exploded = str.split('');
+  exploded = exploded.map(map);
+  return exploded.join('');
+};
+
+// custom formatter methods
+colors.trap = __webpack_require__(21108);
+colors.zalgo = __webpack_require__(8127);
+
+// maps
+colors.maps = {};
+colors.maps.america = __webpack_require__(31979)(colors);
+colors.maps.zebra = __webpack_require__(52284)(colors);
+colors.maps.rainbow = __webpack_require__(32682)(colors);
+colors.maps.random = __webpack_require__(74891)(colors);
+
+for (var map in colors.maps) {
+  (function(map) {
+    colors[map] = function(str) {
+      return sequencer(colors.maps[map], str);
+    };
+  })(map);
+}
+
+defineProps(colors, init());
+
+
+/***/ }),
+
+/***/ 21108:
+/***/ ((module) => {
+
+module['exports'] = function runTheTrap(text, options) {
+  var result = '';
+  text = text || 'Run the trap, drop the bass';
+  text = text.split('');
+  var trap = {
+    a: ['\u0040', '\u0104', '\u023a', '\u0245', '\u0394', '\u039b', '\u0414'],
+    b: ['\u00df', '\u0181', '\u0243', '\u026e', '\u03b2', '\u0e3f'],
+    c: ['\u00a9', '\u023b', '\u03fe'],
+    d: ['\u00d0', '\u018a', '\u0500', '\u0501', '\u0502', '\u0503'],
+    e: ['\u00cb', '\u0115', '\u018e', '\u0258', '\u03a3', '\u03be', '\u04bc',
+      '\u0a6c'],
+    f: ['\u04fa'],
+    g: ['\u0262'],
+    h: ['\u0126', '\u0195', '\u04a2', '\u04ba', '\u04c7', '\u050a'],
+    i: ['\u0f0f'],
+    j: ['\u0134'],
+    k: ['\u0138', '\u04a0', '\u04c3', '\u051e'],
+    l: ['\u0139'],
+    m: ['\u028d', '\u04cd', '\u04ce', '\u0520', '\u0521', '\u0d69'],
+    n: ['\u00d1', '\u014b', '\u019d', '\u0376', '\u03a0', '\u048a'],
+    o: ['\u00d8', '\u00f5', '\u00f8', '\u01fe', '\u0298', '\u047a', '\u05dd',
+      '\u06dd', '\u0e4f'],
+    p: ['\u01f7', '\u048e'],
+    q: ['\u09cd'],
+    r: ['\u00ae', '\u01a6', '\u0210', '\u024c', '\u0280', '\u042f'],
+    s: ['\u00a7', '\u03de', '\u03df', '\u03e8'],
+    t: ['\u0141', '\u0166', '\u0373'],
+    u: ['\u01b1', '\u054d'],
+    v: ['\u05d8'],
+    w: ['\u0428', '\u0460', '\u047c', '\u0d70'],
+    x: ['\u04b2', '\u04fe', '\u04fc', '\u04fd'],
+    y: ['\u00a5', '\u04b0', '\u04cb'],
+    z: ['\u01b5', '\u0240'],
+  };
+  text.forEach(function(c) {
+    c = c.toLowerCase();
+    var chars = trap[c] || [' '];
+    var rand = Math.floor(Math.random() * chars.length);
+    if (typeof trap[c] !== 'undefined') {
+      result += trap[c][rand];
+    } else {
+      result += c;
+    }
+  });
+  return result;
+};
+
+
+/***/ }),
+
+/***/ 8127:
+/***/ ((module) => {
+
+// please no
+module['exports'] = function zalgo(text, options) {
+  text = text || '   he is here   ';
+  var soul = {
+    'up': [
+      '̍', '̎', '̄', '̅',
+      '̿', '̑', '̆', '̐',
+      '͒', '͗', '͑', '̇',
+      '̈', '̊', '͂', '̓',
+      '̈', '͊', '͋', '͌',
+      '̃', '̂', '̌', '͐',
+      '̀', '́', '̋', '̏',
+      '̒', '̓', '̔', '̽',
+      '̉', 'ͣ', 'ͤ', 'ͥ',
+      'ͦ', 'ͧ', 'ͨ', 'ͩ',
+      'ͪ', 'ͫ', 'ͬ', 'ͭ',
+      'ͮ', 'ͯ', '̾', '͛',
+      '͆', '̚',
+    ],
+    'down': [
+      '̖', '̗', '̘', '̙',
+      '̜', '̝', '̞', '̟',
+      '̠', '̤', '̥', '̦',
+      '̩', '̪', '̫', '̬',
+      '̭', '̮', '̯', '̰',
+      '̱', '̲', '̳', '̹',
+      '̺', '̻', '̼', 'ͅ',
+      '͇', '͈', '͉', '͍',
+      '͎', '͓', '͔', '͕',
+      '͖', '͙', '͚', '̣',
+    ],
+    'mid': [
+      '̕', '̛', '̀', '́',
+      '͘', '̡', '̢', '̧',
+      '̨', '̴', '̵', '̶',
+      '͜', '͝', '͞',
+      '͟', '͠', '͢', '̸',
+      '̷', '͡', ' ҉',
+    ],
+  };
+  var all = [].concat(soul.up, soul.down, soul.mid);
+
+  function randomNumber(range) {
+    var r = Math.floor(Math.random() * range);
+    return r;
+  }
+
+  function isChar(character) {
+    var bool = false;
+    all.filter(function(i) {
+      bool = (i === character);
+    });
+    return bool;
+  }
+
+
+  function heComes(text, options) {
+    var result = '';
+    var counts;
+    var l;
+    options = options || {};
+    options['up'] =
+      typeof options['up'] !== 'undefined' ? options['up'] : true;
+    options['mid'] =
+      typeof options['mid'] !== 'undefined' ? options['mid'] : true;
+    options['down'] =
+      typeof options['down'] !== 'undefined' ? options['down'] : true;
+    options['size'] =
+      typeof options['size'] !== 'undefined' ? options['size'] : 'maxi';
+    text = text.split('');
+    for (l in text) {
+      if (isChar(l)) {
+        continue;
+      }
+      result = result + text[l];
+      counts = {'up': 0, 'down': 0, 'mid': 0};
+      switch (options.size) {
+        case 'mini':
+          counts.up = randomNumber(8);
+          counts.mid = randomNumber(2);
+          counts.down = randomNumber(8);
+          break;
+        case 'maxi':
+          counts.up = randomNumber(16) + 3;
+          counts.mid = randomNumber(4) + 1;
+          counts.down = randomNumber(64) + 3;
+          break;
+        default:
+          counts.up = randomNumber(8) + 1;
+          counts.mid = randomNumber(6) / 2;
+          counts.down = randomNumber(8) + 1;
+          break;
+      }
+
+      var arr = ['up', 'mid', 'down'];
+      for (var d in arr) {
+        var index = arr[d];
+        for (var i = 0; i <= counts[index]; i++) {
+          if (options[index]) {
+            result = result + soul[index][randomNumber(soul[index].length)];
+          }
+        }
+      }
+    }
+    return result;
+  }
+  // don't summon him
+  return heComes(text, options);
+};
+
+
+
+/***/ }),
+
+/***/ 31979:
+/***/ ((module) => {
+
+module['exports'] = function(colors) {
+  return function(letter, i, exploded) {
+    if (letter === ' ') return letter;
+    switch (i%3) {
+      case 0: return colors.red(letter);
+      case 1: return colors.white(letter);
+      case 2: return colors.blue(letter);
+    }
+  };
+};
+
+
+/***/ }),
+
+/***/ 32682:
+/***/ ((module) => {
+
+module['exports'] = function(colors) {
+  // RoY G BiV
+  var rainbowColors = ['red', 'yellow', 'green', 'blue', 'magenta'];
+  return function(letter, i, exploded) {
+    if (letter === ' ') {
+      return letter;
+    } else {
+      return colors[rainbowColors[i++ % rainbowColors.length]](letter);
+    }
+  };
+};
+
+
+
+/***/ }),
+
+/***/ 74891:
+/***/ ((module) => {
+
+module['exports'] = function(colors) {
+  var available = ['underline', 'inverse', 'grey', 'yellow', 'red', 'green',
+    'blue', 'white', 'cyan', 'magenta', 'brightYellow', 'brightRed',
+    'brightGreen', 'brightBlue', 'brightWhite', 'brightCyan', 'brightMagenta'];
+  return function(letter, i, exploded) {
+    return letter === ' ' ? letter :
+      colors[
+          available[Math.round(Math.random() * (available.length - 2))]
+      ](letter);
+  };
+};
+
+
+/***/ }),
+
+/***/ 52284:
+/***/ ((module) => {
+
+module['exports'] = function(colors) {
+  return function(letter, i, exploded) {
+    return i % 2 === 0 ? letter : colors.inverse(letter);
+  };
+};
+
+
+/***/ }),
+
+/***/ 79452:
+/***/ ((module) => {
+
+/*
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+var styles = {};
+module['exports'] = styles;
+
+var codes = {
+  reset: [0, 0],
+
+  bold: [1, 22],
+  dim: [2, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  gray: [90, 39],
+  grey: [90, 39],
+
+  brightRed: [91, 39],
+  brightGreen: [92, 39],
+  brightYellow: [93, 39],
+  brightBlue: [94, 39],
+  brightMagenta: [95, 39],
+  brightCyan: [96, 39],
+  brightWhite: [97, 39],
+
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  bgGray: [100, 49],
+  bgGrey: [100, 49],
+
+  bgBrightRed: [101, 49],
+  bgBrightGreen: [102, 49],
+  bgBrightYellow: [103, 49],
+  bgBrightBlue: [104, 49],
+  bgBrightMagenta: [105, 49],
+  bgBrightCyan: [106, 49],
+  bgBrightWhite: [107, 49],
+
+  // legacy styles for colors pre v1.0.0
+  blackBG: [40, 49],
+  redBG: [41, 49],
+  greenBG: [42, 49],
+  yellowBG: [43, 49],
+  blueBG: [44, 49],
+  magentaBG: [45, 49],
+  cyanBG: [46, 49],
+  whiteBG: [47, 49],
+
+};
+
+Object.keys(codes).forEach(function(key) {
+  var val = codes[key];
+  var style = styles[key] = [];
+  style.open = '\u001b[' + val[0] + 'm';
+  style.close = '\u001b[' + val[1] + 'm';
+});
+
+
+/***/ }),
+
+/***/ 6702:
+/***/ ((module) => {
+
+"use strict";
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+
+
+module.exports = function(flag, argv) {
+  argv = argv || process.argv;
+
+  var terminatorPos = argv.indexOf('--');
+  var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+  var pos = argv.indexOf(prefix + flag);
+
+  return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
+
+
+/***/ }),
+
+/***/ 42274:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/*
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+
+
+var os = __webpack_require__(12087);
+var hasFlag = __webpack_require__(6702);
+
+var env = process.env;
+
+var forceColor = void 0;
+if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) {
+  forceColor = false;
+} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true')
+           || hasFlag('color=always')) {
+  forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+  forceColor = env.FORCE_COLOR.length === 0
+    || parseInt(env.FORCE_COLOR, 10) !== 0;
+}
+
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+
+  return {
+    level: level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3,
+  };
+}
+
+function supportsColor(stream) {
+  if (forceColor === false) {
+    return 0;
+  }
+
+  if (hasFlag('color=16m') || hasFlag('color=full')
+      || hasFlag('color=truecolor')) {
+    return 3;
+  }
+
+  if (hasFlag('color=256')) {
+    return 2;
+  }
+
+  if (stream && !stream.isTTY && forceColor !== true) {
+    return 0;
+  }
+
+  var min = forceColor ? 1 : 0;
+
+  if (process.platform === 'win32') {
+    // Node.js 7.5.0 is the first version of Node.js to include a patch to
+    // libuv that enables 256 color output on Windows. Anything earlier and it
+    // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+    // release, and Node.js 7 is not. Windows 10 build 10586 is the first
+    // Windows release that supports 256 colors. Windows 10 build 14931 is the
+    // first release that supports 16m/TrueColor.
+    var osRelease = os.release().split('.');
+    if (Number(process.versions.node.split('.')[0]) >= 8
+        && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+
+    return 1;
+  }
+
+  if ('CI' in env) {
+    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(function(sign) {
+      return sign in env;
+    }) || env.CI_NAME === 'codeship') {
+      return 1;
+    }
+
+    return min;
+  }
+
+  if ('TEAMCITY_VERSION' in env) {
+    return (/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0
+    );
+  }
+
+  if ('TERM_PROGRAM' in env) {
+    var version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+    switch (env.TERM_PROGRAM) {
+      case 'iTerm.app':
+        return version >= 3 ? 3 : 2;
+      case 'Hyper':
+        return 3;
+      case 'Apple_Terminal':
+        return 2;
+      // No default
+    }
+  }
+
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+
+  if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+
+  if ('COLORTERM' in env) {
+    return 1;
+  }
+
+  if (env.TERM === 'dumb') {
+    return min;
+  }
+
+  return min;
+}
+
+function getSupportLevel(stream) {
+  var level = supportsColor(stream);
+  return translateLevel(level);
+}
+
+module.exports = {
+  supportsColor: getSupportLevel,
+  stdout: getSupportLevel(process.stdout),
+  stderr: getSupportLevel(process.stderr),
+};
+
+
+/***/ }),
+
+/***/ 39404:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+//
+// Remark: Requiring this file will use the "safe" colors API,
+// which will not touch String.prototype.
+//
+//   var colors = require('colors/safe');
+//   colors.red("foo")
+//
+//
+var colors = __webpack_require__(31975);
+module['exports'] = colors;
+
+
 /***/ }),
 
 /***/ 42100:
@@ -45183,6 +45958,1181 @@ Object.defineProperty(spinners, 'random', {
 module.exports = spinners;
 
 
+/***/ }),
+
+/***/ 47579:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(37650);
+
+/***/ }),
+
+/***/ 67717:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { info, debug } = __webpack_require__(12480);
+const utils = __webpack_require__(79011);
+
+class Cell {
+  /**
+   * A representation of a cell within the table.
+   * Implementations must have `init` and `draw` methods,
+   * as well as `colSpan`, `rowSpan`, `desiredHeight` and `desiredWidth` properties.
+   * @param options
+   * @constructor
+   */
+  constructor(options) {
+    this.setOptions(options);
+
+    /**
+     * Each cell will have it's `x` and `y` values set by the `layout-manager` prior to
+     * `init` being called;
+     * @type {Number}
+     */
+    this.x = null;
+    this.y = null;
+  }
+
+  setOptions(options) {
+    if (['boolean', 'number', 'string'].indexOf(typeof options) !== -1) {
+      options = { content: '' + options };
+    }
+    options = options || {};
+    this.options = options;
+    let content = options.content;
+    if (['boolean', 'number', 'string'].indexOf(typeof content) !== -1) {
+      this.content = String(content);
+    } else if (!content) {
+      this.content = this.options.href || '';
+    } else {
+      throw new Error('Content needs to be a primitive, got: ' + typeof content);
+    }
+    this.colSpan = options.colSpan || 1;
+    this.rowSpan = options.rowSpan || 1;
+    if (this.options.href) {
+      Object.defineProperty(this, 'href', {
+        get() {
+          return this.options.href;
+        },
+      });
+    }
+  }
+
+  mergeTableOptions(tableOptions, cells) {
+    this.cells = cells;
+
+    let optionsChars = this.options.chars || {};
+    let tableChars = tableOptions.chars;
+    let chars = (this.chars = {});
+    CHAR_NAMES.forEach(function (name) {
+      setOption(optionsChars, tableChars, name, chars);
+    });
+
+    this.truncate = this.options.truncate || tableOptions.truncate;
+
+    let style = (this.options.style = this.options.style || {});
+    let tableStyle = tableOptions.style;
+    setOption(style, tableStyle, 'padding-left', this);
+    setOption(style, tableStyle, 'padding-right', this);
+    this.head = style.head || tableStyle.head;
+    this.border = style.border || tableStyle.border;
+
+    this.fixedWidth = tableOptions.colWidths[this.x];
+    this.lines = this.computeLines(tableOptions);
+
+    this.desiredWidth = utils.strlen(this.content) + this.paddingLeft + this.paddingRight;
+    this.desiredHeight = this.lines.length;
+  }
+
+  computeLines(tableOptions) {
+    const tableWordWrap = tableOptions.wordWrap || tableOptions.textWrap;
+    const { wordWrap = tableWordWrap } = this.options;
+    if (this.fixedWidth && wordWrap) {
+      this.fixedWidth -= this.paddingLeft + this.paddingRight;
+      if (this.colSpan) {
+        let i = 1;
+        while (i < this.colSpan) {
+          this.fixedWidth += tableOptions.colWidths[this.x + i];
+          i++;
+        }
+      }
+      const { wrapOnWordBoundary: tableWrapOnWordBoundary = true } = tableOptions;
+      const { wrapOnWordBoundary = tableWrapOnWordBoundary } = this.options;
+      return this.wrapLines(utils.wordWrap(this.fixedWidth, this.content, wrapOnWordBoundary));
+    }
+    return this.wrapLines(this.content.split('\n'));
+  }
+
+  wrapLines(computedLines) {
+    const lines = utils.colorizeLines(computedLines);
+    if (this.href) {
+      return lines.map((line) => utils.hyperlink(this.href, line));
+    }
+    return lines;
+  }
+
+  /**
+   * Initializes the Cells data structure.
+   *
+   * @param tableOptions - A fully populated set of tableOptions.
+   * In addition to the standard default values, tableOptions must have fully populated the
+   * `colWidths` and `rowWidths` arrays. Those arrays must have lengths equal to the number
+   * of columns or rows (respectively) in this table, and each array item must be a Number.
+   *
+   */
+  init(tableOptions) {
+    let x = this.x;
+    let y = this.y;
+    this.widths = tableOptions.colWidths.slice(x, x + this.colSpan);
+    this.heights = tableOptions.rowHeights.slice(y, y + this.rowSpan);
+    this.width = this.widths.reduce(sumPlusOne, -1);
+    this.height = this.heights.reduce(sumPlusOne, -1);
+
+    this.hAlign = this.options.hAlign || tableOptions.colAligns[x];
+    this.vAlign = this.options.vAlign || tableOptions.rowAligns[y];
+
+    this.drawRight = x + this.colSpan == tableOptions.colWidths.length;
+  }
+
+  /**
+   * Draws the given line of the cell.
+   * This default implementation defers to methods `drawTop`, `drawBottom`, `drawLine` and `drawEmpty`.
+   * @param lineNum - can be `top`, `bottom` or a numerical line number.
+   * @param spanningCell - will be a number if being called from a RowSpanCell, and will represent how
+   * many rows below it's being called from. Otherwise it's undefined.
+   * @returns {String} The representation of this line.
+   */
+  draw(lineNum, spanningCell) {
+    if (lineNum == 'top') return this.drawTop(this.drawRight);
+    if (lineNum == 'bottom') return this.drawBottom(this.drawRight);
+    let content = utils.truncate(this.content, 10, this.truncate);
+    if (!lineNum) {
+      info(`${this.y}-${this.x}: ${this.rowSpan - lineNum}x${this.colSpan} Cell ${content}`);
+    } else {
+      // debug(`${lineNum}-${this.x}: 1x${this.colSpan} RowSpanCell ${content}`);
+    }
+    let padLen = Math.max(this.height - this.lines.length, 0);
+    let padTop;
+    switch (this.vAlign) {
+      case 'center':
+        padTop = Math.ceil(padLen / 2);
+        break;
+      case 'bottom':
+        padTop = padLen;
+        break;
+      default:
+        padTop = 0;
+    }
+    if (lineNum < padTop || lineNum >= padTop + this.lines.length) {
+      return this.drawEmpty(this.drawRight, spanningCell);
+    }
+    let forceTruncation = this.lines.length > this.height && lineNum + 1 >= this.height;
+    return this.drawLine(lineNum - padTop, this.drawRight, forceTruncation, spanningCell);
+  }
+
+  /**
+   * Renders the top line of the cell.
+   * @param drawRight - true if this method should render the right edge of the cell.
+   * @returns {String}
+   */
+  drawTop(drawRight) {
+    let content = [];
+    if (this.cells) {
+      //TODO: cells should always exist - some tests don't fill it in though
+      this.widths.forEach(function (width, index) {
+        content.push(this._topLeftChar(index));
+        content.push(utils.repeat(this.chars[this.y == 0 ? 'top' : 'mid'], width));
+      }, this);
+    } else {
+      content.push(this._topLeftChar(0));
+      content.push(utils.repeat(this.chars[this.y == 0 ? 'top' : 'mid'], this.width));
+    }
+    if (drawRight) {
+      content.push(this.chars[this.y == 0 ? 'topRight' : 'rightMid']);
+    }
+    return this.wrapWithStyleColors('border', content.join(''));
+  }
+
+  _topLeftChar(offset) {
+    let x = this.x + offset;
+    let leftChar;
+    if (this.y == 0) {
+      leftChar = x == 0 ? 'topLeft' : offset == 0 ? 'topMid' : 'top';
+    } else {
+      if (x == 0) {
+        leftChar = 'leftMid';
+      } else {
+        leftChar = offset == 0 ? 'midMid' : 'bottomMid';
+        if (this.cells) {
+          //TODO: cells should always exist - some tests don't fill it in though
+          let spanAbove = this.cells[this.y - 1][x] instanceof Cell.ColSpanCell;
+          if (spanAbove) {
+            leftChar = offset == 0 ? 'topMid' : 'mid';
+          }
+          if (offset == 0) {
+            let i = 1;
+            while (this.cells[this.y][x - i] instanceof Cell.ColSpanCell) {
+              i++;
+            }
+            if (this.cells[this.y][x - i] instanceof Cell.RowSpanCell) {
+              leftChar = 'leftMid';
+            }
+          }
+        }
+      }
+    }
+    return this.chars[leftChar];
+  }
+
+  wrapWithStyleColors(styleProperty, content) {
+    if (this[styleProperty] && this[styleProperty].length) {
+      try {
+        let colors = __webpack_require__(39404);
+        for (let i = this[styleProperty].length - 1; i >= 0; i--) {
+          colors = colors[this[styleProperty][i]];
+        }
+        return colors(content);
+      } catch (e) {
+        return content;
+      }
+    } else {
+      return content;
+    }
+  }
+
+  /**
+   * Renders a line of text.
+   * @param lineNum - Which line of text to render. This is not necessarily the line within the cell.
+   * There may be top-padding above the first line of text.
+   * @param drawRight - true if this method should render the right edge of the cell.
+   * @param forceTruncationSymbol - `true` if the rendered text should end with the truncation symbol even
+   * if the text fits. This is used when the cell is vertically truncated. If `false` the text should
+   * only include the truncation symbol if the text will not fit horizontally within the cell width.
+   * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
+   * @returns {String}
+   */
+  drawLine(lineNum, drawRight, forceTruncationSymbol, spanningCell) {
+    let left = this.chars[this.x == 0 ? 'left' : 'middle'];
+    if (this.x && spanningCell && this.cells) {
+      let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+      while (cellLeft instanceof ColSpanCell) {
+        cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+      }
+      if (!(cellLeft instanceof RowSpanCell)) {
+        left = this.chars['rightMid'];
+      }
+    }
+    let leftPadding = utils.repeat(' ', this.paddingLeft);
+    let right = drawRight ? this.chars['right'] : '';
+    let rightPadding = utils.repeat(' ', this.paddingRight);
+    let line = this.lines[lineNum];
+    let len = this.width - (this.paddingLeft + this.paddingRight);
+    if (forceTruncationSymbol) line += this.truncate || '…';
+    let content = utils.truncate(line, len, this.truncate);
+    content = utils.pad(content, len, ' ', this.hAlign);
+    content = leftPadding + content + rightPadding;
+    return this.stylizeLine(left, content, right);
+  }
+
+  stylizeLine(left, content, right) {
+    left = this.wrapWithStyleColors('border', left);
+    right = this.wrapWithStyleColors('border', right);
+    if (this.y === 0) {
+      content = this.wrapWithStyleColors('head', content);
+    }
+    return left + content + right;
+  }
+
+  /**
+   * Renders the bottom line of the cell.
+   * @param drawRight - true if this method should render the right edge of the cell.
+   * @returns {String}
+   */
+  drawBottom(drawRight) {
+    let left = this.chars[this.x == 0 ? 'bottomLeft' : 'bottomMid'];
+    let content = utils.repeat(this.chars.bottom, this.width);
+    let right = drawRight ? this.chars['bottomRight'] : '';
+    return this.wrapWithStyleColors('border', left + content + right);
+  }
+
+  /**
+   * Renders a blank line of text within the cell. Used for top and/or bottom padding.
+   * @param drawRight - true if this method should render the right edge of the cell.
+   * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
+   * @returns {String}
+   */
+  drawEmpty(drawRight, spanningCell) {
+    let left = this.chars[this.x == 0 ? 'left' : 'middle'];
+    if (this.x && spanningCell && this.cells) {
+      let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+      while (cellLeft instanceof ColSpanCell) {
+        cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+      }
+      if (!(cellLeft instanceof RowSpanCell)) {
+        left = this.chars['rightMid'];
+      }
+    }
+    let right = drawRight ? this.chars['right'] : '';
+    let content = utils.repeat(' ', this.width);
+    return this.stylizeLine(left, content, right);
+  }
+}
+
+class ColSpanCell {
+  /**
+   * A Cell that doesn't do anything. It just draws empty lines.
+   * Used as a placeholder in column spanning.
+   * @constructor
+   */
+  constructor() {}
+
+  draw(lineNum) {
+    if (typeof lineNum === 'number') {
+      debug(`${this.y}-${this.x}: 1x1 ColSpanCell`);
+    }
+    return '';
+  }
+
+  init() {}
+
+  mergeTableOptions() {}
+}
+
+class RowSpanCell {
+  /**
+   * A placeholder Cell for a Cell that spans multiple rows.
+   * It delegates rendering to the original cell, but adds the appropriate offset.
+   * @param originalCell
+   * @constructor
+   */
+  constructor(originalCell) {
+    this.originalCell = originalCell;
+  }
+
+  init(tableOptions) {
+    let y = this.y;
+    let originalY = this.originalCell.y;
+    this.cellOffset = y - originalY;
+    this.offset = findDimension(tableOptions.rowHeights, originalY, this.cellOffset);
+  }
+
+  draw(lineNum) {
+    if (lineNum == 'top') {
+      return this.originalCell.draw(this.offset, this.cellOffset);
+    }
+    if (lineNum == 'bottom') {
+      return this.originalCell.draw('bottom');
+    }
+    debug(`${this.y}-${this.x}: 1x${this.colSpan} RowSpanCell for ${this.originalCell.content}`);
+    return this.originalCell.draw(this.offset + 1 + lineNum);
+  }
+
+  mergeTableOptions() {}
+}
+
+function firstDefined(...args) {
+  return args.filter((v) => v !== undefined && v !== null).shift();
+}
+
+// HELPER FUNCTIONS
+function setOption(objA, objB, nameB, targetObj) {
+  let nameA = nameB.split('-');
+  if (nameA.length > 1) {
+    nameA[1] = nameA[1].charAt(0).toUpperCase() + nameA[1].substr(1);
+    nameA = nameA.join('');
+    targetObj[nameA] = firstDefined(objA[nameA], objA[nameB], objB[nameA], objB[nameB]);
+  } else {
+    targetObj[nameB] = firstDefined(objA[nameB], objB[nameB]);
+  }
+}
+
+function findDimension(dimensionTable, startingIndex, span) {
+  let ret = dimensionTable[startingIndex];
+  for (let i = 1; i < span; i++) {
+    ret += 1 + dimensionTable[startingIndex + i];
+  }
+  return ret;
+}
+
+function sumPlusOne(a, b) {
+  return a + b + 1;
+}
+
+let CHAR_NAMES = [
+  'top',
+  'top-mid',
+  'top-left',
+  'top-right',
+  'bottom',
+  'bottom-mid',
+  'bottom-left',
+  'bottom-right',
+  'left',
+  'left-mid',
+  'mid',
+  'mid-mid',
+  'right',
+  'right-mid',
+  'middle',
+];
+
+module.exports = Cell;
+module.exports.ColSpanCell = ColSpanCell;
+module.exports.RowSpanCell = RowSpanCell;
+
+
+/***/ }),
+
+/***/ 12480:
+/***/ ((module) => {
+
+let messages = [];
+let level = 0;
+
+const debug = (msg, min) => {
+  if (level >= min) {
+    messages.push(msg);
+  }
+};
+
+debug.WARN = 1;
+debug.INFO = 2;
+debug.DEBUG = 3;
+
+debug.reset = () => {
+  messages = [];
+};
+
+debug.setDebugLevel = (v) => {
+  level = v;
+};
+
+debug.warn = (msg) => debug(msg, debug.WARN);
+debug.info = (msg) => debug(msg, debug.INFO);
+debug.debug = (msg) => debug(msg, debug.DEBUG);
+
+debug.debugMessages = () => messages;
+
+module.exports = debug;
+
+
+/***/ }),
+
+/***/ 26574:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { warn, debug } = __webpack_require__(12480);
+const Cell = __webpack_require__(67717);
+const { ColSpanCell, RowSpanCell } = Cell;
+
+(function () {
+  function next(alloc, col) {
+    if (alloc[col] > 0) {
+      return next(alloc, col + 1);
+    }
+    return col;
+  }
+
+  function layoutTable(table) {
+    let alloc = {};
+    table.forEach(function (row, rowIndex) {
+      let col = 0;
+      row.forEach(function (cell) {
+        cell.y = rowIndex;
+        // Avoid erroneous call to next() on first row
+        cell.x = rowIndex ? next(alloc, col) : col;
+        const rowSpan = cell.rowSpan || 1;
+        const colSpan = cell.colSpan || 1;
+        if (rowSpan > 1) {
+          for (let cs = 0; cs < colSpan; cs++) {
+            alloc[cell.x + cs] = rowSpan;
+          }
+        }
+        col = cell.x + colSpan;
+      });
+      Object.keys(alloc).forEach((idx) => {
+        alloc[idx]--;
+        if (alloc[idx] < 1) delete alloc[idx];
+      });
+    });
+  }
+
+  function maxWidth(table) {
+    let mw = 0;
+    table.forEach(function (row) {
+      row.forEach(function (cell) {
+        mw = Math.max(mw, cell.x + (cell.colSpan || 1));
+      });
+    });
+    return mw;
+  }
+
+  function maxHeight(table) {
+    return table.length;
+  }
+
+  function cellsConflict(cell1, cell2) {
+    let yMin1 = cell1.y;
+    let yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
+    let yMin2 = cell2.y;
+    let yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
+    let yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
+
+    let xMin1 = cell1.x;
+    let xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
+    let xMin2 = cell2.x;
+    let xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
+    let xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
+
+    return yConflict && xConflict;
+  }
+
+  function conflictExists(rows, x, y) {
+    let i_max = Math.min(rows.length - 1, y);
+    let cell = { x: x, y: y };
+    for (let i = 0; i <= i_max; i++) {
+      let row = rows[i];
+      for (let j = 0; j < row.length; j++) {
+        if (cellsConflict(cell, row[j])) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  function allBlank(rows, y, xMin, xMax) {
+    for (let x = xMin; x < xMax; x++) {
+      if (conflictExists(rows, x, y)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  function addRowSpanCells(table) {
+    table.forEach(function (row, rowIndex) {
+      row.forEach(function (cell) {
+        for (let i = 1; i < cell.rowSpan; i++) {
+          let rowSpanCell = new RowSpanCell(cell);
+          rowSpanCell.x = cell.x;
+          rowSpanCell.y = cell.y + i;
+          rowSpanCell.colSpan = cell.colSpan;
+          insertCell(rowSpanCell, table[rowIndex + i]);
+        }
+      });
+    });
+  }
+
+  function addColSpanCells(cellRows) {
+    for (let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex--) {
+      let cellColumns = cellRows[rowIndex];
+      for (let columnIndex = 0; columnIndex < cellColumns.length; columnIndex++) {
+        let cell = cellColumns[columnIndex];
+        for (let k = 1; k < cell.colSpan; k++) {
+          let colSpanCell = new ColSpanCell();
+          colSpanCell.x = cell.x + k;
+          colSpanCell.y = cell.y;
+          cellColumns.splice(columnIndex + 1, 0, colSpanCell);
+        }
+      }
+    }
+  }
+
+  function insertCell(cell, row) {
+    let x = 0;
+    while (x < row.length && row[x].x < cell.x) {
+      x++;
+    }
+    row.splice(x, 0, cell);
+  }
+
+  function fillInTable(table) {
+    let h_max = maxHeight(table);
+    let w_max = maxWidth(table);
+    debug(`Max rows: ${h_max}; Max cols: ${w_max}`);
+    for (let y = 0; y < h_max; y++) {
+      for (let x = 0; x < w_max; x++) {
+        if (!conflictExists(table, x, y)) {
+          let opts = { x: x, y: y, colSpan: 1, rowSpan: 1 };
+          x++;
+          while (x < w_max && !conflictExists(table, x, y)) {
+            opts.colSpan++;
+            x++;
+          }
+          let y2 = y + 1;
+          while (y2 < h_max && allBlank(table, y2, opts.x, opts.x + opts.colSpan)) {
+            opts.rowSpan++;
+            y2++;
+          }
+          let cell = new Cell(opts);
+          cell.x = opts.x;
+          cell.y = opts.y;
+          warn(`Missing cell at ${cell.y}-${cell.x}.`);
+          insertCell(cell, table[y]);
+        }
+      }
+    }
+  }
+
+  function generateCells(rows) {
+    return rows.map(function (row) {
+      if (!Array.isArray(row)) {
+        let key = Object.keys(row)[0];
+        row = row[key];
+        if (Array.isArray(row)) {
+          row = row.slice();
+          row.unshift(key);
+        } else {
+          row = [key, row];
+        }
+      }
+      return row.map(function (cell) {
+        return new Cell(cell);
+      });
+    });
+  }
+
+  function makeTableLayout(rows) {
+    let cellRows = generateCells(rows);
+    layoutTable(cellRows);
+    fillInTable(cellRows);
+    addRowSpanCells(cellRows);
+    addColSpanCells(cellRows);
+    return cellRows;
+  }
+
+  module.exports = {
+    makeTableLayout: makeTableLayout,
+    layoutTable: layoutTable,
+    addRowSpanCells: addRowSpanCells,
+    maxWidth: maxWidth,
+    fillInTable: fillInTable,
+    computeWidths: makeComputeWidths('colSpan', 'desiredWidth', 'x', 1),
+    computeHeights: makeComputeWidths('rowSpan', 'desiredHeight', 'y', 1),
+  };
+})();
+
+function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
+  return function (vals, table) {
+    let result = [];
+    let spanners = [];
+    let auto = {};
+    table.forEach(function (row) {
+      row.forEach(function (cell) {
+        if ((cell[colSpan] || 1) > 1) {
+          spanners.push(cell);
+        } else {
+          result[cell[x]] = Math.max(result[cell[x]] || 0, cell[desiredWidth] || 0, forcedMin);
+        }
+      });
+    });
+
+    vals.forEach(function (val, index) {
+      if (typeof val === 'number') {
+        result[index] = val;
+      }
+    });
+
+    //spanners.forEach(function(cell){
+    for (let k = spanners.length - 1; k >= 0; k--) {
+      let cell = spanners[k];
+      let span = cell[colSpan];
+      let col = cell[x];
+      let existingWidth = result[col];
+      let editableCols = typeof vals[col] === 'number' ? 0 : 1;
+      if (typeof existingWidth === 'number') {
+        for (let i = 1; i < span; i++) {
+          existingWidth += 1 + result[col + i];
+          if (typeof vals[col + i] !== 'number') {
+            editableCols++;
+          }
+        }
+      } else {
+        existingWidth = desiredWidth === 'desiredWidth' ? cell.desiredWidth - 1 : 1;
+        if (!auto[col] || auto[col] < existingWidth) {
+          auto[col] = existingWidth;
+        }
+      }
+
+      if (cell[desiredWidth] > existingWidth) {
+        let i = 0;
+        while (editableCols > 0 && cell[desiredWidth] > existingWidth) {
+          if (typeof vals[col + i] !== 'number') {
+            let dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
+            existingWidth += dif;
+            result[col + i] += dif;
+            editableCols--;
+          }
+          i++;
+        }
+      }
+    }
+
+    Object.assign(vals, result, auto);
+    for (let j = 0; j < vals.length; j++) {
+      vals[j] = Math.max(forcedMin, vals[j] || 0);
+    }
+  };
+}
+
+
+/***/ }),
+
+/***/ 37650:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const debug = __webpack_require__(12480);
+const utils = __webpack_require__(79011);
+const tableLayout = __webpack_require__(26574);
+
+class Table extends Array {
+  constructor(opts) {
+    super();
+
+    const options = utils.mergeOptions(opts);
+    Object.defineProperty(this, 'options', {
+      value: options,
+      enumerable: options.debug,
+    });
+
+    if (options.debug) {
+      switch (typeof options.debug) {
+        case 'boolean':
+          debug.setDebugLevel(debug.WARN);
+          break;
+        case 'number':
+          debug.setDebugLevel(options.debug);
+          break;
+        case 'string':
+          debug.setDebugLevel(parseInt(options.debug, 10));
+          break;
+        default:
+          debug.setDebugLevel(debug.WARN);
+          debug.warn(`Debug option is expected to be boolean, number, or string. Received a ${typeof options.debug}`);
+      }
+      Object.defineProperty(this, 'messages', {
+        get() {
+          return debug.debugMessages();
+        },
+      });
+    }
+  }
+
+  toString() {
+    let array = this;
+    let headersPresent = this.options.head && this.options.head.length;
+    if (headersPresent) {
+      array = [this.options.head];
+      if (this.length) {
+        array.push.apply(array, this);
+      }
+    } else {
+      this.options.style.head = [];
+    }
+
+    let cells = tableLayout.makeTableLayout(array);
+
+    cells.forEach(function (row) {
+      row.forEach(function (cell) {
+        cell.mergeTableOptions(this.options, cells);
+      }, this);
+    }, this);
+
+    tableLayout.computeWidths(this.options.colWidths, cells);
+    tableLayout.computeHeights(this.options.rowHeights, cells);
+
+    cells.forEach(function (row) {
+      row.forEach(function (cell) {
+        cell.init(this.options);
+      }, this);
+    }, this);
+
+    let result = [];
+
+    for (let rowIndex = 0; rowIndex < cells.length; rowIndex++) {
+      let row = cells[rowIndex];
+      let heightOfRow = this.options.rowHeights[rowIndex];
+
+      if (rowIndex === 0 || !this.options.style.compact || (rowIndex == 1 && headersPresent)) {
+        doDraw(row, 'top', result);
+      }
+
+      for (let lineNum = 0; lineNum < heightOfRow; lineNum++) {
+        doDraw(row, lineNum, result);
+      }
+
+      if (rowIndex + 1 == cells.length) {
+        doDraw(row, 'bottom', result);
+      }
+    }
+
+    return result.join('\n');
+  }
+
+  get width() {
+    let str = this.toString().split('\n');
+    return str[0].length;
+  }
+}
+
+Table.reset = () => debug.reset();
+
+function doDraw(row, lineNum, result) {
+  let line = [];
+  row.forEach(function (cell) {
+    line.push(cell.draw(lineNum));
+  });
+  let str = line.join('');
+  if (str.length) result.push(str);
+}
+
+module.exports = Table;
+
+
+/***/ }),
+
+/***/ 79011:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const stringWidth = __webpack_require__(80718);
+
+function codeRegex(capture) {
+  return capture ? /\u001b\[((?:\d*;){0,5}\d*)m/g : /\u001b\[(?:\d*;){0,5}\d*m/g;
+}
+
+function strlen(str) {
+  let code = codeRegex();
+  let stripped = ('' + str).replace(code, '');
+  let split = stripped.split('\n');
+  return split.reduce(function (memo, s) {
+    return stringWidth(s) > memo ? stringWidth(s) : memo;
+  }, 0);
+}
+
+function repeat(str, times) {
+  return Array(times + 1).join(str);
+}
+
+function pad(str, len, pad, dir) {
+  let length = strlen(str);
+  if (len + 1 >= length) {
+    let padlen = len - length;
+    switch (dir) {
+      case 'right': {
+        str = repeat(pad, padlen) + str;
+        break;
+      }
+      case 'center': {
+        let right = Math.ceil(padlen / 2);
+        let left = padlen - right;
+        str = repeat(pad, left) + str + repeat(pad, right);
+        break;
+      }
+      default: {
+        str = str + repeat(pad, padlen);
+        break;
+      }
+    }
+  }
+  return str;
+}
+
+let codeCache = {};
+
+function addToCodeCache(name, on, off) {
+  on = '\u001b[' + on + 'm';
+  off = '\u001b[' + off + 'm';
+  codeCache[on] = { set: name, to: true };
+  codeCache[off] = { set: name, to: false };
+  codeCache[name] = { on: on, off: off };
+}
+
+//https://github.com/Marak/colors.js/blob/master/lib/styles.js
+addToCodeCache('bold', 1, 22);
+addToCodeCache('italics', 3, 23);
+addToCodeCache('underline', 4, 24);
+addToCodeCache('inverse', 7, 27);
+addToCodeCache('strikethrough', 9, 29);
+
+function updateState(state, controlChars) {
+  let controlCode = controlChars[1] ? parseInt(controlChars[1].split(';')[0]) : 0;
+  if ((controlCode >= 30 && controlCode <= 39) || (controlCode >= 90 && controlCode <= 97)) {
+    state.lastForegroundAdded = controlChars[0];
+    return;
+  }
+  if ((controlCode >= 40 && controlCode <= 49) || (controlCode >= 100 && controlCode <= 107)) {
+    state.lastBackgroundAdded = controlChars[0];
+    return;
+  }
+  if (controlCode === 0) {
+    for (let i in state) {
+      /* istanbul ignore else */
+      if (Object.prototype.hasOwnProperty.call(state, i)) {
+        delete state[i];
+      }
+    }
+    return;
+  }
+  let info = codeCache[controlChars[0]];
+  if (info) {
+    state[info.set] = info.to;
+  }
+}
+
+function readState(line) {
+  let code = codeRegex(true);
+  let controlChars = code.exec(line);
+  let state = {};
+  while (controlChars !== null) {
+    updateState(state, controlChars);
+    controlChars = code.exec(line);
+  }
+  return state;
+}
+
+function unwindState(state, ret) {
+  let lastBackgroundAdded = state.lastBackgroundAdded;
+  let lastForegroundAdded = state.lastForegroundAdded;
+
+  delete state.lastBackgroundAdded;
+  delete state.lastForegroundAdded;
+
+  Object.keys(state).forEach(function (key) {
+    if (state[key]) {
+      ret += codeCache[key].off;
+    }
+  });
+
+  if (lastBackgroundAdded && lastBackgroundAdded != '\u001b[49m') {
+    ret += '\u001b[49m';
+  }
+  if (lastForegroundAdded && lastForegroundAdded != '\u001b[39m') {
+    ret += '\u001b[39m';
+  }
+
+  return ret;
+}
+
+function rewindState(state, ret) {
+  let lastBackgroundAdded = state.lastBackgroundAdded;
+  let lastForegroundAdded = state.lastForegroundAdded;
+
+  delete state.lastBackgroundAdded;
+  delete state.lastForegroundAdded;
+
+  Object.keys(state).forEach(function (key) {
+    if (state[key]) {
+      ret = codeCache[key].on + ret;
+    }
+  });
+
+  if (lastBackgroundAdded && lastBackgroundAdded != '\u001b[49m') {
+    ret = lastBackgroundAdded + ret;
+  }
+  if (lastForegroundAdded && lastForegroundAdded != '\u001b[39m') {
+    ret = lastForegroundAdded + ret;
+  }
+
+  return ret;
+}
+
+function truncateWidth(str, desiredLength) {
+  if (str.length === strlen(str)) {
+    return str.substr(0, desiredLength);
+  }
+
+  while (strlen(str) > desiredLength) {
+    str = str.slice(0, -1);
+  }
+
+  return str;
+}
+
+function truncateWidthWithAnsi(str, desiredLength) {
+  let code = codeRegex(true);
+  let split = str.split(codeRegex());
+  let splitIndex = 0;
+  let retLen = 0;
+  let ret = '';
+  let myArray;
+  let state = {};
+
+  while (retLen < desiredLength) {
+    myArray = code.exec(str);
+    let toAdd = split[splitIndex];
+    splitIndex++;
+    if (retLen + strlen(toAdd) > desiredLength) {
+      toAdd = truncateWidth(toAdd, desiredLength - retLen);
+    }
+    ret += toAdd;
+    retLen += strlen(toAdd);
+
+    if (retLen < desiredLength) {
+      if (!myArray) {
+        break;
+      } // full-width chars may cause a whitespace which cannot be filled
+      ret += myArray[0];
+      updateState(state, myArray);
+    }
+  }
+
+  return unwindState(state, ret);
+}
+
+function truncate(str, desiredLength, truncateChar) {
+  truncateChar = truncateChar || '…';
+  let lengthOfStr = strlen(str);
+  if (lengthOfStr <= desiredLength) {
+    return str;
+  }
+  desiredLength -= strlen(truncateChar);
+
+  let ret = truncateWidthWithAnsi(str, desiredLength);
+
+  return ret + truncateChar;
+}
+
+function defaultOptions() {
+  return {
+    chars: {
+      top: '─',
+      'top-mid': '┬',
+      'top-left': '┌',
+      'top-right': '┐',
+      bottom: '─',
+      'bottom-mid': '┴',
+      'bottom-left': '└',
+      'bottom-right': '┘',
+      left: '│',
+      'left-mid': '├',
+      mid: '─',
+      'mid-mid': '┼',
+      right: '│',
+      'right-mid': '┤',
+      middle: '│',
+    },
+    truncate: '…',
+    colWidths: [],
+    rowHeights: [],
+    colAligns: [],
+    rowAligns: [],
+    style: {
+      'padding-left': 1,
+      'padding-right': 1,
+      head: ['red'],
+      border: ['grey'],
+      compact: false,
+    },
+    head: [],
+  };
+}
+
+function mergeOptions(options, defaults) {
+  options = options || {};
+  defaults = defaults || defaultOptions();
+  let ret = Object.assign({}, defaults, options);
+  ret.chars = Object.assign({}, defaults.chars, options.chars);
+  ret.style = Object.assign({}, defaults.style, options.style);
+  return ret;
+}
+
+// Wrap on word boundary
+function wordWrap(maxLength, input) {
+  let lines = [];
+  let split = input.split(/(\s+)/g);
+  let line = [];
+  let lineLength = 0;
+  let whitespace;
+  for (let i = 0; i < split.length; i += 2) {
+    let word = split[i];
+    let newLength = lineLength + strlen(word);
+    if (lineLength > 0 && whitespace) {
+      newLength += whitespace.length;
+    }
+    if (newLength > maxLength) {
+      if (lineLength !== 0) {
+        lines.push(line.join(''));
+      }
+      line = [word];
+      lineLength = strlen(word);
+    } else {
+      line.push(whitespace || '', word);
+      lineLength = newLength;
+    }
+    whitespace = split[i + 1];
+  }
+  if (lineLength) {
+    lines.push(line.join(''));
+  }
+  return lines;
+}
+
+// Wrap text (ignoring word boundaries)
+function textWrap(maxLength, input) {
+  let lines = [];
+  let line = '';
+  function pushLine(str, ws) {
+    if (line.length && ws) line += ws;
+    line += str;
+    while (line.length > maxLength) {
+      lines.push(line.slice(0, maxLength));
+      line = line.slice(maxLength);
+    }
+  }
+  let split = input.split(/(\s+)/g);
+  for (let i = 0; i < split.length; i += 2) {
+    pushLine(split[i], i && split[i - 1]);
+  }
+  if (line.length) lines.push(line);
+  return lines;
+}
+
+function multiLineWordWrap(maxLength, input, wrapOnWordBoundary = true) {
+  let output = [];
+  input = input.split('\n');
+  const handler = wrapOnWordBoundary ? wordWrap : textWrap;
+  for (let i = 0; i < input.length; i++) {
+    output.push.apply(output, handler(maxLength, input[i]));
+  }
+  return output;
+}
+
+function colorizeLines(input) {
+  let state = {};
+  let output = [];
+  for (let i = 0; i < input.length; i++) {
+    let line = rewindState(state, input[i]);
+    state = readState(line);
+    let temp = Object.assign({}, state);
+    output.push(unwindState(temp, line));
+  }
+  return output;
+}
+
+/**
+ * Credit: Matheus Sampaio https://github.com/matheussampaio
+ */
+function hyperlink(url, text) {
+  const OSC = '\u001B]';
+  const BEL = '\u0007';
+  const SEP = ';';
+
+  return [OSC, '8', SEP, SEP, url || text, BEL, text, OSC, '8', SEP, SEP, BEL].join('');
+}
+
+module.exports = {
+  strlen: strlen,
+  repeat: repeat,
+  pad: pad,
+  truncate: truncate,
+  mergeOptions: mergeOptions,
+  wordWrap: multiLineWordWrap,
+  colorizeLines: colorizeLines,
+  hyperlink,
+};
+
+
 /***/ }),
 
 /***/ 48216:
@@ -210895,9 +212845,6 @@ class Secrets extends (util_default()) {
 // EXTERNAL MODULE: ./src/util/exit.ts
 var exit = __webpack_require__(25661);
 
-// EXTERNAL MODULE: ./src/util/output/logo.ts
-var logo = __webpack_require__(66669);
-
 // EXTERNAL MODULE: ./src/util/get-scope.ts
 var get_scope = __webpack_require__(60324);
 var get_scope_default = /*#__PURE__*/__webpack_require__.n(get_scope);
@@ -210929,7 +212876,6 @@ var pkg_name = __webpack_require__(79000);
 
 
 
-
 const help = () => {
   console.log(`
   ${source_default().yellow(
@@ -210938,7 +212884,7 @@ const help = () => {
     )} command is recommended instead of ${(0,pkg_name.getCommandName)('secrets')}`
   )}
 
-  ${source_default().bold(`${logo.default} ${(0,pkg_name.getPkgName)()} secrets`)} [options] <command>
+  ${source_default().bold(`${pkg_name.logo} ${pkg_name.packageName} secrets`)} [options] <command>
 
   ${source_default().dim('Commands:')}
 
@@ -210967,7 +212913,7 @@ const help = () => {
 
   ${source_default().gray('–')} Add a new secret
 
-    ${source_default().cyan(`$ ${(0,pkg_name.getPkgName)()} secrets add my-secret "my value"`)}
+    ${source_default().cyan(`$ ${pkg_name.packageName} secrets add my-secret "my value"`)}
 
     ${source_default().gray(
       '–'
@@ -210983,13 +212929,13 @@ const help = () => {
     '`@`'
   )} symbol)
 
-    ${source_default().cyan(`$ ${(0,pkg_name.getPkgName)()} -e MY_SECRET=${source_default().bold('@my-secret')}`)}
+    ${source_default().cyan(`$ ${pkg_name.packageName} -e MY_SECRET=${source_default().bold('@my-secret')}`)}
 
   ${source_default().gray('–')} Paginate results, where ${source_default().dim(
     '`1584722256178`'
   )} is the time in milliseconds since the UNIX epoch
 
-    ${source_default().cyan(`$ ${(0,pkg_name.getPkgName)()} secrets ls --next 1584722256178`)}
+    ${source_default().cyan(`$ ${pkg_name.packageName} secrets ls --next 1584722256178`)}
 `);
 };
 
@@ -212948,7 +214894,7 @@ exports.frameworks = [
         cachePattern: '.cache/**',
     },
     {
-        name: 'Docusaurus 2',
+        name: 'Docusaurus (v2)',
         slug: 'docusaurus-2',
         demo: 'https://docusaurus-2-template.vercel.app',
         logo: 'https://api-frameworks.vercel.sh/framework-logos/docusaurus.svg',
@@ -213031,7 +214977,7 @@ exports.frameworks = [
         ],
     },
     {
-        name: 'Docusaurus 1',
+        name: 'Docusaurus (v1)',
         slug: 'docusaurus',
         demo: 'https://docusaurus-template.vercel.app',
         logo: 'https://api-frameworks.vercel.sh/framework-logos/docusaurus.svg',
@@ -213554,7 +215500,7 @@ exports.frameworks = [
     },
     {
         // TODO: fix detected as "sveltekit-1"
-        name: 'SvelteKit (Legacy Beta)',
+        name: 'SvelteKit (v0)',
         slug: 'sveltekit',
         demo: 'https://sveltekit-template.vercel.app',
         logo: 'https://api-frameworks.vercel.sh/framework-logos/svelte.svg',
@@ -213591,7 +215537,7 @@ exports.frameworks = [
         getOutputDirName: async () => 'public',
     },
     {
-        name: 'SvelteKit',
+        name: 'SvelteKit (v1)',
         slug: 'sveltekit-1',
         demo: 'https://sveltekit-1-template.vercel.app',
         logo: 'https://api-frameworks.vercel.sh/framework-logos/svelte.svg',
@@ -214250,7 +216196,7 @@ exports.frameworks = [
         defaultVersion: '0.13.0', // Must match the build image
     },
     {
-        name: 'Hydrogen',
+        name: 'Hydrogen (v1)',
         slug: 'hydrogen',
         demo: 'https://hydrogen-template.vercel.app',
         logo: 'https://api-frameworks.vercel.sh/framework-logos/hydrogen.svg',
@@ -217929,10 +219875,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.help = void 0;
 const chalk_1 = __importDefault(__webpack_require__(90877));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const pkg_name_1 = __webpack_require__(79000);
 const help = () => `
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()}`)} [options] <command | path>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName}`)} [options] <command | path>
 
   ${chalk_1.default.dim('For deploy command help, run `vercel deploy --help`')}
 
@@ -217987,19 +219932,19 @@ const help = () => `
 
   ${chalk_1.default.gray('–')} Deploy the current directory
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()}`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName}`)}
 
   ${chalk_1.default.gray('–')} Deploy a custom path
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} /usr/src/project`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} /usr/src/project`)}
 
   ${chalk_1.default.gray('–')} Deploy with Environment Variables
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} -e NODE_ENV=production`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} -e NODE_ENV=production`)}
 
   ${chalk_1.default.gray('–')} Show the usage information for the sub command ${chalk_1.default.dim('`list`')}
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} help list`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} help list`)}
 `;
 exports.help = help;
 
@@ -218019,14 +219964,13 @@ const chalk_1 = __importDefault(__webpack_require__(90877));
 const error_1 = __webpack_require__(4400);
 const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_subcommand_1 = __importDefault(__webpack_require__(66167));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const pkg_name_1 = __webpack_require__(79000);
 const ls_1 = __importDefault(__webpack_require__(74021));
 const rm_1 = __importDefault(__webpack_require__(48863));
 const set_1 = __importDefault(__webpack_require__(80734));
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} alias`)} [options] <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} alias`)} [options] <command>
 
   ${chalk_1.default.dim('Commands:')}
 
@@ -218051,11 +219995,11 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Add a new alias to ${chalk_1.default.underline('my-api.vercel.app')}
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} alias set ${chalk_1.default.underline('api-ownv3nc9f8.vercel.app')} ${chalk_1.default.underline('my-api.vercel.app')}`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} alias set ${chalk_1.default.underline('api-ownv3nc9f8.vercel.app')} ${chalk_1.default.underline('my-api.vercel.app')}`)}
 
       Custom domains work as alias targets
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} alias set ${chalk_1.default.underline('api-ownv3nc9f8.vercel.app')} ${chalk_1.default.underline('my-api.com')}`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} alias set ${chalk_1.default.underline('api-ownv3nc9f8.vercel.app')} ${chalk_1.default.underline('my-api.com')}`)}
 
       ${chalk_1.default.dim('–')} The subcommand ${chalk_1.default.dim('`set`')} is the default and can be skipped.
       ${chalk_1.default.dim('–')} ${chalk_1.default.dim('Protocols')} in the URLs are unneeded and ignored.
@@ -218541,15 +220485,15 @@ exports.bisectCommand = {
     examples: [
         {
             name: 'Bisect the current project interactively',
-            value: `${(0, pkg_name_1.getPkgName)()} bisect`,
+            value: `${pkg_name_1.packageName} bisect`,
         },
         {
             name: 'Bisect with a known bad deployment',
-            value: `${(0, pkg_name_1.getPkgName)()} bisect --bad example-310pce9i0.vercel.app`,
+            value: `${pkg_name_1.packageName} bisect --bad example-310pce9i0.vercel.app`,
         },
         {
             name: 'Automated bisect with a run script',
-            value: `${(0, pkg_name_1.getPkgName)()} bisect --run ./test.sh`,
+            value: `${pkg_name_1.packageName} bisect --run ./test.sh`,
         },
     ],
 };
@@ -218882,11 +220826,11 @@ exports.buildCommand = {
     examples: [
         {
             name: 'Build the project',
-            value: `${(0, pkg_name_1.getPkgName)()} build`,
+            value: `${pkg_name_1.packageName} build`,
         },
         {
             name: 'Build the project in a specific directory',
-            value: `${(0, pkg_name_1.getPkgName)()} build --cwd ./path-to-project`,
+            value: `${pkg_name_1.packageName} build --cwd ./path-to-project`,
         },
     ],
 };
@@ -218959,12 +220903,13 @@ const validate_config_1 = __webpack_require__(21144);
 const monorepo_1 = __webpack_require__(21481);
 const help_1 = __webpack_require__(58219);
 const command_1 = __webpack_require__(29216);
+const scrub_argv_1 = __webpack_require__(18119);
 async function main(client) {
     let { cwd } = client;
     const { output } = client;
     // Ensure that `vc build` is not being invoked recursively
     if (process.env.__VERCEL_BUILD_RUNNING) {
-        output.error(`${(0, cmd_1.default)(`${cli.name} build`)} must not recursively invoke itself. Check the Build Command in the Project Settings or the ${(0, cmd_1.default)('build')} script in ${(0, cmd_1.default)('package.json')}`);
+        output.error(`${(0, cmd_1.default)(`${cli.packageName} build`)} must not recursively invoke itself. Check the Build Command in the Project Settings or the ${(0, cmd_1.default)('build')} script in ${(0, cmd_1.default)('package.json')}`);
         output.error(`Learn More: https://vercel.link/recursive-invocation-of-commands`);
         return 1;
     }
@@ -219045,7 +220990,7 @@ async function main(client) {
     const buildsJson = {
         '//': 'This file was generated by the `vercel build` command. It is not part of the Build Output API.',
         target,
-        argv: process.argv,
+        argv: (0, scrub_argv_1.scrubArgv)(process.argv),
     };
     const envToUnset = new Set(['VERCEL', 'NOW_BUILDER']);
     try {
@@ -219558,7 +221503,6 @@ const chalk_1 = __importDefault(__webpack_require__(90877));
 const error_1 = __webpack_require__(4400);
 const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_subcommand_1 = __importDefault(__webpack_require__(66167));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const add_1 = __importDefault(__webpack_require__(30033));
 const issue_1 = __importDefault(__webpack_require__(14008));
 const ls_1 = __importDefault(__webpack_require__(15922));
@@ -219566,7 +221510,7 @@ const rm_1 = __importDefault(__webpack_require__(55667));
 const pkg_name_1 = __webpack_require__(79000);
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} certs`)} [options] <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} certs`)} [options] <command>
 
   ${chalk_1.default.yellow('NOTE:')} This command is intended for advanced use only.
   By default, Vercel manages your certificates automatically.
@@ -219597,15 +221541,15 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Generate a certificate with the cnames "acme.com" and "www.acme.com"
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} certs issue acme.com www.acme.com`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} certs issue acme.com www.acme.com`)}
 
   ${chalk_1.default.gray('–')} Remove a certificate
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} certs rm id`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} certs rm id`)}
 
   ${chalk_1.default.gray('–')} Paginate results, where ${chalk_1.default.dim('`1584722256178`')} is the time in milliseconds since the UNIX epoch.
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} certs ls --next 1584722256178`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} certs ls --next 1584722256178`)}
   `);
 };
 const COMMAND_CONFIG = {
@@ -220868,7 +222812,6 @@ const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_subcommand_1 = __importDefault(__webpack_require__(66167));
 const now_error_1 = __webpack_require__(22216);
 const handle_error_1 = __importDefault(__webpack_require__(64377));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const cmd_1 = __importDefault(__webpack_require__(62422));
 const highlight_1 = __importDefault(__webpack_require__(34661));
 const dev_1 = __importDefault(__webpack_require__(7532));
@@ -220882,9 +222825,9 @@ const COMMAND_CONFIG = {
 };
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} dev`)} [options] <dir>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} dev`)} [options] <dir>
 
-  Starts the \`${(0, pkg_name_1.getPkgName)()} dev\` server.
+  Starts the \`${pkg_name_1.packageName} dev\` server.
 
   ${chalk_1.default.dim('Options:')}
 
@@ -220897,18 +222840,18 @@ const help = () => {
 
   ${chalk_1.default.dim('Examples:')}
 
-  ${chalk_1.default.gray('–')} Start the \`${(0, pkg_name_1.getPkgName)()} dev\` server on port 8080
+  ${chalk_1.default.gray('–')} Start the \`${pkg_name_1.packageName} dev\` server on port 8080
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dev --listen 8080`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dev --listen 8080`)}
 
   ${chalk_1.default.gray('–')} Make the \`vercel dev\` server bind to localhost on port 5000
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dev --listen 127.0.0.1:5000`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dev --listen 127.0.0.1:5000`)}
   `);
 };
 async function main(client) {
     if (process.env.__VERCEL_DEV_RUNNING) {
-        client.output.error(`${(0, cmd_1.default)(`${(0, pkg_name_1.getPkgName)()} dev`)} must not recursively invoke itself. Check the Development Command in the Project Settings or the ${(0, cmd_1.default)('dev')} script in ${(0, cmd_1.default)('package.json')}`);
+        client.output.error(`${(0, cmd_1.default)(`${pkg_name_1.packageName} dev`)} must not recursively invoke itself. Check the Development Command in the Project Settings or the ${(0, cmd_1.default)('dev')} script in ${(0, cmd_1.default)('package.json')}`);
         client.output.error(`Learn More: https://vercel.link/recursive-invocation-of-commands`);
         return 1;
     }
@@ -220961,7 +222904,7 @@ async function main(client) {
             return 1;
         }
         if (/\b(now|vercel)\b\W+\bdev\b/.test(pkg?.scripts?.dev || '')) {
-            client.output.error(`${(0, cmd_1.default)(`${(0, pkg_name_1.getPkgName)()} dev`)} must not recursively invoke itself. Check the Development Command in the Project Settings or the ${(0, cmd_1.default)('dev')} script in ${(0, cmd_1.default)('package.json')}`);
+            client.output.error(`${(0, cmd_1.default)(`${pkg_name_1.packageName} dev`)} must not recursively invoke itself. Check the Development Command in the Project Settings or the ${(0, cmd_1.default)('dev')} script in ${(0, cmd_1.default)('package.json')}`);
             client.output.error(`Learn More: https://vercel.link/recursive-invocation-of-commands`);
             return 1;
         }
@@ -221120,7 +223063,6 @@ const chalk_1 = __importDefault(__webpack_require__(90877));
 const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_subcommand_1 = __importDefault(__webpack_require__(66167));
 const handle_error_1 = __importDefault(__webpack_require__(64377));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const pkg_name_1 = __webpack_require__(79000);
 const add_1 = __importDefault(__webpack_require__(25169));
 const import_1 = __importDefault(__webpack_require__(47626));
@@ -221128,7 +223070,7 @@ const ls_1 = __importDefault(__webpack_require__(35789));
 const rm_1 = __importDefault(__webpack_require__(42206));
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} dns`)} [options] <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} dns`)} [options] <command>
 
   ${chalk_1.default.dim('Commands:')}
 
@@ -221153,33 +223095,33 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Add an A record for a subdomain
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add <DOMAIN> <SUBDOMAIN> <A | AAAA | ALIAS | CNAME | TXT>  <VALUE>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add zeit.rocks api A 198.51.100.100`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add <DOMAIN> <SUBDOMAIN> <A | AAAA | ALIAS | CNAME | TXT>  <VALUE>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add zeit.rocks api A 198.51.100.100`)}
 
   ${chalk_1.default.gray('–')} Add an MX record (@ as a name refers to the domain)
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add <DOMAIN> '@' MX <RECORD VALUE> <PRIORITY>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add zeit.rocks '@' MX mail.zeit.rocks 10`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add <DOMAIN> '@' MX <RECORD VALUE> <PRIORITY>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add zeit.rocks '@' MX mail.zeit.rocks 10`)}
 
   ${chalk_1.default.gray('–')} Add an SRV record
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add <DOMAIN> <NAME> SRV <PRIORITY> <WEIGHT> <PORT> <TARGET>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add zeit.rocks '@' SRV 10 0 389 zeit.party`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add <DOMAIN> <NAME> SRV <PRIORITY> <WEIGHT> <PORT> <TARGET>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add zeit.rocks '@' SRV 10 0 389 zeit.party`)}
 
   ${chalk_1.default.gray('–')} Add a CAA record
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add <DOMAIN> <NAME> CAA '<FLAGS> <TAG> "<VALUE>"'`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns add zeit.rocks '@' CAA '0 issue "example.com"'`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add <DOMAIN> <NAME> CAA '<FLAGS> <TAG> "<VALUE>"'`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns add zeit.rocks '@' CAA '0 issue "example.com"'`)}
 
   ${chalk_1.default.gray('–')} Import a Zone file
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns import <DOMAIN> <FILE>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns import zeit.rocks ./zonefile.txt`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns import <DOMAIN> <FILE>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns import zeit.rocks ./zonefile.txt`)}
 
   ${chalk_1.default.gray('–')} Paginate results, where ${chalk_1.default.dim('`1584722256178`')} is the time in milliseconds since the UNIX epoch.
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns ls --next 1584722256178`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} dns ls zeit.rocks --next 1584722256178`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns ls --next 1584722256178`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} dns ls zeit.rocks --next 1584722256178`)}
 `);
 };
 const COMMAND_CONFIG = {
@@ -221660,7 +223602,6 @@ const chalk_1 = __importDefault(__webpack_require__(90877));
 const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_subcommand_1 = __importDefault(__webpack_require__(66167));
 const handle_error_1 = __importDefault(__webpack_require__(64377));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const add_1 = __importDefault(__webpack_require__(5004));
 const buy_1 = __importDefault(__webpack_require__(93608));
 const transfer_in_1 = __importDefault(__webpack_require__(54878));
@@ -221671,7 +223612,7 @@ const move_1 = __importDefault(__webpack_require__(41020));
 const pkg_name_1 = __webpack_require__(79000);
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} domains`)} [options] <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} domains`)} [options] <command>
 
   ${chalk_1.default.dim('Commands:')}
 
@@ -221701,17 +223642,17 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Add a domain that you already own
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} domains add ${chalk_1.default.underline('domain-name.com')}`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} domains add ${chalk_1.default.underline('domain-name.com')}`)}
 
       Make sure the domain's DNS nameservers are at least 2 of the
       ones listed on ${chalk_1.default.underline('https://vercel.com/edge-network')}.
 
-      ${chalk_1.default.yellow('NOTE:')} Running ${chalk_1.default.dim(`${(0, pkg_name_1.getPkgName)()} alias`)} will automatically register your domain
+      ${chalk_1.default.yellow('NOTE:')} Running ${chalk_1.default.dim(`${pkg_name_1.packageName} alias`)} will automatically register your domain
       if it's configured with these nameservers (no need to ${chalk_1.default.dim('`domain add`')}).
 
   ${chalk_1.default.gray('–')} Paginate results, where ${chalk_1.default.dim('`1584722256178`')} is the time in milliseconds since the UNIX epoch.
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} domains ls --next 1584722256178`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} domains ls --next 1584722256178`)}
 `);
 };
 const COMMAND_CONFIG = {
@@ -222545,7 +224486,6 @@ const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_invalid_subcommand_1 = __importDefault(__webpack_require__(6479));
 const get_subcommand_1 = __importDefault(__webpack_require__(66167));
 const handle_error_1 = __importDefault(__webpack_require__(64377));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const pkg_name_1 = __webpack_require__(79000);
 const link_1 = __webpack_require__(49347);
 const add_1 = __importDefault(__webpack_require__(12185));
@@ -222555,7 +224495,7 @@ const rm_1 = __importDefault(__webpack_require__(66266));
 const help = () => {
     const targetPlaceholder = (0, env_target_1.getEnvTargetPlaceholder)();
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} env`)} [options] <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} env`)} [options] <command>
 
   ${chalk_1.default.dim('Commands:')}
 
@@ -222580,44 +224520,44 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Pull all Development Environment Variables down from the cloud
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env pull <file>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env pull .env.development.local`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env pull <file>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env pull .env.development.local`)}
 
   ${chalk_1.default.gray('–')} Add a new variable to multiple Environments
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env add <name>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env add API_TOKEN`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env add <name>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env add API_TOKEN`)}
 
   ${chalk_1.default.gray('–')} Add a new variable for a specific Environment
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env add <name> ${targetPlaceholder}`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env add DB_PASS production`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env add <name> ${targetPlaceholder}`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env add DB_PASS production`)}
 
   ${chalk_1.default.gray('–')} Add a new variable for a specific Environment and Git Branch
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env add <name> ${targetPlaceholder} <gitbranch>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env add DB_PASS preview feat1`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env add <name> ${targetPlaceholder} <gitbranch>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env add DB_PASS preview feat1`)}
 
   ${chalk_1.default.gray('–')} Add a new Environment Variable from stdin
 
-      ${chalk_1.default.cyan(`$ cat <file> | ${(0, pkg_name_1.getPkgName)()} env add <name> ${targetPlaceholder}`)}
-      ${chalk_1.default.cyan(`$ cat ~/.npmrc | ${(0, pkg_name_1.getPkgName)()} env add NPM_RC preview`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env add API_URL production < url.txt`)}
+      ${chalk_1.default.cyan(`$ cat <file> | ${pkg_name_1.packageName} env add <name> ${targetPlaceholder}`)}
+      ${chalk_1.default.cyan(`$ cat ~/.npmrc | ${pkg_name_1.packageName} env add NPM_RC preview`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env add API_URL production < url.txt`)}
 
   ${chalk_1.default.gray('–')} Remove a variable from multiple Environments
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env rm <name>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env rm API_TOKEN`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env rm <name>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env rm API_TOKEN`)}
 
   ${chalk_1.default.gray('–')} Remove a variable from a specific Environment
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env rm <name> ${targetPlaceholder}`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env rm NPM_RC preview`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env rm <name> ${targetPlaceholder}`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env rm NPM_RC preview`)}
 
   ${chalk_1.default.gray('–')} Remove a variable from a specific Environment and Git Branch
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env rm <name> ${targetPlaceholder} <gitbranch>`)}
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} env rm NPM_RC preview feat1`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env rm <name> ${targetPlaceholder} <gitbranch>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} env rm NPM_RC preview feat1`)}
 `);
 };
 const COMMAND_CONFIG = {
@@ -223296,13 +225236,12 @@ const ensure_link_1 = __webpack_require__(65382);
 const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_invalid_subcommand_1 = __importDefault(__webpack_require__(6479));
 const handle_error_1 = __importDefault(__webpack_require__(64377));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const pkg_name_1 = __webpack_require__(79000);
 const connect_1 = __importDefault(__webpack_require__(44813));
 const disconnect_1 = __importDefault(__webpack_require__(47108));
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} git`)} <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} git`)} <command>
 
   ${chalk_1.default.dim('Commands:')}
 
@@ -223319,15 +225258,15 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Connect your Vercel Project to your Git repository defined in your local .git config
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} git connect`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} git connect`)}
 
   ${chalk_1.default.gray('–')} Connect your Vercel Project to a Git repository using the remote URL
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} git connect https://github.com/user/repo.git`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} git connect https://github.com/user/repo.git`)}
 
   ${chalk_1.default.gray('–')} Disconnect the Git provider repository
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} git disconnect`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} git disconnect`)}
 `);
 };
 const COMMAND_CONFIG = {
@@ -223390,10 +225329,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.help = exports.buildHelpOutput = exports.buildCommandExampleLines = exports.buildCommandOptionLines = exports.buildCommandSynopsisLine = exports.outputArrayToString = exports.lineToString = exports.calcLineLength = void 0;
+exports.help = exports.buildHelpOutput = exports.buildCommandExampleLines = exports.buildCommandOptionLines = exports.buildCommandSynopsisLine = exports.outputArrayToString = exports.lineToString = void 0;
 const chalk_1 = __importDefault(__webpack_require__(90877));
-const strip_ansi_1 = __importDefault(__webpack_require__(66884));
 const constants_1 = __webpack_require__(98551);
+const cli_table3_1 = __importDefault(__webpack_require__(47579));
 const INDENT = ' '.repeat(2);
 const NEWLINE = '\n';
 const globalCommandOptions = [
@@ -223474,10 +225413,6 @@ const globalCommandOptions = [
         multi: false,
     },
 ];
-function calcLineLength(line) {
-    return (0, strip_ansi_1.default)(lineToString(line)).length;
-}
-exports.calcLineLength = calcLineLength;
 // Insert spaces in between non-whitespace items only
 function lineToString(line) {
     let string = '';
@@ -223526,84 +225461,72 @@ function buildCommandSynopsisLine(command) {
 }
 exports.buildCommandSynopsisLine = buildCommandSynopsisLine;
 function buildCommandOptionLines(commandOptions, options, sectionTitle) {
-    // Filter out deprecated and intentionally undocumented options
-    commandOptions = commandOptions.filter(option => !option.deprecated && option.description !== undefined);
     if (commandOptions.length === 0) {
         return null;
     }
-    // Initialize output array with header and empty line
-    const outputArray = [`${INDENT}${chalk_1.default.dim(sectionTitle)}:`, ''];
-    // Start building option lines
-    const optionLines = [];
+    // Filter out deprecated and intentionally undocumented options
+    commandOptions = commandOptions.filter(option => !option.deprecated && option.description !== undefined);
     // Sort command options alphabetically
     commandOptions.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-    // Keep track of longest "start" of an option line to determine description spacing
-    let maxLineStartLength = 0;
-    // Iterate over options and create the "start" of each option (e.g. `  -b, --build-env <key=value>`)
+    // word wrapping requires the wrapped cell to have a fixed width.
+    // We need to track cell sizes to make the final column of cells is
+    // equal to  the remaindner of unused horizontal space.
+    let maxWidthOfUnwrappedColumns = 0;
+    const rows = [];
     for (const option of commandOptions) {
-        const startLine = [INDENT, INDENT, INDENT];
-        if (option.shorthand) {
-            startLine.push(`-${option.shorthand},`);
-        }
-        startLine.push(`--${option.name}`);
+        const shorthandCell = option.shorthand
+            ? `${INDENT}-${option.shorthand},`
+            : '';
+        let longhandCell = `${INDENT}--${option.name}`;
         if (option.argument) {
-            startLine.push(`<${option.argument}>`);
+            longhandCell += ` <${option.argument}>`;
         }
-        // the length includes the INDENT
-        const lineLength = calcLineLength(startLine);
-        maxLineStartLength = Math.max(lineLength, maxLineStartLength);
-        optionLines.push(startLine);
+        longhandCell += INDENT;
+        const widthOfUnwrappedColumns = shorthandCell.length + longhandCell.length;
+        maxWidthOfUnwrappedColumns = Math.max(widthOfUnwrappedColumns, maxWidthOfUnwrappedColumns);
+        rows.push([
+            shorthandCell,
+            longhandCell,
+            {
+                content: option.description,
+                wordWrap: true,
+            },
+        ]);
     }
-    /*
-     * Iterate over in-progress option lines to add space-filler and description
-     * For Example:
-     * |  --archive                    My description starts here.
-     * |
-     * |  -b, --build-env <key=value>  Start of description here then
-     * |                               it wraps here.
-     * |
-     * |  -e, --env <key=value>        My description is short.
-     *
-     * Breaking down option lines:
-     * |  -b, --build-env <key=value>  Start of description here then
-     * |[][                         ][][                             ]
-     * |↑ ↑                          ↑ ↑
-     * |1 2                          3 4
-     * |                               it wraps here.
-     * |[][                           ][                            ]
-     * |↑ ↑                            ↑
-     * |5 6                            7
-     * | 1, 5 = indent
-     * | 2 = start
-     * | 3, 6 = space-filler
-     * | 4, 7 = description
-     */
-    for (let i = 0; i < optionLines.length; i++) {
-        const optionLine = optionLines[i];
-        const option = commandOptions[i];
-        // Add only 2 spaces to the longest line, and then make all shorter lines the same length.
-        optionLine.push(' '.repeat(2 + (maxLineStartLength - calcLineLength(optionLine))));
-        // Descriptions may be longer than max line length. Wrap them to the same column as the first description line
-        const lines = [optionLine];
-        if (option.description) {
-            for (const descriptionWord of option.description.split(' ')) {
-                // insert a new line when the next word would match or exceed the maximum line length
-                if (calcLineLength(lines[lines.length - 1]) +
-                    (0, strip_ansi_1.default)(descriptionWord).length >=
-                    options.columns) {
-                    // initialize the new line with the necessary whitespace. The INDENT is apart of `maxLineStartLength`
-                    lines.push([' '.repeat(maxLineStartLength + 2)]);
-                }
-                // insert the word to the current last line
-                lines[lines.length - 1].push(descriptionWord);
-            }
-        }
-        // for every line, transform into a string and push it to the output
-        for (const line of lines) {
-            outputArray.push(lineToString(line));
-        }
-    }
-    return `${outputArrayToString(outputArray)}${NEWLINE}`;
+    const finalColumnWidth = options.columns - maxWidthOfUnwrappedColumns;
+    const table = new cli_table3_1.default({
+        chars: {
+            top: '',
+            'top-mid': '',
+            'top-left': '',
+            'top-right': '',
+            bottom: '',
+            'bottom-mid': '',
+            'bottom-left': '',
+            'bottom-right': '',
+            left: '',
+            'left-mid': '',
+            mid: '',
+            'mid-mid': '',
+            right: '',
+            'right-mid': '',
+            middle: '',
+        },
+        style: {
+            'padding-left': 0,
+            'padding-right': 0,
+        },
+        colWidths: [null, null, finalColumnWidth],
+    });
+    table.push(...rows);
+    return [
+        `${INDENT}${chalk_1.default.dim(sectionTitle)}:`,
+        NEWLINE,
+        NEWLINE,
+        table.toString(),
+        NEWLINE,
+        NEWLINE,
+    ].join('');
 }
 exports.buildCommandOptionLines = buildCommandOptionLines;
 function buildCommandExampleLines(command) {
@@ -223721,7 +225644,6 @@ const chalk_1 = __importDefault(__webpack_require__(90877));
 const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_subcommand_1 = __importDefault(__webpack_require__(66167));
 const handle_error_1 = __importDefault(__webpack_require__(64377));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const init_1 = __importDefault(__webpack_require__(6148));
 const pkg_name_1 = __webpack_require__(79000);
 const error_utils_1 = __webpack_require__(39799);
@@ -223730,7 +225652,7 @@ const COMMAND_CONFIG = {
 };
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} init`)} [example] [dir] [-f | --force]
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} init`)} [example] [dir] [-f | --force]
 
   ${chalk_1.default.dim('Options:')}
 
@@ -223743,19 +225665,19 @@ const help = () => {
 
   ${chalk_1.default.gray('–')}  Choose from all available examples
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} init`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} init`)}
 
   ${chalk_1.default.gray('–')}  Initialize example project into a new directory
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} init <example>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} init <example>`)}
 
   ${chalk_1.default.gray('–')}  Initialize example project into specified directory
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} init <example> <dir>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} init <example> <dir>`)}
 
   ${chalk_1.default.gray('–')}  Initialize example project without checking
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} init <example> --force`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} init <example> --force`)}
   `);
 };
 async function main(client) {
@@ -223995,19 +225917,19 @@ exports.inspectCommand = {
     examples: [
         {
             name: 'Get information about a deployment by its unique URL',
-            value: `${(0, pkg_name_1.getPkgName)()} inspect my-deployment-ji2fjij2.vercel.app`,
+            value: `${pkg_name_1.packageName} inspect my-deployment-ji2fjij2.vercel.app`,
         },
         {
             name: 'Get information about the deployment an alias points to',
-            value: `${(0, pkg_name_1.getPkgName)()} inspect my-deployment.vercel.app`,
+            value: `${pkg_name_1.packageName} inspect my-deployment.vercel.app`,
         },
         {
             name: 'Get information about a deployment by piping in the URL',
-            value: `echo my-deployment.vercel.app | ${(0, pkg_name_1.getPkgName)()} inspect`,
+            value: `echo my-deployment.vercel.app | ${pkg_name_1.packageName} inspect`,
         },
         {
             name: 'Wait up to 90 seconds for deployment to complete',
-            value: `${(0, pkg_name_1.getPkgName)()} inspect my-deployment.vercel.app --wait --timeout 90s`,
+            value: `${pkg_name_1.packageName} inspect my-deployment.vercel.app --wait --timeout 90s`,
         },
     ],
 };
@@ -224220,19 +226142,19 @@ exports.linkCommand = {
     examples: [
         {
             name: 'Link current directory to a Vercel Project',
-            value: `${(0, pkg_name_1.getPkgName)()} link`,
+            value: `${pkg_name_1.packageName} link`,
         },
         {
             name: 'Link current directory with default options and skip questions',
-            value: `${(0, pkg_name_1.getPkgName)()} link --yes`,
+            value: `${pkg_name_1.packageName} link --yes`,
         },
         {
             name: 'Link a specific directory to a Vercel Project',
-            value: `${(0, pkg_name_1.getPkgName)()} link --cwd /path/to/project`,
+            value: `${pkg_name_1.packageName} link --cwd /path/to/project`,
         },
         {
             name: 'Link to the current Git repository, allowing for multiple Vercel Projects to be linked simultaneously (useful for monorepos)',
-            value: `${(0, pkg_name_1.getPkgName)()} link --repo`,
+            value: `${pkg_name_1.packageName} link --repo`,
         },
     ],
 };
@@ -224354,19 +226276,19 @@ exports.listCommand = {
     examples: [
         {
             name: 'List all deployments for the currently linked project',
-            value: `${(0, pkg_name_1.getPkgName)()} list`,
+            value: `${pkg_name_1.packageName} list`,
         },
         {
             name: 'List all deployments for the project `my-app` in the team of the currently linked project',
-            value: `${(0, pkg_name_1.getPkgName)()} list my-app`,
+            value: `${pkg_name_1.packageName} list my-app`,
         },
         {
             name: 'Filter deployments by metadata',
-            value: `${(0, pkg_name_1.getPkgName)()} list -m key1=value1 -m key2=value2`,
+            value: `${pkg_name_1.packageName} list -m key1=value1 -m key2=value2`,
         },
         {
             name: 'Paginate deployments for a project, where `1584722256178` is the time in milliseconds since the UNIX epoch',
-            value: `${(0, pkg_name_1.getPkgName)()} list my-app --next 1584722256178`,
+            value: `${pkg_name_1.packageName} list my-app --next 1584722256178`,
         },
     ],
 };
@@ -224708,19 +226630,19 @@ exports.loginCommand = {
     examples: [
         {
             name: 'Log into the Vercel platform',
-            value: `${(0, pkg_name_1.getPkgName)()} login`,
+            value: `${pkg_name_1.packageName} login`,
         },
         {
             name: 'Log in using a specific email address',
-            value: `${(0, pkg_name_1.getPkgName)()} login username@example.com`,
+            value: `${pkg_name_1.packageName} login username@example.com`,
         },
         {
             name: 'Log in using a specific team "slug" for SAML Single Sign-On',
-            value: `${(0, pkg_name_1.getPkgName)()} login acme`,
+            value: `${pkg_name_1.packageName} login acme`,
         },
         {
             name: 'Log in using GitHub in "out-of-band" mode',
-            value: `${(0, pkg_name_1.getPkgName)()} login --github --oob`,
+            value: `${pkg_name_1.packageName} login --github --oob`,
         },
     ],
 };
@@ -224839,7 +226761,7 @@ exports.logoutCommand = {
     examples: [
         {
             name: 'Logout from the CLI',
-            value: `${(0, pkg_name_1.getPkgName)()} logout`,
+            value: `${pkg_name_1.packageName} logout`,
         },
     ],
 };
@@ -224999,7 +226921,7 @@ exports.logsCommand = {
     examples: [
         {
             name: 'Print the logs for the deployment DEPLOYMENT_ID',
-            value: `${(0, pkg_name_1.getPkgName)()} logs DEPLOYMENT_ID`,
+            value: `${pkg_name_1.packageName} logs DEPLOYMENT_ID`,
         },
     ],
 };
@@ -225305,14 +227227,13 @@ const get_args_1 = __importDefault(__webpack_require__(2505));
 const get_invalid_subcommand_1 = __importDefault(__webpack_require__(6479));
 const get_scope_1 = __importDefault(__webpack_require__(60324));
 const handle_error_1 = __importDefault(__webpack_require__(64377));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const pkg_name_1 = __webpack_require__(79000);
 const add_1 = __importDefault(__webpack_require__(35330));
 const list_1 = __importDefault(__webpack_require__(21743));
 const rm_1 = __importDefault(__webpack_require__(55810));
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} project`)} [options] <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} project`)} [options] <command>
 
   ${chalk_1.default.dim('Commands:')}
 
@@ -225331,11 +227252,11 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Add a new project
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} project add my-project`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} project add my-project`)}
 
   ${chalk_1.default.gray('–')} Paginate projects, where ${chalk_1.default.dim('`1584722256178`')} is the time in milliseconds since the UNIX epoch.
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} project ls --next 1584722256178`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} project ls --next 1584722256178`)}
 `);
 };
 const COMMAND_CONFIG = {
@@ -225529,13 +227450,12 @@ const get_project_by_cwd_or_link_1 = __importDefault(__webpack_require__(90675))
 const pkg_name_1 = __webpack_require__(79000);
 const handle_error_1 = __importDefault(__webpack_require__(64377));
 const error_utils_1 = __webpack_require__(39799);
-const logo_1 = __importDefault(__webpack_require__(66669));
 const ms_1 = __importDefault(__webpack_require__(21378));
 const request_promote_1 = __importDefault(__webpack_require__(73455));
 const status_1 = __importDefault(__webpack_require__(48821));
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} promote`)} [deployment id/url]
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} promote`)} [deployment id/url]
 
   Promote an existing deployment to current.
 
@@ -225554,14 +227474,14 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Show the status of any current pending promotions
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} promote`)}
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} promote status`)}
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} promote status <project>`)}
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} promote status --timeout 30s`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} promote`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} promote status`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} promote status <project>`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} promote status --timeout 30s`)}
 
   ${chalk_1.default.gray('–')} Promote a deployment using id or url
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} promote <deployment id/url>`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} promote <deployment id/url>`)}
 `);
 };
 /**
@@ -225793,7 +227713,7 @@ async function promoteStatus({ client, contextName, deployment, project, timeout
             }
             // check if we have been running for too long
             if (requestedAt < recentThreshold || Date.now() >= promoteTimeout) {
-                output.log(`The promotion exceeded its deadline - rerun ${chalk_1.default.bold(`${(0, pkg_name_1.getPkgName)()} promote ${toDeploymentId}`)} to try again`);
+                output.log(`The promotion exceeded its deadline - rerun ${chalk_1.default.bold(`${pkg_name_1.packageName} promote ${toDeploymentId}`)} to try again`);
                 return 1;
             }
             // if we've done our first poll and not rolling back, then print the
@@ -225900,19 +227820,19 @@ exports.pullCommand = {
     examples: [
         {
             name: 'Pull the latest Environment Variables and Project Settings from the cloud',
-            value: `${(0, pkg_name_1.getPkgName)()} pull`,
+            value: `${pkg_name_1.packageName} pull`,
         },
         {
             name: 'Pull the latest Environment Variables and Project Settings from the cloud targeting a directory',
-            value: `${(0, pkg_name_1.getPkgName)()} pull ./path-to-project`,
+            value: `${pkg_name_1.packageName} pull ./path-to-project`,
         },
         {
             name: 'Pull for a specific environment',
-            value: `${(0, pkg_name_1.getPkgName)()} pull --environment=${(0, env_target_1.getEnvTargetPlaceholder)()}`,
+            value: `${pkg_name_1.packageName} pull --environment=${(0, env_target_1.getEnvTargetPlaceholder)()}`,
         },
         {
             name: 'If you want to download environment variables to a specific file, use `vercel env pull` instead',
-            value: `${(0, pkg_name_1.getPkgName)()} env pull`,
+            value: `${pkg_name_1.packageName} env pull`,
         },
     ],
 };
@@ -226036,11 +227956,11 @@ exports.redeployCommand = {
     examples: [
         {
             name: 'Rebuild and deploy an existing deployment using id or url',
-            value: `${(0, pkg_name_1.getPkgName)()} redeploy my-deployment.vercel.app`,
+            value: `${pkg_name_1.packageName} redeploy my-deployment.vercel.app`,
         },
         {
             name: 'Write Deployment URL to a file',
-            value: `${(0, pkg_name_1.getPkgName)()} redeploy my-deployment.vercel.app > deployment-url.txt`,
+            value: `${pkg_name_1.packageName} redeploy my-deployment.vercel.app > deployment-url.txt`,
         },
     ],
 };
@@ -226238,15 +228158,15 @@ exports.removeCommand = {
     examples: [
         {
             name: 'Remove a deployment identified by `deploymentId`',
-            value: `${(0, pkg_name_1.getPkgName)()} remove my-app`,
+            value: `${pkg_name_1.packageName} remove my-app`,
         },
         {
             name: 'Remove all deployments with name `my-app`',
-            value: `${(0, pkg_name_1.getPkgName)()} remove deploymentId`,
+            value: `${pkg_name_1.packageName} remove deploymentId`,
         },
         {
             name: 'Remove two deployments with IDs `eyWt6zuSdeus` and `uWHoA9RQ1d1o`',
-            value: `${(0, pkg_name_1.getPkgName)()} remove eyWt6zuSdeus uWHoA9RQ1d1o`,
+            value: `${pkg_name_1.packageName} remove eyWt6zuSdeus uWHoA9RQ1d1o`,
         },
     ],
 };
@@ -226484,13 +228404,12 @@ const get_project_by_cwd_or_link_1 = __importDefault(__webpack_require__(90675))
 const pkg_name_1 = __webpack_require__(79000);
 const handle_error_1 = __importDefault(__webpack_require__(64377));
 const error_utils_1 = __webpack_require__(39799);
-const logo_1 = __importDefault(__webpack_require__(66669));
 const ms_1 = __importDefault(__webpack_require__(21378));
 const request_rollback_1 = __importDefault(__webpack_require__(30964));
 const status_1 = __importDefault(__webpack_require__(16097));
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} rollback`)} [deployment id/url]
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} rollback`)} [deployment id/url]
 
   Quickly revert back to a previous deployment.
 
@@ -226509,14 +228428,14 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Show the status of any current pending rollbacks
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} rollback`)}
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} rollback status`)}
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} rollback status <project>`)}
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} rollback status --timeout 30s`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} rollback`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} rollback status`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} rollback status <project>`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} rollback status --timeout 30s`)}
 
   ${chalk_1.default.gray('–')} Rollback a deployment using id or url
 
-    ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} rollback <deployment id/url>`)}
+    ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} rollback <deployment id/url>`)}
 `);
 };
 /**
@@ -226735,7 +228654,7 @@ async function rollbackStatus({ client, contextName, deployment, project, timeou
             }
             // check if we have been running for too long
             if (requestedAt < recentThreshold || Date.now() >= rollbackTimeout) {
-                output.log(`The rollback exceeded its deadline - rerun ${chalk_1.default.bold(`${(0, pkg_name_1.getPkgName)()} rollback ${toDeploymentId}`)} to try again`);
+                output.log(`The rollback exceeded its deadline - rerun ${chalk_1.default.bold(`${pkg_name_1.packageName} rollback ${toDeploymentId}`)} to try again`);
                 return 1;
             }
             // if we've done our first poll and not rolling back, then print the
@@ -226834,7 +228753,7 @@ const validateNameKeypress = (data, value) =>
 /^[ a-zA-Z0-9_-]+$/.test(value + data);
 const gracefulExit = () => {
     console.log(); // Blank line
-    (0, note_1.default)(`Your team is now active for all ${(0, pkg_name_1.getPkgName)()} commands!\n  Run ${(0, pkg_name_1.getCommandName)(`switch`)} to change it in the future.`);
+    (0, note_1.default)(`Your team is now active for all ${pkg_name_1.packageName} commands!\n  Run ${(0, pkg_name_1.getCommandName)(`switch`)} to change it in the future.`);
     return 0;
 };
 const teamUrlPrefix = 'Team URL'.padEnd(14) + chalk_1.default.gray('vercel.com/');
@@ -226939,7 +228858,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const chalk_1 = __importDefault(__webpack_require__(90877));
 const error_1 = __importDefault(__webpack_require__(598));
-const logo_1 = __importDefault(__webpack_require__(66669));
 const list_1 = __importDefault(__webpack_require__(88583));
 const add_1 = __importDefault(__webpack_require__(54609));
 const switch_1 = __importDefault(__webpack_require__(17066));
@@ -226948,7 +228866,7 @@ const pkg_name_1 = __webpack_require__(79000);
 const get_args_1 = __importDefault(__webpack_require__(2505));
 const help = () => {
     console.log(`
-  ${chalk_1.default.bold(`${logo_1.default} ${(0, pkg_name_1.getPkgName)()} teams`)} [options] <command>
+  ${chalk_1.default.bold(`${pkg_name_1.logo} ${pkg_name_1.packageName} teams`)} [options] <command>
 
   ${chalk_1.default.dim('Commands:')}
 
@@ -226970,7 +228888,7 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Switch to a team
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} switch <slug>`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} switch <slug>`)}
 
       ${chalk_1.default.gray('–')} If your team's url is 'vercel.com/teams/name', 'name' is the slug
       ${chalk_1.default.gray('–')} If the slug is omitted, you can choose interactively
@@ -226979,11 +228897,11 @@ const help = () => {
 
   ${chalk_1.default.gray('–')} Invite new members (interactively)
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} teams invite`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} teams invite`)}
 
   ${chalk_1.default.gray('–')} Paginate results, where ${chalk_1.default.dim('`1584722256178`')} is the time in milliseconds since the UNIX epoch.
 
-      ${chalk_1.default.cyan(`$ ${(0, pkg_name_1.getPkgName)()} teams ls --next 1584722256178`)}
+      ${chalk_1.default.cyan(`$ ${pkg_name_1.packageName} teams ls --next 1584722256178`)}
   `);
 };
 exports.default = async (client) => {
@@ -227277,7 +229195,7 @@ async function list(client) {
     if (pagination?.count === 20) {
         const prefixedArgs = (0, get_prefixed_flags_1.default)(argv);
         const flags = (0, get_command_flags_1.default)(prefixedArgs, ['_', '--next', '-N', '-d']);
-        const nextCmd = `${(0, pkg_name_1.getPkgName)()} teams ls${flags} --next ${pagination.next}`;
+        const nextCmd = `${pkg_name_1.packageName} teams ls${flags} --next ${pagination.next}`;
         console.log(); // empty line
         output.log(`To display the next page run ${(0, cmd_1.default)(nextCmd)}`);
     }
@@ -227435,7 +229353,7 @@ exports.whoamiCommand = {
     examples: [
         {
             name: 'Shows the username of the currently logged in user',
-            value: `${(0, pkg_name_1.getPkgName)()} whoami`,
+            value: `${pkg_name_1.packageName} whoami`,
         },
     ],
 };
@@ -228971,6 +230889,35 @@ async function setMonorepoDefaultSettings(cwd, workPath, projectSettings, output
 exports.setMonorepoDefaultSettings = setMonorepoDefaultSettings;
 
 
+/***/ }),
+
+/***/ 18119:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.scrubArgv = void 0;
+/**
+ * Redacts `--env`, `--build-env`, and `--token` in `argv`.
+ */
+function scrubArgv(argv) {
+    const clonedArgv = [...argv];
+    const tokenRE = /^(-[A-Za-z]*[bet]|--(?:build-env|env|token))(=.*)?$/;
+    for (let i = 0, len = clonedArgv.length; i < len; i++) {
+        const m = clonedArgv[i].match(tokenRE);
+        if (m?.[2]) {
+            clonedArgv[i] = `${m[1]}=REDACTED`;
+        }
+        else if (m && i + 1 < len) {
+            clonedArgv[++i] = 'REDACTED';
+        }
+    }
+    return clonedArgv;
+}
+exports.scrubArgv = scrubArgv;
+
+
 /***/ }),
 
 /***/ 84701:
@@ -238076,7 +240023,7 @@ async function isGlobal() {
     }
 }
 async function getUpdateCommand() {
-    const pkgAndVersion = `${(0, pkg_name_1.getPkgName)()}@latest`;
+    const pkgAndVersion = `${pkg_name_1.packageName}@latest`;
     const entrypoint = await (0, fs_extra_1.realpath)(process.argv[1]);
     let { cliType, lockfilePath } = await (0, build_utils_1.scanParentDirs)((0, path_1.dirname)((0, path_1.dirname)(entrypoint)));
     if (!lockfilePath) {
@@ -240039,23 +241986,31 @@ async function ensureRepoLink(client, cwd, { yes, overwrite }) {
         if (!remoteUrls) {
             throw new Error('Could not determine Git remote URLs');
         }
-        const remoteNames = Object.keys(remoteUrls);
+        const remoteNames = Object.keys(remoteUrls).sort();
         let remoteName;
         if (remoteNames.length === 1) {
             remoteName = remoteNames[0];
         }
         else {
             // Prompt user to select which remote to use
-            const answer = await client.prompt({
-                type: 'list',
-                name: 'value',
-                message: 'Which Git remote should be used?',
-                choices: remoteNames.sort().map(name => {
-                    return { name: name, value: name };
-                }),
-                default: remoteNames.includes('origin') ? 'origin' : undefined,
-            });
-            remoteName = answer.value;
+            const defaultRemote = remoteNames.includes('origin')
+                ? 'origin'
+                : remoteNames[0];
+            if (yes) {
+                remoteName = defaultRemote;
+            }
+            else {
+                const answer = await client.prompt({
+                    type: 'list',
+                    name: 'value',
+                    message: 'Which Git remote should be used?',
+                    choices: remoteNames.map(name => {
+                        return { name: name, value: name };
+                    }),
+                    default: defaultRemote,
+                });
+                remoteName = answer.value;
+            }
         }
         const repoUrl = remoteUrls[remoteName];
         const parsedRepoUrl = (0, connect_git_provider_1.parseRepoUrl)(repoUrl);
@@ -240092,71 +242047,82 @@ async function ensureRepoLink(client, cwd, { yes, overwrite }) {
         if (detectedProjectsCount > 0) {
             output.log(`Detected ${(0, pluralize_1.default)('new Project', detectedProjectsCount, true)} that may be created.`);
         }
-        const addSeparators = projects.length > 0 && detectedProjectsCount > 0;
-        const { selected } = await client.prompt({
-            type: 'checkbox',
-            name: 'selected',
-            message: `Which Projects should be ${projects.length ? 'linked to' : 'created'}?`,
-            choices: [
-                ...(addSeparators
-                    ? [new inquirer_1.default.Separator('----- Existing Projects -----')]
-                    : []),
-                ...projects.map(project => {
-                    return {
-                        name: `${org.slug}/${project.name}`,
-                        value: project,
-                        checked: true,
-                    };
-                }),
-                ...(addSeparators
-                    ? [new inquirer_1.default.Separator('----- New Projects to be created -----')]
-                    : []),
-                ...Array.from(detectedProjects.entries()).flatMap(([rootDirectory, frameworks]) => frameworks.map((framework, i) => {
-                    const name = (0, slugify_1.default)([
-                        (0, path_1.basename)(rootPath),
-                        (0, path_1.basename)(rootDirectory),
-                        i > 0 ? framework.slug : '',
-                    ]
-                        .filter(Boolean)
-                        .join('-'));
-                    return {
-                        name: `${org.slug}/${name} (${framework.name})`,
-                        value: {
-                            newProject: true,
-                            rootDirectory,
-                            name,
-                            framework,
-                        },
-                        // Checked by default when there are no other existing Projects
-                        checked: projects.length === 0,
-                    };
-                })),
-            ],
-        });
+        let selected;
+        if (yes) {
+            selected = projects;
+        }
+        else {
+            const addSeparators = projects.length > 0 && detectedProjectsCount > 0;
+            const answer = await client.prompt({
+                type: 'checkbox',
+                name: 'selected',
+                message: `Which Projects should be ${projects.length ? 'linked to' : 'created'}?`,
+                choices: [
+                    ...(addSeparators
+                        ? [new inquirer_1.default.Separator('----- Existing Projects -----')]
+                        : []),
+                    ...projects.map(project => {
+                        return {
+                            name: `${org.slug}/${project.name}`,
+                            value: project,
+                            checked: true,
+                        };
+                    }),
+                    ...(addSeparators
+                        ? [new inquirer_1.default.Separator('----- New Projects to be created -----')]
+                        : []),
+                    ...Array.from(detectedProjects.entries()).flatMap(([rootDirectory, frameworks]) => frameworks.map((framework, i) => {
+                        const name = (0, slugify_1.default)([
+                            (0, path_1.basename)(rootPath),
+                            (0, path_1.basename)(rootDirectory),
+                            i > 0 ? framework.slug : '',
+                        ]
+                            .filter(Boolean)
+                            .join('-'));
+                        return {
+                            name: `${org.slug}/${name} (${framework.name})`,
+                            value: {
+                                newProject: true,
+                                rootDirectory,
+                                name,
+                                framework,
+                            },
+                            // Checked by default when there are no other existing Projects
+                            checked: projects.length === 0,
+                        };
+                    })),
+                ],
+            });
+            selected = answer.selected;
+        }
         if (selected.length === 0) {
             output.print(`No Projects were selected. Repository not linked.\n`);
             return;
         }
         for (let i = 0; i < selected.length; i++) {
             const selection = selected[i];
-            if (!selection.newProject)
+            if (!('newProject' in selection && selection.newProject))
                 continue;
             const orgAndName = `${org.slug}/${selection.name}`;
             output.spinner(`Creating new Project: ${orgAndName}`);
             delete selection.newProject;
             if (!selection.rootDirectory)
                 delete selection.rootDirectory;
-            selected[i] = await (0, create_project_1.default)(client, {
+            const project = (selected[i] = await (0, create_project_1.default)(client, {
                 ...selection,
                 framework: selection.framework.slug,
-            });
-            await (0, connect_git_provider_1.connectGitProvider)(client, org, selected[i].id, parsedRepoUrl.provider, `${parsedRepoUrl.org}/${parsedRepoUrl.repo}`);
+            }));
+            await (0, connect_git_provider_1.connectGitProvider)(client, org, project.id, parsedRepoUrl.provider, `${parsedRepoUrl.org}/${parsedRepoUrl.repo}`);
             output.log(`Created new Project: ${output.link(orgAndName, `https://vercel.com/${orgAndName}`, { fallback: false })}`);
         }
         repoConfig = {
             orgId: org.id,
             remoteName,
-            projects: selected.map((project) => {
+            projects: selected.map(project => {
+                if (!('id' in project)) {
+                    // Shouldn't happen at this point, but just to make TS happy
+                    throw new TypeError(`Not a Project: ${JSON.stringify(project)}`);
+                }
                 return {
                     id: project.id,
                     name: project.name,
@@ -241800,17 +243766,6 @@ const listItem = (msg, n) => {
 exports.default = listItem;
 
 
-/***/ }),
-
-/***/ 66669:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.default = '▲';
-
-
 /***/ }),
 
 /***/ 41719:
@@ -242136,31 +244091,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getCommandName = exports.getTitleName = exports.getPkgName = exports.logo = exports.name = void 0;
+exports.getCommandName = exports.getTitleName = exports.logo = exports.packageName = void 0;
 const title_1 = __importDefault(__webpack_require__(16650));
 const pkg_1 = __importDefault(__webpack_require__(42246));
 const cmd_1 = __importDefault(__webpack_require__(62422));
 /**
  * The package name defined in the CLI's `package.json` file (`vercel`).
  */
-exports.name = pkg_1.default.name;
+exports.packageName = pkg_1.default.name;
 /**
  * Unicode symbol used to represent the CLI.
  */
 exports.logo = '▲';
-/**
- * Returns the package name such as `vercel` or `now`.
- */
-function getPkgName() {
-    return pkg_1.default.name;
-}
-exports.getPkgName = getPkgName;
 /**
  * Returns the package name with title-case
  * such as `Vercel` or `Now`.
  */
 function getTitleName() {
-    const str = getPkgName();
+    const str = exports.packageName;
     return (0, title_1.default)(str);
 }
 exports.getTitleName = getTitleName;
@@ -242169,7 +244117,7 @@ exports.getTitleName = getTitleName;
  * as a suffix such as `vercel env pull` or `now env pull`.
  */
 function getCommandName(subcommands) {
-    let vercel = getPkgName();
+    let vercel = exports.packageName;
     if (subcommands) {
         vercel = `${vercel} ${subcommands}`;
     }