{"version":3,"sources":["jsdelivr-header.js","/npm/argparse@3.0.4/lib/argparse.js"],"names":[],"mappings":"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","file":"/npm/argparse@3.0.4/lib/argparse.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.48.0.\n * Original file: /npm/argparse@3.0.4/lib/argparse.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","// Port of python's argparse module, version 3.14.6:\n// https://github.com/python/cpython/blob/v3.14.6/Lib/argparse.py\n\n'use strict'\n\n// Copyright (C) 2010-2020 Python Software Foundation.\n// Copyright (C) 2020 argparse.js authors\n\n/*\n * Command-line parsing library\n *\n * This module is an optparse-inspired command-line parsing library that:\n *\n *     - handles both optional and positional arguments\n *     - produces highly informative usage messages\n *     - supports parsers that dispatch to sub-parsers\n *\n * The following is a simple usage example that sums integers from the\n * command-line and writes the result to a file::\n *\n *     parser = argparse.ArgumentParser(\n *         description='sum the integers at the command line')\n *     parser.add_argument(\n *         'integers', metavar='int', nargs='+', type=int,\n *         help='an integer to be summed')\n *     parser.add_argument(\n *         '--log',\n *         help='the file where the sum should be written')\n *     args = parser.parse_args()\n *     with (open(args.log, 'w') if args.log is not None\n *           else contextlib.nullcontext(sys.stdout)) as log:\n *         log.write('%s' % sum(args.integers))\n *\n * The module contains the following public classes:\n *\n *     - ArgumentParser -- The main entry point for command-line parsing. As the\n *         example above shows, the add_argument() method is used to populate\n *         the parser with actions for optional and positional arguments. Then\n *         the parse_args() method is invoked to convert the args at the\n *         command-line into an object with attributes.\n *\n *     - ArgumentError -- The exception raised by ArgumentParser objects when\n *         there are errors with the parser's actions. Errors raised while\n *         parsing the command-line are caught by ArgumentParser and emitted\n *         as command-line messages.\n *\n *     - FileType -- A factory for defining types of files to be created. As the\n *         example above shows, instances of FileType are typically passed as\n *         the type= argument of add_argument() calls.\n *\n *     - Action -- The base class for parser actions. Typically actions are\n *         selected by passing strings like 'store_true' or 'append_const' to\n *         the action= argument of add_argument(). However, for greater\n *         customization of ArgumentParser actions, subclasses of Action may\n *         be defined and passed as the action= argument.\n *\n *     - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,\n *         ArgumentDefaultsHelpFormatter -- Formatter classes which\n *         may be passed as the formatter_class= argument to the\n *         ArgumentParser constructor. HelpFormatter is the default,\n *         RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser\n *         not to change the formatting for help text, and\n *         ArgumentDefaultsHelpFormatter adds information about argument defaults\n *         to the help.\n *\n * All other classes in this module are considered implementation details.\n * (Also note that HelpFormatter and RawDescriptionHelpFormatter are only\n * considered public as object names -- the API of the formatter objects is\n * still considered an implementation detail.)\n */\n\nconst SUPPRESS = '==SUPPRESS=='\n\nconst OPTIONAL = '?'\nconst ZERO_OR_MORE = '*'\nconst ONE_OR_MORE = '+'\nconst PARSER = 'A...'\nconst REMAINDER = '...'\nconst _UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'\n\n\n// ==================================\n// Utility functions used for porting\n// ==================================\nconst assert = require('assert')\nconst util = require('util')\nconst fs = require('fs')\nconst sub = require('./sub')\nconst path = require('path')\nconst repr = util.inspect\n\nfunction get_argv () {\n    // omit first argument (which is assumed to be interpreter - `node`, `coffee`, `ts-node`, etc.)\n    return process.argv.slice(1)\n}\n\nfunction get_terminal_size () {\n    return {\n        columns: +process.env.COLUMNS || process.stdout.columns || 80\n    }\n}\n\nfunction hasattr (object, name) {\n    return Object.prototype.hasOwnProperty.call(object, name)\n}\n\nfunction getattr (object, name, value) {\n    return hasattr(object, name) ? object[name] : value\n}\n\nfunction setattr (object, name, value) {\n    object[name] = value\n}\n\nfunction setdefault (object, name, value) {\n    if (!hasattr(object, name)) object[name] = value\n    return object[name]\n}\n\nfunction delattr (object, name) {\n    delete object[name]\n}\n\nfunction range (from, to, step = 1) {\n    // range(10) is equivalent to range(0, 10)\n    if (arguments.length === 1) [to, from] = [from, 0]\n    if (typeof from !== 'number' || typeof to !== 'number' || typeof step !== 'number') {\n        throw new TypeError('argument cannot be interpreted as an integer')\n    }\n    if (step === 0) throw new TypeError('range() arg 3 must not be zero')\n\n    const result = []\n    if (step > 0) {\n        for (let i = from; i < to; i += step) result.push(i)\n    } else {\n        for (let i = from; i > to; i += step) result.push(i)\n    }\n    return result\n}\n\nfunction splitlines (str, keepends = false) {\n    let result\n    if (!keepends) {\n        result = str.split(/\\r\\n|[\\n\\r\\v\\f\\x1c\\x1d\\x1e\\x85\\u2028\\u2029]/)\n    } else {\n        result = []\n        const parts = str.split(/(\\r\\n|[\\n\\r\\v\\f\\x1c\\x1d\\x1e\\x85\\u2028\\u2029])/)\n        for (let i = 0; i < parts.length; i += 2) {\n            result.push(parts[i] + (i + 1 < parts.length ? parts[i + 1] : ''))\n        }\n    }\n    if (!result[result.length - 1]) result.pop()\n    return result\n}\n\nfunction _string_lstrip (string, prefix_chars) {\n    let idx = 0\n    while (idx < string.length && prefix_chars.includes(string[idx])) idx++\n    return idx ? string.slice(idx) : string\n}\n\nfunction _string_split (string, sep, maxsplit) {\n    let result = string.split(sep)\n    if (result.length > maxsplit) {\n        result = result.slice(0, maxsplit).concat([result.slice(maxsplit).join(sep)])\n    }\n    return result\n}\n\nfunction _string_to_number (string) {\n    if (typeof string === 'string' && !/(?:^|\\D)_|_(?:\\D|$)/.test(string)) {\n        string = string.replace(/_/g, '')\n    }\n    return Number(string)\n}\n\nfunction _array_remove (array, item) {\n    const idx = array.indexOf(item)\n    if (idx === -1) throw new TypeError(sub('%r not in list', item))\n    array.splice(idx, 1)\n}\n\n// normalize choices to array;\n// this isn't required in python because `in` and `map` operators work with anything,\n// but in js dealing with multiple types here is too clunky\nfunction _choices_to_array (choices) {\n    if (choices === undefined) {\n        return []\n    } else if (Array.isArray(choices)) {\n        return choices\n    } else if (choices instanceof Map) {\n        return Array.from(choices.keys())\n    } else if (choices !== null && typeof choices[Symbol.iterator] === 'function') {\n        return Array.from(choices)\n    } else if (typeof choices === 'object' && choices !== null) {\n        return Object.keys(choices)\n    } else {\n        throw new Error(sub('invalid choices value: %r', choices))\n    }\n}\n\n// decorator that allows a class to be called without new\nfunction _callable (cls) {\n    const result = { // object is needed for inferred class name\n        [cls.name]: function (...args) {\n            const this_class = new.target === result || !new.target\n            return Reflect.construct(cls, args, this_class ? cls : new.target)\n        }\n    }\n    result[cls.name].prototype = cls.prototype\n    // fix default tag for toString, e.g. [object Action] instead of [object Object]\n    cls.prototype[Symbol.toStringTag] = cls.name\n    return result[cls.name]\n}\n\n// parse options\nconst no_default = Symbol('no_default_value')\nfunction _parse_opts (args, descriptor) {\n    function get_name () {\n        const stack = new Error().stack.split('\\n')\n            .map(x => x.match(/^    at (.*) \\(.*\\)$/))\n            .filter(Boolean)\n            .map(m => m[1])\n            .map(fn => fn.match(/[^ .]*$/)[0])\n\n        if (stack.length && stack[0] === get_name.name) stack.shift()\n        if (stack.length && stack[0] === _parse_opts.name) stack.shift()\n        return stack.length ? stack[0] : ''\n    }\n\n    args = Array.from(args)\n    let kwargs = {}\n    const result = []\n    const last_opt = args.length && args[args.length - 1]\n\n    if (typeof last_opt === 'object' && last_opt !== null && !Array.isArray(last_opt) &&\n        (!last_opt.constructor || last_opt.constructor.name === 'Object')) {\n        kwargs = Object.assign({}, args.pop())\n    }\n\n    const missing_positionals = []\n    const positional_count = args.length\n    let keyword_only = false\n\n    for (const [key, def] of Object.entries(descriptor)) {\n        if (key === '*') {\n            keyword_only = true\n        } else if (key[0] === '*') {\n            if (key.length > 0 && key[1] === '*') {\n                result.push(kwargs)\n                kwargs = {}\n            } else {\n                result.push(args)\n                args = []\n            }\n        } else if (key in kwargs && args.length > 0) {\n            throw new TypeError(sub('%s() got multiple values for argument %r', get_name(), key))\n        } else if (key in kwargs) {\n            result.push(kwargs[key])\n            delete kwargs[key]\n        } else if (args.length > 0 && !keyword_only) {\n            result.push(args.shift())\n        } else if (def !== no_default) {\n            result.push(def)\n        } else {\n            missing_positionals.push(key)\n        }\n    }\n\n    if (Object.keys(kwargs).length) {\n        throw new TypeError(sub('%s() got an unexpected keyword argument %r',\n            get_name(), Object.keys(kwargs)[0]))\n    }\n\n    if (args.length) {\n        const entries = Object.entries(descriptor)\n        const marker = entries.findIndex(([k]) => k === '*')\n        const positional_entries = (marker === -1 ? entries : entries.slice(0, marker))\n            .filter(([k]) => k[0] !== '*')\n        const from = positional_entries.filter(([, v]) => v !== no_default).length\n        const to = positional_entries.length\n        throw new TypeError(sub('%s() takes %s positional argument%s but %s %s given',\n            get_name(),\n            from === to ? sub('from %s to %s', from, to) : to,\n            from === to && to === 1 ? '' : 's',\n            positional_count,\n            positional_count === 1 ? 'was' : 'were'))\n    }\n\n    if (missing_positionals.length) {\n        const strs = missing_positionals.map(repr)\n        if (strs.length > 1) strs[strs.length - 1] = 'and ' + strs[strs.length - 1]\n        const str_joined = strs.join(strs.length === 2 ? '' : ', ')\n        throw new TypeError(sub('%s() missing %i required positional argument%s: %s',\n            get_name(), strs.length, strs.length === 1 ? '' : 's', str_joined))\n    }\n\n    return result\n}\n\n// =============================\n// Utility functions and classes\n// =============================\nfunction _AttributeHolder (cls = Object) {\n    /*\n     *  Abstract base class that provides __repr__.\n     *\n     *  The __repr__ method returns a string in the format::\n     *      ClassName(attr=name, attr=name, ...)\n     *  The attributes are determined either by a class-level attribute,\n     *  '_kwarg_names', or by inspecting the instance __dict__.\n     */\n\n    return class _AttributeHolder extends cls {\n        [util.inspect.custom] () {\n            const type_name = this.constructor.name\n            const arg_strings = []\n            const star_args = {}\n            for (const arg of this._get_args()) {\n                arg_strings.push(repr(arg))\n            }\n            for (const [name, value] of this._get_kwargs()) {\n                if (/^[a-z_][a-z0-9_$]*$/i.test(name)) {\n                    arg_strings.push(sub('%s=%r', name, value))\n                } else {\n                    star_args[name] = value\n                }\n            }\n            if (Object.keys(star_args).length) {\n                arg_strings.push(sub('**%s', repr(star_args)))\n            }\n            return sub('%s(%s)', type_name, arg_strings.join(', '))\n        }\n\n        toString () {\n            return this[util.inspect.custom]()\n        }\n\n        _get_kwargs () {\n            return Object.entries(this)\n        }\n\n        _get_args () {\n            return []\n        }\n    }\n}\n\n\nfunction _copy_items (items) {\n    if (items === undefined || items === null) {\n        return []\n    }\n    return items.slice(0)\n}\n\nfunction _identity (value) {\n    return value\n}\n\n\n// ===============\n// Formatting Help\n// ===============\nconst HelpFormatter = _callable(class HelpFormatter {\n    /*\n     *  Formatter for generating usage messages and argument help strings.\n     *\n     *  Only the name of this class is considered a public API. All the methods\n     *  provided by the class are considered an implementation detail.\n     */\n\n    constructor () {\n        let [\n            prog,\n            indent_increment,\n            max_help_position,\n            width,\n            color\n        ] = _parse_opts(arguments, {\n            prog: no_default,\n            indent_increment: 2,\n            max_help_position: 24,\n            width: undefined,\n            color: true\n        })\n\n        // default setting for width\n        if (width === undefined) {\n            width = get_terminal_size().columns\n            width -= 2\n        }\n\n        this._set_color(color)\n        this._prog = prog\n        this._indent_increment = indent_increment\n        this._max_help_position = Math.min(max_help_position,\n                                      Math.max(width - 20, indent_increment * 2))\n        this._width = width\n\n        this._current_indent = 0\n        this._level = 0\n        this._action_max_length = 0\n\n        this._root_section = this._Section(this, undefined)\n        this._current_section = this._root_section\n\n        this._whitespace_matcher = /[ \\t\\n\\r\\f\\v]+/g // equivalent to python /\\s+/ with ASCII flag\n        this._long_break_matcher = /\\n\\n\\n+/g\n    }\n\n    _set_color (color) {\n        const { can_colorize, decolor, get_theme } = require('./_colorize')\n\n        if (color && can_colorize()) {\n            this._theme = get_theme({ force_color: true }).argparse\n            this._decolor = decolor\n        } else {\n            this._theme = get_theme({ force_no_color: true }).argparse\n            this._decolor = _identity\n        }\n    }\n\n    // ===============================\n    // Section and indentation methods\n    // ===============================\n    _indent () {\n        this._current_indent += this._indent_increment\n        this._level += 1\n    }\n\n    _dedent () {\n        this._current_indent -= this._indent_increment\n        assert(this._current_indent >= 0, 'Indent decreased below 0.')\n        this._level -= 1\n    }\n\n    _add_item (func, args) {\n        this._current_section.items.push([func, args])\n    }\n\n    // ========================\n    // Message building methods\n    // ========================\n    start_section (heading) {\n        this._indent()\n        const section = this._Section(this, this._current_section, heading)\n        this._add_item(section.format_help.bind(section), [])\n        this._current_section = section\n    }\n\n    end_section () {\n        this._current_section = this._current_section.parent\n        this._dedent()\n    }\n\n    add_text (text) {\n        if (text !== SUPPRESS && text !== undefined) {\n            this._add_item(this._format_text.bind(this), [text])\n        }\n    }\n\n    add_usage (usage, actions, groups, prefix = undefined) {\n        if (usage !== SUPPRESS) {\n            const args = [usage, actions, groups, prefix]\n            this._add_item(this._format_usage.bind(this), args)\n        }\n    }\n\n    add_argument (action) {\n        if (action.help !== SUPPRESS) {\n\n            // find all invocations\n            const get_invocation = action => this._decolor(this._format_action_invocation(action))\n            const invocation_lengths = [\n                get_invocation(action).length + this._current_indent\n            ]\n            for (const subaction of this._iter_indented_subactions(action)) {\n                invocation_lengths.push(\n                    get_invocation(subaction).length + this._current_indent\n                )\n            }\n\n            // update the maximum item length\n            const action_length = Math.max(...invocation_lengths)\n            this._action_max_length = Math.max(this._action_max_length,\n                                               action_length)\n\n            // add the item to the list\n            this._add_item(this._format_action.bind(this), [action])\n        }\n    }\n\n    add_arguments (actions) {\n        for (const action of actions) {\n            this.add_argument(action)\n        }\n    }\n\n    // =======================\n    // Help-formatting methods\n    // =======================\n    format_help () {\n        let help = this._root_section.format_help()\n        if (help) {\n            help = help.replace(this._long_break_matcher, '\\n\\n')\n            help = help.replace(/^\\n+|\\n+$/g, '') + '\\n'\n        }\n        return help\n    }\n\n    _join_parts (part_strings) {\n        return part_strings.filter(part => part && part !== SUPPRESS).join('')\n    }\n\n    _format_usage (usage, actions, groups, prefix) {\n        const t = this._theme\n\n        if (prefix === undefined) {\n            prefix = 'usage: '\n        }\n\n        // if usage is specified, use that\n        if (usage !== undefined) {\n            usage = t.prog_extra + sub(usage, {\n                prog: t.prog + this._prog + t.reset + t.prog_extra\n            }) + t.reset\n\n        // if no optionals or positionals are available, usage is just prog\n        } else if (usage === undefined && !actions.length) {\n            usage = t.prog + this._prog + t.reset\n\n        // if optionals and positionals are available, calculate usage\n        } else if (usage === undefined) {\n            const prog = sub('%(prog)s', { prog: this._prog })\n\n            const [parts, pos_start] = this._get_actions_usage_parts(actions, groups)\n            // build full usage string\n            usage = [prog].concat(parts).filter(Boolean).join(' ')\n\n            // wrap the usage parts if it's too long\n            const text_width = this._width - this._current_indent\n            if (prefix.length + this._decolor(usage).length > text_width) {\n\n                // break usage into wrappable parts\n                const opt_parts = parts.slice(0, pos_start)\n                const pos_parts = parts.slice(pos_start)\n\n                // helper for wrapping lines\n                const get_lines = (parts, indent, prefix = undefined) => {\n                    const lines = []\n                    let line = []\n                    const indent_length = indent.length\n                    let line_len\n                    if (prefix !== undefined) {\n                        line_len = prefix.length - 1\n                    } else {\n                        line_len = indent_length - 1\n                    }\n                    for (const part of parts) {\n                        const part_len = this._decolor(part).length\n                        if (line_len + 1 + part_len > text_width && line.length) {\n                            lines.push(indent + line.join(' '))\n                            line = []\n                            line_len = indent_length - 1\n                        }\n                        line.push(part)\n                        line_len += part_len + 1\n                    }\n                    if (line.length) {\n                        lines.push(indent + line.join(' '))\n                    }\n                    if (prefix !== undefined) {\n                        lines[0] = lines[0].slice(indent_length)\n                    }\n                    return lines\n                }\n\n                let lines\n\n                // if prog is short, follow it with optionals or positionals\n                const prog_len = this._decolor(prog).length\n                if (prefix.length + prog_len <= 0.75 * text_width) {\n                    const indent = ' '.repeat(prefix.length + prog_len + 1)\n                    if (opt_parts.length) {\n                        lines = get_lines([prog].concat(opt_parts), indent, prefix)\n                        lines = lines.concat(get_lines(pos_parts, indent))\n                    } else if (pos_parts.length) {\n                        lines = get_lines([prog].concat(pos_parts), indent, prefix)\n                    } else {\n                        lines = [prog]\n                    }\n\n                // if prog is long, put it on its own line\n                } else {\n                    const indent = ' '.repeat(prefix.length)\n                    const parts = [].concat(opt_parts).concat(pos_parts)\n                    lines = get_lines(parts, indent)\n                    if (lines.length > 1) {\n                        lines = []\n                        lines = lines.concat(get_lines(opt_parts, indent))\n                        lines = lines.concat(get_lines(pos_parts, indent))\n                    }\n                    lines = [prog].concat(lines)\n                }\n\n                // join lines into usage\n                usage = lines.join('\\n')\n            }\n\n            if (usage.startsWith(prog)) usage = usage.slice(prog.length)\n            usage = t.prog + prog + t.reset + usage\n        }\n\n        // prefix with 'usage:'\n        return t.usage + prefix + t.reset + usage + '\\n\\n'\n    }\n\n    _is_long_option (string) {\n        return string.length > 2\n    }\n\n    _get_actions_usage_parts (actions, groups) {\n        /* Get usage parts with split index for optionals/positionals.\n\n         * Returns [parts, pos_start] where pos_start is the index in parts\n         * where positionals begin. This preserves mutually exclusive group\n         * formatting across the optionals/positionals boundary (gh-75949).\n         */\n        actions = actions.filter(action => action.help !== SUPPRESS)\n\n        // group actions by mutually exclusive groups\n        const action_groups = new Map(actions.map(action => [action, undefined]))\n        for (const group of groups) {\n            for (const action of group._group_actions) {\n                if (action_groups.has(action)) {\n                    action_groups.set(action, group)\n                }\n            }\n        }\n\n        // positional arguments keep their position\n        const positionals = []\n        for (const action of actions) {\n            if (!action.option_strings.length) {\n                const group = action_groups.get(action)\n                action_groups.delete(action)\n                if (group) {\n                    const group_actions = []\n                    for (const action2 of group._group_actions) {\n                        if (action2.option_strings.length && action_groups.has(action2)) {\n                            const action_group = action_groups.get(action2)\n                            action_groups.delete(action2)\n                            if (action_group) {\n                                group_actions.push(action2)\n                            }\n                        }\n                    }\n                    group_actions.push(action)\n                    positionals.push([group.required, group_actions])\n                } else {\n                    positionals.push([undefined, [action]])\n                }\n            }\n        }\n\n        // the remaining optional arguments are sorted by the position of\n        // the first option in the group\n        const optionals = []\n        for (const action of actions) {\n            if (action.option_strings.length && action_groups.has(action)) {\n                const group = action_groups.get(action)\n                action_groups.delete(action)\n                if (group) {\n                    const group_actions = [action]\n                    for (const action2 of group._group_actions) {\n                        if (action2.option_strings.length && action_groups.has(action2)) {\n                            const action_group = action_groups.get(action2)\n                            action_groups.delete(action2)\n                            if (action_group) {\n                                group_actions.push(action2)\n                            }\n                        }\n                    }\n                    optionals.push([group.required, group_actions])\n                } else {\n                    optionals.push([undefined, [action]])\n                }\n            }\n        }\n\n        // collect all actions format strings\n        const parts = []\n        const t = this._theme\n        let pos_start\n        const action_sets = optionals.concat(positionals)\n        for (let i = 0; i < action_sets.length; i++) {\n            const [required, group] = action_sets[i]\n            const start = parts.length\n            if (i === optionals.length) {\n                pos_start = start\n            }\n            const in_group = group.length > 1\n            for (const action of group) {\n                let part\n\n                // produce all arg strings\n                if (!action.option_strings.length) {\n                    const default_value = this._get_default_metavar_for_positional(action)\n                    part = this._format_args(action, default_value)\n\n                    // if it's in a group, strip the outer []\n                    if (in_group && part[0] === '[' && part[part.length - 1] === ']') {\n                        part = part.slice(1, -1)\n                    }\n                    part = t.summary_action + part + t.reset\n\n                // produce the first way to invoke the option in brackets\n                } else {\n                    const option_string = action.option_strings[0]\n                    const option_color = this._is_long_option(option_string)\n                        ? t.summary_long_option\n                        : t.summary_short_option\n\n                    // if the Optional doesn't take a value, format is:\n                    //    -s or --long\n                    if (action.nargs === 0) {\n                        part = action.format_usage()\n                        part = option_color + part + t.reset\n\n                    // if the Optional takes a value, format is:\n                    //    -s ARGS or --long ARGS\n                    } else {\n                        const default_value = this._get_default_metavar_for_optional(action)\n                        const args_string = this._format_args(action, default_value)\n                        part = option_color + option_string + ' ' +\n                            t.summary_label + args_string + t.reset\n                    }\n\n                    // make it look optional if it's not required or in a group\n                    if (!(action.required || required || in_group)) {\n                        part = sub('[%s]', part)\n                    }\n                }\n\n                // add the action string to the list\n                parts.push(part)\n            }\n\n            if (in_group) {\n                parts[start] = (required ? '(' : '[') + parts[start]\n                for (let i = start; i < parts.length - 1; i++) {\n                    parts[i] += ' |'\n                }\n                parts[parts.length - 1] += required ? ')' : ']'\n            }\n        }\n\n        if (pos_start === undefined) {\n            pos_start = parts.length\n        }\n        return [parts, pos_start]\n    }\n\n    _format_text (text) {\n        if (text.includes('%(prog)')) {\n            text = sub(text, { prog: this._prog })\n        }\n        const text_width = Math.max(this._width - this._current_indent, 11)\n        const indent = ' '.repeat(this._current_indent)\n        return this._fill_text(text, text_width, indent) + '\\n\\n'\n    }\n\n    _format_action (action) {\n        // determine the required width and the entry label\n        const help_position = Math.min(this._action_max_length + 2,\n                                     this._max_help_position)\n        const help_width = Math.max(this._width - help_position, 11)\n        const action_width = help_position - this._current_indent - 2\n        let action_header = this._format_action_invocation(action)\n        const action_header_no_color = this._decolor(action_header)\n        let indent_first\n\n        // no help; start on same line and add a final newline\n        if (!action.help) {\n            const tup = [this._current_indent, '', action_header]\n            action_header = sub('%*s%s\\n', ...tup)\n\n        // short action name; start on the same line and pad two spaces\n        } else if (action_header_no_color.length <= action_width) {\n            // calculate widths without color codes\n            const action_header_color = action_header\n            const tup = [this._current_indent, '', action_width, action_header_no_color]\n            action_header = sub('%*s%-*s  ', ...tup)\n            // swap in the colored header\n            action_header = action_header.replace(action_header_no_color, action_header_color)\n            indent_first = 0\n\n        // long action name; start on the next line\n        } else {\n            const tup = [this._current_indent, '', action_header]\n            action_header = sub('%*s%s\\n', ...tup)\n            indent_first = help_position\n        }\n\n        // collect the pieces of the action help\n        const parts = [action_header]\n\n        // if there was help for the action, add lines of help text\n        if (action.help && action.help.trim()) {\n            const help_text = this._expand_help(action)\n            if (help_text) {\n                const help_lines = this._split_lines(help_text, help_width)\n                parts.push(sub('%*s%s\\n', indent_first, '', help_lines[0]))\n                for (const line of help_lines.slice(1)) {\n                    parts.push(sub('%*s%s\\n', help_position, '', line))\n                }\n            }\n\n        // or add a newline if the description doesn't end with one\n        } else if (!action_header.endsWith('\\n')) {\n            parts.push('\\n')\n        }\n\n        // if there are any sub-actions, add their help as well\n        for (const subaction of this._iter_indented_subactions(action)) {\n            parts.push(this._format_action(subaction))\n        }\n\n        // return a single string\n        return this._join_parts(parts)\n    }\n\n    _format_action_invocation (action) {\n        const t = this._theme\n\n        if (!action.option_strings.length) {\n            const default_value = this._get_default_metavar_for_positional(action)\n            return t.action +\n                this._metavar_formatter(action, default_value)(1).join(' ') +\n                t.reset\n\n        } else {\n            const color_option_strings = strings => strings.map(string => {\n                const color = this._is_long_option(string) ? t.long_option : t.short_option\n                return color + string + t.reset\n            })\n\n            // if the Optional doesn't take a value, format is:\n            //    -s, --long\n            if (action.nargs === 0) {\n                return color_option_strings(action.option_strings).join(', ')\n\n            // if the Optional takes a value, format is:\n            //    -s, --long ARGS\n            } else {\n                const default_value = this._get_default_metavar_for_optional(action)\n                const option_strings = color_option_strings(action.option_strings)\n                const args_string = t.label + this._format_args(action, default_value) + t.reset\n                return option_strings.join(', ') + ' ' + args_string\n            }\n        }\n    }\n\n    _metavar_formatter (action, default_metavar) {\n        let result\n        if (action.metavar !== undefined) {\n            result = action.metavar\n        } else if (action.choices !== undefined) {\n            const choice_strs = _choices_to_array(action.choices).map(String)\n            result = sub('{%s}', choice_strs.join(','))\n        } else {\n            result = default_metavar\n        }\n\n        function format (tuple_size) {\n            if (Array.isArray(result)) {\n                return result\n            } else {\n                return Array(tuple_size).fill(result)\n            }\n        }\n        return format\n    }\n\n    _format_args (action, default_metavar) {\n        const get_metavar = this._metavar_formatter(action, default_metavar)\n        let result\n        if (action.nargs === undefined) {\n            result = sub('%s', ...get_metavar(1))\n        } else if (action.nargs === OPTIONAL) {\n            result = sub('[%s]', ...get_metavar(1))\n        } else if (action.nargs === ZERO_OR_MORE) {\n            const metavar = get_metavar(1)\n            if (metavar.length === 2) {\n                result = sub('[%s [%s ...]]', ...metavar)\n            } else {\n                result = sub('[%s ...]', ...metavar)\n            }\n        } else if (action.nargs === ONE_OR_MORE) {\n            result = sub('%s [%s ...]', ...get_metavar(2))\n        } else if (action.nargs === REMAINDER) {\n            result = '...'\n        } else if (action.nargs === PARSER) {\n            result = sub('%s ...', ...get_metavar(1))\n        } else if (action.nargs === SUPPRESS) {\n            result = ''\n        } else {\n            let formats\n            try {\n                formats = range(action.nargs).map(() => '%s')\n            } catch (err) {\n                throw new TypeError('invalid nargs value')\n            }\n            result = sub(formats.join(' '), ...get_metavar(action.nargs))\n        }\n        return result\n    }\n\n    _expand_help (action) {\n        const help_string = this._get_help_string(action)\n        if (!help_string.includes('%')) {\n            return help_string\n        }\n        const params = Object.assign({}, action, { prog: this._prog })\n        for (const name of Object.keys(params)) {\n            const value = params[name]\n            if (value === SUPPRESS) {\n                delete params[name]\n            } else if (value !== undefined && value !== null && 'name' in Object(value)) {\n                params[name] = value.name\n            }\n        }\n        if (params.choices !== undefined) {\n            const choices_str = _choices_to_array(params.choices).map(String).join(', ')\n            params.choices = choices_str\n        }\n        return sub(help_string, params)\n    }\n\n    * _iter_indented_subactions (action) {\n        if (typeof action._get_subactions === 'function') {\n            this._indent()\n            yield * action._get_subactions()\n            this._dedent()\n        }\n    }\n\n    _split_lines (text, width) {\n        text = text.replace(this._whitespace_matcher, ' ').trim()\n        // The textwrap module is used only for formatting help.\n        // Delay its import for speeding up the common usage of argparse.\n        const textwrap = require('./textwrap')\n        return textwrap.wrap(text, { width })\n    }\n\n    _fill_text (text, width, indent) {\n        text = text.replace(this._whitespace_matcher, ' ').trim()\n        const textwrap = require('./textwrap')\n        return textwrap.fill(text, { width,\n                                     initial_indent: indent,\n                                     subsequent_indent: indent })\n    }\n\n    _get_help_string (action) {\n        return action.help\n    }\n\n    _get_default_metavar_for_optional (action) {\n        return action.dest.toUpperCase()\n    }\n\n    _get_default_metavar_for_positional (action) {\n        return action.dest\n    }\n})\n\nHelpFormatter.prototype._Section = _callable(class _Section {\n\n    constructor (formatter, parent, heading = undefined) {\n        this.formatter = formatter\n        this.parent = parent\n        this.heading = heading\n        this.items = []\n    }\n\n    format_help () {\n        // format the indented section\n        if (this.parent !== undefined) {\n            this.formatter._indent()\n        }\n        const item_help = this.formatter._join_parts(this.items.map(([func, args]) => func.apply(null, args)))\n        if (this.parent !== undefined) {\n            this.formatter._dedent()\n        }\n\n        // return nothing if the section was empty\n        if (!item_help) {\n            return ''\n        }\n\n        // add the heading if the section was non-empty\n        let heading\n        if (this.heading !== SUPPRESS && this.heading !== undefined) {\n            const current_indent = this.formatter._current_indent\n            const t = this.formatter._theme\n            const heading_text = this.heading + ':'\n            heading = ' '.repeat(current_indent) + t.heading + heading_text + t.reset + '\\n'\n        } else {\n            heading = ''\n        }\n\n        // join the section-initial newline, the heading and the help\n        return this.formatter._join_parts(['\\n', heading, item_help, '\\n'])\n    }\n})\n\n\nconst RawDescriptionHelpFormatter = _callable(class RawDescriptionHelpFormatter extends HelpFormatter {\n    /*\n     *  Help message formatter which retains any formatting in descriptions.\n     *\n     *  Only the name of this class is considered a public API. All the methods\n     *  provided by the class are considered an implementation detail.\n     */\n\n    _fill_text (text, width, indent) {\n        return splitlines(text, true).map(line => indent + line).join('')\n    }\n})\n\n\nconst RawTextHelpFormatter = _callable(class RawTextHelpFormatter extends RawDescriptionHelpFormatter {\n    /*\n     *  Help message formatter which retains formatting of all help text.\n     *\n     *  Only the name of this class is considered a public API. All the methods\n     *  provided by the class are considered an implementation detail.\n     */\n\n    _split_lines (text/*, width */) {\n        return splitlines(text)\n    }\n})\n\n\nconst ArgumentDefaultsHelpFormatter = _callable(class ArgumentDefaultsHelpFormatter extends HelpFormatter {\n    /*\n     *  Help message formatter which adds default values to argument help.\n     *\n     *  Only the name of this class is considered a public API. All the methods\n     *  provided by the class are considered an implementation detail.\n     */\n\n    _get_help_string (action) {\n        let help = action.help\n        if (help === undefined) {\n            help = ''\n        }\n\n        if (!help.includes('%(default)') &&\n            action.default !== SUPPRESS &&\n            !action.required) {\n            const defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]\n            if (action.option_strings.length || defaulting_nargs.includes(action.nargs)) {\n                help += ' (default: %(default)s)'\n            }\n        }\n        return help\n    }\n})\n\n\nconst MetavarTypeHelpFormatter = _callable(class MetavarTypeHelpFormatter extends HelpFormatter {\n    /*\n     *  Help message formatter which uses the argument 'type' as the default\n     *  metavar value (instead of the argument 'dest')\n     *\n     *  Only the name of this class is considered a public API. All the methods\n     *  provided by the class are considered an implementation detail.\n     */\n\n    _get_default_metavar_for_optional (action) {\n        return typeof action.type === 'function' ? action.type.name : action.type\n    }\n\n    _get_default_metavar_for_positional (action) {\n        return typeof action.type === 'function' ? action.type.name : action.type\n    }\n})\n\n\n// =====================\n// Options and Arguments\n// =====================\nfunction _get_action_name (argument) {\n    if (argument === undefined) {\n        return undefined\n    } else if (argument.option_strings.length) {\n        return argument.option_strings.join('/')\n    } else if (![undefined, SUPPRESS].includes(argument.metavar)) {\n        const metavar = argument.metavar\n        if (!Array.isArray(metavar)) {\n            return metavar\n        }\n        if (argument.nargs === ZERO_OR_MORE && metavar.length === 2) {\n            return sub('%s[, %s]', ...metavar)\n        } else if (argument.nargs === ONE_OR_MORE) {\n            return sub('%s[, %s]', ...metavar)\n        } else {\n            return metavar.join(', ')\n        }\n    } else if (![undefined, SUPPRESS].includes(argument.dest)) {\n        return argument.dest\n    } else if (argument.choices) {\n        const choices = _choices_to_array(argument.choices)\n        if (choices.length) {\n            return sub('{%s}', choices.map(String).join(','))\n        }\n    }\n    return undefined\n}\n\n\nconst ArgumentError = _callable(class ArgumentError extends Error {\n    /*\n     *  An error from creating or using an argument (optional or positional).\n     *\n     *  The string value of this exception is the message, augmented with\n     *  information about the argument that caused it.\n     */\n\n    constructor (argument, message) {\n        super()\n        this.name = 'ArgumentError'\n        this._argument_name = _get_action_name(argument)\n        this._message = message\n        this.message = this.str()\n    }\n\n    str () {\n        let format\n        if (this._argument_name === undefined) {\n            format = '%(message)s'\n        } else {\n            format = 'argument %(argument_name)s: %(message)s'\n        }\n        return sub(format, { message: this._message,\n                             argument_name: this._argument_name })\n    }\n})\n\n\nconst ArgumentTypeError = _callable(class ArgumentTypeError extends Error {\n    /*\n     * An error from trying to convert a command line string to a type.\n     */\n\n    constructor (message) {\n        super(message)\n        this.name = 'ArgumentTypeError'\n    }\n})\n\n\n// ==============\n// Action classes\n// ==============\nconst Action = _callable(class Action extends _AttributeHolder(Function) {\n    /*\n     *  Information about how to convert command line strings to Python objects.\n     *\n     *  Action objects are used by an ArgumentParser to represent the information\n     *  needed to parse a single argument from one or more strings from the\n     *  command line. The keyword arguments to the Action constructor are also\n     *  all attributes of Action instances.\n     *\n     *  Keyword Arguments:\n     *\n     *      - option_strings -- A list of command-line option strings which\n     *          should be associated with this action.\n     *\n     *      - dest -- The name of the attribute to hold the created object(s)\n     *\n     *      - nargs -- The number of command-line arguments that should be\n     *          consumed. By default, one argument will be consumed and a single\n     *          value will be produced.  Other values include:\n     *              - N (an integer) consumes N arguments (and produces a list)\n     *              - '?' consumes zero or one arguments\n     *              - '*' consumes zero or more arguments (and produces a list)\n     *              - '+' consumes one or more arguments (and produces a list)\n     *          Note that the difference between the default and nargs=1 is that\n     *          with the default, a single value will be produced, while with\n     *          nargs=1, a list containing a single value will be produced.\n     *\n     *      - const -- The value to be produced if the option is specified and the\n     *          option uses an action that takes no values.\n     *\n     *      - default -- The value to be produced if the option is not specified.\n     *\n     *      - type -- A callable that accepts a single string argument, and\n     *          returns the converted value.  The standard Python types str, int,\n     *          float, and complex are useful examples of such callables.  If None,\n     *          str is used.\n     *\n     *      - choices -- A container of values that should be allowed. If not None,\n     *          after a command-line argument has been converted to the appropriate\n     *          type, an exception will be raised if it is not a member of this\n     *          collection.\n     *\n     *      - required -- True if the action must always be specified at the\n     *          command line. This is only meaningful for optional command-line\n     *          arguments.\n     *\n     *      - help -- The help string describing the argument.\n     *\n     *      - metavar -- The name to be used for the option's argument with the\n     *          help string. If None, the 'dest' value will be used as the name.\n     */\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            nargs,\n            const_value,\n            default_value,\n            type,\n            choices,\n            required,\n            help,\n            metavar,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            nargs: undefined,\n            const: undefined,\n            default: undefined,\n            type: undefined,\n            choices: undefined,\n            required: false,\n            help: undefined,\n            metavar: undefined,\n            deprecated: false\n        })\n\n        // when this class is called as a function, redirect it to .call() method of itself\n        super('return arguments.callee.call.apply(arguments.callee, arguments)')\n\n        this.option_strings = option_strings\n        this.dest = dest\n        this.nargs = nargs\n        this.const = const_value\n        this.default = default_value\n        this.type = type\n        this.choices = choices\n        this.required = required\n        this.help = help\n        this.metavar = metavar\n        this.deprecated = deprecated\n    }\n\n    _get_kwargs () {\n        const names = [\n            'option_strings',\n            'dest',\n            'nargs',\n            'const',\n            'default',\n            'type',\n            'choices',\n            'required',\n            'help',\n            'metavar',\n            'deprecated'\n        ]\n        return names.map(name => [name, getattr(this, name)])\n    }\n\n    format_usage () {\n        return this.option_strings[0]\n    }\n\n    call (/* parser, namespace, values, option_string = undefined */) {\n        throw new Error('.call() not defined')\n    }\n})\n\n\nconst BooleanOptionalAction = _callable(class BooleanOptionalAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            default_value,\n            required,\n            help,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            default: undefined,\n            required: false,\n            help: undefined,\n            deprecated: false\n        })\n\n        const _option_strings = []\n        for (let option_string of option_strings) {\n            _option_strings.push(option_string)\n\n            if (option_string.startsWith('--')) {\n                if (option_string.startsWith('--no-')) {\n                    throw new TypeError(sub('invalid option name %r ' +\n                                            'for BooleanOptionalAction', option_string))\n                }\n                option_string = '--no-' + option_string.slice(2)\n                _option_strings.push(option_string)\n            }\n        }\n\n        super({\n            option_strings: _option_strings,\n            dest,\n            nargs: 0,\n            default: default_value,\n            required,\n            help,\n            deprecated\n        })\n    }\n\n    call (parser, namespace, values, option_string = undefined) {\n        if (this.option_strings.includes(option_string)) {\n            setattr(namespace, this.dest, !option_string.startsWith('--no-'))\n        }\n    }\n\n    format_usage () {\n        return this.option_strings.join(' | ')\n    }\n})\n\n\nconst _StoreAction = _callable(class _StoreAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            nargs,\n            const_value,\n            default_value,\n            type,\n            choices,\n            required,\n            help,\n            metavar,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            nargs: undefined,\n            const: undefined,\n            default: undefined,\n            type: undefined,\n            choices: undefined,\n            required: false,\n            help: undefined,\n            metavar: undefined,\n            deprecated: false\n        })\n\n        if (nargs === 0) {\n            throw new TypeError('nargs for store actions must be != 0; if you ' +\n                        'have nothing to store, actions such as store ' +\n                        'true or store const may be more appropriate')\n        }\n        if (const_value !== undefined && nargs !== OPTIONAL) {\n            throw new TypeError(sub('nargs must be %r to supply const', OPTIONAL))\n        }\n        super({\n            option_strings,\n            dest,\n            nargs,\n            const: const_value,\n            default: default_value,\n            type,\n            choices,\n            required,\n            help,\n            metavar,\n            deprecated\n        })\n    }\n\n    call (parser, namespace, values/*, option_string = undefined */) {\n        setattr(namespace, this.dest, values)\n    }\n})\n\n\nconst _StoreConstAction = _callable(class _StoreConstAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            const_value,\n            default_value,\n            required,\n            help,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            const: undefined,\n            default: undefined,\n            required: false,\n            help: undefined,\n            deprecated: false,\n            metavar: undefined\n        })\n\n        super({\n            option_strings,\n            dest,\n            nargs: 0,\n            const: const_value,\n            default: default_value,\n            required,\n            help,\n            deprecated\n        })\n    }\n\n    call (parser, namespace/*, values, option_string = undefined */) {\n        setattr(namespace, this.dest, this.const)\n    }\n})\n\n\nconst _StoreTrueAction = _callable(class _StoreTrueAction extends _StoreConstAction {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            default_value,\n            required,\n            help,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            default: false,\n            required: false,\n            help: undefined,\n            deprecated: false\n        })\n\n        super({\n            option_strings,\n            dest,\n            const: true,\n            default: default_value,\n            required,\n            help,\n            deprecated\n        })\n    }\n})\n\n\nconst _StoreFalseAction = _callable(class _StoreFalseAction extends _StoreConstAction {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            default_value,\n            required,\n            help,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            default: true,\n            required: false,\n            help: undefined,\n            deprecated: false\n        })\n\n        super({\n            option_strings,\n            dest,\n            const: false,\n            default: default_value,\n            required,\n            help,\n            deprecated\n        })\n    }\n})\n\n\nconst _AppendAction = _callable(class _AppendAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            nargs,\n            const_value,\n            default_value,\n            type,\n            choices,\n            required,\n            help,\n            metavar,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            nargs: undefined,\n            const: undefined,\n            default: undefined,\n            type: undefined,\n            choices: undefined,\n            required: false,\n            help: undefined,\n            metavar: undefined,\n            deprecated: false\n        })\n\n        if (nargs === 0) {\n            throw new TypeError('nargs for append actions must be != 0; if arg ' +\n                        'strings are not supplying the value to append, ' +\n                        'the append const action may be more appropriate')\n        }\n        if (const_value !== undefined && nargs !== OPTIONAL) {\n            throw new TypeError(sub('nargs must be %r to supply const', OPTIONAL))\n        }\n        super({\n            option_strings,\n            dest,\n            nargs,\n            const: const_value,\n            default: default_value,\n            type,\n            choices,\n            required,\n            help,\n            metavar,\n            deprecated\n        })\n    }\n\n    call (parser, namespace, values/*, option_string = undefined */) {\n        let items = getattr(namespace, this.dest, undefined)\n        items = _copy_items(items)\n        items.push(values)\n        setattr(namespace, this.dest, items)\n    }\n})\n\n\nconst _AppendConstAction = _callable(class _AppendConstAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            const_value,\n            default_value,\n            required,\n            help,\n            metavar,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            const: undefined,\n            default: undefined,\n            required: false,\n            help: undefined,\n            metavar: undefined,\n            deprecated: false\n        })\n\n        super({\n            option_strings,\n            dest,\n            nargs: 0,\n            const: const_value,\n            default: default_value,\n            required,\n            help,\n            metavar,\n            deprecated\n        })\n    }\n\n    call (parser, namespace/*, values, option_string = undefined */) {\n        let items = getattr(namespace, this.dest, undefined)\n        items = _copy_items(items)\n        items.push(this.const)\n        setattr(namespace, this.dest, items)\n    }\n})\n\n\nconst _CountAction = _callable(class _CountAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            default_value,\n            required,\n            help,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: no_default,\n            default: undefined,\n            required: false,\n            help: undefined,\n            deprecated: false\n        })\n\n        super({\n            option_strings,\n            dest,\n            nargs: 0,\n            default: default_value,\n            required,\n            help,\n            deprecated\n        })\n    }\n\n    call (parser, namespace/*, values, option_string = undefined */) {\n        let count = getattr(namespace, this.dest, undefined)\n        if (count === undefined) {\n            count = 0\n        }\n        setattr(namespace, this.dest, count + 1)\n    }\n})\n\n\nconst _HelpAction = _callable(class _HelpAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            dest,\n            default_value,\n            help,\n            deprecated\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            dest: SUPPRESS,\n            default: SUPPRESS,\n            help: undefined,\n            deprecated: false\n        })\n\n        super({\n            option_strings,\n            dest,\n            default: default_value,\n            nargs: 0,\n            help,\n            deprecated\n        })\n    }\n\n    call (parser/*, namespace, values, option_string = undefined */) {\n        parser.print_help()\n        parser.exit()\n    }\n})\n\n\nconst _VersionAction = _callable(class _VersionAction extends Action {\n\n    constructor () {\n        let [\n            option_strings,\n            version,\n            dest,\n            default_value,\n            help\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            version: undefined,\n            dest: SUPPRESS,\n            default: SUPPRESS,\n            help: \"show program's version number and exit\",\n            deprecated: false\n        })\n\n        if (help === undefined || help === null) {\n            help = \"show program's version number and exit\"\n        }\n\n        super({\n            option_strings,\n            dest,\n            default: default_value,\n            nargs: 0,\n            help\n        })\n        this.version = version\n    }\n\n    call (parser/*, namespace, values, option_string = undefined */) {\n        let version = this.version\n        if (version === undefined) {\n            version = parser.version\n        }\n        const formatter = parser._get_formatter()\n        formatter.add_text(version)\n        parser._print_message(formatter.format_help(), process.stdout)\n        parser.exit()\n    }\n})\n\n\nconst _SubParsersAction = _callable(class _SubParsersAction extends Action {\n\n    constructor () {\n        const [\n            option_strings,\n            prog,\n            parser_class,\n            dest,\n            required,\n            help,\n            metavar\n        ] = _parse_opts(arguments, {\n            option_strings: no_default,\n            prog: no_default,\n            parser_class: no_default,\n            dest: SUPPRESS,\n            required: false,\n            help: undefined,\n            metavar: undefined\n        })\n\n        const name_parser_map = Object.create(null)\n\n        super({\n            option_strings,\n            dest,\n            nargs: PARSER,\n            choices: name_parser_map,\n            required,\n            help,\n            metavar\n        })\n\n        this._prog_prefix = prog\n        this._parser_class = parser_class\n        this._name_parser_map = name_parser_map\n        this._choices_actions = []\n        this._deprecated = new Set()\n        this._color = true\n    }\n\n    add_parser () {\n        const [\n            name,\n            kwargs\n        ] = _parse_opts(arguments, {\n            name: no_default,\n            '**kwargs': no_default\n        })\n\n        // set prog from the existing prefix\n        if (kwargs.prog === undefined) {\n            kwargs.prog = sub('%s %s', this._prog_prefix, name)\n        }\n\n        // set color\n        if (kwargs.color === undefined) {\n            kwargs.color = this._color\n        }\n\n        const aliases = getattr(kwargs, 'aliases', [])\n        delete kwargs.aliases\n        const deprecated = getattr(kwargs, 'deprecated', false)\n        delete kwargs.deprecated\n\n        if (hasattr(this._name_parser_map, name)) {\n            throw new TypeError(sub('conflicting subparser: %s', name))\n        }\n        for (const alias of aliases) {\n            if (hasattr(this._name_parser_map, alias)) {\n                throw new TypeError(sub('conflicting subparser alias: %s', alias))\n            }\n        }\n\n        // create a pseudo-action to hold the choice help\n        let choice_action\n        if ('help' in kwargs) {\n            const help = kwargs.help\n            delete kwargs.help\n            choice_action = this._ChoicesPseudoAction(name, aliases, help)\n            this._choices_actions.push(choice_action)\n        }\n\n        // create the parser and add it to the map\n        const parser = new this._parser_class(kwargs)\n        if (choice_action !== undefined) {\n            parser._check_help(choice_action)\n        }\n        this._name_parser_map[name] = parser\n\n        // make parser available under aliases also\n        for (const alias of aliases) {\n            this._name_parser_map[alias] = parser\n        }\n\n        if (deprecated) {\n            this._deprecated.add(name)\n            for (const alias of aliases) {\n                this._deprecated.add(alias)\n            }\n        }\n\n        return parser\n    }\n\n    _get_subactions () {\n        return this._choices_actions\n    }\n\n    call (parser, namespace, values/*, option_string = undefined */) {\n        const parser_name = values[0]\n        let arg_strings = values.slice(1)\n\n        // set the parser name if requested\n        if (this.dest !== SUPPRESS) {\n            setattr(namespace, this.dest, parser_name)\n        }\n\n        // select the parser\n        let subparser\n        if (hasattr(this._name_parser_map, parser_name)) {\n            subparser = this._name_parser_map[parser_name]\n        } else {\n            const args = {parser_name,\n                        choices: Object.keys(this._name_parser_map).join(', ')}\n            const msg = sub('unknown parser %(parser_name)r (choices: %(choices)s)', args)\n            throw new ArgumentError(this, msg)\n        }\n\n        if (this._deprecated.has(parser_name)) {\n            parser._warning(sub(\"command '%(parser_name)s' is deprecated\", { parser_name }))\n        }\n\n        // parse all the remaining options into the namespace\n        // store any unrecognized options on the object, so that the top\n        // level parser can decide what to do with them\n\n        // In case this subparser defines new defaults, we parse them\n        // in a new namespace object and then update the original\n        // namespace for the relevant parts.\n        let subnamespace\n        [subnamespace, arg_strings] = subparser.parse_known_args(arg_strings, undefined)\n        for (const [key, value] of Object.entries(subnamespace)) {\n            setattr(namespace, key, value)\n        }\n\n        if (arg_strings.length) {\n            if (!hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR)) {\n                setattr(namespace, _UNRECOGNIZED_ARGS_ATTR, [])\n            }\n            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).push(...arg_strings)\n        }\n    }\n})\n\n\n_SubParsersAction.prototype._ChoicesPseudoAction = _callable(class _ChoicesPseudoAction extends Action {\n    constructor (name, aliases, help) {\n        let metavar = name\n        const dest = name\n        if (aliases.length) {\n            metavar += sub(' (%s)', aliases.join(', '))\n        }\n        super({ option_strings: [], dest, help, metavar })\n    }\n})\n\n\nconst _ExtendAction = _callable(class _ExtendAction extends _AppendAction {\n    call (parser, namespace, values/*, option_string = undefined */) {\n        let items = getattr(namespace, this.dest, undefined)\n        items = _copy_items(items)\n        for (const value of values) {\n            items.push(value)\n        }\n        setattr(namespace, this.dest, items)\n    }\n})\n\n\n// ==============\n// Type classes\n// ==============\nconst FileType = _callable(class FileType extends Function {\n    /*\n     *  Deprecated factory for creating file object types\n     *\n     *  Instances of FileType are typically passed as type= arguments to the\n     *  ArgumentParser add_argument() method.\n     *\n     *  Keyword Arguments:\n     *      - mode -- A string indicating how the file is to be opened. Accepts the\n     *          same values as the builtin open() function.\n     *      - bufsize -- The file's desired buffer size. Accepts the same values as\n     *          the builtin open() function.\n     *      - encoding -- The file's encoding. Accepts the same values as the\n     *          builtin open() function.\n     *      - errors -- A string indicating how encoding and decoding errors are to\n     *          be handled. Accepts the same value as the builtin open() function.\n     */\n\n    constructor () {\n        const [\n            flags,\n            encoding,\n            mode,\n            autoClose,\n            emitClose,\n            start,\n            end,\n            highWaterMark,\n            fs\n        ] = _parse_opts(arguments, {\n            flags: 'r',\n            encoding: undefined,\n            mode: undefined, // 0o666\n            autoClose: undefined, // true\n            emitClose: undefined, // false\n            start: undefined, // 0\n            end: undefined, // Infinity\n            highWaterMark: undefined, // 64 * 1024\n            fs: undefined\n        })\n\n        process.emitWarning(\n            'FileType is deprecated. Simply open files after parsing arguments.',\n            'PendingDeprecationWarning')\n\n        // when this class is called as a function, redirect it to .call() method of itself\n        super('return arguments.callee.call.apply(arguments.callee, arguments)')\n\n        Object.defineProperty(this, 'name', {\n            get () {\n                return sub('FileType(%r)', flags)\n            }\n        })\n        this._flags = flags\n        this._options = {}\n        if (encoding !== undefined) this._options.encoding = encoding\n        if (mode !== undefined) this._options.mode = mode\n        if (autoClose !== undefined) this._options.autoClose = autoClose\n        if (emitClose !== undefined) this._options.emitClose = emitClose\n        if (start !== undefined) this._options.start = start\n        if (end !== undefined) this._options.end = end\n        if (highWaterMark !== undefined) this._options.highWaterMark = highWaterMark\n        if (fs !== undefined) this._options.fs = fs\n    }\n\n    call (string) {\n        // the special argument \"-\" means sys.std{in,out}\n        if (string === '-') {\n            if (this._flags.includes('r')) {\n                return process.stdin\n            } else if ([...'wax'].some(flag => this._flags.includes(flag))) {\n                return process.stdout\n            } else {\n                const msg = sub('argument \"-\" with mode %r', this._flags)\n                throw new TypeError(msg)\n            }\n        }\n\n        // all other arguments are used as file names\n        let fd\n        try {\n            fd = fs.openSync(string, this._flags, this._options.mode)\n        } catch (e) {\n            if (e instanceof TypeError) {\n                throw e\n            }\n            const args = { filename: string, error: e.message }\n            const message = \"can't open '%(filename)s': %(error)s\"\n            throw new ArgumentTypeError(sub(message, args))\n        }\n\n        const options = Object.assign({ fd, flags: this._flags }, this._options)\n        if (this._flags.includes('r')) {\n            const file = fs.createReadStream(string, options)\n            file.path = string\n            return file\n        } else if (this._flags.includes('w')) {\n            const file = fs.createWriteStream(string, options)\n            file.path = string\n            return file\n        } else {\n            fs.closeSync(fd)\n            const msg = sub('argument \"%s\" with mode %r', string, this._flags)\n            throw new TypeError(msg)\n        }\n    }\n\n    [util.inspect.custom] () {\n        const args = [this._flags]\n        const kwargs = Object.entries(this._options).map(([k, v]) => {\n            if (k === 'mode') v = { value: v, [util.inspect.custom] () { return '0o' + this.value.toString(8) } }\n            return [k, v]\n        })\n        const args_str = []\n                .concat(args.filter(arg => arg !== -1).map(repr))\n                .concat(kwargs.filter(([/* kw */, arg]) => arg !== undefined)\n                    .map(([kw, arg]) => sub('%s=%r', kw, arg)))\n                .join(', ')\n        return sub('%s(%s)', this.constructor.name, args_str)\n    }\n\n    toString () {\n        return this[util.inspect.custom]()\n    }\n})\n\n// ===========================\n// Optional and Positional Parsing\n// ===========================\nconst Namespace = _callable(class Namespace extends _AttributeHolder() {\n    /*\n     *  Simple object for storing attributes.\n     *\n     *  Implements equality by attribute names and values, and provides a simple\n     *  string representation.\n     */\n\n    constructor (options = {}) {\n        super()\n        Object.assign(this, options)\n    }\n})\n\n// unset string tag to mimic plain object\nNamespace.prototype[Symbol.toStringTag] = undefined\n\n\nconst _ActionsContainer = _callable(class _ActionsContainer {\n\n    constructor () {\n        const [\n            description,\n            prefix_chars,\n            argument_default,\n            conflict_handler\n        ] = _parse_opts(arguments, {\n            description: no_default,\n            prefix_chars: no_default,\n            argument_default: no_default,\n            conflict_handler: no_default\n        })\n\n        this.description = description\n        this.argument_default = argument_default\n        this.prefix_chars = prefix_chars\n        this.conflict_handler = conflict_handler\n\n        // set up registries\n        this._registries = Object.create(null)\n\n        // register actions\n        this.register('action', undefined, _StoreAction)\n        this.register('action', 'store', _StoreAction)\n        this.register('action', 'store_const', _StoreConstAction)\n        this.register('action', 'store_true', _StoreTrueAction)\n        this.register('action', 'store_false', _StoreFalseAction)\n        this.register('action', 'append', _AppendAction)\n        this.register('action', 'append_const', _AppendConstAction)\n        this.register('action', 'count', _CountAction)\n        this.register('action', 'help', _HelpAction)\n        this.register('action', 'version', _VersionAction)\n        this.register('action', 'parsers', _SubParsersAction)\n        this.register('action', 'extend', _ExtendAction)\n        // raise an exception if the conflict handler is invalid\n        this._get_handler()\n\n        // action storage\n        this._actions = []\n        this._option_string_actions = Object.create(null)\n\n        // groups\n        this._action_groups = []\n        this._mutually_exclusive_groups = []\n\n        // defaults storage\n        this._defaults = Object.create(null)\n\n        // determines whether an \"option\" looks like a negative number\n        this._negative_number_matcher = /^-\\.?\\d/\n\n        // whether or not there are any optionals that look like negative\n        // numbers -- uses a list so it can be shared and edited\n        this._has_negative_number_optionals = []\n    }\n\n    // ====================\n    // Registration methods\n    // ====================\n    register (registry_name, value, object) {\n        const registry = setdefault(this._registries, registry_name, Object.create(null))\n        registry[value] = object\n    }\n\n    _registry_get (registry_name, value, default_value = undefined) {\n        return getattr(this._registries[registry_name], value, default_value)\n    }\n\n    // ==================================\n    // Namespace default accessor methods\n    // ==================================\n    set_defaults (kwargs) {\n        Object.assign(this._defaults, kwargs)\n\n        // if these defaults match any existing arguments, replace\n        // the previous default on the object with the new one\n        for (const action of this._actions) {\n            if (action.dest in kwargs) {\n                action.default = kwargs[action.dest]\n            }\n        }\n    }\n\n    get_default (dest) {\n        for (const action of this._actions) {\n            if (action.dest === dest && action.default !== undefined) {\n                return action.default\n            }\n        }\n        return this._defaults[dest]\n    }\n\n\n    // =======================\n    // Adding argument actions\n    // =======================\n    add_argument () {\n        /*\n         *  add_argument(dest, ..., name=value, ...)\n         *  add_argument(option_string, option_string, ..., name=value, ...)\n         */\n        let [\n            args,\n            kwargs\n        ] = _parse_opts(arguments, {\n            '*args': no_default,\n            '**kwargs': no_default\n        })\n        // argparse v1 accepted an array of argument names here. Python argparse\n        // accepts only individual string names and rejects a list; reject it\n        // explicitly because JS would otherwise coerce the array to a string.\n        if (args.some(arg => typeof arg !== 'string')) {\n            throw new TypeError('argument name must be a string')\n        }\n        if (args.some(arg => !arg.length)) {\n            throw new TypeError('argument name must not be empty')\n        }\n        // if no positional args are supplied or only one is supplied and\n        // it doesn't look like an option string, parse a positional\n        // argument\n        const chars = this.prefix_chars\n        if (!args.length || args.length === 1 && !chars.includes(args[0][0])) {\n            if (args.length && 'dest' in kwargs) {\n                throw new TypeError('dest supplied twice for positional argument,' +\n                                    ' did you mean metavar?')\n            }\n            kwargs = this._get_positional_kwargs(...args, kwargs)\n\n        // otherwise, we're adding an optional argument\n        } else {\n            kwargs = this._get_optional_kwargs(...args, kwargs)\n        }\n\n        // if no default was supplied, use the parser-level default\n        if (!('default' in kwargs)) {\n            const dest = kwargs.dest\n            if (dest in this._defaults) {\n                kwargs.default = this._defaults[dest]\n            } else if (this.argument_default !== undefined) {\n                kwargs.default = this.argument_default\n            }\n        }\n\n        // create the action object, and add it to the parser\n        const action_name = kwargs.action\n        const action_class = this._pop_action_class(kwargs)\n        if (typeof action_class !== 'function') {\n            throw new TypeError(sub('unknown action %r', action_class))\n        }\n        // eslint-disable-next-line new-cap\n        const action = new action_class(kwargs)\n\n        // raise an error if action for positional argument does not\n        // consume arguments\n        if (!action.option_strings.length && action.nargs === 0) {\n            throw new TypeError(sub('action %r is not valid for positional arguments', action_name))\n        }\n\n        // raise an error if the action type is not callable\n        const type_func = this._registry_get('type', action.type, action.type)\n        if (typeof type_func !== 'function') {\n            throw new TypeError(sub('%r is not callable', type_func))\n        }\n\n        if (type_func === FileType) {\n            throw new TypeError(sub('%r is a FileType class object, instance of it' +\n                                    ' must be passed', type_func))\n        }\n\n        // raise an error if the metavar does not match the type\n        if ('_get_validation_formatter' in this) {\n            const formatter = this._get_validation_formatter()\n            try {\n                formatter._format_args(action, undefined)\n            } catch (err) {\n                // check for 'invalid nargs value' is an artifact of TypeError and ValueError in js being the same\n                if (err instanceof TypeError && err.message !== 'invalid nargs value') {\n                    throw new TypeError('length of metavar tuple does not match nargs')\n                } else {\n                    throw err\n                }\n            }\n        }\n\n        this._check_help(action)\n\n        return this._add_action(action)\n    }\n\n    add_argument_group () {\n        const group = _ArgumentGroup(this, ...arguments)\n        this._action_groups.push(group)\n        return group\n    }\n\n    add_mutually_exclusive_group () {\n\n        const group = _MutuallyExclusiveGroup(this, ...arguments)\n        this._mutually_exclusive_groups.push(group)\n        return group\n    }\n\n    _add_action (action) {\n        // resolve any conflicts\n        this._check_conflict(action)\n\n        // add to actions list\n        this._actions.push(action)\n        action.container = this\n\n        // index the action by any option strings it has\n        for (const option_string of action.option_strings) {\n            this._option_string_actions[option_string] = action\n        }\n\n        // set the flag if any option strings look like negative numbers\n        for (const option_string of action.option_strings) {\n            if (this._negative_number_matcher.test(option_string)) {\n                if (!this._has_negative_number_optionals.length) {\n                    this._has_negative_number_optionals.push(true)\n                }\n            }\n        }\n\n        // return the created action\n        return action\n    }\n\n    _remove_action (action) {\n        _array_remove(this._actions, action)\n    }\n\n    _add_container_actions (container) {\n        // collect groups by titles\n        const title_group_map = Object.create(null)\n        for (const group of this._action_groups) {\n            if (group.title in title_group_map) {\n                // This branch could happen if a derived class added\n                // groups with duplicated titles in constructor.\n                const msg = 'cannot merge actions - two groups are named %r'\n                throw new TypeError(sub(msg, group.title))\n            }\n            title_group_map[group.title] = group\n        }\n\n        // map each action to its group\n        const group_map = new Map()\n        for (const group of container._action_groups) {\n\n            // if a group with the title exists, use that, otherwise\n            // create a new group matching the container's group\n            if (!(group.title in title_group_map)) {\n                title_group_map[group.title] = this.add_argument_group({\n                    title: group.title,\n                    description: group.description,\n                    conflict_handler: group.conflict_handler\n                })\n            }\n\n            // map the actions to their new group\n            for (const action of group._group_actions) {\n                group_map.set(action, title_group_map[group.title])\n            }\n        }\n\n        // add container's mutually exclusive groups\n        // NOTE: if add_mutually_exclusive_group ever gains title= and\n        // description= then this code will need to be expanded as above\n        for (const group of container._mutually_exclusive_groups) {\n            let cont\n            if (group._container === container) {\n                cont = this\n            } else {\n                cont = title_group_map[group._container.title]\n            }\n            const mutex_group = cont.add_mutually_exclusive_group({\n                required: group.required\n            })\n\n            // map the actions to their new mutex group\n            for (const action of group._group_actions) {\n                group_map.set(action, mutex_group)\n            }\n        }\n\n        // add all actions to this container or their group\n        for (const action of container._actions) {\n            const action_group = group_map.get(action) || this\n            action_group._add_action(action)\n        }\n    }\n\n    _get_positional_kwargs () {\n        const [\n            dest,\n            kwargs\n        ] = _parse_opts(arguments, {\n            dest: no_default,\n            '**kwargs': no_default\n        })\n\n        // make sure required is not specified\n        if ('required' in kwargs) {\n            const msg = \"'required' is an invalid argument for positionals\"\n            throw new TypeError(msg)\n        }\n\n        // mark positional arguments as required if at least one is\n        // always required\n        const nargs = kwargs.nargs\n        if (nargs === 0) {\n            throw new TypeError('nargs for positionals must be != 0')\n        }\n        if (![OPTIONAL, ZERO_OR_MORE, REMAINDER, SUPPRESS].includes(nargs)) {\n            kwargs.required = true\n        }\n\n        // return the keyword arguments with no option strings\n        return Object.assign(kwargs, { dest, option_strings: [] })\n    }\n\n    _get_optional_kwargs () {\n        const [\n            args,\n            kwargs\n        ] = _parse_opts(arguments, {\n            '*args': no_default,\n            '**kwargs': no_default\n        })\n\n        // determine short and long option strings\n        const option_strings = []\n        const long_option_strings = []\n        let option_string\n        for (option_string of args) {\n            // error on strings that don't start with an appropriate prefix\n            if (!this.prefix_chars.includes(option_string[0])) {\n                const args = {option: option_string,\n                            prefix_chars: this.prefix_chars}\n                const msg = 'invalid option string %(option)r: ' +\n                          'must start with a character %(prefix_chars)r'\n                throw new TypeError(sub(msg, args))\n            }\n\n            // strings starting with two prefix characters are long options\n            option_strings.push(option_string)\n            if (option_string.length > 1 && this.prefix_chars.includes(option_string[1])) {\n                long_option_strings.push(option_string)\n            }\n        }\n\n        // infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'\n        let dest = kwargs.dest\n        delete kwargs.dest\n        if (dest === undefined) {\n            let dest_option_string\n            if (long_option_strings.length) {\n                dest_option_string = long_option_strings[0]\n            } else {\n                dest_option_string = option_strings[0]\n            }\n            dest = _string_lstrip(dest_option_string, this.prefix_chars)\n            if (!dest) {\n                const msg = 'dest= is required for options like %r'\n                throw new TypeError(sub(msg, option_string))\n            }\n            dest = dest.replace(/-/g, '_')\n        }\n\n        // return the updated keyword arguments\n        return Object.assign(kwargs, { dest, option_strings })\n    }\n\n    _pop_action_class (kwargs, default_value = undefined) {\n        const action = getattr(kwargs, 'action', default_value)\n        delete kwargs.action\n        return this._registry_get('action', action, action)\n    }\n\n    _get_handler () {\n        // determine function from conflict handler string\n        const handler_func_name = sub('_handle_conflict_%s', this.conflict_handler)\n        if (typeof this[handler_func_name] === 'function') {\n            return this[handler_func_name]\n        } else {\n            const msg = 'invalid conflict_resolution value: %r'\n            throw new TypeError(sub(msg, this.conflict_handler))\n        }\n    }\n\n    _check_conflict (action) {\n\n        // find all options that conflict with this option\n        const confl_optionals = []\n        for (const option_string of action.option_strings) {\n            if (hasattr(this._option_string_actions, option_string)) {\n                const confl_optional = this._option_string_actions[option_string]\n                confl_optionals.push([option_string, confl_optional])\n            }\n        }\n\n        // resolve any conflicts\n        if (confl_optionals.length) {\n            const conflict_handler = this._get_handler()\n            conflict_handler.call(this, action, confl_optionals)\n        }\n    }\n\n    _handle_conflict_error (action, conflicting_actions) {\n        const message = conflicting_actions.length === 1 ?\n            'conflicting option string: %s' :\n            'conflicting option strings: %s'\n        const conflict_string = conflicting_actions.map(([option_string]) => option_string).join(', ')\n        throw new ArgumentError(action, sub(message, conflict_string))\n    }\n\n    _handle_conflict_resolve (action, conflicting_actions) {\n\n        // remove all conflicting options\n        for (const [option_string, action] of conflicting_actions) {\n\n            // remove the conflicting option\n            _array_remove(action.option_strings, option_string)\n            delete this._option_string_actions[option_string]\n\n            // if the option now has no option string, remove it from the\n            // container holding it\n            if (!action.option_strings.length) {\n                action.container._remove_action(action)\n            }\n        }\n    }\n\n    _check_help (action) {\n        if (action.help && '_get_validation_formatter' in this) {\n            const formatter = this._get_validation_formatter()\n            try {\n                formatter._expand_help(action)\n            } catch (err) {\n                if (err instanceof TypeError) {\n                    throw new TypeError('badly formed help string', { cause: err })\n                }\n                throw err\n            }\n        }\n    }\n})\n\n\nconst _ArgumentGroup = _callable(class _ArgumentGroup extends _ActionsContainer {\n\n    constructor () {\n        const [\n            container,\n            title,\n            description,\n            kwargs\n        ] = _parse_opts(arguments, {\n            container: no_default,\n            title: undefined,\n            description: undefined,\n            '**kwargs': no_default\n        })\n\n        if ('prefix_chars' in kwargs) {\n            const depr_msg =\n                \"The use of the undocumented 'prefix_chars' parameter in \" +\n                'ArgumentParser.add_argument_group() is deprecated.'\n            process.emitWarning(depr_msg, 'DeprecationWarning')\n        }\n\n        // add any missing keyword arguments by checking the container\n        setdefault(kwargs, 'conflict_handler', container.conflict_handler)\n        setdefault(kwargs, 'prefix_chars', container.prefix_chars)\n        setdefault(kwargs, 'argument_default', container.argument_default)\n        super(Object.assign({ description }, kwargs))\n\n        // group attributes\n        this.title = title\n        this._group_actions = []\n\n        // share most attributes with the container\n        this._registries = container._registries\n        this._actions = container._actions\n        this._option_string_actions = container._option_string_actions\n        this._defaults = container._defaults\n        this._has_negative_number_optionals =\n            container._has_negative_number_optionals\n        this._mutually_exclusive_groups = container._mutually_exclusive_groups\n    }\n\n    _add_action (action) {\n        action = super._add_action(action)\n        this._group_actions.push(action)\n        return action\n    }\n\n    _remove_action (action) {\n        super._remove_action(action)\n        _array_remove(this._group_actions, action)\n    }\n\n    add_argument_group () {\n        throw new TypeError('argument groups cannot be nested')\n    }\n})\n\n\nconst _MutuallyExclusiveGroup = _callable(class _MutuallyExclusiveGroup extends _ArgumentGroup {\n\n    constructor () {\n        const [\n            container,\n            required\n        ] = _parse_opts(arguments, {\n            container: no_default,\n            required: false\n        })\n\n        super(container)\n        this.required = required\n        this._container = container\n    }\n\n    _add_action (action) {\n        if (action.required) {\n            const msg = 'mutually exclusive arguments must be optional'\n            throw new TypeError(msg)\n        }\n        action = this._container._add_action(action)\n        this._group_actions.push(action)\n        return action\n    }\n\n    _remove_action (action) {\n        this._container._remove_action(action)\n        _array_remove(this._group_actions, action)\n    }\n\n    add_mutually_exclusive_group () {\n        throw new TypeError('mutually exclusive groups cannot be nested')\n    }\n})\n\n\nconst ArgumentParser = _callable(class ArgumentParser extends _AttributeHolder(_ActionsContainer) {\n    /*\n     *  Object for parsing command line strings into Python objects.\n     *\n     *  Keyword Arguments:\n     *      - prog -- The name of the program (default: sys.argv[0])\n     *      - usage -- A usage message (default: auto-generated from arguments)\n     *      - description -- A description of what the program does\n     *      - epilog -- Text following the argument descriptions\n     *      - parents -- Parsers whose arguments should be copied into this one\n     *      - formatter_class -- HelpFormatter class for printing help messages\n     *      - prefix_chars -- Characters that prefix optional arguments\n     *      - fromfile_prefix_chars -- Characters that prefix files containing\n     *          additional arguments\n     *      - argument_default -- The default value for all arguments\n     *      - conflict_handler -- String indicating how to handle conflicts\n     *      - add_help -- Add a -h/-help option\n     *      - allow_abbrev -- Allow long options to be abbreviated unambiguously\n     *      - exit_on_error -- Determines whether or not ArgumentParser exits with\n     *          error info when an error occurs\n     *      - suggest_on_error - Enables suggestions for mistyped argument choices\n     *          and subparser names. (default: false)\n     *      - color - Allow color output in help messages (default: true)\n     */\n\n    constructor () {\n        let [\n            prog,\n            usage,\n            description,\n            epilog,\n            parents,\n            formatter_class,\n            prefix_chars,\n            fromfile_prefix_chars,\n            argument_default,\n            conflict_handler,\n            add_help,\n            allow_abbrev,\n            exit_on_error,\n            suggest_on_error,\n            color\n        ] = _parse_opts(arguments, {\n            prog: undefined,\n            usage: undefined,\n            description: undefined,\n            epilog: undefined,\n            parents: [],\n            formatter_class: HelpFormatter,\n            prefix_chars: '-',\n            fromfile_prefix_chars: undefined,\n            argument_default: undefined,\n            conflict_handler: 'error',\n            add_help: true,\n            allow_abbrev: true,\n            exit_on_error: true,\n            '*': no_default,\n            suggest_on_error: false,\n            color: true\n        })\n\n        super({\n            description,\n            prefix_chars,\n            argument_default,\n            conflict_handler\n        })\n\n        // default setting for prog\n        if (prog === undefined) {\n            prog = path.basename(get_argv()[0] || '')\n        }\n\n        this.prog = prog\n        this.usage = usage\n        this.epilog = epilog\n        this.formatter_class = formatter_class\n        this.fromfile_prefix_chars = fromfile_prefix_chars\n        this.add_help = add_help\n        this.allow_abbrev = allow_abbrev\n        this.exit_on_error = exit_on_error\n        this.suggest_on_error = suggest_on_error\n        this.color = color\n\n        // Cached formatter for validation (avoids repeated _set_color calls)\n        this._cached_formatter = undefined\n\n        this._positionals = this.add_argument_group('positional arguments')\n        this._optionals = this.add_argument_group('options')\n        this._subparsers = undefined\n\n        // register types\n        function identity (string) {\n            return string\n        }\n        this.register('type', undefined, identity)\n        this.register('type', null, identity)\n        this.register('type', 'int', function (x) {\n            if (typeof x === 'string' && !/^[+-]?\\d+(?:_\\d+)*$/.test(x.trim())) {\n                throw new TypeError(sub('could not convert string to int: %r', x))\n            }\n            const result = _string_to_number(x)\n            if (!Number.isInteger(result)) {\n                throw new TypeError(sub('could not convert string to int: %r', x))\n            }\n            // python integers have no negative zero\n            return result === 0 ? 0 : result\n        })\n        this.register('type', 'float', function (x) {\n            if (typeof x === 'string') {\n                const value = x.trim().toLowerCase()\n                // Number() knows neither spelling\n                if (/^[+-]?nan$/.test(value)) return NaN\n                if (/^[+-]?inf(?:inity)?$/.test(value)) {\n                    return value[0] === '-' ? -Infinity : Infinity\n                }\n                // python's float() grammar: PEP 515 underscores, optional exponent\n                const number = /^[+-]?(\\d+(_\\d+)*(\\.(\\d+(_\\d+)*)?)?|\\.\\d+(_\\d+)*)(e[+-]?\\d+(_\\d+)*)?$/\n                if (!number.test(value)) {\n                    throw new TypeError(sub('could not convert string to float: %r', x))\n                }\n            }\n            const result = _string_to_number(x)\n            if (isNaN(result)) {\n                throw new TypeError(sub('could not convert string to float: %r', x))\n            }\n            return result\n        })\n        this.register('type', 'str', String)\n\n        // add help argument if necessary\n        // (using explicit default to override global argument_default)\n        const default_prefix = prefix_chars.includes('-') ? '-' : prefix_chars[0]\n        if (this.add_help) {\n            this.add_argument(\n                default_prefix + 'h',\n                default_prefix.repeat(2) + 'help',\n                {\n                    action: 'help',\n                    default: SUPPRESS,\n                    help: 'show this help message and exit'\n                }\n            )\n        }\n        // add parent arguments and defaults\n        for (const parent of parents) {\n            if (!(parent instanceof ArgumentParser)) {\n                throw new TypeError('parents must be a list of ArgumentParser')\n            }\n            this._add_container_actions(parent)\n            Object.assign(this._defaults, parent._defaults)\n        }\n    }\n\n    // =======================\n    // Pretty __repr__ methods\n    // =======================\n    _get_kwargs () {\n        const names = [\n            'prog',\n            'usage',\n            'description',\n            'formatter_class',\n            'conflict_handler',\n            'add_help'\n        ]\n        return names.map(name => [name, getattr(this, name)])\n    }\n\n    // ==================================\n    // Optional/Positional adding methods\n    // ==================================\n    add_subparsers () {\n        const [\n            kwargs\n        ] = _parse_opts(arguments, {\n            '**kwargs': no_default\n        })\n\n        if (this._subparsers !== undefined) {\n            throw new TypeError('cannot have multiple subparser arguments')\n        }\n\n        // add the parser class to the arguments if it's not present\n        setdefault(kwargs, 'parser_class', this.constructor)\n\n        if ('title' in kwargs || 'description' in kwargs) {\n            const title = getattr(kwargs, 'title', 'subcommands')\n            const description = getattr(kwargs, 'description', undefined)\n            delete kwargs.title\n            delete kwargs.description\n            this._subparsers = this.add_argument_group(title, description)\n        } else {\n            this._subparsers = this._positionals\n        }\n\n        // prog defaults to the usage message of this parser, skipping\n        // optional arguments and with no \"usage:\" prefix\n        if (kwargs.prog === undefined) {\n            // Create formatter without color to avoid storing ANSI codes in prog\n            // eslint-disable-next-line new-cap\n            const formatter = new this.formatter_class({ prog: this.prog })\n            formatter._set_color(false)\n            const positionals = this._get_positional_actions()\n            const groups = this._mutually_exclusive_groups\n            formatter.add_usage(undefined, positionals, groups, '')\n            kwargs.prog = formatter.format_help().trim()\n        }\n\n        // create the parsers action and add it to the positionals list\n        const parsers_class = this._pop_action_class(kwargs, 'parsers')\n        if (hasattr(kwargs, 'option_strings')) {\n            throw new TypeError(\"add_subparsers() got multiple values for argument 'option_strings'\")\n        }\n        // eslint-disable-next-line new-cap\n        const action = new parsers_class(Object.assign({ option_strings: [] }, kwargs))\n        action._color = this.color\n        this._check_help(action)\n        this._subparsers._add_action(action)\n\n        // return the created parsers action\n        return action\n    }\n\n    _add_action (action) {\n        if (action.option_strings.length) {\n            this._optionals._add_action(action)\n        } else {\n            this._positionals._add_action(action)\n        }\n        return action\n    }\n\n    _get_optional_actions () {\n        return this._actions.filter(action => action.option_strings.length)\n    }\n\n    _get_positional_actions () {\n        return this._actions.filter(action => !action.option_strings.length)\n    }\n\n    // =====================================\n    // Command line argument parsing methods\n    // =====================================\n    parse_args (args = undefined, namespace = undefined) {\n        let argv\n        [args, argv] = this.parse_known_args(args, namespace)\n        if (argv && argv.length > 0) {\n            const msg = sub('unrecognized arguments: %s', argv.join(' '))\n            if (this.exit_on_error) {\n                this.error(msg)\n            } else {\n                throw new ArgumentError(undefined, msg)\n            }\n        }\n        return args\n    }\n\n    parse_known_args (args = undefined, namespace = undefined) {\n        return this._parse_known_args2(args, namespace, false)\n    }\n\n    _parse_known_args2 (args, namespace, intermixed) {\n        if (args === undefined) {\n            args = get_argv().slice(1)\n        } else {\n            args = Array.from(args)\n        }\n\n        // default Namespace built from parser defaults\n        if (namespace === undefined) {\n            namespace = new Namespace()\n        }\n\n        // add any action defaults that aren't present\n        for (const action of this._actions) {\n            if (action.dest !== SUPPRESS) {\n                if (!hasattr(namespace, action.dest)) {\n                    if (action.default !== SUPPRESS) {\n                        setattr(namespace, action.dest, action.default)\n                    }\n                }\n            }\n        }\n\n        // add any parser defaults that aren't present\n        for (const dest of Object.keys(this._defaults)) {\n            if (!hasattr(namespace, dest)) {\n                setattr(namespace, dest, this._defaults[dest])\n            }\n        }\n\n        // parse the arguments and exit if there are any errors\n        if (this.exit_on_error) {\n            try {\n                [namespace, args] = this._parse_known_args(args, namespace, intermixed)\n            } catch (err) {\n                if (err instanceof ArgumentError) {\n                    this.error(err.message)\n                } else {\n                    throw err\n                }\n            }\n        } else {\n            [namespace, args] = this._parse_known_args(args, namespace, intermixed)\n        }\n\n        if (hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR)) {\n            args = args.concat(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))\n            delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)\n        }\n\n        return [namespace, args]\n    }\n\n    _parse_known_args (arg_strings, namespace, intermixed) {\n        // replace arg strings that are file references\n        if (this.fromfile_prefix_chars !== undefined) {\n            arg_strings = this._read_args_from_files(arg_strings)\n        }\n\n        // map all mutually exclusive arguments to the other arguments\n        // they can't occur with\n        const action_conflicts = new Map()\n        for (const mutex_group of this._mutually_exclusive_groups) {\n            const group_actions = mutex_group._group_actions\n            for (const [i, mutex_action] of Object.entries(mutex_group._group_actions)) {\n                let conflicts = action_conflicts.get(mutex_action) || []\n                conflicts = conflicts.concat(group_actions.slice(0, +i))\n                conflicts = conflicts.concat(group_actions.slice(+i + 1))\n                action_conflicts.set(mutex_action, conflicts)\n            }\n        }\n\n        // find all option indices, and determine the arg_string_pattern\n        // which has an 'O' if there is an option at an index,\n        // an 'A' if there is an argument, or a '-' if there is a '--'\n        const option_string_indices = {}\n        const arg_string_pattern_parts = []\n        const arg_strings_iter = Object.entries(arg_strings)[Symbol.iterator]()\n        for (let [i, arg_string] of arg_strings_iter) {\n\n            // all args after -- are non-options\n            if (arg_string === '--') {\n                arg_string_pattern_parts.push('-')\n                for ([i, arg_string] of arg_strings_iter) {\n                    arg_string_pattern_parts.push('A')\n                }\n\n            // otherwise, add the arg to the arg strings\n            // and note the index if it was an option\n            } else {\n                const option_tuples = this._parse_optional(arg_string)\n                let pattern\n                if (option_tuples === undefined) {\n                    pattern = 'A'\n                } else {\n                    option_string_indices[i] = option_tuples\n                    pattern = 'O'\n                }\n                arg_string_pattern_parts.push(pattern)\n            }\n        }\n\n        // join the pieces together to form the pattern\n        let arg_strings_pattern = arg_string_pattern_parts.join('')\n\n        // converts arg strings to the appropriate and then takes the action\n        const seen_actions = new Set()\n        const seen_non_default_actions = new Set()\n        const warned = new Set()\n        let extras\n\n        const take_action = (action, argument_strings, option_string = undefined) => {\n            seen_actions.add(action)\n            const argument_values = this._get_values(action, argument_strings)\n\n            // error if this argument is not allowed with other previously\n            // seen arguments\n            if (action.option_strings.length || argument_strings.length) {\n                seen_non_default_actions.add(action)\n                for (const conflict_action of action_conflicts.get(action) || []) {\n                    if (seen_non_default_actions.has(conflict_action)) {\n                        const msg = 'not allowed with argument %s'\n                        const action_name = _get_action_name(conflict_action)\n                        throw new ArgumentError(action, sub(msg, action_name))\n                    }\n                }\n            }\n\n            // take the action if we didn't receive a SUPPRESS value\n            // (e.g. from a default)\n            if (argument_values !== SUPPRESS) {\n                action(this, namespace, argument_values, option_string)\n            }\n        }\n\n        // function to convert arg_strings into an optional action\n        const consume_optional = start_index => {\n\n            // get the optional identified at this index\n            const option_tuples = option_string_indices[start_index]\n            if (option_tuples.length > 1) {\n                const options = option_tuples.map(([, option_string]) => option_string).join(', ')\n                const args = {option: arg_strings[start_index], matches: options}\n                const msg = 'ambiguous option: %(option)s could match %(matches)s'\n                throw new ArgumentError(undefined, sub(msg, args))\n            }\n            let [action, option_string, sep, explicit_arg] = option_tuples[0]\n\n            // identify additional optionals in the same arg string\n            // (e.g. -xyz is the same as -x -y -z if no args are required)\n            const action_tuples = []\n            let stop\n            for (;;) {\n\n                // if we found no optional action, skip it\n                if (action === undefined) {\n                    extras.push(arg_strings[start_index])\n                    extras_pattern.push('O')\n                    return start_index + 1\n                }\n\n                // if there is an explicit argument, try to match the\n                // optional's string arguments to only this\n                if (explicit_arg !== undefined) {\n                    const arg_count = this._match_argument(action, 'A')\n\n                    // if the action is a single-dash option and takes no\n                    // arguments, try to parse more single-dash options out\n                    // of the tail of the option string\n                    const chars = this.prefix_chars\n                    if (arg_count === 0 &&\n                        !chars.includes(option_string[1]) &&\n                        explicit_arg !== '') {\n                        if (sep || chars.includes(explicit_arg[0])) {\n                            const msg = 'ignored explicit argument %r'\n                            throw new ArgumentError(action, sub(msg, explicit_arg))\n                        }\n                        action_tuples.push([action, [], option_string])\n                        const char = option_string[0]\n                        option_string = char + explicit_arg[0]\n                        const optionals_map = this._option_string_actions\n                        if (hasattr(optionals_map, option_string)) {\n                            action = optionals_map[option_string]\n                            explicit_arg = explicit_arg.slice(1)\n                            if (!explicit_arg) {\n                                sep = explicit_arg = undefined\n                            } else if (explicit_arg[0] === '=') {\n                                sep = '='\n                                explicit_arg = explicit_arg.slice(1)\n                            } else {\n                                sep = ''\n                            }\n                        } else {\n                            extras.push(char + explicit_arg)\n                            extras_pattern.push('O')\n                            stop = start_index + 1\n                            break\n                        }\n\n                    // if the action expect exactly one argument, we've\n                    // successfully matched the option; exit the loop\n                    } else if (arg_count === 1) {\n                        stop = start_index + 1\n                        const args = [explicit_arg]\n                        action_tuples.push([action, args, option_string])\n                        break\n\n                    // error if a double-dash option did not use the\n                    // explicit argument\n                    } else {\n                        const msg = 'ignored explicit argument %r'\n                        throw new ArgumentError(action, sub(msg, explicit_arg))\n                    }\n\n                // if there is no explicit argument, try to match the\n                // optional's string arguments with the following strings\n                // if successful, exit the loop\n                } else {\n                    const start = start_index + 1\n                    const selected_patterns = arg_strings_pattern.slice(start)\n                    const arg_count = this._match_argument(action, selected_patterns)\n                    stop = start + arg_count\n                    const args = arg_strings.slice(start, stop)\n                    action_tuples.push([action, args, option_string])\n                    break\n                }\n            }\n\n            // add the Optional to the list and return the index at which\n            // the Optional's string args stopped\n            assert(action_tuples.length)\n            for (const [action, args, option_string] of action_tuples) {\n                if (action.deprecated && !warned.has(option_string)) {\n                    this._warning(sub(\"option '%(option)s' is deprecated\", {\n                        option: option_string\n                    }))\n                    warned.add(option_string)\n                }\n                take_action(action, args, option_string)\n            }\n            return stop\n        }\n\n        // the list of Positionals left to be parsed; this is modified\n        // by consume_positionals()\n        let positionals = this._get_positional_actions()\n\n        // function to convert arg_strings into positional actions\n        const consume_positionals = start_index => {\n            // match as many Positionals as possible\n            const selected_pattern = arg_strings_pattern.slice(start_index)\n            const arg_counts = this._match_arguments_partial(positionals, selected_pattern)\n\n            // slice off the appropriate arg strings for each Positional\n            // and add the Positional and its args to the list\n            for (let i = 0; i < positionals.length && i < arg_counts.length; i++) {\n                const action = positionals[i]\n                const arg_count = arg_counts[i]\n                const args = arg_strings.slice(start_index, start_index + arg_count)\n                // Strip out the first '--' if it is not in REMAINDER arg.\n                if (action.nargs === PARSER) {\n                    if (arg_strings_pattern[start_index] === '-') {\n                        assert(args[0] === '--')\n                        _array_remove(args, '--')\n                    }\n                } else if (action.nargs !== REMAINDER) {\n                    if (arg_strings_pattern.slice(start_index, start_index + arg_count).includes('-')) {\n                        _array_remove(args, '--')\n                    }\n                }\n                start_index += arg_count\n                if (args.length && action.deprecated && !warned.has(action.dest)) {\n                    this._warning(sub(\"argument '%(argument_name)s' is deprecated\", {\n                        argument_name: action.dest\n                    }))\n                    warned.add(action.dest)\n                }\n                take_action(action, args)\n            }\n\n            // slice off the Positionals that we just parsed and return the\n            // index at which the Positionals' string args stopped\n            positionals = positionals.slice(arg_counts.length)\n            return start_index\n        }\n\n        // consume Positionals and Optionals alternately, until we have\n        // passed the last option string\n        extras = []\n        let extras_pattern = []\n        let start_index = 0\n        const max_option_string_index = Math.max(-1, ...Object.keys(option_string_indices).map(Number))\n        while (start_index <= max_option_string_index) {\n\n            // consume any Positionals preceding the next option\n            let next_option_string_index = start_index\n            while (next_option_string_index <= max_option_string_index) {\n                if (next_option_string_index in option_string_indices) {\n                    break\n                }\n                next_option_string_index += 1\n            }\n            if (!intermixed && start_index !== next_option_string_index) {\n                const positionals_end_index = consume_positionals(start_index)\n\n                // only try to parse the next optional if we didn't consume\n                // the option string during the positionals parsing\n                if (positionals_end_index > start_index) {\n                    start_index = positionals_end_index\n                    continue\n                } else {\n                    start_index = positionals_end_index\n                }\n            }\n\n            // if we consumed all the positionals we could and we're not\n            // at the index of an option string, there were extra arguments\n            if (!(start_index in option_string_indices)) {\n                const strings = arg_strings.slice(start_index, next_option_string_index)\n                extras = extras.concat(strings)\n                extras_pattern = extras_pattern.concat(\n                    arg_strings_pattern.slice(start_index, next_option_string_index).split(''))\n                start_index = next_option_string_index\n            }\n\n            // consume the next optional and any arguments for it\n            start_index = consume_optional(start_index)\n        }\n\n        if (!intermixed) {\n            // consume any positionals following the last Optional\n            const stop_index = consume_positionals(start_index)\n\n            // if we didn't consume all the argument strings, there were extras\n            extras = extras.concat(arg_strings.slice(stop_index))\n        } else {\n            extras = extras.concat(arg_strings.slice(start_index))\n            extras_pattern = extras_pattern.concat(\n                arg_strings_pattern.slice(start_index).split(''))\n            extras_pattern = extras_pattern.join('')\n            assert(extras_pattern.length === extras.length)\n            // consume all positionals\n            arg_strings = extras.filter((string, i) => extras_pattern[i] !== 'O')\n            arg_strings_pattern = extras_pattern.replace(/O/g, '')\n            let stop_index = consume_positionals(0)\n            // leave unknown optionals and non-consumed positionals in extras\n            for (let i = 0; i < extras_pattern.length; i++) {\n                if (!stop_index) break\n                if (extras_pattern[i] !== 'O') {\n                    stop_index -= 1\n                    extras[i] = undefined\n                }\n            }\n            extras = extras.filter(string => string !== undefined)\n        }\n\n        // make sure all required actions were present and also convert\n        // action defaults which were not given as arguments\n        const required_actions = []\n        for (const action of this._actions) {\n            if (!seen_actions.has(action)) {\n                if (action.required) {\n                    required_actions.push(_get_action_name(action))\n                } else {\n                    // Convert action default now instead of doing it before\n                    // parsing arguments to avoid calling convert functions\n                    // twice (which may fail) if the argument was given, but\n                    // only if it was defined already in the namespace\n                    if (action.default !== undefined &&\n                        typeof action.default === 'string' &&\n                        hasattr(namespace, action.dest) &&\n                        action.default === getattr(namespace, action.dest)) {\n                        setattr(namespace, action.dest,\n                                this._get_value(action, action.default))\n                    }\n                }\n            }\n        }\n\n        if (required_actions.length) {\n            throw new ArgumentError(undefined,\n                sub('the following arguments are required: %s', required_actions.join(', ')))\n        }\n\n        // make sure all required groups had one option present\n        for (const group of this._mutually_exclusive_groups) {\n            if (group.required) {\n                let no_actions_used = true\n                for (const action of group._group_actions) {\n                    if (seen_non_default_actions.has(action)) {\n                        no_actions_used = false\n                        break\n                    }\n                }\n\n                // if no actions were used, report the error\n                if (no_actions_used) {\n                    const names = group._group_actions\n                        .filter(action => action.help !== SUPPRESS)\n                        .map(action => _get_action_name(action))\n                    const msg = 'one of the arguments %s is required'\n                    throw new ArgumentError(undefined, sub(msg, names.join(' ')))\n                }\n            }\n        }\n\n        // return the updated namespace and the extra arguments\n        return [namespace, extras]\n    }\n\n    _read_args_from_files (arg_strings) {\n        // expand arguments referencing files\n        let new_arg_strings = []\n        for (const arg_string of arg_strings) {\n\n            // for regular arguments, just add them back into the list\n            if (!arg_string || !this.fromfile_prefix_chars.includes(arg_string[0])) {\n                new_arg_strings.push(arg_string)\n\n            // replace arguments referencing files with the file content\n            } else {\n                let args_file\n                try {\n                    args_file = fs.readFileSync(arg_string.slice(1), 'utf8')\n                } catch (err) {\n                    throw new ArgumentError(undefined, err.message)\n                }\n                let arg_strings = []\n                for (const arg_line of splitlines(args_file)) {\n                    for (const arg of this.convert_arg_line_to_args(arg_line)) {\n                        arg_strings.push(arg)\n                    }\n                }\n                arg_strings = this._read_args_from_files(arg_strings)\n                new_arg_strings = new_arg_strings.concat(arg_strings)\n            }\n        }\n\n        // return the modified argument list\n        return new_arg_strings\n    }\n\n    convert_arg_line_to_args (arg_line) {\n        return [arg_line]\n    }\n\n    _match_argument (action, arg_strings_pattern) {\n        // match the pattern for this action to the arg strings\n        const nargs_pattern = this._get_nargs_pattern(action)\n        const match = arg_strings_pattern.match(new RegExp('^' + nargs_pattern))\n\n        // raise an exception if we weren't able to find a match\n        if (match === null) {\n            const nargs_errors = {\n                undefined: 'expected one argument',\n                [OPTIONAL]: 'expected at most one argument',\n                [ONE_OR_MORE]: 'expected at least one argument'\n            }\n            let msg = nargs_errors[action.nargs]\n            if (msg === undefined) {\n                msg = sub(action.nargs === 1 ? 'expected %s argument' : 'expected %s arguments', action.nargs)\n            }\n            throw new ArgumentError(action, msg)\n        }\n\n        // return the number of arguments matched\n        return match[1].length\n    }\n\n    _match_arguments_partial (actions, arg_strings_pattern) {\n        // progressively shorten the actions list by slicing off the\n        // final actions until we find a match\n        for (const i of range(actions.length, 0, -1)) {\n            const actions_slice = actions.slice(0, i)\n            const pattern = actions_slice.map(action => this._get_nargs_pattern(action)).join('')\n            const match = arg_strings_pattern.match(new RegExp('^' + pattern))\n            if (match !== null) {\n                const result = match.slice(1).map(string => string.length)\n                if (match[0].length < arg_strings_pattern.length &&\n                    arg_strings_pattern[match[0].length] === 'O') {\n                    while (result.length && !result[result.length - 1]) {\n                        result.pop()\n                    }\n                }\n                return result\n            }\n        }\n        return []\n    }\n\n    _parse_optional (arg_string) {\n        // if it's an empty string, it was meant to be a positional\n        if (!arg_string) {\n            return undefined\n        }\n\n        // if it doesn't start with a prefix, it was meant to be positional\n        if (!this.prefix_chars.includes(arg_string[0])) {\n            return undefined\n        }\n\n        // if the option string is present in the parser, return the action\n        if (arg_string in this._option_string_actions) {\n            const action = this._option_string_actions[arg_string]\n            return [[action, arg_string, undefined, undefined]]\n        }\n\n        // if it's just a single character, it was meant to be positional\n        if (arg_string.length === 1) {\n            return undefined\n        }\n\n        // if the option string before the \"=\" is present, return the action\n        if (arg_string.includes('=')) {\n            const [option_string, explicit_arg] = _string_split(arg_string, '=', 1)\n            if (option_string in this._option_string_actions) {\n                const action = this._option_string_actions[option_string]\n                return [[action, option_string, '=', explicit_arg]]\n            }\n        }\n\n        // search through all possible prefixes of the option string\n        // and all actions in the parser for possible interpretations\n        const option_tuples = this._get_option_tuples(arg_string)\n\n        // if at least one action matched, return the options\n        if (option_tuples.length) {\n            return option_tuples\n        }\n\n        // if it was not found as an option, but it looks like a negative\n        // number, it was meant to be positional\n        // unless there are negative-number-like options\n        if (this._negative_number_matcher.test(arg_string)) {\n            if (!this._has_negative_number_optionals.length) {\n                return undefined\n            }\n        }\n\n        // if it contains a space, it was meant to be a positional\n        if (arg_string.includes(' ')) {\n            return undefined\n        }\n\n        // it was meant to be an optional but there is no such option\n        // in this parser (though it might be a valid option in a subparser)\n        return [[undefined, arg_string, undefined, undefined]]\n    }\n\n    _get_option_tuples (option_string) {\n        const result = []\n\n        // option strings starting with two prefix characters are only\n        // split at the '='\n        const chars = this.prefix_chars\n        if (chars.includes(option_string[0]) && chars.includes(option_string[1])) {\n            if (this.allow_abbrev) {\n                let option_prefix, sep, explicit_arg\n                if (option_string.includes('=')) {\n                    [option_prefix, explicit_arg] = _string_split(option_string, '=', 1)\n                    sep = '='\n                } else {\n                    option_prefix = option_string\n                    sep = undefined\n                    explicit_arg = undefined\n                }\n                for (const option_string of Object.keys(this._option_string_actions)) {\n                    if (option_string.startsWith(option_prefix)) {\n                        const action = this._option_string_actions[option_string]\n                        const tup = [action, option_string, sep, explicit_arg]\n                        result.push(tup)\n                    }\n                }\n            }\n\n        // single character options can be concatenated with their arguments\n        // but multiple character options always have to have their argument\n        // separate\n        } else if (chars.includes(option_string[0]) && !chars.includes(option_string[1])) {\n            let option_prefix, sep, explicit_arg\n            if (option_string.includes('=')) {\n                [option_prefix, explicit_arg] = _string_split(option_string, '=', 1)\n                sep = '='\n            } else {\n                option_prefix = option_string\n                sep = explicit_arg = undefined\n            }\n            const short_option_prefix = option_string.slice(0, 2)\n            const short_explicit_arg = option_string.slice(2)\n\n            for (const option_string of Object.keys(this._option_string_actions)) {\n                if (option_string === short_option_prefix) {\n                    const action = this._option_string_actions[option_string]\n                    const tup = [action, option_string, '', short_explicit_arg]\n                    result.push(tup)\n                } else if (this.allow_abbrev && option_string.startsWith(option_prefix)) {\n                    const action = this._option_string_actions[option_string]\n                    const tup = [action, option_string, sep, explicit_arg]\n                    result.push(tup)\n                }\n            }\n\n        // shouldn't ever get here\n        } else {\n            throw new ArgumentError(undefined, sub('unexpected option string: %s', option_string))\n        }\n\n        // return the collected option tuples\n        return result\n    }\n\n    _get_nargs_pattern (action) {\n        // in all examples below, we have to allow for '--' args\n        // which are represented as '-' in the pattern\n        const nargs = action.nargs\n        const option = action.option_strings.length\n        let nargs_pattern\n\n        // the default (None) is assumed to be a single argument\n        if (nargs === undefined) {\n            nargs_pattern = option ? '([A])' : '(-*A-*)'\n\n        // allow zero or one arguments\n        } else if (nargs === OPTIONAL) {\n            nargs_pattern = option ? '(A?)' : '(-*A?-*)'\n\n        // allow zero or more arguments\n        } else if (nargs === ZERO_OR_MORE) {\n            nargs_pattern = option ? '(A*)' : '(-*[A-]*)'\n\n        // allow one or more arguments\n        } else if (nargs === ONE_OR_MORE) {\n            nargs_pattern = option ? '(A+)' : '(-*A[A-]*)'\n\n        // allow any number of options or arguments\n        } else if (nargs === REMAINDER) {\n            nargs_pattern = option ? '([AO]*)' : '(.*)'\n\n        // allow one argument followed by any number of options or arguments\n        } else if (nargs === PARSER) {\n            nargs_pattern = option ? '(A[AO]*)' : '(-*A[-AO]*)'\n\n        // suppress action, like nargs=0\n        } else if (nargs === SUPPRESS) {\n            nargs_pattern = option ? '()' : '(-*)'\n\n        // all others should be integers\n        } else {\n            nargs_pattern = option\n                ? sub('([AO]{%s})', nargs)\n                : sub('((?:-*A){%s}-*)', nargs)\n        }\n\n        // return the pattern\n        return nargs_pattern\n    }\n\n    // ========================\n    // Alt command line argument parsing, allowing free intermix\n    // ========================\n\n    parse_intermixed_args (args = undefined, namespace = undefined) {\n        let argv\n        [args, argv] = this.parse_known_intermixed_args(args, namespace)\n        if (argv.length) {\n            const msg = sub('unrecognized arguments: %s', argv.join(' '))\n            if (this.exit_on_error) {\n                this.error(msg)\n            } else {\n                throw new ArgumentError(undefined, msg)\n            }\n        }\n        return args\n    }\n\n    parse_known_intermixed_args (args = undefined, namespace = undefined) {\n        // returns a namespace and list of extras\n        //\n        // positional can be freely intermixed with optionals.  optionals are\n        // first parsed with all positional arguments deactivated.  The 'extras'\n        // are then parsed.  If the parser definition is incompatible with the\n        // intermixed assumptions (e.g. use of REMAINDER, subparsers) a\n        // TypeError is raised.\n\n        const positionals = this._get_positional_actions()\n        const a = positionals.filter(action => [PARSER, REMAINDER].includes(action.nargs))\n        if (a.length) {\n            throw new TypeError(sub('parse_intermixed_args: positional arg' +\n                                    ' with nargs=%s', a[0].nargs))\n        }\n\n        return this._parse_known_args2(args, namespace, true)\n    }\n\n    // ========================\n    // Value conversion methods\n    // ========================\n    _get_values (action, arg_strings) {\n        let value\n        // optional argument produces a default when not present\n        if (!arg_strings.length && action.nargs === OPTIONAL) {\n            if (action.option_strings.length) {\n                value = action.const\n            } else {\n                value = action.default\n            }\n            if (typeof value === 'string' && value !== SUPPRESS) {\n                value = this._get_value(action, value)\n            }\n\n        // when nargs='*' on a positional, if there were no command-line\n        // args, use the default if it is anything other than None\n        } else if (!arg_strings.length && action.nargs === ZERO_OR_MORE &&\n              !action.option_strings.length) {\n            if (action.default !== undefined) {\n                value = action.default\n            } else {\n                value = []\n            }\n\n        // single argument or optional argument produces a single value\n        } else if (arg_strings.length === 1 && [undefined, OPTIONAL].includes(action.nargs)) {\n            const arg_string = arg_strings[0]\n            value = this._get_value(action, arg_string)\n            this._check_value(action, value)\n\n        // REMAINDER arguments convert all values, checking none\n        } else if (action.nargs === REMAINDER) {\n            value = arg_strings.map(v => this._get_value(action, v))\n\n        // PARSER arguments convert all values, but check only the first\n        } else if (action.nargs === PARSER) {\n            value = arg_strings.map(v => this._get_value(action, v))\n            this._check_value(action, value[0])\n\n        // SUPPRESS argument does not put anything in the namespace\n        } else if (action.nargs === SUPPRESS) {\n            value = SUPPRESS\n\n        // all other types of nargs produce a list\n        } else {\n            value = arg_strings.map(v => this._get_value(action, v))\n            for (const v of value) {\n                this._check_value(action, v)\n            }\n        }\n\n        // return the converted value\n        return value\n    }\n\n    _get_value (action, arg_string) {\n        const type_func = this._registry_get('type', action.type, action.type)\n        if (typeof type_func !== 'function') {\n            throw new TypeError(sub('%r is not callable', type_func))\n        }\n\n        // convert the value to the appropriate type\n        let result\n        try {\n            try {\n                result = type_func(arg_string)\n            } catch (err) {\n                // Dear TC39, why would you ever consider making es6 classes not callable?\n                // We had one universal interface, [[Call]], which worked for anything\n                // (with familiar this-instanceof guard for classes). Now we have two.\n                if (err instanceof TypeError &&\n                    /Class constructor .* cannot be invoked without 'new'/.test(err.message)) {\n                    // eslint-disable-next-line new-cap\n                    result = new type_func(arg_string)\n                } else {\n                    throw err\n                }\n            }\n\n        } catch (err) {\n            // ArgumentTypeErrors indicate errors\n            if (err instanceof ArgumentTypeError) {\n                const msg = err.message\n                throw new ArgumentError(action, msg)\n\n            // TypeErrors or ValueErrors also indicate errors\n            } else if (err instanceof TypeError) {\n                const name = getattr(action.type, 'name', repr(action.type))\n                const args = {type: name, value: arg_string}\n                const msg = 'invalid %(type)s value: %(value)r'\n                throw new ArgumentError(action, sub(msg, args))\n            } else {\n                throw err\n            }\n        }\n\n        // return the converted value\n        return result\n    }\n\n    _check_value (action, value) {\n        // converted value must be one of the choices (if specified)\n        if (action.choices === undefined) return\n\n        const choices = _choices_to_array(action.choices)\n        if (choices.includes(value)) return\n\n        const args = {value: String(value),\n                    choices: choices.map(choice => repr(String(choice))).join(', ')}\n        let msg = 'invalid choice: %(value)r (choose from %(choices)s)'\n\n        if (this.suggest_on_error && typeof value === 'string') {\n            if (choices.every(choice => typeof choice === 'string')) {\n                const { get_close_matches } = require('./difflib')\n                const suggestions = get_close_matches(value, choices, 1)\n                if (suggestions.length) {\n                    args.closest = suggestions[0]\n                    msg = 'invalid choice: %(value)r, maybe you meant %(closest)r? ' +\n                          '(choose from %(choices)s)'\n                }\n            }\n        }\n\n        throw new ArgumentError(action, sub(msg, args))\n    }\n\n    // =======================\n    // Help-formatting methods\n    // =======================\n    format_usage () {\n        const formatter = this._get_formatter()\n        formatter.add_usage(this.usage, this._actions,\n                            this._mutually_exclusive_groups)\n        return formatter.format_help()\n    }\n\n    format_help () {\n        const formatter = this._get_formatter()\n\n        // usage\n        formatter.add_usage(this.usage, this._actions,\n                            this._mutually_exclusive_groups)\n\n        // description\n        formatter.add_text(this.description)\n\n        // positionals, optionals and user-defined groups\n        for (const action_group of this._action_groups) {\n            formatter.start_section(action_group.title)\n            formatter.add_text(action_group.description)\n            formatter.add_arguments(action_group._group_actions)\n            formatter.end_section()\n        }\n\n        // epilog\n        formatter.add_text(this.epilog)\n\n        // determine help from format above\n        return formatter.format_help()\n    }\n\n    _get_formatter () {\n        // eslint-disable-next-line new-cap\n        const formatter = new this.formatter_class({ prog: this.prog })\n        formatter._set_color(this.color)\n        return formatter\n    }\n\n    _get_validation_formatter () {\n        // Return cached formatter for read-only validation operations\n        // (_expand_help and _format_args). Avoids repeated slow _set_color calls.\n        if (this._cached_formatter === undefined) {\n            this._cached_formatter = this._get_formatter()\n        }\n        return this._cached_formatter\n    }\n\n    // =====================\n    // Help-printing methods\n    // =====================\n    print_usage (file = undefined) {\n        if (file === undefined) file = process.stdout\n        this._print_message(this.format_usage(), file)\n    }\n\n    print_help (file = undefined) {\n        if (file === undefined) file = process.stdout\n        this._print_message(this.format_help(), file)\n    }\n\n    _print_message (message, file = undefined) {\n        if (message) {\n            file = file || process.stderr\n            if (file && typeof file.write === 'function') {\n                file.write(message)\n            }\n        }\n    }\n\n    // ===============\n    // Exiting methods\n    // ===============\n    exit (status = 0, message = undefined) {\n        if (message) {\n            this._print_message(message, process.stderr)\n        }\n        process.exit(status)\n    }\n\n    error (message) {\n        /*\n         *  error(message: string)\n         *\n         *  Prints a usage message incorporating the message to stderr and\n         *  exits.\n         *\n         *  If you override this in a subclass, it should not return -- it\n         *  should either exit or raise an exception.\n         */\n\n        this.print_usage(process.stderr)\n        const args = {prog: this.prog, message}\n        this.exit(2, sub('%(prog)s: error: %(message)s\\n', args))\n    }\n\n    _warning (message) {\n        const args = { prog: this.prog, message }\n        this._print_message(sub('%(prog)s: warning: %(message)s\\n', args), process.stderr)\n    }\n})\n\n\nmodule.exports = {\n    ArgumentParser,\n    ArgumentError,\n    ArgumentTypeError,\n    BooleanOptionalAction,\n    FileType,\n    HelpFormatter,\n    ArgumentDefaultsHelpFormatter,\n    RawDescriptionHelpFormatter,\n    RawTextHelpFormatter,\n    MetavarTypeHelpFormatter,\n    Namespace,\n    Action,\n    ONE_OR_MORE,\n    OPTIONAL,\n    PARSER,\n    REMAINDER,\n    SUPPRESS,\n    ZERO_OR_MORE\n}\n"]}