@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/external/yargs-parser.js

@@ -1,4 +1,57 @@
+"use strict";
+/**
+ * Bundled from yargs-parser
+ * This is a zero-dependency bundle created by rolldown.
+ */
+'use strict';
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
+let util = require("util");
+let path = require("path");
+let fs = require("fs");
+let node_module = require("node:module");
+
 const { ArrayIsArray: _p_ArrayIsArray } = require('../primordials/array.js')
+
 const { JSONParse: _p_JSONParse } = require('../primordials/json.js')
 
 const { SetCtor: _p_SetCtor } = require('../primordials/map-set.js')
@@ -13,1104 +66,828 @@ const { RegExpCtor: _p_RegExpCtor } = require('../primordials/regexp.js')
 
 const { StringPrototypeCharAt: _p_StringPrototypeCharAt, StringPrototypeSubstring: _p_StringPrototypeSubstring } = require('../primordials/string.js')
 
-"use strict";
+//#region node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/string-utils.js
 /**
- * Bundled from yargs-parser
- * This is a zero-dependency bundle created by esbuild.
- */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/string-utils.js
+* @license
+* Copyright (c) 2016, Contributors
+* SPDX-License-Identifier: ISC
+*/
 function camelCase(str) {
-  const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
-  if (!isCamelCase) {
-    str = str.toLowerCase();
-  }
-  if (str.indexOf("-") === -1 && str.indexOf("_") === -1) {
-    return str;
-  } else {
-    let camelcase = "";
-    let nextChrUpper = false;
-    const leadingHyphens = str.match(/^-+/);
-    for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
-      let chr = _p_StringPrototypeCharAt(str, i);
-      if (nextChrUpper) {
-        nextChrUpper = false;
-        chr = chr.toUpperCase();
-      }
-      if (i !== 0 && (chr === "-" || chr === "_")) {
-        nextChrUpper = true;
-      } else if (chr !== "-" && chr !== "_") {
-        camelcase += chr;
-      }
-    }
-    return camelcase;
-  }
+	if (!(str !== str.toLowerCase() && str !== str.toUpperCase())) str = str.toLowerCase();
+	if (str.indexOf("-") === -1 && str.indexOf("_") === -1) return str;
+	else {
+		let camelcase = "";
+		let nextChrUpper = false;
+		const leadingHyphens = str.match(/^-+/);
+		for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
+			let chr = _p_StringPrototypeCharAt(str, i);
+			if (nextChrUpper) {
+				nextChrUpper = false;
+				chr = chr.toUpperCase();
+			}
+			if (i !== 0 && (chr === "-" || chr === "_")) nextChrUpper = true;
+			else if (chr !== "-" && chr !== "_") camelcase += chr;
+		}
+		return camelcase;
+	}
 }
 function decamelize(str, joinString) {
-  const lowercase = str.toLowerCase();
-  joinString = joinString || "-";
-  let notCamelcase = "";
-  for (let i = 0; i < str.length; i++) {
-    const chrLower = _p_StringPrototypeCharAt(lowercase, i);
-    const chrString = _p_StringPrototypeCharAt(str, i);
-    if (chrLower !== chrString && i > 0) {
-      notCamelcase += `${joinString}${_p_StringPrototypeCharAt(lowercase, i)}`;
-    } else {
-      notCamelcase += chrString;
-    }
-  }
-  return notCamelcase;
+	const lowercase = str.toLowerCase();
+	joinString = joinString || "-";
+	let notCamelcase = "";
+	for (let i = 0; i < str.length; i++) {
+		const chrLower = _p_StringPrototypeCharAt(lowercase, i);
+		const chrString = _p_StringPrototypeCharAt(str, i);
+		if (chrLower !== chrString && i > 0) notCamelcase += `${joinString}${_p_StringPrototypeCharAt(lowercase, i)}`;
+		else notCamelcase += chrString;
+	}
+	return notCamelcase;
 }
 function looksLikeNumber(x) {
-  if (x === null || x === void 0)
-    return false;
-  if (typeof x === "number")
-    return true;
-  if (/^0x[0-9a-f]+$/i.test(x))
-    return true;
-  if (/^0[^.]/.test(x))
-    return false;
-  return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+	if (x === null || x === void 0) return false;
+	if (typeof x === "number") return true;
+	if (/^0x[0-9a-f]+$/i.test(x)) return true;
+	if (/^0[^.]/.test(x)) return false;
+	return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
 }
-var init_string_utils = __esm({
-  "node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/string-utils.js"() {
-    __name(camelCase, "camelCase");
-    __name(decamelize, "decamelize");
-    __name(looksLikeNumber, "looksLikeNumber");
-  }
-});
+var init_string_utils = __esmMin((() => {}));
 
-// node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/tokenize-arg-string.js
+//#endregion
+//#region node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/tokenize-arg-string.js
+/**
+* @license
+* Copyright (c) 2016, Contributors
+* SPDX-License-Identifier: ISC
+*/
 function tokenizeArgString(argString) {
-  if (_p_ArrayIsArray(argString)) {
-    return argString.map((e) => typeof e !== "string" ? e + "" : e);
-  }
-  argString = argString.trim();
-  let i = 0;
-  let prevC = null;
-  let c = null;
-  let opening = null;
-  const args = [];
-  for (let ii = 0; ii < argString.length; ii++) {
-    prevC = c;
-    c = _p_StringPrototypeCharAt(argString, ii);
-    if (c === " " && !opening) {
-      if (!(prevC === " ")) {
-        i++;
-      }
-      continue;
-    }
-    if (c === opening) {
-      opening = null;
-    } else if ((c === "'" || c === '"') && !opening) {
-      opening = c;
-    }
-    if (!args[i])
-      args[i] = "";
-    args[i] += c;
-  }
-  return args;
+	if (_p_ArrayIsArray(argString)) return argString.map((e) => typeof e !== "string" ? e + "" : e);
+	argString = argString.trim();
+	let i = 0;
+	let prevC = null;
+	let c = null;
+	let opening = null;
+	const args = [];
+	for (let ii = 0; ii < argString.length; ii++) {
+		prevC = c;
+		c = _p_StringPrototypeCharAt(argString, ii);
+		if (c === " " && !opening) {
+			if (!(prevC === " ")) i++;
+			continue;
+		}
+		if (c === opening) opening = null;
+		else if ((c === "'" || c === "\"") && !opening) opening = c;
+		if (!args[i]) args[i] = "";
+		args[i] += c;
+	}
+	return args;
 }
-var init_tokenize_arg_string = __esm({
-  "node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/tokenize-arg-string.js"() {
-    __name(tokenizeArgString, "tokenizeArgString");
-  }
-});
+var init_tokenize_arg_string = __esmMin((() => {}));
 
-// node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/yargs-parser-types.js
+//#endregion
+//#region node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/yargs-parser-types.js
 var DefaultValuesForTypeKey;
-var init_yargs_parser_types = __esm({
-  "node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/yargs-parser-types.js"() {
-    (function(DefaultValuesForTypeKey2) {
-      DefaultValuesForTypeKey2["BOOLEAN"] = "boolean";
-      DefaultValuesForTypeKey2["STRING"] = "string";
-      DefaultValuesForTypeKey2["NUMBER"] = "number";
-      DefaultValuesForTypeKey2["ARRAY"] = "array";
-    })(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
-  }
-});
+var init_yargs_parser_types = __esmMin((() => {
+	;
+	/**
+	* @license
+	* Copyright (c) 2016, Contributors
+	* SPDX-License-Identifier: ISC
+	*/
+	(function(DefaultValuesForTypeKey) {
+		DefaultValuesForTypeKey["BOOLEAN"] = "boolean";
+		DefaultValuesForTypeKey["STRING"] = "string";
+		DefaultValuesForTypeKey["NUMBER"] = "number";
+		DefaultValuesForTypeKey["ARRAY"] = "array";
+	})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
+}));
 
-// node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/yargs-parser.js
+//#endregion
+//#region node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/yargs-parser.js
+/**
+* @license
+* Copyright (c) 2016, Contributors
+* SPDX-License-Identifier: ISC
+*/
 function combineAliases(aliases) {
-  const aliasArrays = [];
-  const combined = /* @__PURE__ */ _p_ObjectCreate(null);
-  let change = true;
-  _p_ObjectKeys(aliases).forEach(function(key) {
-    aliasArrays.push([].concat(aliases[key], key));
-  });
-  while (change) {
-    change = false;
-    for (let i = 0; i < aliasArrays.length; i++) {
-      for (let ii = i + 1; ii < aliasArrays.length; ii++) {
-        const intersect = aliasArrays[i].filter(function(v) {
-          return aliasArrays[ii].indexOf(v) !== -1;
-        });
-        if (intersect.length) {
-          aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
-          aliasArrays.splice(ii, 1);
-          change = true;
-          break;
-        }
-      }
-    }
-  }
-  aliasArrays.forEach(function(aliasArray) {
-    aliasArray = aliasArray.filter(function(v, i, self) {
-      return self.indexOf(v) === i;
-    });
-    const lastAlias = aliasArray.pop();
-    if (lastAlias !== void 0 && typeof lastAlias === "string") {
-      combined[lastAlias] = aliasArray;
-    }
-  });
-  return combined;
+	const aliasArrays = [];
+	const combined = _p_ObjectCreate(null);
+	let change = true;
+	_p_ObjectKeys(aliases).forEach(function(key) {
+		aliasArrays.push([].concat(aliases[key], key));
+	});
+	while (change) {
+		change = false;
+		for (let i = 0; i < aliasArrays.length; i++) for (let ii = i + 1; ii < aliasArrays.length; ii++) if (aliasArrays[i].filter(function(v) {
+			return aliasArrays[ii].indexOf(v) !== -1;
+		}).length) {
+			aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
+			aliasArrays.splice(ii, 1);
+			change = true;
+			break;
+		}
+	}
+	aliasArrays.forEach(function(aliasArray) {
+		aliasArray = aliasArray.filter(function(v, i, self) {
+			return self.indexOf(v) === i;
+		});
+		const lastAlias = aliasArray.pop();
+		if (lastAlias !== void 0 && typeof lastAlias === "string") combined[lastAlias] = aliasArray;
+	});
+	return combined;
 }
 function increment(orig) {
-  return orig !== void 0 ? orig + 1 : 1;
+	return orig !== void 0 ? orig + 1 : 1;
 }
 function sanitizeKey(key) {
-  if (key === "__proto__")
-    return "___proto___";
-  return key;
+	if (key === "__proto__") return "___proto___";
+	return key;
 }
 function stripQuotes(val) {
-  return typeof val === "string" && (val[0] === "'" || val[0] === '"') && val[val.length - 1] === val[0] ? val.substring(1, val.length - 1) : val;
+	return typeof val === "string" && (val[0] === "'" || val[0] === "\"") && val[val.length - 1] === val[0] ? val.substring(1, val.length - 1) : val;
 }
 var mixin, YargsParser;
-var init_yargs_parser = __esm({
-  "node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/yargs-parser.js"() {
-    init_tokenize_arg_string();
-    init_yargs_parser_types();
-    init_string_utils();
-    YargsParser = class {
-      static {
-        __name(this, "YargsParser");
-      }
-      constructor(_mixin) {
-        mixin = _mixin;
-      }
-      parse(argsInput, options) {
-        const opts = _p_ObjectAssign({
-          alias: void 0,
-          array: void 0,
-          boolean: void 0,
-          config: void 0,
-          configObjects: void 0,
-          configuration: void 0,
-          coerce: void 0,
-          count: void 0,
-          default: void 0,
-          envPrefix: void 0,
-          narg: void 0,
-          normalize: void 0,
-          string: void 0,
-          number: void 0,
-          __: void 0,
-          key: void 0
-        }, options);
-        const args = tokenizeArgString(argsInput);
-        const inputIsString = typeof argsInput === "string";
-        const aliases = combineAliases(_p_ObjectAssign(/* @__PURE__ */ _p_ObjectCreate(null), opts.alias));
-        const configuration = _p_ObjectAssign({
-          "boolean-negation": true,
-          "camel-case-expansion": true,
-          "combine-arrays": false,
-          "dot-notation": true,
-          "duplicate-arguments-array": true,
-          "flatten-duplicate-arrays": true,
-          "greedy-arrays": true,
-          "halt-at-non-option": false,
-          "nargs-eats-options": false,
-          "negation-prefix": "no-",
-          "parse-numbers": true,
-          "parse-positional-numbers": true,
-          "populate--": false,
-          "set-placeholder-key": false,
-          "short-option-groups": true,
-          "strip-aliased": false,
-          "strip-dashed": false,
-          "unknown-options-as-args": false
-        }, opts.configuration);
-        const defaults = _p_ObjectAssign(/* @__PURE__ */ _p_ObjectCreate(null), opts.default);
-        const configObjects = opts.configObjects || [];
-        const envPrefix = opts.envPrefix;
-        const notFlagsOption = configuration["populate--"];
-        const notFlagsArgv = notFlagsOption ? "--" : "_";
-        const newAliases = /* @__PURE__ */ _p_ObjectCreate(null);
-        const defaulted = /* @__PURE__ */ _p_ObjectCreate(null);
-        const __ = opts.__ || mixin.format;
-        const flags = {
-          aliases: /* @__PURE__ */ _p_ObjectCreate(null),
-          arrays: /* @__PURE__ */ _p_ObjectCreate(null),
-          bools: /* @__PURE__ */ _p_ObjectCreate(null),
-          strings: /* @__PURE__ */ _p_ObjectCreate(null),
-          numbers: /* @__PURE__ */ _p_ObjectCreate(null),
-          counts: /* @__PURE__ */ _p_ObjectCreate(null),
-          normalize: /* @__PURE__ */ _p_ObjectCreate(null),
-          configs: /* @__PURE__ */ _p_ObjectCreate(null),
-          nargs: /* @__PURE__ */ _p_ObjectCreate(null),
-          coercions: /* @__PURE__ */ _p_ObjectCreate(null),
-          keys: []
-        };
-        const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
-        const negatedBoolean = new _p_RegExpCtor("^--" + configuration["negation-prefix"] + "(.+)");
-        [].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
-          const key = typeof opt === "object" ? opt.key : opt;
-          const assignment = _p_ObjectKeys(opt).map(function(key2) {
-            const arrayFlagKeys = {
-              boolean: "bools",
-              string: "strings",
-              number: "numbers"
-            };
-            return arrayFlagKeys[key2];
-          }).filter(Boolean).pop();
-          if (assignment) {
-            flags[assignment][key] = true;
-          }
-          flags.arrays[key] = true;
-          flags.keys.push(key);
-        });
-        [].concat(opts.boolean || []).filter(Boolean).forEach(function(key) {
-          flags.bools[key] = true;
-          flags.keys.push(key);
-        });
-        [].concat(opts.string || []).filter(Boolean).forEach(function(key) {
-          flags.strings[key] = true;
-          flags.keys.push(key);
-        });
-        [].concat(opts.number || []).filter(Boolean).forEach(function(key) {
-          flags.numbers[key] = true;
-          flags.keys.push(key);
-        });
-        [].concat(opts.count || []).filter(Boolean).forEach(function(key) {
-          flags.counts[key] = true;
-          flags.keys.push(key);
-        });
-        [].concat(opts.normalize || []).filter(Boolean).forEach(function(key) {
-          flags.normalize[key] = true;
-          flags.keys.push(key);
-        });
-        if (typeof opts.narg === "object") {
-          _p_ObjectEntries(opts.narg).forEach(([key, value]) => {
-            if (typeof value === "number") {
-              flags.nargs[key] = value;
-              flags.keys.push(key);
-            }
-          });
-        }
-        if (typeof opts.coerce === "object") {
-          _p_ObjectEntries(opts.coerce).forEach(([key, value]) => {
-            if (typeof value === "function") {
-              flags.coercions[key] = value;
-              flags.keys.push(key);
-            }
-          });
-        }
-        if (typeof opts.config !== "undefined") {
-          if (_p_ArrayIsArray(opts.config) || typeof opts.config === "string") {
-            ;
-            [].concat(opts.config).filter(Boolean).forEach(function(key) {
-              flags.configs[key] = true;
-            });
-          } else if (typeof opts.config === "object") {
-            _p_ObjectEntries(opts.config).forEach(([key, value]) => {
-              if (typeof value === "boolean" || typeof value === "function") {
-                flags.configs[key] = value;
-              }
-            });
-          }
-        }
-        extendAliases(opts.key, aliases, opts.default, flags.arrays);
-        _p_ObjectKeys(defaults).forEach(function(key) {
-          (flags.aliases[key] || []).forEach(function(alias) {
-            defaults[alias] = defaults[key];
-          });
-        });
-        let error = null;
-        checkConfiguration();
-        let notFlags = [];
-        const argv = _p_ObjectAssign(/* @__PURE__ */ _p_ObjectCreate(null), { _: [] });
-        const argvReturn = {};
-        for (let i = 0; i < args.length; i++) {
-          const arg = args[i];
-          const truncatedArg = arg.replace(/^-{3,}/, "---");
-          let broken;
-          let key;
-          let letters;
-          let m;
-          let next;
-          let value;
-          if (arg !== "--" && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {
-            pushPositional(arg);
-          } else if (truncatedArg.match(/^---+(=|$)/)) {
-            pushPositional(arg);
-            continue;
-          } else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
-            m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
-            if (m !== null && _p_ArrayIsArray(m) && m.length >= 3) {
-              if (checkAllAliases(m[1], flags.arrays)) {
-                i = eatArray(i, m[1], args, m[2]);
-              } else if (checkAllAliases(m[1], flags.nargs) !== false) {
-                i = eatNargs(i, m[1], args, m[2]);
-              } else {
-                setArg(m[1], m[2], true);
-              }
-            }
-          } else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
-            m = arg.match(negatedBoolean);
-            if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
-              key = m[1];
-              setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
-            }
-          } else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
-            m = arg.match(/^--?(.+)/);
-            if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
-              key = m[1];
-              if (checkAllAliases(key, flags.arrays)) {
-                i = eatArray(i, key, args);
-              } else if (checkAllAliases(key, flags.nargs) !== false) {
-                i = eatNargs(i, key, args);
-              } else {
-                next = args[i + 1];
-                if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
-                  setArg(key, next);
-                  i++;
-                } else if (/^(true|false)$/.test(next)) {
-                  setArg(key, next);
-                  i++;
-                } else {
-                  setArg(key, defaultValue(key));
-                }
-              }
-            }
-          } else if (arg.match(/^-.\..+=/)) {
-            m = arg.match(/^-([^=]+)=([\s\S]*)$/);
-            if (m !== null && _p_ArrayIsArray(m) && m.length >= 3) {
-              setArg(m[1], m[2]);
-            }
-          } else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
-            next = args[i + 1];
-            m = arg.match(/^-(.\..+)/);
-            if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
-              key = m[1];
-              if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
-                setArg(key, next);
-                i++;
-              } else {
-                setArg(key, defaultValue(key));
-              }
-            }
-          } else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
-            letters = arg.slice(1, -1).split("");
-            broken = false;
-            for (let j = 0; j < letters.length; j++) {
-              next = arg.slice(j + 2);
-              if (letters[j + 1] && letters[j + 1] === "=") {
-                value = arg.slice(j + 3);
-                key = letters[j];
-                if (checkAllAliases(key, flags.arrays)) {
-                  i = eatArray(i, key, args, value);
-                } else if (checkAllAliases(key, flags.nargs) !== false) {
-                  i = eatNargs(i, key, args, value);
-                } else {
-                  setArg(key, value);
-                }
-                broken = true;
-                break;
-              }
-              if (next === "-") {
-                setArg(letters[j], next);
-                continue;
-              }
-              if (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags.bools) === false) {
-                setArg(letters[j], next);
-                broken = true;
-                break;
-              }
-              if (letters[j + 1] && letters[j + 1].match(/\W/)) {
-                setArg(letters[j], next);
-                broken = true;
-                break;
-              } else {
-                setArg(letters[j], defaultValue(letters[j]));
-              }
-            }
-            key = arg.slice(-1)[0];
-            if (!broken && key !== "-") {
-              if (checkAllAliases(key, flags.arrays)) {
-                i = eatArray(i, key, args);
-              } else if (checkAllAliases(key, flags.nargs) !== false) {
-                i = eatNargs(i, key, args);
-              } else {
-                next = args[i + 1];
-                if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
-                  setArg(key, next);
-                  i++;
-                } else if (/^(true|false)$/.test(next)) {
-                  setArg(key, next);
-                  i++;
-                } else {
-                  setArg(key, defaultValue(key));
-                }
-              }
-            }
-          } else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
-            key = arg.slice(1);
-            setArg(key, defaultValue(key));
-          } else if (arg === "--") {
-            notFlags = args.slice(i + 1);
-            break;
-          } else if (configuration["halt-at-non-option"]) {
-            notFlags = args.slice(i);
-            break;
-          } else {
-            pushPositional(arg);
-          }
-        }
-        applyEnvVars(argv, true);
-        applyEnvVars(argv, false);
-        setConfig(argv);
-        setConfigObjects();
-        applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
-        applyCoercions(argv);
-        if (configuration["set-placeholder-key"])
-          setPlaceholderKeys(argv);
-        _p_ObjectKeys(flags.counts).forEach(function(key) {
-          if (!hasKey(argv, key.split(".")))
-            setArg(key, 0);
-        });
-        if (notFlagsOption && notFlags.length)
-          argv[notFlagsArgv] = [];
-        notFlags.forEach(function(key) {
-          argv[notFlagsArgv].push(key);
-        });
-        if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) {
-          _p_ObjectKeys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
-            delete argv[key];
-          });
-        }
-        if (configuration["strip-aliased"]) {
-          ;
-          [].concat(..._p_ObjectKeys(aliases).map((k) => aliases[k])).forEach((alias) => {
-            if (configuration["camel-case-expansion"] && alias.includes("-")) {
-              delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
-            }
-            delete argv[alias];
-          });
-        }
-        function pushPositional(arg) {
-          const maybeCoercedNumber = maybeCoerceNumber("_", arg);
-          if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") {
-            argv._.push(maybeCoercedNumber);
-          }
-        }
-        __name(pushPositional, "pushPositional");
-        function eatNargs(i, key, args2, argAfterEqualSign) {
-          let ii;
-          let toEat = checkAllAliases(key, flags.nargs);
-          toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
-          if (toEat === 0) {
-            if (!isUndefined(argAfterEqualSign)) {
-              error = Error(__("Argument unexpected for: %s", key));
-            }
-            setArg(key, defaultValue(key));
-            return i;
-          }
-          let available = isUndefined(argAfterEqualSign) ? 0 : 1;
-          if (configuration["nargs-eats-options"]) {
-            if (args2.length - (i + 1) + available < toEat) {
-              error = Error(__("Not enough arguments following: %s", key));
-            }
-            available = toEat;
-          } else {
-            for (ii = i + 1; ii < args2.length; ii++) {
-              if (!args2[ii].match(/^-[^0-9]/) || args2[ii].match(negative) || isUnknownOptionAsArg(args2[ii]))
-                available++;
-              else
-                break;
-            }
-            if (available < toEat)
-              error = Error(__("Not enough arguments following: %s", key));
-          }
-          let consumed = _p_MathMin(available, toEat);
-          if (!isUndefined(argAfterEqualSign) && consumed > 0) {
-            setArg(key, argAfterEqualSign);
-            consumed--;
-          }
-          for (ii = i + 1; ii < consumed + i + 1; ii++) {
-            setArg(key, args2[ii]);
-          }
-          return i + consumed;
-        }
-        __name(eatNargs, "eatNargs");
-        function eatArray(i, key, args2, argAfterEqualSign) {
-          let argsToSet = [];
-          let next = argAfterEqualSign || args2[i + 1];
-          const nargsCount = checkAllAliases(key, flags.nargs);
-          if (checkAllAliases(key, flags.bools) && !/^(true|false)$/.test(next)) {
-            argsToSet.push(true);
-          } else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
-            if (defaults[key] !== void 0) {
-              const defVal = defaults[key];
-              argsToSet = _p_ArrayIsArray(defVal) ? defVal : [defVal];
-            }
-          } else {
-            if (!isUndefined(argAfterEqualSign)) {
-              argsToSet.push(processValue(key, argAfterEqualSign, true));
-            }
-            for (let ii = i + 1; ii < args2.length; ii++) {
-              if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount)
-                break;
-              next = args2[ii];
-              if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
-                break;
-              i = ii;
-              argsToSet.push(processValue(key, next, inputIsString));
-            }
-          }
-          if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) {
-            error = Error(__("Not enough arguments following: %s", key));
-          }
-          setArg(key, argsToSet);
-          return i;
-        }
-        __name(eatArray, "eatArray");
-        function setArg(key, val, shouldStripQuotes = inputIsString) {
-          if (/-/.test(key) && configuration["camel-case-expansion"]) {
-            const alias = key.split(".").map(function(prop) {
-              return camelCase(prop);
-            }).join(".");
-            addNewAlias(key, alias);
-          }
-          const value = processValue(key, val, shouldStripQuotes);
-          const splitKey = key.split(".");
-          setKey(argv, splitKey, value);
-          if (flags.aliases[key]) {
-            flags.aliases[key].forEach(function(x) {
-              const keyProperties = x.split(".");
-              setKey(argv, keyProperties, value);
-            });
-          }
-          if (splitKey.length > 1 && configuration["dot-notation"]) {
-            ;
-            (flags.aliases[splitKey[0]] || []).forEach(function(x) {
-              let keyProperties = x.split(".");
-              const a = [].concat(splitKey);
-              a.shift();
-              keyProperties = keyProperties.concat(a);
-              if (!(flags.aliases[key] || []).includes(keyProperties.join("."))) {
-                setKey(argv, keyProperties, value);
-              }
-            });
-          }
-          if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
-            const keys = [key].concat(flags.aliases[key] || []);
-            keys.forEach(function(key2) {
-              _p_ObjectDefineProperty(argvReturn, key2, {
-                enumerable: true,
-                get() {
-                  return val;
-                },
-                set(value2) {
-                  val = typeof value2 === "string" ? mixin.normalize(value2) : value2;
-                }
-              });
-            });
-          }
-        }
-        __name(setArg, "setArg");
-        function addNewAlias(key, alias) {
-          if (!(flags.aliases[key] && flags.aliases[key].length)) {
-            flags.aliases[key] = [alias];
-            newAliases[alias] = true;
-          }
-          if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
-            addNewAlias(alias, key);
-          }
-        }
-        __name(addNewAlias, "addNewAlias");
-        function processValue(key, val, shouldStripQuotes) {
-          if (shouldStripQuotes) {
-            val = stripQuotes(val);
-          }
-          if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
-            if (typeof val === "string")
-              val = val === "true";
-          }
-          let value = _p_ArrayIsArray(val) ? val.map(function(v) {
-            return maybeCoerceNumber(key, v);
-          }) : maybeCoerceNumber(key, val);
-          if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) {
-            value = increment();
-          }
-          if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
-            if (_p_ArrayIsArray(val))
-              value = val.map((val2) => {
-                return mixin.normalize(val2);
-              });
-            else
-              value = mixin.normalize(val);
-          }
-          return value;
-        }
-        __name(processValue, "processValue");
-        function maybeCoerceNumber(key, value) {
-          if (!configuration["parse-positional-numbers"] && key === "_")
-            return value;
-          if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !_p_ArrayIsArray(value)) {
-            const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && _p_NumberIsSafeInteger(_p_MathFloor(parseFloat(`${value}`)));
-            if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags.numbers)) {
-              value = Number(value);
-            }
-          }
-          return value;
-        }
-        __name(maybeCoerceNumber, "maybeCoerceNumber");
-        function setConfig(argv2) {
-          const configLookup = /* @__PURE__ */ _p_ObjectCreate(null);
-          applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
-          _p_ObjectKeys(flags.configs).forEach(function(configKey) {
-            const configPath = argv2[configKey] || configLookup[configKey];
-            if (configPath) {
-              try {
-                let config = null;
-                const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
-                const resolveConfig = flags.configs[configKey];
-                if (typeof resolveConfig === "function") {
-                  try {
-                    config = resolveConfig(resolvedConfigPath);
-                  } catch (e) {
-                    config = e;
-                  }
-                  if (config instanceof Error) {
-                    error = config;
-                    return;
-                  }
-                } else {
-                  config = mixin.require(resolvedConfigPath);
-                }
-                setConfigObject(config);
-              } catch (ex) {
-                if (ex.name === "PermissionDenied")
-                  error = ex;
-                else if (argv2[configKey])
-                  error = Error(__("Invalid JSON config file: %s", configPath));
-              }
-            }
-          });
-        }
-        __name(setConfig, "setConfig");
-        function setConfigObject(config, prev) {
-          _p_ObjectKeys(config).forEach(function(key) {
-            const value = config[key];
-            const fullKey = prev ? prev + "." + key : key;
-            if (typeof value === "object" && value !== null && !_p_ArrayIsArray(value) && configuration["dot-notation"]) {
-              setConfigObject(value, fullKey);
-            } else {
-              if (!hasKey(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) {
-                setArg(fullKey, value);
-              }
-            }
-          });
-        }
-        __name(setConfigObject, "setConfigObject");
-        function setConfigObjects() {
-          if (typeof configObjects !== "undefined") {
-            configObjects.forEach(function(configObject) {
-              setConfigObject(configObject);
-            });
-          }
-        }
-        __name(setConfigObjects, "setConfigObjects");
-        function applyEnvVars(argv2, configOnly) {
-          if (typeof envPrefix === "undefined")
-            return;
-          const prefix = typeof envPrefix === "string" ? envPrefix : "";
-          const env2 = mixin.env();
-          _p_ObjectKeys(env2).forEach(function(envVar) {
-            if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
-              const keys = envVar.split("__").map(function(key, i) {
-                if (i === 0) {
-                  key = _p_StringPrototypeSubstring(key, prefix.length);
-                }
-                return camelCase(key);
-              });
-              if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey(argv2, keys)) {
-                setArg(keys.join("."), env2[envVar]);
-              }
-            }
-          });
-        }
-        __name(applyEnvVars, "applyEnvVars");
-        function applyCoercions(argv2) {
-          let coerce;
-          const applied = /* @__PURE__ */ new _p_SetCtor();
-          _p_ObjectKeys(argv2).forEach(function(key) {
-            if (!applied.has(key)) {
-              coerce = checkAllAliases(key, flags.coercions);
-              if (typeof coerce === "function") {
-                try {
-                  const value = maybeCoerceNumber(key, coerce(argv2[key]));
-                  [].concat(flags.aliases[key] || [], key).forEach((ali) => {
-                    applied.add(ali);
-                    argv2[ali] = value;
-                  });
-                } catch (err) {
-                  error = err;
-                }
-              }
-            }
-          });
-        }
-        __name(applyCoercions, "applyCoercions");
-        function setPlaceholderKeys(argv2) {
-          flags.keys.forEach((key) => {
-            if (~key.indexOf("."))
-              return;
-            if (typeof argv2[key] === "undefined")
-              argv2[key] = void 0;
-          });
-          return argv2;
-        }
-        __name(setPlaceholderKeys, "setPlaceholderKeys");
-        function applyDefaultsAndAliases(obj, aliases2, defaults2, canLog = false) {
-          _p_ObjectKeys(defaults2).forEach(function(key) {
-            if (!hasKey(obj, key.split("."))) {
-              setKey(obj, key.split("."), defaults2[key]);
-              if (canLog)
-                defaulted[key] = true;
-              (aliases2[key] || []).forEach(function(x) {
-                if (hasKey(obj, x.split(".")))
-                  return;
-                setKey(obj, x.split("."), defaults2[key]);
-              });
-            }
-          });
-        }
-        __name(applyDefaultsAndAliases, "applyDefaultsAndAliases");
-        function hasKey(obj, keys) {
-          let o = obj;
-          if (!configuration["dot-notation"])
-            keys = [keys.join(".")];
-          keys.slice(0, -1).forEach(function(key2) {
-            o = o[key2] || {};
-          });
-          const key = keys[keys.length - 1];
-          if (typeof o !== "object")
-            return false;
-          else
-            return key in o;
-        }
-        __name(hasKey, "hasKey");
-        function setKey(obj, keys, value) {
-          let o = obj;
-          if (!configuration["dot-notation"])
-            keys = [keys.join(".")];
-          keys.slice(0, -1).forEach(function(key2) {
-            key2 = sanitizeKey(key2);
-            if (typeof o === "object" && o[key2] === void 0) {
-              o[key2] = {};
-            }
-            if (typeof o[key2] !== "object" || _p_ArrayIsArray(o[key2])) {
-              if (_p_ArrayIsArray(o[key2])) {
-                o[key2].push({});
-              } else {
-                o[key2] = [o[key2], {}];
-              }
-              o = o[key2][o[key2].length - 1];
-            } else {
-              o = o[key2];
-            }
-          });
-          const key = sanitizeKey(keys[keys.length - 1]);
-          const isTypeArray = checkAllAliases(keys.join("."), flags.arrays);
-          const isValueArray = _p_ArrayIsArray(value);
-          let duplicate = configuration["duplicate-arguments-array"];
-          if (!duplicate && checkAllAliases(key, flags.nargs)) {
-            duplicate = true;
-            if (!isUndefined(o[key]) && flags.nargs[key] === 1 || _p_ArrayIsArray(o[key]) && o[key].length === flags.nargs[key]) {
-              o[key] = void 0;
-            }
-          }
-          if (value === increment()) {
-            o[key] = increment(o[key]);
-          } else if (_p_ArrayIsArray(o[key])) {
-            if (duplicate && isTypeArray && isValueArray) {
-              o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (_p_ArrayIsArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
-            } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
-              o[key] = value;
-            } else {
-              o[key] = o[key].concat([value]);
-            }
-          } else if (o[key] === void 0 && isTypeArray) {
-            o[key] = isValueArray ? value : [value];
-          } else if (duplicate && !(o[key] === void 0 || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) {
-            o[key] = [o[key], value];
-          } else {
-            o[key] = value;
-          }
-        }
-        __name(setKey, "setKey");
-        function extendAliases(...args2) {
-          args2.forEach(function(obj) {
-            _p_ObjectKeys(obj || {}).forEach(function(key) {
-              if (flags.aliases[key])
-                return;
-              flags.aliases[key] = [].concat(aliases[key] || []);
-              flags.aliases[key].concat(key).forEach(function(x) {
-                if (/-/.test(x) && configuration["camel-case-expansion"]) {
-                  const c = camelCase(x);
-                  if (c !== key && flags.aliases[key].indexOf(c) === -1) {
-                    flags.aliases[key].push(c);
-                    newAliases[c] = true;
-                  }
-                }
-              });
-              flags.aliases[key].concat(key).forEach(function(x) {
-                if (x.length > 1 && /[A-Z]/.test(x) && configuration["camel-case-expansion"]) {
-                  const c = decamelize(x, "-");
-                  if (c !== key && flags.aliases[key].indexOf(c) === -1) {
-                    flags.aliases[key].push(c);
-                    newAliases[c] = true;
-                  }
-                }
-              });
-              flags.aliases[key].forEach(function(x) {
-                flags.aliases[x] = [key].concat(flags.aliases[key].filter(function(y) {
-                  return x !== y;
-                }));
-              });
-            });
-          });
-        }
-        __name(extendAliases, "extendAliases");
-        function checkAllAliases(key, flag) {
-          const toCheck = [].concat(flags.aliases[key] || [], key);
-          const keys = _p_ObjectKeys(flag);
-          const setAlias = toCheck.find((key2) => keys.includes(key2));
-          return setAlias ? flag[setAlias] : false;
-        }
-        __name(checkAllAliases, "checkAllAliases");
-        function hasAnyFlag(key) {
-          const flagsKeys = _p_ObjectKeys(flags);
-          const toCheck = [].concat(flagsKeys.map((k) => flags[k]));
-          return toCheck.some(function(flag) {
-            return _p_ArrayIsArray(flag) ? flag.includes(key) : flag[key];
-          });
-        }
-        __name(hasAnyFlag, "hasAnyFlag");
-        function hasFlagsMatching(arg, ...patterns) {
-          const toCheck = [].concat(...patterns);
-          return toCheck.some(function(pattern) {
-            const match = arg.match(pattern);
-            return match && hasAnyFlag(match[1]);
-          });
-        }
-        __name(hasFlagsMatching, "hasFlagsMatching");
-        function hasAllShortFlags(arg) {
-          if (arg.match(negative) || !arg.match(/^-[^-]+/)) {
-            return false;
-          }
-          let hasAllFlags = true;
-          let next;
-          const letters = arg.slice(1).split("");
-          for (let j = 0; j < letters.length; j++) {
-            next = arg.slice(j + 2);
-            if (!hasAnyFlag(letters[j])) {
-              hasAllFlags = false;
-              break;
-            }
-            if (letters[j + 1] && letters[j + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j + 1] && letters[j + 1].match(/\W/)) {
-              break;
-            }
-          }
-          return hasAllFlags;
-        }
-        __name(hasAllShortFlags, "hasAllShortFlags");
-        function isUnknownOptionAsArg(arg) {
-          return configuration["unknown-options-as-args"] && isUnknownOption(arg);
-        }
-        __name(isUnknownOptionAsArg, "isUnknownOptionAsArg");
-        function isUnknownOption(arg) {
-          arg = arg.replace(/^-{3,}/, "--");
-          if (arg.match(negative)) {
-            return false;
-          }
-          if (hasAllShortFlags(arg)) {
-            return false;
-          }
-          const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/;
-          const normalFlag = /^-+([^=]+?)$/;
-          const flagEndingInHyphen = /^-+([^=]+?)-$/;
-          const flagEndingInDigits = /^-+([^=]+?\d+)$/;
-          const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/;
-          return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);
-        }
-        __name(isUnknownOption, "isUnknownOption");
-        function defaultValue(key) {
-          if (!checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts) && `${key}` in defaults) {
-            return defaults[key];
-          } else {
-            return defaultForType(guessType(key));
-          }
-        }
-        __name(defaultValue, "defaultValue");
-        function defaultForType(type) {
-          const def = {
-            [DefaultValuesForTypeKey.BOOLEAN]: true,
-            [DefaultValuesForTypeKey.STRING]: "",
-            [DefaultValuesForTypeKey.NUMBER]: void 0,
-            [DefaultValuesForTypeKey.ARRAY]: []
-          };
-          return def[type];
-        }
-        __name(defaultForType, "defaultForType");
-        function guessType(key) {
-          let type = DefaultValuesForTypeKey.BOOLEAN;
-          if (checkAllAliases(key, flags.strings))
-            type = DefaultValuesForTypeKey.STRING;
-          else if (checkAllAliases(key, flags.numbers))
-            type = DefaultValuesForTypeKey.NUMBER;
-          else if (checkAllAliases(key, flags.bools))
-            type = DefaultValuesForTypeKey.BOOLEAN;
-          else if (checkAllAliases(key, flags.arrays))
-            type = DefaultValuesForTypeKey.ARRAY;
-          return type;
-        }
-        __name(guessType, "guessType");
-        function isUndefined(num) {
-          return num === void 0;
-        }
-        __name(isUndefined, "isUndefined");
-        function checkConfiguration() {
-          _p_ObjectKeys(flags.counts).find((key) => {
-            if (checkAllAliases(key, flags.arrays)) {
-              error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
-              return true;
-            } else if (checkAllAliases(key, flags.nargs)) {
-              error = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
-              return true;
-            }
-            return false;
-          });
-        }
-        __name(checkConfiguration, "checkConfiguration");
-        return {
-          aliases: _p_ObjectAssign({}, flags.aliases),
-          argv: _p_ObjectAssign(argvReturn, argv),
-          configuration,
-          defaulted: _p_ObjectAssign({}, defaulted),
-          error,
-          newAliases: _p_ObjectAssign({}, newAliases)
-        };
-      }
-    };
-    __name(combineAliases, "combineAliases");
-    __name(increment, "increment");
-    __name(sanitizeKey, "sanitizeKey");
-    __name(stripQuotes, "stripQuotes");
-  }
-});
+var init_yargs_parser = __esmMin((() => {
+	init_tokenize_arg_string();
+	init_yargs_parser_types();
+	init_string_utils();
+	;
+	YargsParser = class {
+		constructor(_mixin) {
+			mixin = _mixin;
+		}
+		parse(argsInput, options) {
+			const opts = _p_ObjectAssign({
+				alias: void 0,
+				array: void 0,
+				boolean: void 0,
+				config: void 0,
+				configObjects: void 0,
+				configuration: void 0,
+				coerce: void 0,
+				count: void 0,
+				default: void 0,
+				envPrefix: void 0,
+				narg: void 0,
+				normalize: void 0,
+				string: void 0,
+				number: void 0,
+				__: void 0,
+				key: void 0
+			}, options);
+			const args = tokenizeArgString(argsInput);
+			const inputIsString = typeof argsInput === "string";
+			const aliases = combineAliases(_p_ObjectAssign(_p_ObjectCreate(null), opts.alias));
+			const configuration = _p_ObjectAssign({
+				"boolean-negation": true,
+				"camel-case-expansion": true,
+				"combine-arrays": false,
+				"dot-notation": true,
+				"duplicate-arguments-array": true,
+				"flatten-duplicate-arrays": true,
+				"greedy-arrays": true,
+				"halt-at-non-option": false,
+				"nargs-eats-options": false,
+				"negation-prefix": "no-",
+				"parse-numbers": true,
+				"parse-positional-numbers": true,
+				"populate--": false,
+				"set-placeholder-key": false,
+				"short-option-groups": true,
+				"strip-aliased": false,
+				"strip-dashed": false,
+				"unknown-options-as-args": false
+			}, opts.configuration);
+			const defaults = _p_ObjectAssign(_p_ObjectCreate(null), opts.default);
+			const configObjects = opts.configObjects || [];
+			const envPrefix = opts.envPrefix;
+			const notFlagsOption = configuration["populate--"];
+			const notFlagsArgv = notFlagsOption ? "--" : "_";
+			const newAliases = _p_ObjectCreate(null);
+			const defaulted = _p_ObjectCreate(null);
+			const __ = opts.__ || mixin.format;
+			const flags = {
+				aliases: _p_ObjectCreate(null),
+				arrays: _p_ObjectCreate(null),
+				bools: _p_ObjectCreate(null),
+				strings: _p_ObjectCreate(null),
+				numbers: _p_ObjectCreate(null),
+				counts: _p_ObjectCreate(null),
+				normalize: _p_ObjectCreate(null),
+				configs: _p_ObjectCreate(null),
+				nargs: _p_ObjectCreate(null),
+				coercions: _p_ObjectCreate(null),
+				keys: []
+			};
+			const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
+			const negatedBoolean = new _p_RegExpCtor("^--" + configuration["negation-prefix"] + "(.+)");
+			[].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
+				const key = typeof opt === "object" ? opt.key : opt;
+				const assignment = _p_ObjectKeys(opt).map(function(key) {
+					return {
+						boolean: "bools",
+						string: "strings",
+						number: "numbers"
+					}[key];
+				}).filter(Boolean).pop();
+				if (assignment) flags[assignment][key] = true;
+				flags.arrays[key] = true;
+				flags.keys.push(key);
+			});
+			[].concat(opts.boolean || []).filter(Boolean).forEach(function(key) {
+				flags.bools[key] = true;
+				flags.keys.push(key);
+			});
+			[].concat(opts.string || []).filter(Boolean).forEach(function(key) {
+				flags.strings[key] = true;
+				flags.keys.push(key);
+			});
+			[].concat(opts.number || []).filter(Boolean).forEach(function(key) {
+				flags.numbers[key] = true;
+				flags.keys.push(key);
+			});
+			[].concat(opts.count || []).filter(Boolean).forEach(function(key) {
+				flags.counts[key] = true;
+				flags.keys.push(key);
+			});
+			[].concat(opts.normalize || []).filter(Boolean).forEach(function(key) {
+				flags.normalize[key] = true;
+				flags.keys.push(key);
+			});
+			if (typeof opts.narg === "object") _p_ObjectEntries(opts.narg).forEach(([key, value]) => {
+				if (typeof value === "number") {
+					flags.nargs[key] = value;
+					flags.keys.push(key);
+				}
+			});
+			if (typeof opts.coerce === "object") _p_ObjectEntries(opts.coerce).forEach(([key, value]) => {
+				if (typeof value === "function") {
+					flags.coercions[key] = value;
+					flags.keys.push(key);
+				}
+			});
+			if (typeof opts.config !== "undefined") {
+				if (_p_ArrayIsArray(opts.config) || typeof opts.config === "string") [].concat(opts.config).filter(Boolean).forEach(function(key) {
+					flags.configs[key] = true;
+				});
+				else if (typeof opts.config === "object") _p_ObjectEntries(opts.config).forEach(([key, value]) => {
+					if (typeof value === "boolean" || typeof value === "function") flags.configs[key] = value;
+				});
+			}
+			extendAliases(opts.key, aliases, opts.default, flags.arrays);
+			_p_ObjectKeys(defaults).forEach(function(key) {
+				(flags.aliases[key] || []).forEach(function(alias) {
+					defaults[alias] = defaults[key];
+				});
+			});
+			let error = null;
+			checkConfiguration();
+			let notFlags = [];
+			const argv = _p_ObjectAssign(_p_ObjectCreate(null), { _: [] });
+			const argvReturn = {};
+			for (let i = 0; i < args.length; i++) {
+				const arg = args[i];
+				const truncatedArg = arg.replace(/^-{3,}/, "---");
+				let broken;
+				let key;
+				let letters;
+				let m;
+				let next;
+				let value;
+				if (arg !== "--" && /^-/.test(arg) && isUnknownOptionAsArg(arg)) pushPositional(arg);
+				else if (truncatedArg.match(/^---+(=|$)/)) {
+					pushPositional(arg);
+					continue;
+				} else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
+					m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
+					if (m !== null && _p_ArrayIsArray(m) && m.length >= 3) if (checkAllAliases(m[1], flags.arrays)) i = eatArray(i, m[1], args, m[2]);
+					else if (checkAllAliases(m[1], flags.nargs) !== false) i = eatNargs(i, m[1], args, m[2]);
+					else setArg(m[1], m[2], true);
+				} else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
+					m = arg.match(negatedBoolean);
+					if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
+						key = m[1];
+						setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
+					}
+				} else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
+					m = arg.match(/^--?(.+)/);
+					if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
+						key = m[1];
+						if (checkAllAliases(key, flags.arrays)) i = eatArray(i, key, args);
+						else if (checkAllAliases(key, flags.nargs) !== false) i = eatNargs(i, key, args);
+						else {
+							next = args[i + 1];
+							if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
+								setArg(key, next);
+								i++;
+							} else if (/^(true|false)$/.test(next)) {
+								setArg(key, next);
+								i++;
+							} else setArg(key, defaultValue(key));
+						}
+					}
+				} else if (arg.match(/^-.\..+=/)) {
+					m = arg.match(/^-([^=]+)=([\s\S]*)$/);
+					if (m !== null && _p_ArrayIsArray(m) && m.length >= 3) setArg(m[1], m[2]);
+				} else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
+					next = args[i + 1];
+					m = arg.match(/^-(.\..+)/);
+					if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
+						key = m[1];
+						if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
+							setArg(key, next);
+							i++;
+						} else setArg(key, defaultValue(key));
+					}
+				} else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
+					letters = arg.slice(1, -1).split("");
+					broken = false;
+					for (let j = 0; j < letters.length; j++) {
+						next = arg.slice(j + 2);
+						if (letters[j + 1] && letters[j + 1] === "=") {
+							value = arg.slice(j + 3);
+							key = letters[j];
+							if (checkAllAliases(key, flags.arrays)) i = eatArray(i, key, args, value);
+							else if (checkAllAliases(key, flags.nargs) !== false) i = eatNargs(i, key, args, value);
+							else setArg(key, value);
+							broken = true;
+							break;
+						}
+						if (next === "-") {
+							setArg(letters[j], next);
+							continue;
+						}
+						if (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags.bools) === false) {
+							setArg(letters[j], next);
+							broken = true;
+							break;
+						}
+						if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+							setArg(letters[j], next);
+							broken = true;
+							break;
+						} else setArg(letters[j], defaultValue(letters[j]));
+					}
+					key = arg.slice(-1)[0];
+					if (!broken && key !== "-") if (checkAllAliases(key, flags.arrays)) i = eatArray(i, key, args);
+					else if (checkAllAliases(key, flags.nargs) !== false) i = eatNargs(i, key, args);
+					else {
+						next = args[i + 1];
+						if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
+							setArg(key, next);
+							i++;
+						} else if (/^(true|false)$/.test(next)) {
+							setArg(key, next);
+							i++;
+						} else setArg(key, defaultValue(key));
+					}
+				} else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
+					key = arg.slice(1);
+					setArg(key, defaultValue(key));
+				} else if (arg === "--") {
+					notFlags = args.slice(i + 1);
+					break;
+				} else if (configuration["halt-at-non-option"]) {
+					notFlags = args.slice(i);
+					break;
+				} else pushPositional(arg);
+			}
+			applyEnvVars(argv, true);
+			applyEnvVars(argv, false);
+			setConfig(argv);
+			setConfigObjects();
+			applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
+			applyCoercions(argv);
+			if (configuration["set-placeholder-key"]) setPlaceholderKeys(argv);
+			_p_ObjectKeys(flags.counts).forEach(function(key) {
+				if (!hasKey(argv, key.split("."))) setArg(key, 0);
+			});
+			if (notFlagsOption && notFlags.length) argv[notFlagsArgv] = [];
+			notFlags.forEach(function(key) {
+				argv[notFlagsArgv].push(key);
+			});
+			if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) _p_ObjectKeys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
+				delete argv[key];
+			});
+			if (configuration["strip-aliased"]) [].concat(..._p_ObjectKeys(aliases).map((k) => aliases[k])).forEach((alias) => {
+				if (configuration["camel-case-expansion"] && alias.includes("-")) delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
+				delete argv[alias];
+			});
+			function pushPositional(arg) {
+				const maybeCoercedNumber = maybeCoerceNumber("_", arg);
+				if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") argv._.push(maybeCoercedNumber);
+			}
+			function eatNargs(i, key, args, argAfterEqualSign) {
+				let ii;
+				let toEat = checkAllAliases(key, flags.nargs);
+				toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
+				if (toEat === 0) {
+					if (!isUndefined(argAfterEqualSign)) error = Error(__("Argument unexpected for: %s", key));
+					setArg(key, defaultValue(key));
+					return i;
+				}
+				let available = isUndefined(argAfterEqualSign) ? 0 : 1;
+				if (configuration["nargs-eats-options"]) {
+					if (args.length - (i + 1) + available < toEat) error = Error(__("Not enough arguments following: %s", key));
+					available = toEat;
+				} else {
+					for (ii = i + 1; ii < args.length; ii++) if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii])) available++;
+					else break;
+					if (available < toEat) error = Error(__("Not enough arguments following: %s", key));
+				}
+				let consumed = _p_MathMin(available, toEat);
+				if (!isUndefined(argAfterEqualSign) && consumed > 0) {
+					setArg(key, argAfterEqualSign);
+					consumed--;
+				}
+				for (ii = i + 1; ii < consumed + i + 1; ii++) setArg(key, args[ii]);
+				return i + consumed;
+			}
+			function eatArray(i, key, args, argAfterEqualSign) {
+				let argsToSet = [];
+				let next = argAfterEqualSign || args[i + 1];
+				const nargsCount = checkAllAliases(key, flags.nargs);
+				if (checkAllAliases(key, flags.bools) && !/^(true|false)$/.test(next)) argsToSet.push(true);
+				else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
+					if (defaults[key] !== void 0) {
+						const defVal = defaults[key];
+						argsToSet = _p_ArrayIsArray(defVal) ? defVal : [defVal];
+					}
+				} else {
+					if (!isUndefined(argAfterEqualSign)) argsToSet.push(processValue(key, argAfterEqualSign, true));
+					for (let ii = i + 1; ii < args.length; ii++) {
+						if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount) break;
+						next = args[ii];
+						if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) break;
+						i = ii;
+						argsToSet.push(processValue(key, next, inputIsString));
+					}
+				}
+				if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) error = Error(__("Not enough arguments following: %s", key));
+				setArg(key, argsToSet);
+				return i;
+			}
+			function setArg(key, val, shouldStripQuotes = inputIsString) {
+				if (/-/.test(key) && configuration["camel-case-expansion"]) addNewAlias(key, key.split(".").map(function(prop) {
+					return camelCase(prop);
+				}).join("."));
+				const value = processValue(key, val, shouldStripQuotes);
+				const splitKey = key.split(".");
+				setKey(argv, splitKey, value);
+				if (flags.aliases[key]) flags.aliases[key].forEach(function(x) {
+					setKey(argv, x.split("."), value);
+				});
+				if (splitKey.length > 1 && configuration["dot-notation"]) (flags.aliases[splitKey[0]] || []).forEach(function(x) {
+					let keyProperties = x.split(".");
+					const a = [].concat(splitKey);
+					a.shift();
+					keyProperties = keyProperties.concat(a);
+					if (!(flags.aliases[key] || []).includes(keyProperties.join("."))) setKey(argv, keyProperties, value);
+				});
+				if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) [key].concat(flags.aliases[key] || []).forEach(function(key) {
+					_p_ObjectDefineProperty(argvReturn, key, {
+						enumerable: true,
+						get() {
+							return val;
+						},
+						set(value) {
+							val = typeof value === "string" ? mixin.normalize(value) : value;
+						}
+					});
+				});
+			}
+			function addNewAlias(key, alias) {
+				if (!(flags.aliases[key] && flags.aliases[key].length)) {
+					flags.aliases[key] = [alias];
+					newAliases[alias] = true;
+				}
+				if (!(flags.aliases[alias] && flags.aliases[alias].length)) addNewAlias(alias, key);
+			}
+			function processValue(key, val, shouldStripQuotes) {
+				if (shouldStripQuotes) val = stripQuotes(val);
+				if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
+					if (typeof val === "string") val = val === "true";
+				}
+				let value = _p_ArrayIsArray(val) ? val.map(function(v) {
+					return maybeCoerceNumber(key, v);
+				}) : maybeCoerceNumber(key, val);
+				if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) value = increment();
+				if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) if (_p_ArrayIsArray(val)) value = val.map((val) => {
+					return mixin.normalize(val);
+				});
+				else value = mixin.normalize(val);
+				return value;
+			}
+			function maybeCoerceNumber(key, value) {
+				if (!configuration["parse-positional-numbers"] && key === "_") return value;
+				if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !_p_ArrayIsArray(value)) {
+					if (looksLikeNumber(value) && configuration["parse-numbers"] && _p_NumberIsSafeInteger(_p_MathFloor(parseFloat(`${value}`))) || !isUndefined(value) && checkAllAliases(key, flags.numbers)) value = Number(value);
+				}
+				return value;
+			}
+			function setConfig(argv) {
+				const configLookup = _p_ObjectCreate(null);
+				applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
+				_p_ObjectKeys(flags.configs).forEach(function(configKey) {
+					const configPath = argv[configKey] || configLookup[configKey];
+					if (configPath) try {
+						let config = null;
+						const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
+						const resolveConfig = flags.configs[configKey];
+						if (typeof resolveConfig === "function") {
+							try {
+								config = resolveConfig(resolvedConfigPath);
+							} catch (e) {
+								config = e;
+							}
+							if (config instanceof Error) {
+								error = config;
+								return;
+							}
+						} else config = mixin.require(resolvedConfigPath);
+						setConfigObject(config);
+					} catch (ex) {
+						if (ex.name === "PermissionDenied") error = ex;
+						else if (argv[configKey]) error = Error(__("Invalid JSON config file: %s", configPath));
+					}
+				});
+			}
+			function setConfigObject(config, prev) {
+				_p_ObjectKeys(config).forEach(function(key) {
+					const value = config[key];
+					const fullKey = prev ? prev + "." + key : key;
+					if (typeof value === "object" && value !== null && !_p_ArrayIsArray(value) && configuration["dot-notation"]) setConfigObject(value, fullKey);
+					else if (!hasKey(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) setArg(fullKey, value);
+				});
+			}
+			function setConfigObjects() {
+				if (typeof configObjects !== "undefined") configObjects.forEach(function(configObject) {
+					setConfigObject(configObject);
+				});
+			}
+			function applyEnvVars(argv, configOnly) {
+				if (typeof envPrefix === "undefined") return;
+				const prefix = typeof envPrefix === "string" ? envPrefix : "";
+				const env = mixin.env();
+				_p_ObjectKeys(env).forEach(function(envVar) {
+					if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
+						const keys = envVar.split("__").map(function(key, i) {
+							if (i === 0) key = _p_StringPrototypeSubstring(key, prefix.length);
+							return camelCase(key);
+						});
+						if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey(argv, keys)) setArg(keys.join("."), env[envVar]);
+					}
+				});
+			}
+			function applyCoercions(argv) {
+				let coerce;
+				const applied = /* @__PURE__ */ new _p_SetCtor();
+				_p_ObjectKeys(argv).forEach(function(key) {
+					if (!applied.has(key)) {
+						coerce = checkAllAliases(key, flags.coercions);
+						if (typeof coerce === "function") try {
+							const value = maybeCoerceNumber(key, coerce(argv[key]));
+							[].concat(flags.aliases[key] || [], key).forEach((ali) => {
+								applied.add(ali);
+								argv[ali] = value;
+							});
+						} catch (err) {
+							error = err;
+						}
+					}
+				});
+			}
+			function setPlaceholderKeys(argv) {
+				flags.keys.forEach((key) => {
+					if (~key.indexOf(".")) return;
+					if (typeof argv[key] === "undefined") argv[key] = void 0;
+				});
+				return argv;
+			}
+			function applyDefaultsAndAliases(obj, aliases, defaults, canLog = false) {
+				_p_ObjectKeys(defaults).forEach(function(key) {
+					if (!hasKey(obj, key.split("."))) {
+						setKey(obj, key.split("."), defaults[key]);
+						if (canLog) defaulted[key] = true;
+						(aliases[key] || []).forEach(function(x) {
+							if (hasKey(obj, x.split("."))) return;
+							setKey(obj, x.split("."), defaults[key]);
+						});
+					}
+				});
+			}
+			function hasKey(obj, keys) {
+				let o = obj;
+				if (!configuration["dot-notation"]) keys = [keys.join(".")];
+				keys.slice(0, -1).forEach(function(key) {
+					o = o[key] || {};
+				});
+				const key = keys[keys.length - 1];
+				if (typeof o !== "object") return false;
+				else return key in o;
+			}
+			function setKey(obj, keys, value) {
+				let o = obj;
+				if (!configuration["dot-notation"]) keys = [keys.join(".")];
+				keys.slice(0, -1).forEach(function(key) {
+					key = sanitizeKey(key);
+					if (typeof o === "object" && o[key] === void 0) o[key] = {};
+					if (typeof o[key] !== "object" || _p_ArrayIsArray(o[key])) {
+						if (_p_ArrayIsArray(o[key])) o[key].push({});
+						else o[key] = [o[key], {}];
+						o = o[key][o[key].length - 1];
+					} else o = o[key];
+				});
+				const key = sanitizeKey(keys[keys.length - 1]);
+				const isTypeArray = checkAllAliases(keys.join("."), flags.arrays);
+				const isValueArray = _p_ArrayIsArray(value);
+				let duplicate = configuration["duplicate-arguments-array"];
+				if (!duplicate && checkAllAliases(key, flags.nargs)) {
+					duplicate = true;
+					if (!isUndefined(o[key]) && flags.nargs[key] === 1 || _p_ArrayIsArray(o[key]) && o[key].length === flags.nargs[key]) o[key] = void 0;
+				}
+				if (value === increment()) o[key] = increment(o[key]);
+				else if (_p_ArrayIsArray(o[key])) if (duplicate && isTypeArray && isValueArray) o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (_p_ArrayIsArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
+				else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) o[key] = value;
+				else o[key] = o[key].concat([value]);
+				else if (o[key] === void 0 && isTypeArray) o[key] = isValueArray ? value : [value];
+				else if (duplicate && !(o[key] === void 0 || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) o[key] = [o[key], value];
+				else o[key] = value;
+			}
+			function extendAliases(...args) {
+				args.forEach(function(obj) {
+					_p_ObjectKeys(obj || {}).forEach(function(key) {
+						if (flags.aliases[key]) return;
+						flags.aliases[key] = [].concat(aliases[key] || []);
+						flags.aliases[key].concat(key).forEach(function(x) {
+							if (/-/.test(x) && configuration["camel-case-expansion"]) {
+								const c = camelCase(x);
+								if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+									flags.aliases[key].push(c);
+									newAliases[c] = true;
+								}
+							}
+						});
+						flags.aliases[key].concat(key).forEach(function(x) {
+							if (x.length > 1 && /[A-Z]/.test(x) && configuration["camel-case-expansion"]) {
+								const c = decamelize(x, "-");
+								if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+									flags.aliases[key].push(c);
+									newAliases[c] = true;
+								}
+							}
+						});
+						flags.aliases[key].forEach(function(x) {
+							flags.aliases[x] = [key].concat(flags.aliases[key].filter(function(y) {
+								return x !== y;
+							}));
+						});
+					});
+				});
+			}
+			function checkAllAliases(key, flag) {
+				const toCheck = [].concat(flags.aliases[key] || [], key);
+				const keys = _p_ObjectKeys(flag);
+				const setAlias = toCheck.find((key) => keys.includes(key));
+				return setAlias ? flag[setAlias] : false;
+			}
+			function hasAnyFlag(key) {
+				const flagsKeys = _p_ObjectKeys(flags);
+				return [].concat(flagsKeys.map((k) => flags[k])).some(function(flag) {
+					return _p_ArrayIsArray(flag) ? flag.includes(key) : flag[key];
+				});
+			}
+			function hasFlagsMatching(arg, ...patterns) {
+				return [].concat(...patterns).some(function(pattern) {
+					const match = arg.match(pattern);
+					return match && hasAnyFlag(match[1]);
+				});
+			}
+			function hasAllShortFlags(arg) {
+				if (arg.match(negative) || !arg.match(/^-[^-]+/)) return false;
+				let hasAllFlags = true;
+				let next;
+				const letters = arg.slice(1).split("");
+				for (let j = 0; j < letters.length; j++) {
+					next = arg.slice(j + 2);
+					if (!hasAnyFlag(letters[j])) {
+						hasAllFlags = false;
+						break;
+					}
+					if (letters[j + 1] && letters[j + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j + 1] && letters[j + 1].match(/\W/)) break;
+				}
+				return hasAllFlags;
+			}
+			function isUnknownOptionAsArg(arg) {
+				return configuration["unknown-options-as-args"] && isUnknownOption(arg);
+			}
+			function isUnknownOption(arg) {
+				arg = arg.replace(/^-{3,}/, "--");
+				if (arg.match(negative)) return false;
+				if (hasAllShortFlags(arg)) return false;
+				return !hasFlagsMatching(arg, /^-+([^=]+?)=[\s\S]*$/, negatedBoolean, /^-+([^=]+?)$/, /^-+([^=]+?)-$/, /^-+([^=]+?\d+)$/, /^-+([^=]+?)\W+.*$/);
+			}
+			function defaultValue(key) {
+				if (!checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts) && `${key}` in defaults) return defaults[key];
+				else return defaultForType(guessType(key));
+			}
+			function defaultForType(type) {
+				return {
+					[DefaultValuesForTypeKey.BOOLEAN]: true,
+					[DefaultValuesForTypeKey.STRING]: "",
+					[DefaultValuesForTypeKey.NUMBER]: void 0,
+					[DefaultValuesForTypeKey.ARRAY]: []
+				}[type];
+			}
+			function guessType(key) {
+				let type = DefaultValuesForTypeKey.BOOLEAN;
+				if (checkAllAliases(key, flags.strings)) type = DefaultValuesForTypeKey.STRING;
+				else if (checkAllAliases(key, flags.numbers)) type = DefaultValuesForTypeKey.NUMBER;
+				else if (checkAllAliases(key, flags.bools)) type = DefaultValuesForTypeKey.BOOLEAN;
+				else if (checkAllAliases(key, flags.arrays)) type = DefaultValuesForTypeKey.ARRAY;
+				return type;
+			}
+			function isUndefined(num) {
+				return num === void 0;
+			}
+			function checkConfiguration() {
+				_p_ObjectKeys(flags.counts).find((key) => {
+					if (checkAllAliases(key, flags.arrays)) {
+						error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
+						return true;
+					} else if (checkAllAliases(key, flags.nargs)) {
+						error = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
+						return true;
+					}
+					return false;
+				});
+			}
+			return {
+				aliases: _p_ObjectAssign({}, flags.aliases),
+				argv: _p_ObjectAssign(argvReturn, argv),
+				configuration,
+				defaulted: _p_ObjectAssign({}, defaulted),
+				error,
+				newAliases: _p_ObjectAssign({}, newAliases)
+			};
+		}
+	};
+}));
 
-// node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/index.js
-var lib_exports = {};
-__export(lib_exports, {
-  default: () => lib_default,
-  "module.exports": () => yargsParser
-});
-var import_util, import_path, import_fs, import_node_module, _a, _b, _c, minNodeVersion, nodeVersion, env, require2, parser, yargsParser, lib_default;
-var init_lib = __esm({
-  "node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/index.js"() {
-    import_util = require("util");
-    import_path = require("path");
-    init_string_utils();
-    init_yargs_parser();
-    import_fs = require("fs");
-    import_node_module = require("node:module");
-    minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 20;
-    nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);
-    if (nodeVersion) {
-      const major = Number(nodeVersion.match(/^([^.]+)/)[1]);
-      if (major < minNodeVersion) {
-        throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
-      }
-    }
-    env = process ? process.env : {};
-    require2 = import_node_module.createRequire ? (0, import_node_module.createRequire)(__filename) : void 0;
-    parser = new YargsParser({
-      cwd: process.cwd,
-      env: /* @__PURE__ */ __name(() => {
-        return env;
-      }, "env"),
-      format: import_util.format,
-      normalize: import_path.normalize,
-      resolve: import_path.resolve,
-      require: /* @__PURE__ */ __name((path) => {
-        if (typeof require2 !== "undefined") {
-          return require2(path);
-        } else if (path.match(/\.json$/)) {
-          return _p_JSONParse((0, import_fs.readFileSync)(path, "utf8"));
-        } else {
-          throw Error("only .json config files are supported in ESM");
-        }
-      }, "require")
-    });
-    yargsParser = /* @__PURE__ */ __name(function Parser(args, opts) {
-      const result = parser.parse(args.slice(), opts);
-      return result.argv;
-    }, "Parser");
-    yargsParser.detailed = function(args, opts) {
-      return parser.parse(args.slice(), opts);
-    };
-    yargsParser.camelCase = camelCase;
-    yargsParser.decamelize = decamelize;
-    yargsParser.looksLikeNumber = looksLikeNumber;
-    lib_default = yargsParser;
-  }
+//#endregion
+//#region node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/index.js
+var lib_exports = /* @__PURE__ */ __exportAll({
+	default: () => yargsParser,
+	"module.exports": () => yargsParser
 });
+var _a, _b, _c, minNodeVersion, nodeVersion, env, require$1, parser, yargsParser;
+var init_lib = __esmMin((() => {
+	init_string_utils();
+	init_yargs_parser();
+	;
+	;
+	;
+	minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 20;
+	nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);
+	/**
+	* @fileoverview Main entrypoint for libraries using yargs-parser in Node.js
+	*
+	* @license
+	* Copyright (c) 2016, Contributors
+	* SPDX-License-Identifier: ISC
+	*/
+	if (nodeVersion) {
+		if (Number(nodeVersion.match(/^([^.]+)/)[1]) < minNodeVersion) throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
+	}
+	env = process ? process.env : {};
+	require$1 = node_module.createRequire ? (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href) : void 0;
+	parser = new YargsParser({
+		cwd: process.cwd,
+		env: () => {
+			return env;
+		},
+		format: util.format,
+		normalize: path.normalize,
+		resolve: path.resolve,
+		require: (path$1) => {
+			if (typeof require$1 !== "undefined") return require$1(path$1);
+			else if (path$1.match(/\.json$/)) return _p_JSONParse((0, fs.readFileSync)(path$1, "utf8"));
+			else throw Error("only .json config files are supported in ESM");
+		}
+	});
+	yargsParser = function Parser(args, opts) {
+		return parser.parse(args.slice(), opts).argv;
+	};
+	yargsParser.detailed = function(args, opts) {
+		return parser.parse(args.slice(), opts);
+	};
+	yargsParser.camelCase = camelCase;
+	yargsParser.decamelize = decamelize;
+	yargsParser.looksLikeNumber = looksLikeNumber;
+}));
 
-// src/external/yargs-parser.js
+//#endregion
+//#region src/external/yargs-parser.js
 module.exports = (init_lib(), __toCommonJS(lib_exports));
-/*! Bundled license information:
 
-yargs-parser/build/lib/string-utils.js:
-yargs-parser/build/lib/tokenize-arg-string.js:
-yargs-parser/build/lib/yargs-parser-types.js:
-yargs-parser/build/lib/yargs-parser.js:
-  (**
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-
-yargs-parser/build/lib/index.js:
-  (**
-   * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js
-   *
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-*/
+//#endregion
+exports["module.exports"] = yargsParser;