@teams-max/mwsp 1.0.2 → 2.0.0

package/es/utils/yargs-parser/index.js

@@ -0,0 +1,919 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+module.exports = function () {
+  var s = {
+    362: function _(s) {
+      'use strict';
+
+      var n = function n(s) {
+        var n = false;
+        var t = false;
+        var e = false;
+        for (var c = 0; c < s.length; c++) {
+          var r = s[c];
+          if (n && /[a-zA-Z]/.test(r) && r.toUpperCase() === r) {
+            s = s.slice(0, c) + '-' + s.slice(c);
+            n = false;
+            e = t;
+            t = true;
+            c++;
+          } else if (t && e && /[a-zA-Z]/.test(r) && r.toLowerCase() === r) {
+            s = s.slice(0, c - 1) + '-' + s.slice(c - 1);
+            e = t;
+            t = false;
+            n = true;
+          } else {
+            n = r.toLowerCase() === r && r.toUpperCase() !== r;
+            e = t;
+            t = r.toUpperCase() === r && r.toLowerCase() !== r;
+          }
+        }
+        return s;
+      };
+      var t = function t(s, _t) {
+        if (!(typeof s === 'string' || Array.isArray(s))) {
+          throw new TypeError('Expected the input to be `string | string[]`');
+        }
+        _t = Object.assign({
+          pascalCase: false
+        }, _t);
+        var e = function e(s) {
+          return _t.pascalCase ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+        };
+        if (Array.isArray(s)) {
+          s = s.map(function (s) {
+            return s.trim();
+          }).filter(function (s) {
+            return s.length;
+          }).join('-');
+        } else {
+          s = s.trim();
+        }
+        if (s.length === 0) {
+          return '';
+        }
+        if (s.length === 1) {
+          return _t.pascalCase ? s.toUpperCase() : s.toLowerCase();
+        }
+        var c = s !== s.toLowerCase();
+        if (c) {
+          s = n(s);
+        }
+        s = s.replace(/^[_.\- ]+/, '').toLowerCase().replace(/[_.\- ]+(\w|$)/g, function (s, n) {
+          return n.toUpperCase();
+        }).replace(/\d+(\w|$)/g, function (s) {
+          return s.toUpperCase();
+        });
+        return e(s);
+      };
+      s.exports = t;
+      s.exports.default = t;
+    },
+    159: function _(s) {
+      'use strict';
+
+      s.exports = function (s, n) {
+        if (typeof s !== 'string') {
+          throw new TypeError('Expected a string');
+        }
+        n = typeof n === 'undefined' ? '_' : n;
+        return s.replace(/([a-z\d])([A-Z])/g, '$1' + n + '$2').replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1' + n + '$2').toLowerCase();
+      };
+    },
+    246: function _(s, n, t) {
+      var e = t(362);
+      var c = t(159);
+      var r = t(622);
+      var l = t(433);
+      var o = t(669);
+      function parse(s, n) {
+        n = Object.assign(Object.create(null), n);
+        s = l(s);
+        var t = combineAliases(Object.assign(Object.create(null), n.alias));
+        var f = Object.assign({
+          'boolean-negation': true,
+          'camel-case-expansion': true,
+          'combine-arrays': false,
+          'dot-notation': true,
+          'duplicate-arguments-array': true,
+          'flatten-duplicate-arrays': true,
+          'greedy-arrays': true,
+          'halt-at-non-option': false,
+          'nargs-eats-options': false,
+          'negation-prefix': 'no-',
+          'parse-numbers': true,
+          'populate--': false,
+          'set-placeholder-key': false,
+          'short-option-groups': true,
+          'strip-aliased': false,
+          'strip-dashed': false,
+          'unknown-options-as-args': false
+        }, n.configuration);
+        var a = Object.assign(Object.create(null), n.default);
+        var i = n.configObjects || [];
+        var u = n.envPrefix;
+        var h = f['populate--'];
+        var A = h ? '--' : '_';
+        var p = Object.create(null);
+        var d = Object.create(null);
+        var b = n.__ || o.format;
+        var O = {
+          aliases: Object.create(null),
+          arrays: Object.create(null),
+          bools: Object.create(null),
+          strings: Object.create(null),
+          numbers: Object.create(null),
+          counts: Object.create(null),
+          normalize: Object.create(null),
+          configs: Object.create(null),
+          nargs: Object.create(null),
+          coercions: Object.create(null),
+          keys: []
+        };
+        var m = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
+        var E = new RegExp('^--' + f['negation-prefix'] + '(.+)');
+        [].concat(n.array).filter(Boolean).forEach(function (s) {
+          var n = s.key || s;
+          var t = Object.keys(s).map(function (s) {
+            return {
+              boolean: 'bools',
+              string: 'strings',
+              number: 'numbers'
+            }[s];
+          }).filter(Boolean).pop();
+          if (t) {
+            O[t][n] = true;
+          }
+          O.arrays[n] = true;
+          O.keys.push(n);
+        });
+        [].concat(n.boolean).filter(Boolean).forEach(function (s) {
+          O.bools[s] = true;
+          O.keys.push(s);
+        });
+        [].concat(n.string).filter(Boolean).forEach(function (s) {
+          O.strings[s] = true;
+          O.keys.push(s);
+        });
+        [].concat(n.number).filter(Boolean).forEach(function (s) {
+          O.numbers[s] = true;
+          O.keys.push(s);
+        });
+        [].concat(n.count).filter(Boolean).forEach(function (s) {
+          O.counts[s] = true;
+          O.keys.push(s);
+        });
+        [].concat(n.normalize).filter(Boolean).forEach(function (s) {
+          O.normalize[s] = true;
+          O.keys.push(s);
+        });
+        Object.keys(n.narg || {}).forEach(function (s) {
+          O.nargs[s] = n.narg[s];
+          O.keys.push(s);
+        });
+        Object.keys(n.coerce || {}).forEach(function (s) {
+          O.coercions[s] = n.coerce[s];
+          O.keys.push(s);
+        });
+        if (Array.isArray(n.config) || typeof n.config === 'string') {
+          [].concat(n.config).filter(Boolean).forEach(function (s) {
+            O.configs[s] = true;
+          });
+        } else {
+          Object.keys(n.config || {}).forEach(function (s) {
+            O.configs[s] = n.config[s];
+          });
+        }
+        extendAliases(n.key, t, n.default, O.arrays);
+        Object.keys(a).forEach(function (s) {
+          (O.aliases[s] || []).forEach(function (n) {
+            a[n] = a[s];
+          });
+        });
+        var _ = null;
+        checkConfiguration();
+        var w = [];
+        var j = Object.assign(Object.create(null), {
+          _: []
+        });
+        var N = {};
+        for (var _n = 0; _n < s.length; _n++) {
+          var _t2 = s[_n];
+          var _e = void 0;
+          var _c = void 0;
+          var _r = void 0;
+          var _l = void 0;
+          var _o = void 0;
+          var _a = void 0;
+          if (_t2 !== '--' && isUnknownOptionAsArg(_t2)) {
+            j._.push(_t2);
+          } else if (_t2.match(/^--.+=/) || !f['short-option-groups'] && _t2.match(/^-.+=/)) {
+            _l = _t2.match(/^--?([^=]+)=([\s\S]*)$/);
+            if (checkAllAliases(_l[1], O.arrays)) {
+              _n = eatArray(_n, _l[1], s, _l[2]);
+            } else if (checkAllAliases(_l[1], O.nargs) !== false) {
+              _n = eatNargs(_n, _l[1], s, _l[2]);
+            } else {
+              setArg(_l[1], _l[2]);
+            }
+          } else if (_t2.match(E) && f['boolean-negation']) {
+            _c = _t2.match(E)[1];
+            setArg(_c, checkAllAliases(_c, O.arrays) ? [false] : false);
+          } else if (_t2.match(/^--.+/) || !f['short-option-groups'] && _t2.match(/^-[^-]+/)) {
+            _c = _t2.match(/^--?(.+)/)[1];
+            if (checkAllAliases(_c, O.arrays)) {
+              _n = eatArray(_n, _c, s);
+            } else if (checkAllAliases(_c, O.nargs) !== false) {
+              _n = eatNargs(_n, _c, s);
+            } else {
+              _o = s[_n + 1];
+              if (_o !== undefined && (!_o.match(/^-/) || _o.match(m)) && !checkAllAliases(_c, O.bools) && !checkAllAliases(_c, O.counts)) {
+                setArg(_c, _o);
+                _n++;
+              } else if (/^(true|false)$/.test(_o)) {
+                setArg(_c, _o);
+                _n++;
+              } else {
+                setArg(_c, defaultValue(_c));
+              }
+            }
+          } else if (_t2.match(/^-.\..+=/)) {
+            _l = _t2.match(/^-([^=]+)=([\s\S]*)$/);
+            setArg(_l[1], _l[2]);
+          } else if (_t2.match(/^-.\..+/) && !_t2.match(m)) {
+            _o = s[_n + 1];
+            _c = _t2.match(/^-(.\..+)/)[1];
+            if (_o !== undefined && !_o.match(/^-/) && !checkAllAliases(_c, O.bools) && !checkAllAliases(_c, O.counts)) {
+              setArg(_c, _o);
+              _n++;
+            } else {
+              setArg(_c, defaultValue(_c));
+            }
+          } else if (_t2.match(/^-[^-]+/) && !_t2.match(m)) {
+            _r = _t2.slice(1, -1).split('');
+            _e = false;
+            for (var _l2 = 0; _l2 < _r.length; _l2++) {
+              _o = _t2.slice(_l2 + 2);
+              if (_r[_l2 + 1] && _r[_l2 + 1] === '=') {
+                _a = _t2.slice(_l2 + 3);
+                _c = _r[_l2];
+                if (checkAllAliases(_c, O.arrays)) {
+                  _n = eatArray(_n, _c, s, _a);
+                } else if (checkAllAliases(_c, O.nargs) !== false) {
+                  _n = eatNargs(_n, _c, s, _a);
+                } else {
+                  setArg(_c, _a);
+                }
+                _e = true;
+                break;
+              }
+              if (_o === '-') {
+                setArg(_r[_l2], _o);
+                continue;
+              }
+              if (/[A-Za-z]/.test(_r[_l2]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(_o)) {
+                setArg(_r[_l2], _o);
+                _e = true;
+                break;
+              }
+              if (_r[_l2 + 1] && _r[_l2 + 1].match(/\W/)) {
+                setArg(_r[_l2], _o);
+                _e = true;
+                break;
+              } else {
+                setArg(_r[_l2], defaultValue(_r[_l2]));
+              }
+            }
+            _c = _t2.slice(-1)[0];
+            if (!_e && _c !== '-') {
+              if (checkAllAliases(_c, O.arrays)) {
+                _n = eatArray(_n, _c, s);
+              } else if (checkAllAliases(_c, O.nargs) !== false) {
+                _n = eatNargs(_n, _c, s);
+              } else {
+                _o = s[_n + 1];
+                if (_o !== undefined && (!/^(-|--)[^-]/.test(_o) || _o.match(m)) && !checkAllAliases(_c, O.bools) && !checkAllAliases(_c, O.counts)) {
+                  setArg(_c, _o);
+                  _n++;
+                } else if (/^(true|false)$/.test(_o)) {
+                  setArg(_c, _o);
+                  _n++;
+                } else {
+                  setArg(_c, defaultValue(_c));
+                }
+              }
+            }
+          } else if (_t2.match(/^-[0-9]$/) && _t2.match(m) && checkAllAliases(_t2.slice(1), O.bools)) {
+            _c = _t2.slice(1);
+            setArg(_c, defaultValue(_c));
+          } else if (_t2 === '--') {
+            w = s.slice(_n + 1);
+            break;
+          } else if (f['halt-at-non-option']) {
+            w = s.slice(_n);
+            break;
+          } else {
+            j._.push(maybeCoerceNumber('_', _t2));
+          }
+        }
+        applyEnvVars(j, true);
+        applyEnvVars(j, false);
+        setConfig(j);
+        setConfigObjects();
+        applyDefaultsAndAliases(j, O.aliases, a, true);
+        applyCoercions(j);
+        if (f['set-placeholder-key']) setPlaceholderKeys(j);
+        Object.keys(O.counts).forEach(function (s) {
+          if (!hasKey(j, s.split('.'))) setArg(s, 0);
+        });
+        if (h && w.length) j[A] = [];
+        w.forEach(function (s) {
+          j[A].push(s);
+        });
+        if (f['camel-case-expansion'] && f['strip-dashed']) {
+          Object.keys(j).filter(function (s) {
+            return s !== '--' && s.includes('-');
+          }).forEach(function (s) {
+            delete j[s];
+          });
+        }
+        if (f['strip-aliased']) {
+          var _ref;
+          (_ref = []).concat.apply(_ref, _toConsumableArray(Object.keys(t).map(function (s) {
+            return t[s];
+          }))).forEach(function (s) {
+            if (f['camel-case-expansion']) {
+              delete j[s.split('.').map(function (s) {
+                return e(s);
+              }).join('.')];
+            }
+            delete j[s];
+          });
+        }
+        function eatNargs(s, n, t, e) {
+          var c;
+          var r = checkAllAliases(n, O.nargs);
+          r = isNaN(r) ? 1 : r;
+          if (r === 0) {
+            if (!isUndefined(e)) {
+              _ = Error(b('Argument unexpected for: %s', n));
+            }
+            setArg(n, defaultValue(n));
+            return s;
+          }
+          var l = isUndefined(e) ? 0 : 1;
+          if (f['nargs-eats-options']) {
+            if (t.length - (s + 1) + l < r) {
+              _ = Error(b('Not enough arguments following: %s', n));
+            }
+            l = r;
+          } else {
+            for (c = s + 1; c < t.length; c++) {
+              if (!t[c].match(/^-[^0-9]/) || t[c].match(m) || isUnknownOptionAsArg(t[c])) l++;else break;
+            }
+            if (l < r) _ = Error(b('Not enough arguments following: %s', n));
+          }
+          var o = Math.min(l, r);
+          if (!isUndefined(e) && o > 0) {
+            setArg(n, e);
+            o--;
+          }
+          for (c = s + 1; c < o + s + 1; c++) {
+            setArg(n, t[c]);
+          }
+          return s + o;
+        }
+        function eatArray(s, n, t, e) {
+          var c = [];
+          var r = e || t[s + 1];
+          var l = checkAllAliases(n, O.nargs);
+          if (checkAllAliases(n, O.bools) && !/^(true|false)$/.test(r)) {
+            c.push(true);
+          } else if (isUndefined(r) || isUndefined(e) && /^-/.test(r) && !m.test(r) && !isUnknownOptionAsArg(r)) {
+            if (a[n] !== undefined) {
+              var _s = a[n];
+              c = Array.isArray(_s) ? _s : [_s];
+            }
+          } else {
+            if (!isUndefined(e)) {
+              c.push(processValue(n, e));
+            }
+            for (var _e2 = s + 1; _e2 < t.length; _e2++) {
+              if (!f['greedy-arrays'] && c.length > 0 || l && c.length >= l) break;
+              r = t[_e2];
+              if (/^-/.test(r) && !m.test(r) && !isUnknownOptionAsArg(r)) break;
+              s = _e2;
+              c.push(processValue(n, r));
+            }
+          }
+          if (l && c.length < l || isNaN(l) && c.length === 0) {
+            _ = Error(b('Not enough arguments following: %s', n));
+          }
+          setArg(n, c);
+          return s;
+        }
+        function setArg(s, n) {
+          if (/-/.test(s) && f['camel-case-expansion']) {
+            var _n2 = s.split('.').map(function (s) {
+              return e(s);
+            }).join('.');
+            addNewAlias(s, _n2);
+          }
+          var t = processValue(s, n);
+          var c = s.split('.');
+          setKey(j, c, t);
+          if (O.aliases[s]) {
+            O.aliases[s].forEach(function (s) {
+              s = s.split('.');
+              setKey(j, s, t);
+            });
+          }
+          if (c.length > 1 && f['dot-notation']) {
+            (O.aliases[c[0]] || []).forEach(function (n) {
+              n = n.split('.');
+              var e = [].concat(c);
+              e.shift();
+              n = n.concat(e);
+              if (!(O.aliases[s] || []).includes(n.join('.'))) {
+                setKey(j, n, t);
+              }
+            });
+          }
+          if (checkAllAliases(s, O.normalize) && !checkAllAliases(s, O.arrays)) {
+            var _t3 = [s].concat(O.aliases[s] || []);
+            _t3.forEach(function (s) {
+              Object.defineProperty(N, s, {
+                enumerable: true,
+                get: function get() {
+                  return n;
+                },
+                set: function set(s) {
+                  n = typeof s === 'string' ? r.normalize(s) : s;
+                }
+              });
+            });
+          }
+        }
+        function addNewAlias(s, n) {
+          if (!(O.aliases[s] && O.aliases[s].length)) {
+            O.aliases[s] = [n];
+            p[n] = true;
+          }
+          if (!(O.aliases[n] && O.aliases[n].length)) {
+            addNewAlias(n, s);
+          }
+        }
+        function processValue(s, n) {
+          if (typeof n === 'string' && (n[0] === "'" || n[0] === '"') && n[n.length - 1] === n[0]) {
+            n = n.substring(1, n.length - 1);
+          }
+          if (checkAllAliases(s, O.bools) || checkAllAliases(s, O.counts)) {
+            if (typeof n === 'string') n = n === 'true';
+          }
+          var t = Array.isArray(n) ? n.map(function (n) {
+            return maybeCoerceNumber(s, n);
+          }) : maybeCoerceNumber(s, n);
+          if (checkAllAliases(s, O.counts) && (isUndefined(t) || typeof t === 'boolean')) {
+            t = increment;
+          }
+          if (checkAllAliases(s, O.normalize) && checkAllAliases(s, O.arrays)) {
+            if (Array.isArray(n)) t = n.map(r.normalize);else t = r.normalize(n);
+          }
+          return t;
+        }
+        function maybeCoerceNumber(s, n) {
+          if (!checkAllAliases(s, O.strings) && !checkAllAliases(s, O.bools) && !Array.isArray(n)) {
+            var _t4 = isNumber(n) && f['parse-numbers'] && Number.isSafeInteger(Math.floor(n));
+            if (_t4 || !isUndefined(n) && checkAllAliases(s, O.numbers)) n = Number(n);
+          }
+          return n;
+        }
+        function setConfig(s) {
+          var n = Object.create(null);
+          applyDefaultsAndAliases(n, O.aliases, a);
+          Object.keys(O.configs).forEach(function (t) {
+            var e = s[t] || n[t];
+            if (e) {
+              try {
+                var _n3 = null;
+                var _c2 = r.resolve(process.cwd(), e);
+                if (typeof O.configs[t] === 'function') {
+                  try {
+                    _n3 = O.configs[t](_c2);
+                  } catch (s) {
+                    _n3 = s;
+                  }
+                  if (_n3 instanceof Error) {
+                    _ = _n3;
+                    return;
+                  }
+                } else {
+                  _n3 = require(_c2);
+                }
+                setConfigObject(_n3);
+              } catch (n) {
+                if (s[t]) _ = Error(b('Invalid JSON config file: %s', e));
+              }
+            }
+          });
+        }
+        function setConfigObject(s, n) {
+          Object.keys(s).forEach(function (t) {
+            var e = s[t];
+            var c = n ? n + '.' + t : t;
+            if (_typeof(e) === 'object' && e !== null && !Array.isArray(e) && f['dot-notation']) {
+              setConfigObject(e, c);
+            } else {
+              if (!hasKey(j, c.split('.')) || checkAllAliases(c, O.arrays) && f['combine-arrays']) {
+                setArg(c, e);
+              }
+            }
+          });
+        }
+        function setConfigObjects() {
+          if (typeof i === 'undefined') return;
+          i.forEach(function (s) {
+            setConfigObject(s);
+          });
+        }
+        function applyEnvVars(s, n) {
+          if (typeof u === 'undefined') return;
+          var t = typeof u === 'string' ? u : '';
+          Object.keys(process.env).forEach(function (c) {
+            if (t === '' || c.lastIndexOf(t, 0) === 0) {
+              var _r2 = c.split('__').map(function (s, n) {
+                if (n === 0) {
+                  s = s.substring(t.length);
+                }
+                return e(s);
+              });
+              if ((n && O.configs[_r2.join('.')] || !n) && !hasKey(s, _r2)) {
+                setArg(_r2.join('.'), process.env[c]);
+              }
+            }
+          });
+        }
+        function applyCoercions(s) {
+          var n;
+          var t = new Set();
+          Object.keys(s).forEach(function (e) {
+            if (!t.has(e)) {
+              n = checkAllAliases(e, O.coercions);
+              if (typeof n === 'function') {
+                try {
+                  var _c3 = maybeCoerceNumber(e, n(s[e]));
+                  [].concat(O.aliases[e] || [], e).forEach(function (n) {
+                    t.add(n);
+                    s[n] = _c3;
+                  });
+                } catch (s) {
+                  _ = s;
+                }
+              }
+            }
+          });
+        }
+        function setPlaceholderKeys(s) {
+          O.keys.forEach(function (n) {
+            if (~n.indexOf('.')) return;
+            if (typeof s[n] === 'undefined') s[n] = undefined;
+          });
+          return s;
+        }
+        function applyDefaultsAndAliases(s, n, t) {
+          var e = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+          Object.keys(t).forEach(function (c) {
+            if (!hasKey(s, c.split('.'))) {
+              setKey(s, c.split('.'), t[c]);
+              if (e) d[c] = true;
+              (n[c] || []).forEach(function (n) {
+                if (hasKey(s, n.split('.'))) return;
+                setKey(s, n.split('.'), t[c]);
+              });
+            }
+          });
+        }
+        function hasKey(s, n) {
+          var t = s;
+          if (!f['dot-notation']) n = [n.join('.')];
+          n.slice(0, -1).forEach(function (s) {
+            t = t[s] || {};
+          });
+          var e = n[n.length - 1];
+          if (_typeof(t) !== 'object') return false;else return e in t;
+        }
+        function setKey(s, n, t) {
+          var e = s;
+          if (!f['dot-notation']) n = [n.join('.')];
+          n.slice(0, -1).forEach(function (s, n) {
+            s = sanitizeKey(s);
+            if (_typeof(e) === 'object' && e[s] === undefined) {
+              e[s] = {};
+            }
+            if (_typeof(e[s]) !== 'object' || Array.isArray(e[s])) {
+              if (Array.isArray(e[s])) {
+                e[s].push({});
+              } else {
+                e[s] = [e[s], {}];
+              }
+              e = e[s][e[s].length - 1];
+            } else {
+              e = e[s];
+            }
+          });
+          var c = sanitizeKey(n[n.length - 1]);
+          var r = checkAllAliases(n.join('.'), O.arrays);
+          var l = Array.isArray(t);
+          var o = f['duplicate-arguments-array'];
+          if (!o && checkAllAliases(c, O.nargs)) {
+            o = true;
+            if (!isUndefined(e[c]) && O.nargs[c] === 1 || Array.isArray(e[c]) && e[c].length === O.nargs[c]) {
+              e[c] = undefined;
+            }
+          }
+          if (t === increment) {
+            e[c] = increment(e[c]);
+          } else if (Array.isArray(e[c])) {
+            if (o && r && l) {
+              e[c] = f['flatten-duplicate-arrays'] ? e[c].concat(t) : (Array.isArray(e[c][0]) ? e[c] : [e[c]]).concat([t]);
+            } else if (!o && Boolean(r) === Boolean(l)) {
+              e[c] = t;
+            } else {
+              e[c] = e[c].concat([t]);
+            }
+          } else if (e[c] === undefined && r) {
+            e[c] = l ? t : [t];
+          } else if (o && !(e[c] === undefined || checkAllAliases(c, O.counts) || checkAllAliases(c, O.bools))) {
+            e[c] = [e[c], t];
+          } else {
+            e[c] = t;
+          }
+        }
+        function extendAliases() {
+          for (var _len = arguments.length, s = new Array(_len), _key = 0; _key < _len; _key++) {
+            s[_key] = arguments[_key];
+          }
+          s.forEach(function (s) {
+            Object.keys(s || {}).forEach(function (s) {
+              if (O.aliases[s]) return;
+              O.aliases[s] = [].concat(t[s] || []);
+              O.aliases[s].concat(s).forEach(function (n) {
+                if (/-/.test(n) && f['camel-case-expansion']) {
+                  var _t5 = e(n);
+                  if (_t5 !== s && O.aliases[s].indexOf(_t5) === -1) {
+                    O.aliases[s].push(_t5);
+                    p[_t5] = true;
+                  }
+                }
+              });
+              O.aliases[s].concat(s).forEach(function (n) {
+                if (n.length > 1 && /[A-Z]/.test(n) && f['camel-case-expansion']) {
+                  var _t6 = c(n, '-');
+                  if (_t6 !== s && O.aliases[s].indexOf(_t6) === -1) {
+                    O.aliases[s].push(_t6);
+                    p[_t6] = true;
+                  }
+                }
+              });
+              O.aliases[s].forEach(function (n) {
+                O.aliases[n] = [s].concat(O.aliases[s].filter(function (s) {
+                  return n !== s;
+                }));
+              });
+            });
+          });
+        }
+        function checkAllAliases(s, n) {
+          var t = [].concat(O.aliases[s] || [], s);
+          var e = Object.keys(n);
+          var c = t.find(function (s) {
+            return e.includes(s);
+          });
+          return c ? n[c] : false;
+        }
+        function hasAnyFlag(s) {
+          var n = [].concat(Object.keys(O).map(function (s) {
+            return O[s];
+          }));
+          return n.some(function (n) {
+            return Array.isArray(n) ? n.includes(s) : n[s];
+          });
+        }
+        function hasFlagsMatching(s) {
+          var _ref2;
+          for (var _len2 = arguments.length, n = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            n[_key2 - 1] = arguments[_key2];
+          }
+          var t = (_ref2 = []).concat.apply(_ref2, n);
+          return t.some(function (n) {
+            var t = s.match(n);
+            return t && hasAnyFlag(t[1]);
+          });
+        }
+        function hasAllShortFlags(s) {
+          if (s.match(m) || !s.match(/^-[^-]+/)) {
+            return false;
+          }
+          var n = true;
+          var t;
+          var e = s.slice(1).split('');
+          for (var _c4 = 0; _c4 < e.length; _c4++) {
+            t = s.slice(_c4 + 2);
+            if (!hasAnyFlag(e[_c4])) {
+              n = false;
+              break;
+            }
+            if (e[_c4 + 1] && e[_c4 + 1] === '=' || t === '-' || /[A-Za-z]/.test(e[_c4]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(t) || e[_c4 + 1] && e[_c4 + 1].match(/\W/)) {
+              break;
+            }
+          }
+          return n;
+        }
+        function isUnknownOptionAsArg(s) {
+          return f['unknown-options-as-args'] && isUnknownOption(s);
+        }
+        function isUnknownOption(s) {
+          if (s.match(m)) {
+            return false;
+          }
+          if (hasAllShortFlags(s)) {
+            return false;
+          }
+          var n = /^-+([^=]+?)=[\s\S]*$/;
+          var t = /^-+([^=]+?)$/;
+          var e = /^-+([^=]+?)-$/;
+          var c = /^-+([^=]+?\d+)$/;
+          var r = /^-+([^=]+?)\W+.*$/;
+          return !hasFlagsMatching(s, n, E, t, e, c, r);
+        }
+        function defaultValue(s) {
+          if (!checkAllAliases(s, O.bools) && !checkAllAliases(s, O.counts) && "".concat(s) in a) {
+            return a[s];
+          } else {
+            return defaultForType(guessType(s));
+          }
+        }
+        function defaultForType(s) {
+          var n = {
+            boolean: true,
+            string: '',
+            number: undefined,
+            array: []
+          };
+          return n[s];
+        }
+        function guessType(s) {
+          var n = 'boolean';
+          if (checkAllAliases(s, O.strings)) n = 'string';else if (checkAllAliases(s, O.numbers)) n = 'number';else if (checkAllAliases(s, O.bools)) n = 'boolean';else if (checkAllAliases(s, O.arrays)) n = 'array';
+          return n;
+        }
+        function isNumber(s) {
+          if (s === null || s === undefined) return false;
+          if (typeof s === 'number') return true;
+          if (/^0x[0-9a-f]+$/i.test(s)) return true;
+          if (s.length > 1 && s[0] === '0') return false;
+          return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(s);
+        }
+        function isUndefined(s) {
+          return s === undefined;
+        }
+        function checkConfiguration() {
+          Object.keys(O.counts).find(function (s) {
+            if (checkAllAliases(s, O.arrays)) {
+              _ = Error(b('Invalid configuration: %s, opts.count excludes opts.array.', s));
+              return true;
+            } else if (checkAllAliases(s, O.nargs)) {
+              _ = Error(b('Invalid configuration: %s, opts.count excludes opts.narg.', s));
+              return true;
+            }
+          });
+        }
+        return {
+          argv: Object.assign(N, j),
+          error: _,
+          aliases: Object.assign({}, O.aliases),
+          newAliases: Object.assign({}, p),
+          defaulted: Object.assign({}, d),
+          configuration: f
+        };
+      }
+      function combineAliases(s) {
+        var n = [];
+        var t = Object.create(null);
+        var e = true;
+        Object.keys(s).forEach(function (t) {
+          n.push([].concat(s[t], t));
+        });
+        while (e) {
+          e = false;
+          for (var _s2 = 0; _s2 < n.length; _s2++) {
+            var _loop = function _loop(t) {
+              var c = n[_s2].filter(function (s) {
+                return n[t].indexOf(s) !== -1;
+              });
+              if (c.length) {
+                n[_s2] = n[_s2].concat(n[t]);
+                n.splice(t, 1);
+                e = true;
+                return "break";
+              }
+            };
+            for (var _t7 = _s2 + 1; _t7 < n.length; _t7++) {
+              var _ret = _loop(_t7);
+              if (_ret === "break") break;
+            }
+          }
+        }
+        n.forEach(function (s) {
+          s = s.filter(function (s, n, t) {
+            return t.indexOf(s) === n;
+          });
+          t[s.pop()] = s;
+        });
+        return t;
+      }
+      function increment(s) {
+        return s !== undefined ? s + 1 : 1;
+      }
+      function Parser(s, n) {
+        var t = parse(s.slice(), n);
+        return t.argv;
+      }
+      Parser.detailed = function (s, n) {
+        return parse(s.slice(), n);
+      };
+      function sanitizeKey(s) {
+        if (s === '__proto__') return '___proto___';
+        return s;
+      }
+      s.exports = Parser;
+    },
+    433: function _(s) {
+      s.exports = function (s) {
+        if (Array.isArray(s)) {
+          return s.map(function (s) {
+            return typeof s !== 'string' ? s + '' : s;
+          });
+        }
+        s = s.trim();
+        var n = 0;
+        var t = null;
+        var e = null;
+        var c = null;
+        var r = [];
+        for (var l = 0; l < s.length; l++) {
+          t = e;
+          e = s.charAt(l);
+          if (e === ' ' && !c) {
+            if (!(t === ' ')) {
+              n++;
+            }
+            continue;
+          }
+          if (e === c) {
+            c = null;
+          } else if ((e === "'" || e === '"') && !c) {
+            c = e;
+          }
+          if (!r[n]) r[n] = '';
+          r[n] += e;
+        }
+        return r;
+      };
+    },
+    622: function _(s) {
+      'use strict';
+
+      s.exports = require('path');
+    },
+    669: function _(s) {
+      'use strict';
+
+      s.exports = require('util');
+    }
+  };
+  var n = {};
+  function __nccwpck_require__(t) {
+    if (n[t]) {
+      return n[t].exports;
+    }
+    var e = n[t] = {
+      exports: {}
+    };
+    var c = true;
+    try {
+      s[t](e, e.exports, __nccwpck_require__);
+      c = false;
+    } finally {
+      if (c) delete n[t];
+    }
+    return e.exports;
+  }
+  __nccwpck_require__.ab = __dirname + '/';
+  return __nccwpck_require__(246);
+}();