var arg_1;
var hasRequiredArg;
function requireArg() {
  if (hasRequiredArg) return arg_1;
  hasRequiredArg = 1;
  const flagSymbol = Symbol('arg flag');
  class ArgError extends Error {
    constructor(msg, code) {
      super(msg);
      this.name = 'ArgError';
      this.code = code;
      Object.setPrototypeOf(this, ArgError.prototype);
    }
  }
  function arg(opts, {
    argv = process.argv.slice(2),
    permissive = false,
    stopAtPositional = false
  } = {}) {
    if (!opts) {
      throw new ArgError('argument specification object is required', 'ARG_CONFIG_NO_SPEC');
    }
    const result = {
      _: []
    };
    const aliases = {};
    const handlers = {};
    for (const key of Object.keys(opts)) {
      if (!key) {
        throw new ArgError('argument key cannot be an empty string', 'ARG_CONFIG_EMPTY_KEY');
      }
      if (key[0] !== '-') {
        throw new ArgError(`argument key must start with '-' but found: '${key}'`, 'ARG_CONFIG_NONOPT_KEY');
      }
      if (key.length === 1) {
        throw new ArgError(`argument key must have a name; singular '-' keys are not allowed: ${key}`, 'ARG_CONFIG_NONAME_KEY');
      }
      if (typeof opts[key] === 'string') {
        aliases[key] = opts[key];
        continue;
      }
      let type = opts[key];
      let isFlag = false;
      if (Array.isArray(type) && type.length === 1 && typeof type[0] === 'function') {
        const [fn] = type;
        type = (value, name, prev = []) => {
          prev.push(fn(value, name, prev[prev.length - 1]));
          return prev;
        };
        isFlag = fn === Boolean || fn[flagSymbol] === true;
      } else if (typeof type === 'function') {
        isFlag = type === Boolean || type[flagSymbol] === true;
      } else {
        throw new ArgError(`type missing or not a function or valid array type: ${key}`, 'ARG_CONFIG_VAD_TYPE');
      }
      if (key[1] !== '-' && key.length > 2) {
        throw new ArgError(`short argument keys (with a single hyphen) must have only one character: ${key}`, 'ARG_CONFIG_SHORTOPT_TOOLONG');
      }
      handlers[key] = [type, isFlag];
    }
    for (let i = 0, len = argv.length; i < len; i++) {
      const wholeArg = argv[i];
      if (stopAtPositional && result._.length > 0) {
        result._ = result._.concat(argv.slice(i));
        break;
      }
      if (wholeArg === '--') {
        result._ = result._.concat(argv.slice(i + 1));
        break;
      }
      if (wholeArg.length > 1 && wholeArg[0] === '-') {
        /* eslint-disable operator-linebreak */
        const separatedArguments = wholeArg[1] === '-' || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split('').map(a => `-${a}`);
        /* eslint-enable operator-linebreak */

        for (let j = 0; j < separatedArguments.length; j++) {
          const arg = separatedArguments[j];
          const [originalArgName, argStr] = arg[1] === '-' ? arg.split(/=(.*)/, 2) : [arg, undefined];
          let argName = originalArgName;
          while (argName in aliases) {
            argName = aliases[argName];
          }
          if (!(argName in handlers)) {
            if (permissive) {
              result._.push(arg);
              continue;
            } else {
              throw new ArgError(`unknown or unexpected option: ${originalArgName}`, 'ARG_UNKNOWN_OPTION');
            }
          }
          const [type, isFlag] = handlers[argName];
          if (!isFlag && j + 1 < separatedArguments.length) {
            throw new ArgError(`option requires argument (but was followed by another short argument): ${originalArgName}`, 'ARG_MISSING_REQUIRED_SHORTARG');
          }
          if (isFlag) {
            result[argName] = type(true, argName, result[argName]);
          } else if (argStr === undefined) {
            if (argv.length < i + 2 || argv[i + 1].length > 1 && argv[i + 1][0] === '-' && !(argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) && (type === Number ||
            // eslint-disable-next-line no-undef
            typeof BigInt !== 'undefined' && type === BigInt))) {
              const extended = originalArgName === argName ? '' : ` (alias for ${argName})`;
              throw new ArgError(`option requires argument: ${originalArgName}${extended}`, 'ARG_MISSING_REQUIRED_LONGARG');
            }
            result[argName] = type(argv[i + 1], argName, result[argName]);
            ++i;
          } else {
            result[argName] = type(argStr, argName, result[argName]);
          }
        }
      } else {
        result._.push(wholeArg);
      }
    }
    return result;
  }
  arg.flag = fn => {
    fn[flagSymbol] = true;
    return fn;
  };

  // Utility types
  arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);

  // Expose error class
  arg.ArgError = ArgError;
  arg_1 = arg;
  return arg_1;
}

export { requireArg as __require };
