@teams-max/mwsp 1.0.2 → 2.0.0

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

@@ -0,0 +1,905 @@
+// src/utils/yargs-parser/index.js
+module.exports = (() => {
+  var s = {
+    362: (s2) => {
+      "use strict";
+      const n2 = (s3) => {
+        let n3 = false;
+        let t2 = false;
+        let e = false;
+        for (let c = 0; c < s3.length; c++) {
+          const r = s3[c];
+          if (n3 && /[a-zA-Z]/.test(r) && r.toUpperCase() === r) {
+            s3 = s3.slice(0, c) + "-" + s3.slice(c);
+            n3 = false;
+            e = t2;
+            t2 = true;
+            c++;
+          } else if (t2 && e && /[a-zA-Z]/.test(r) && r.toLowerCase() === r) {
+            s3 = s3.slice(0, c - 1) + "-" + s3.slice(c - 1);
+            e = t2;
+            t2 = false;
+            n3 = true;
+          } else {
+            n3 = r.toLowerCase() === r && r.toUpperCase() !== r;
+            e = t2;
+            t2 = r.toUpperCase() === r && r.toLowerCase() !== r;
+          }
+        }
+        return s3;
+      };
+      const t = (s3, t2) => {
+        if (!(typeof s3 === "string" || Array.isArray(s3))) {
+          throw new TypeError("Expected the input to be `string | string[]`");
+        }
+        t2 = Object.assign({ pascalCase: false }, t2);
+        const e = (s4) => t2.pascalCase ? s4.charAt(0).toUpperCase() + s4.slice(1) : s4;
+        if (Array.isArray(s3)) {
+          s3 = s3.map((s4) => s4.trim()).filter((s4) => s4.length).join("-");
+        } else {
+          s3 = s3.trim();
+        }
+        if (s3.length === 0) {
+          return "";
+        }
+        if (s3.length === 1) {
+          return t2.pascalCase ? s3.toUpperCase() : s3.toLowerCase();
+        }
+        const c = s3 !== s3.toLowerCase();
+        if (c) {
+          s3 = n2(s3);
+        }
+        s3 = s3.replace(/^[_.\- ]+/, "").toLowerCase().replace(/[_.\- ]+(\w|$)/g, (s4, n3) => n3.toUpperCase()).replace(/\d+(\w|$)/g, (s4) => s4.toUpperCase());
+        return e(s3);
+      };
+      s2.exports = t;
+      s2.exports.default = t;
+    },
+    159: (s2) => {
+      "use strict";
+      s2.exports = function(s3, n2) {
+        if (typeof s3 !== "string") {
+          throw new TypeError("Expected a string");
+        }
+        n2 = typeof n2 === "undefined" ? "_" : n2;
+        return s3.replace(/([a-z\d])([A-Z])/g, "$1" + n2 + "$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1" + n2 + "$2").toLowerCase();
+      };
+    },
+    246: (s2, n2, t) => {
+      const e = t(362);
+      const c = t(159);
+      const r = t(622);
+      const l = t(433);
+      const o = t(669);
+      function parse(s3, n3) {
+        n3 = Object.assign(/* @__PURE__ */ Object.create(null), n3);
+        s3 = l(s3);
+        const t2 = combineAliases(Object.assign(/* @__PURE__ */ Object.create(null), n3.alias));
+        const 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
+          },
+          n3.configuration
+        );
+        const a = Object.assign(/* @__PURE__ */ Object.create(null), n3.default);
+        const i = n3.configObjects || [];
+        const u = n3.envPrefix;
+        const h = f["populate--"];
+        const A = h ? "--" : "_";
+        const p = /* @__PURE__ */ Object.create(null);
+        const d = /* @__PURE__ */ Object.create(null);
+        const b = n3.__ || o.format;
+        const O = {
+          aliases: /* @__PURE__ */ Object.create(null),
+          arrays: /* @__PURE__ */ Object.create(null),
+          bools: /* @__PURE__ */ Object.create(null),
+          strings: /* @__PURE__ */ Object.create(null),
+          numbers: /* @__PURE__ */ Object.create(null),
+          counts: /* @__PURE__ */ Object.create(null),
+          normalize: /* @__PURE__ */ Object.create(null),
+          configs: /* @__PURE__ */ Object.create(null),
+          nargs: /* @__PURE__ */ Object.create(null),
+          coercions: /* @__PURE__ */ Object.create(null),
+          keys: []
+        };
+        const m = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
+        const E = new RegExp("^--" + f["negation-prefix"] + "(.+)");
+        [].concat(n3.array).filter(Boolean).forEach(function(s4) {
+          const n4 = s4.key || s4;
+          const t3 = Object.keys(s4).map(function(s5) {
+            return { boolean: "bools", string: "strings", number: "numbers" }[s5];
+          }).filter(Boolean).pop();
+          if (t3) {
+            O[t3][n4] = true;
+          }
+          O.arrays[n4] = true;
+          O.keys.push(n4);
+        });
+        [].concat(n3.boolean).filter(Boolean).forEach(function(s4) {
+          O.bools[s4] = true;
+          O.keys.push(s4);
+        });
+        [].concat(n3.string).filter(Boolean).forEach(function(s4) {
+          O.strings[s4] = true;
+          O.keys.push(s4);
+        });
+        [].concat(n3.number).filter(Boolean).forEach(function(s4) {
+          O.numbers[s4] = true;
+          O.keys.push(s4);
+        });
+        [].concat(n3.count).filter(Boolean).forEach(function(s4) {
+          O.counts[s4] = true;
+          O.keys.push(s4);
+        });
+        [].concat(n3.normalize).filter(Boolean).forEach(function(s4) {
+          O.normalize[s4] = true;
+          O.keys.push(s4);
+        });
+        Object.keys(n3.narg || {}).forEach(function(s4) {
+          O.nargs[s4] = n3.narg[s4];
+          O.keys.push(s4);
+        });
+        Object.keys(n3.coerce || {}).forEach(function(s4) {
+          O.coercions[s4] = n3.coerce[s4];
+          O.keys.push(s4);
+        });
+        if (Array.isArray(n3.config) || typeof n3.config === "string") {
+          [].concat(n3.config).filter(Boolean).forEach(function(s4) {
+            O.configs[s4] = true;
+          });
+        } else {
+          Object.keys(n3.config || {}).forEach(function(s4) {
+            O.configs[s4] = n3.config[s4];
+          });
+        }
+        extendAliases(n3.key, t2, n3.default, O.arrays);
+        Object.keys(a).forEach(function(s4) {
+          (O.aliases[s4] || []).forEach(function(n4) {
+            a[n4] = a[s4];
+          });
+        });
+        let _ = null;
+        checkConfiguration();
+        let w = [];
+        const j = Object.assign(/* @__PURE__ */ Object.create(null), { _: [] });
+        const N = {};
+        for (let n4 = 0; n4 < s3.length; n4++) {
+          const t3 = s3[n4];
+          let e2;
+          let c2;
+          let r2;
+          let l2;
+          let o2;
+          let a2;
+          if (t3 !== "--" && isUnknownOptionAsArg(t3)) {
+            j._.push(t3);
+          } else if (t3.match(/^--.+=/) || !f["short-option-groups"] && t3.match(/^-.+=/)) {
+            l2 = t3.match(/^--?([^=]+)=([\s\S]*)$/);
+            if (checkAllAliases(l2[1], O.arrays)) {
+              n4 = eatArray(n4, l2[1], s3, l2[2]);
+            } else if (checkAllAliases(l2[1], O.nargs) !== false) {
+              n4 = eatNargs(n4, l2[1], s3, l2[2]);
+            } else {
+              setArg(l2[1], l2[2]);
+            }
+          } else if (t3.match(E) && f["boolean-negation"]) {
+            c2 = t3.match(E)[1];
+            setArg(c2, checkAllAliases(c2, O.arrays) ? [false] : false);
+          } else if (t3.match(/^--.+/) || !f["short-option-groups"] && t3.match(/^-[^-]+/)) {
+            c2 = t3.match(/^--?(.+)/)[1];
+            if (checkAllAliases(c2, O.arrays)) {
+              n4 = eatArray(n4, c2, s3);
+            } else if (checkAllAliases(c2, O.nargs) !== false) {
+              n4 = eatNargs(n4, c2, s3);
+            } else {
+              o2 = s3[n4 + 1];
+              if (o2 !== void 0 && (!o2.match(/^-/) || o2.match(m)) && !checkAllAliases(c2, O.bools) && !checkAllAliases(c2, O.counts)) {
+                setArg(c2, o2);
+                n4++;
+              } else if (/^(true|false)$/.test(o2)) {
+                setArg(c2, o2);
+                n4++;
+              } else {
+                setArg(c2, defaultValue(c2));
+              }
+            }
+          } else if (t3.match(/^-.\..+=/)) {
+            l2 = t3.match(/^-([^=]+)=([\s\S]*)$/);
+            setArg(l2[1], l2[2]);
+          } else if (t3.match(/^-.\..+/) && !t3.match(m)) {
+            o2 = s3[n4 + 1];
+            c2 = t3.match(/^-(.\..+)/)[1];
+            if (o2 !== void 0 && !o2.match(/^-/) && !checkAllAliases(c2, O.bools) && !checkAllAliases(c2, O.counts)) {
+              setArg(c2, o2);
+              n4++;
+            } else {
+              setArg(c2, defaultValue(c2));
+            }
+          } else if (t3.match(/^-[^-]+/) && !t3.match(m)) {
+            r2 = t3.slice(1, -1).split("");
+            e2 = false;
+            for (let l3 = 0; l3 < r2.length; l3++) {
+              o2 = t3.slice(l3 + 2);
+              if (r2[l3 + 1] && r2[l3 + 1] === "=") {
+                a2 = t3.slice(l3 + 3);
+                c2 = r2[l3];
+                if (checkAllAliases(c2, O.arrays)) {
+                  n4 = eatArray(n4, c2, s3, a2);
+                } else if (checkAllAliases(c2, O.nargs) !== false) {
+                  n4 = eatNargs(n4, c2, s3, a2);
+                } else {
+                  setArg(c2, a2);
+                }
+                e2 = true;
+                break;
+              }
+              if (o2 === "-") {
+                setArg(r2[l3], o2);
+                continue;
+              }
+              if (/[A-Za-z]/.test(r2[l3]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(o2)) {
+                setArg(r2[l3], o2);
+                e2 = true;
+                break;
+              }
+              if (r2[l3 + 1] && r2[l3 + 1].match(/\W/)) {
+                setArg(r2[l3], o2);
+                e2 = true;
+                break;
+              } else {
+                setArg(r2[l3], defaultValue(r2[l3]));
+              }
+            }
+            c2 = t3.slice(-1)[0];
+            if (!e2 && c2 !== "-") {
+              if (checkAllAliases(c2, O.arrays)) {
+                n4 = eatArray(n4, c2, s3);
+              } else if (checkAllAliases(c2, O.nargs) !== false) {
+                n4 = eatNargs(n4, c2, s3);
+              } else {
+                o2 = s3[n4 + 1];
+                if (o2 !== void 0 && (!/^(-|--)[^-]/.test(o2) || o2.match(m)) && !checkAllAliases(c2, O.bools) && !checkAllAliases(c2, O.counts)) {
+                  setArg(c2, o2);
+                  n4++;
+                } else if (/^(true|false)$/.test(o2)) {
+                  setArg(c2, o2);
+                  n4++;
+                } else {
+                  setArg(c2, defaultValue(c2));
+                }
+              }
+            }
+          } else if (t3.match(/^-[0-9]$/) && t3.match(m) && checkAllAliases(t3.slice(1), O.bools)) {
+            c2 = t3.slice(1);
+            setArg(c2, defaultValue(c2));
+          } else if (t3 === "--") {
+            w = s3.slice(n4 + 1);
+            break;
+          } else if (f["halt-at-non-option"]) {
+            w = s3.slice(n4);
+            break;
+          } else {
+            j._.push(maybeCoerceNumber("_", t3));
+          }
+        }
+        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(s4) {
+          if (!hasKey(j, s4.split(".")))
+            setArg(s4, 0);
+        });
+        if (h && w.length)
+          j[A] = [];
+        w.forEach(function(s4) {
+          j[A].push(s4);
+        });
+        if (f["camel-case-expansion"] && f["strip-dashed"]) {
+          Object.keys(j).filter((s4) => s4 !== "--" && s4.includes("-")).forEach((s4) => {
+            delete j[s4];
+          });
+        }
+        if (f["strip-aliased"]) {
+          [].concat(...Object.keys(t2).map((s4) => t2[s4])).forEach((s4) => {
+            if (f["camel-case-expansion"]) {
+              delete j[s4.split(".").map((s5) => e(s5)).join(".")];
+            }
+            delete j[s4];
+          });
+        }
+        function eatNargs(s4, n4, t3, e2) {
+          let c2;
+          let r2 = checkAllAliases(n4, O.nargs);
+          r2 = isNaN(r2) ? 1 : r2;
+          if (r2 === 0) {
+            if (!isUndefined(e2)) {
+              _ = Error(b("Argument unexpected for: %s", n4));
+            }
+            setArg(n4, defaultValue(n4));
+            return s4;
+          }
+          let l2 = isUndefined(e2) ? 0 : 1;
+          if (f["nargs-eats-options"]) {
+            if (t3.length - (s4 + 1) + l2 < r2) {
+              _ = Error(b("Not enough arguments following: %s", n4));
+            }
+            l2 = r2;
+          } else {
+            for (c2 = s4 + 1; c2 < t3.length; c2++) {
+              if (!t3[c2].match(/^-[^0-9]/) || t3[c2].match(m) || isUnknownOptionAsArg(t3[c2]))
+                l2++;
+              else
+                break;
+            }
+            if (l2 < r2)
+              _ = Error(b("Not enough arguments following: %s", n4));
+          }
+          let o2 = Math.min(l2, r2);
+          if (!isUndefined(e2) && o2 > 0) {
+            setArg(n4, e2);
+            o2--;
+          }
+          for (c2 = s4 + 1; c2 < o2 + s4 + 1; c2++) {
+            setArg(n4, t3[c2]);
+          }
+          return s4 + o2;
+        }
+        function eatArray(s4, n4, t3, e2) {
+          let c2 = [];
+          let r2 = e2 || t3[s4 + 1];
+          const l2 = checkAllAliases(n4, O.nargs);
+          if (checkAllAliases(n4, O.bools) && !/^(true|false)$/.test(r2)) {
+            c2.push(true);
+          } else if (isUndefined(r2) || isUndefined(e2) && /^-/.test(r2) && !m.test(r2) && !isUnknownOptionAsArg(r2)) {
+            if (a[n4] !== void 0) {
+              const s5 = a[n4];
+              c2 = Array.isArray(s5) ? s5 : [s5];
+            }
+          } else {
+            if (!isUndefined(e2)) {
+              c2.push(processValue(n4, e2));
+            }
+            for (let e3 = s4 + 1; e3 < t3.length; e3++) {
+              if (!f["greedy-arrays"] && c2.length > 0 || l2 && c2.length >= l2)
+                break;
+              r2 = t3[e3];
+              if (/^-/.test(r2) && !m.test(r2) && !isUnknownOptionAsArg(r2))
+                break;
+              s4 = e3;
+              c2.push(processValue(n4, r2));
+            }
+          }
+          if (l2 && c2.length < l2 || isNaN(l2) && c2.length === 0) {
+            _ = Error(b("Not enough arguments following: %s", n4));
+          }
+          setArg(n4, c2);
+          return s4;
+        }
+        function setArg(s4, n4) {
+          if (/-/.test(s4) && f["camel-case-expansion"]) {
+            const n5 = s4.split(".").map(function(s5) {
+              return e(s5);
+            }).join(".");
+            addNewAlias(s4, n5);
+          }
+          const t3 = processValue(s4, n4);
+          const c2 = s4.split(".");
+          setKey(j, c2, t3);
+          if (O.aliases[s4]) {
+            O.aliases[s4].forEach(function(s5) {
+              s5 = s5.split(".");
+              setKey(j, s5, t3);
+            });
+          }
+          if (c2.length > 1 && f["dot-notation"]) {
+            (O.aliases[c2[0]] || []).forEach(function(n5) {
+              n5 = n5.split(".");
+              const e2 = [].concat(c2);
+              e2.shift();
+              n5 = n5.concat(e2);
+              if (!(O.aliases[s4] || []).includes(n5.join("."))) {
+                setKey(j, n5, t3);
+              }
+            });
+          }
+          if (checkAllAliases(s4, O.normalize) && !checkAllAliases(s4, O.arrays)) {
+            const t4 = [s4].concat(O.aliases[s4] || []);
+            t4.forEach(function(s5) {
+              Object.defineProperty(N, s5, {
+                enumerable: true,
+                get() {
+                  return n4;
+                },
+                set(s6) {
+                  n4 = typeof s6 === "string" ? r.normalize(s6) : s6;
+                }
+              });
+            });
+          }
+        }
+        function addNewAlias(s4, n4) {
+          if (!(O.aliases[s4] && O.aliases[s4].length)) {
+            O.aliases[s4] = [n4];
+            p[n4] = true;
+          }
+          if (!(O.aliases[n4] && O.aliases[n4].length)) {
+            addNewAlias(n4, s4);
+          }
+        }
+        function processValue(s4, n4) {
+          if (typeof n4 === "string" && (n4[0] === "'" || n4[0] === '"') && n4[n4.length - 1] === n4[0]) {
+            n4 = n4.substring(1, n4.length - 1);
+          }
+          if (checkAllAliases(s4, O.bools) || checkAllAliases(s4, O.counts)) {
+            if (typeof n4 === "string")
+              n4 = n4 === "true";
+          }
+          let t3 = Array.isArray(n4) ? n4.map(function(n5) {
+            return maybeCoerceNumber(s4, n5);
+          }) : maybeCoerceNumber(s4, n4);
+          if (checkAllAliases(s4, O.counts) && (isUndefined(t3) || typeof t3 === "boolean")) {
+            t3 = increment;
+          }
+          if (checkAllAliases(s4, O.normalize) && checkAllAliases(s4, O.arrays)) {
+            if (Array.isArray(n4))
+              t3 = n4.map(r.normalize);
+            else
+              t3 = r.normalize(n4);
+          }
+          return t3;
+        }
+        function maybeCoerceNumber(s4, n4) {
+          if (!checkAllAliases(s4, O.strings) && !checkAllAliases(s4, O.bools) && !Array.isArray(n4)) {
+            const t3 = isNumber(n4) && f["parse-numbers"] && Number.isSafeInteger(Math.floor(n4));
+            if (t3 || !isUndefined(n4) && checkAllAliases(s4, O.numbers))
+              n4 = Number(n4);
+          }
+          return n4;
+        }
+        function setConfig(s4) {
+          const n4 = /* @__PURE__ */ Object.create(null);
+          applyDefaultsAndAliases(n4, O.aliases, a);
+          Object.keys(O.configs).forEach(function(t3) {
+            const e2 = s4[t3] || n4[t3];
+            if (e2) {
+              try {
+                let n5 = null;
+                const c2 = r.resolve(process.cwd(), e2);
+                if (typeof O.configs[t3] === "function") {
+                  try {
+                    n5 = O.configs[t3](c2);
+                  } catch (s5) {
+                    n5 = s5;
+                  }
+                  if (n5 instanceof Error) {
+                    _ = n5;
+                    return;
+                  }
+                } else {
+                  n5 = require(c2);
+                }
+                setConfigObject(n5);
+              } catch (n5) {
+                if (s4[t3])
+                  _ = Error(b("Invalid JSON config file: %s", e2));
+              }
+            }
+          });
+        }
+        function setConfigObject(s4, n4) {
+          Object.keys(s4).forEach(function(t3) {
+            const e2 = s4[t3];
+            const c2 = n4 ? n4 + "." + t3 : t3;
+            if (typeof e2 === "object" && e2 !== null && !Array.isArray(e2) && f["dot-notation"]) {
+              setConfigObject(e2, c2);
+            } else {
+              if (!hasKey(j, c2.split(".")) || checkAllAliases(c2, O.arrays) && f["combine-arrays"]) {
+                setArg(c2, e2);
+              }
+            }
+          });
+        }
+        function setConfigObjects() {
+          if (typeof i === "undefined")
+            return;
+          i.forEach(function(s4) {
+            setConfigObject(s4);
+          });
+        }
+        function applyEnvVars(s4, n4) {
+          if (typeof u === "undefined")
+            return;
+          const t3 = typeof u === "string" ? u : "";
+          Object.keys(process.env).forEach(function(c2) {
+            if (t3 === "" || c2.lastIndexOf(t3, 0) === 0) {
+              const r2 = c2.split("__").map(function(s5, n5) {
+                if (n5 === 0) {
+                  s5 = s5.substring(t3.length);
+                }
+                return e(s5);
+              });
+              if ((n4 && O.configs[r2.join(".")] || !n4) && !hasKey(s4, r2)) {
+                setArg(r2.join("."), process.env[c2]);
+              }
+            }
+          });
+        }
+        function applyCoercions(s4) {
+          let n4;
+          const t3 = /* @__PURE__ */ new Set();
+          Object.keys(s4).forEach(function(e2) {
+            if (!t3.has(e2)) {
+              n4 = checkAllAliases(e2, O.coercions);
+              if (typeof n4 === "function") {
+                try {
+                  const c2 = maybeCoerceNumber(e2, n4(s4[e2]));
+                  [].concat(O.aliases[e2] || [], e2).forEach((n5) => {
+                    t3.add(n5);
+                    s4[n5] = c2;
+                  });
+                } catch (s5) {
+                  _ = s5;
+                }
+              }
+            }
+          });
+        }
+        function setPlaceholderKeys(s4) {
+          O.keys.forEach((n4) => {
+            if (~n4.indexOf("."))
+              return;
+            if (typeof s4[n4] === "undefined")
+              s4[n4] = void 0;
+          });
+          return s4;
+        }
+        function applyDefaultsAndAliases(s4, n4, t3, e2 = false) {
+          Object.keys(t3).forEach(function(c2) {
+            if (!hasKey(s4, c2.split("."))) {
+              setKey(s4, c2.split("."), t3[c2]);
+              if (e2)
+                d[c2] = true;
+              (n4[c2] || []).forEach(function(n5) {
+                if (hasKey(s4, n5.split(".")))
+                  return;
+                setKey(s4, n5.split("."), t3[c2]);
+              });
+            }
+          });
+        }
+        function hasKey(s4, n4) {
+          let t3 = s4;
+          if (!f["dot-notation"])
+            n4 = [n4.join(".")];
+          n4.slice(0, -1).forEach(function(s5) {
+            t3 = t3[s5] || {};
+          });
+          const e2 = n4[n4.length - 1];
+          if (typeof t3 !== "object")
+            return false;
+          else
+            return e2 in t3;
+        }
+        function setKey(s4, n4, t3) {
+          let e2 = s4;
+          if (!f["dot-notation"])
+            n4 = [n4.join(".")];
+          n4.slice(0, -1).forEach(function(s5, n5) {
+            s5 = sanitizeKey(s5);
+            if (typeof e2 === "object" && e2[s5] === void 0) {
+              e2[s5] = {};
+            }
+            if (typeof e2[s5] !== "object" || Array.isArray(e2[s5])) {
+              if (Array.isArray(e2[s5])) {
+                e2[s5].push({});
+              } else {
+                e2[s5] = [e2[s5], {}];
+              }
+              e2 = e2[s5][e2[s5].length - 1];
+            } else {
+              e2 = e2[s5];
+            }
+          });
+          const c2 = sanitizeKey(n4[n4.length - 1]);
+          const r2 = checkAllAliases(n4.join("."), O.arrays);
+          const l2 = Array.isArray(t3);
+          let o2 = f["duplicate-arguments-array"];
+          if (!o2 && checkAllAliases(c2, O.nargs)) {
+            o2 = true;
+            if (!isUndefined(e2[c2]) && O.nargs[c2] === 1 || Array.isArray(e2[c2]) && e2[c2].length === O.nargs[c2]) {
+              e2[c2] = void 0;
+            }
+          }
+          if (t3 === increment) {
+            e2[c2] = increment(e2[c2]);
+          } else if (Array.isArray(e2[c2])) {
+            if (o2 && r2 && l2) {
+              e2[c2] = f["flatten-duplicate-arrays"] ? e2[c2].concat(t3) : (Array.isArray(e2[c2][0]) ? e2[c2] : [e2[c2]]).concat([t3]);
+            } else if (!o2 && Boolean(r2) === Boolean(l2)) {
+              e2[c2] = t3;
+            } else {
+              e2[c2] = e2[c2].concat([t3]);
+            }
+          } else if (e2[c2] === void 0 && r2) {
+            e2[c2] = l2 ? t3 : [t3];
+          } else if (o2 && !(e2[c2] === void 0 || checkAllAliases(c2, O.counts) || checkAllAliases(c2, O.bools))) {
+            e2[c2] = [e2[c2], t3];
+          } else {
+            e2[c2] = t3;
+          }
+        }
+        function extendAliases(...s4) {
+          s4.forEach(function(s5) {
+            Object.keys(s5 || {}).forEach(function(s6) {
+              if (O.aliases[s6])
+                return;
+              O.aliases[s6] = [].concat(t2[s6] || []);
+              O.aliases[s6].concat(s6).forEach(function(n4) {
+                if (/-/.test(n4) && f["camel-case-expansion"]) {
+                  const t3 = e(n4);
+                  if (t3 !== s6 && O.aliases[s6].indexOf(t3) === -1) {
+                    O.aliases[s6].push(t3);
+                    p[t3] = true;
+                  }
+                }
+              });
+              O.aliases[s6].concat(s6).forEach(function(n4) {
+                if (n4.length > 1 && /[A-Z]/.test(n4) && f["camel-case-expansion"]) {
+                  const t3 = c(n4, "-");
+                  if (t3 !== s6 && O.aliases[s6].indexOf(t3) === -1) {
+                    O.aliases[s6].push(t3);
+                    p[t3] = true;
+                  }
+                }
+              });
+              O.aliases[s6].forEach(function(n4) {
+                O.aliases[n4] = [s6].concat(
+                  O.aliases[s6].filter(function(s7) {
+                    return n4 !== s7;
+                  })
+                );
+              });
+            });
+          });
+        }
+        function checkAllAliases(s4, n4) {
+          const t3 = [].concat(O.aliases[s4] || [], s4);
+          const e2 = Object.keys(n4);
+          const c2 = t3.find((s5) => e2.includes(s5));
+          return c2 ? n4[c2] : false;
+        }
+        function hasAnyFlag(s4) {
+          const n4 = [].concat(Object.keys(O).map((s5) => O[s5]));
+          return n4.some(function(n5) {
+            return Array.isArray(n5) ? n5.includes(s4) : n5[s4];
+          });
+        }
+        function hasFlagsMatching(s4, ...n4) {
+          const t3 = [].concat(...n4);
+          return t3.some(function(n5) {
+            const t4 = s4.match(n5);
+            return t4 && hasAnyFlag(t4[1]);
+          });
+        }
+        function hasAllShortFlags(s4) {
+          if (s4.match(m) || !s4.match(/^-[^-]+/)) {
+            return false;
+          }
+          let n4 = true;
+          let t3;
+          const e2 = s4.slice(1).split("");
+          for (let c2 = 0; c2 < e2.length; c2++) {
+            t3 = s4.slice(c2 + 2);
+            if (!hasAnyFlag(e2[c2])) {
+              n4 = false;
+              break;
+            }
+            if (e2[c2 + 1] && e2[c2 + 1] === "=" || t3 === "-" || /[A-Za-z]/.test(e2[c2]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(t3) || e2[c2 + 1] && e2[c2 + 1].match(/\W/)) {
+              break;
+            }
+          }
+          return n4;
+        }
+        function isUnknownOptionAsArg(s4) {
+          return f["unknown-options-as-args"] && isUnknownOption(s4);
+        }
+        function isUnknownOption(s4) {
+          if (s4.match(m)) {
+            return false;
+          }
+          if (hasAllShortFlags(s4)) {
+            return false;
+          }
+          const n4 = /^-+([^=]+?)=[\s\S]*$/;
+          const t3 = /^-+([^=]+?)$/;
+          const e2 = /^-+([^=]+?)-$/;
+          const c2 = /^-+([^=]+?\d+)$/;
+          const r2 = /^-+([^=]+?)\W+.*$/;
+          return !hasFlagsMatching(s4, n4, E, t3, e2, c2, r2);
+        }
+        function defaultValue(s4) {
+          if (!checkAllAliases(s4, O.bools) && !checkAllAliases(s4, O.counts) && `${s4}` in a) {
+            return a[s4];
+          } else {
+            return defaultForType(guessType(s4));
+          }
+        }
+        function defaultForType(s4) {
+          const n4 = { boolean: true, string: "", number: void 0, array: [] };
+          return n4[s4];
+        }
+        function guessType(s4) {
+          let n4 = "boolean";
+          if (checkAllAliases(s4, O.strings))
+            n4 = "string";
+          else if (checkAllAliases(s4, O.numbers))
+            n4 = "number";
+          else if (checkAllAliases(s4, O.bools))
+            n4 = "boolean";
+          else if (checkAllAliases(s4, O.arrays))
+            n4 = "array";
+          return n4;
+        }
+        function isNumber(s4) {
+          if (s4 === null || s4 === void 0)
+            return false;
+          if (typeof s4 === "number")
+            return true;
+          if (/^0x[0-9a-f]+$/i.test(s4))
+            return true;
+          if (s4.length > 1 && s4[0] === "0")
+            return false;
+          return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(s4);
+        }
+        function isUndefined(s4) {
+          return s4 === void 0;
+        }
+        function checkConfiguration() {
+          Object.keys(O.counts).find((s4) => {
+            if (checkAllAliases(s4, O.arrays)) {
+              _ = Error(b("Invalid configuration: %s, opts.count excludes opts.array.", s4));
+              return true;
+            } else if (checkAllAliases(s4, O.nargs)) {
+              _ = Error(b("Invalid configuration: %s, opts.count excludes opts.narg.", s4));
+              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(s3) {
+        const n3 = [];
+        const t2 = /* @__PURE__ */ Object.create(null);
+        let e2 = true;
+        Object.keys(s3).forEach(function(t3) {
+          n3.push([].concat(s3[t3], t3));
+        });
+        while (e2) {
+          e2 = false;
+          for (let s4 = 0; s4 < n3.length; s4++) {
+            for (let t3 = s4 + 1; t3 < n3.length; t3++) {
+              const c2 = n3[s4].filter(function(s5) {
+                return n3[t3].indexOf(s5) !== -1;
+              });
+              if (c2.length) {
+                n3[s4] = n3[s4].concat(n3[t3]);
+                n3.splice(t3, 1);
+                e2 = true;
+                break;
+              }
+            }
+          }
+        }
+        n3.forEach(function(s4) {
+          s4 = s4.filter(function(s5, n4, t3) {
+            return t3.indexOf(s5) === n4;
+          });
+          t2[s4.pop()] = s4;
+        });
+        return t2;
+      }
+      function increment(s3) {
+        return s3 !== void 0 ? s3 + 1 : 1;
+      }
+      function Parser(s3, n3) {
+        const t2 = parse(s3.slice(), n3);
+        return t2.argv;
+      }
+      Parser.detailed = function(s3, n3) {
+        return parse(s3.slice(), n3);
+      };
+      function sanitizeKey(s3) {
+        if (s3 === "__proto__")
+          return "___proto___";
+        return s3;
+      }
+      s2.exports = Parser;
+    },
+    433: (s2) => {
+      s2.exports = function(s3) {
+        if (Array.isArray(s3)) {
+          return s3.map((s4) => typeof s4 !== "string" ? s4 + "" : s4);
+        }
+        s3 = s3.trim();
+        let n2 = 0;
+        let t = null;
+        let e = null;
+        let c = null;
+        const r = [];
+        for (let l = 0; l < s3.length; l++) {
+          t = e;
+          e = s3.charAt(l);
+          if (e === " " && !c) {
+            if (!(t === " ")) {
+              n2++;
+            }
+            continue;
+          }
+          if (e === c) {
+            c = null;
+          } else if ((e === "'" || e === '"') && !c) {
+            c = e;
+          }
+          if (!r[n2])
+            r[n2] = "";
+          r[n2] += e;
+        }
+        return r;
+      };
+    },
+    622: (s2) => {
+      "use strict";
+      s2.exports = require("path");
+    },
+    669: (s2) => {
+      "use strict";
+      s2.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);
+})();