@openclaw/matrix 2026.8.1-beta.3 → 2026.8.2

package/node_modules/markdown-it/node_modules/argparse/{argparse.js → lib/argparse.js}

@@ -1,5 +1,5 @@
-// Port of python's argparse module, version 3.9.0:
-// https://github.com/python/cpython/blob/v3.9.0rc1/Lib/argparse.py
+// Port of python's argparse module, version 3.14.6:
+// https://github.com/python/cpython/blob/v3.14.6/Lib/argparse.py
 
 'use strict'
 
@@ -24,11 +24,12 @@
  *         'integers', metavar='int', nargs='+', type=int,
  *         help='an integer to be summed')
  *     parser.add_argument(
- *         '--log', default=sys.stdout, type=argparse.FileType('w'),
+ *         '--log',
  *         help='the file where the sum should be written')
  *     args = parser.parse_args()
- *     args.log.write('%s' % sum(args.integers))
- *     args.log.close()
+ *     with (open(args.log, 'w') if args.log is not None
+ *           else contextlib.nullcontext(sys.stdout)) as log:
+ *         log.write('%s' % sum(args.integers))
  *
  * The module contains the following public classes:
  *
@@ -84,51 +85,51 @@ const _UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
 const assert = require('assert')
 const util = require('util')
 const fs = require('fs')
-const sub = require('./lib/sub')
+const sub = require('./sub')
 const path = require('path')
 const repr = util.inspect
 
-function get_argv() {
+function get_argv () {
     // omit first argument (which is assumed to be interpreter - `node`, `coffee`, `ts-node`, etc.)
     return process.argv.slice(1)
 }
 
-function get_terminal_size() {
+function get_terminal_size () {
     return {
         columns: +process.env.COLUMNS || process.stdout.columns || 80
     }
 }
 
-function hasattr(object, name) {
+function hasattr (object, name) {
     return Object.prototype.hasOwnProperty.call(object, name)
 }
 
-function getattr(object, name, value) {
+function getattr (object, name, value) {
     return hasattr(object, name) ? object[name] : value
 }
 
-function setattr(object, name, value) {
+function setattr (object, name, value) {
     object[name] = value
 }
 
-function setdefault(object, name, value) {
+function setdefault (object, name, value) {
     if (!hasattr(object, name)) object[name] = value
     return object[name]
 }
 
-function delattr(object, name) {
+function delattr (object, name) {
     delete object[name]
 }
 
-function range(from, to, step=1) {
+function range (from, to, step = 1) {
     // range(10) is equivalent to range(0, 10)
-    if (arguments.length === 1) [ to, from ] = [ from, 0 ]
+    if (arguments.length === 1) [to, from] = [from, 0]
     if (typeof from !== 'number' || typeof to !== 'number' || typeof step !== 'number') {
         throw new TypeError('argument cannot be interpreted as an integer')
     }
     if (step === 0) throw new TypeError('range() arg 3 must not be zero')
 
-    let result = []
+    const result = []
     if (step > 0) {
         for (let i = from; i < to; i += step) result.push(i)
     } else {
@@ -137,13 +138,13 @@ function range(from, to, step=1) {
     return result
 }
 
-function splitlines(str, keepends = false) {
+function splitlines (str, keepends = false) {
     let result
     if (!keepends) {
         result = str.split(/\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029]/)
     } else {
         result = []
-        let parts = str.split(/(\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029])/)
+        const parts = str.split(/(\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029])/)
         for (let i = 0; i < parts.length; i += 2) {
             result.push(parts[i] + (i + 1 < parts.length ? parts[i + 1] : ''))
         }
@@ -152,30 +153,29 @@ function splitlines(str, keepends = false) {
     return result
 }
 
-function _string_lstrip(string, prefix_chars) {
+function _string_lstrip (string, prefix_chars) {
     let idx = 0
     while (idx < string.length && prefix_chars.includes(string[idx])) idx++
     return idx ? string.slice(idx) : string
 }
 
-function _string_split(string, sep, maxsplit) {
+function _string_split (string, sep, maxsplit) {
     let result = string.split(sep)
     if (result.length > maxsplit) {
-        result = result.slice(0, maxsplit).concat([ result.slice(maxsplit).join(sep) ])
+        result = result.slice(0, maxsplit).concat([result.slice(maxsplit).join(sep)])
     }
     return result
 }
 
-function _array_equal(array1, array2) {
-    if (array1.length !== array2.length) return false
-    for (let i = 0; i < array1.length; i++) {
-        if (array1[i] !== array2[i]) return false
+function _string_to_number (string) {
+    if (typeof string === 'string' && !/(?:^|\D)_|_(?:\D|$)/.test(string)) {
+        string = string.replace(/_/g, '')
     }
-    return true
+    return Number(string)
 }
 
-function _array_remove(array, item) {
-    let idx = array.indexOf(item)
+function _array_remove (array, item) {
+    const idx = array.indexOf(item)
     if (idx === -1) throw new TypeError(sub('%r not in list', item))
     array.splice(idx, 1)
 }
@@ -183,11 +183,13 @@ function _array_remove(array, item) {
 // normalize choices to array;
 // this isn't required in python because `in` and `map` operators work with anything,
 // but in js dealing with multiple types here is too clunky
-function _choices_to_array(choices) {
+function _choices_to_array (choices) {
     if (choices === undefined) {
         return []
     } else if (Array.isArray(choices)) {
         return choices
+    } else if (choices instanceof Map) {
+        return Array.from(choices.keys())
     } else if (choices !== null && typeof choices[Symbol.iterator] === 'function') {
         return Array.from(choices)
     } else if (typeof choices === 'object' && choices !== null) {
@@ -198,10 +200,10 @@ function _choices_to_array(choices) {
 }
 
 // decorator that allows a class to be called without new
-function _callable(cls) {
-    let result = { // object is needed for inferred class name
+function _callable (cls) {
+    const result = { // object is needed for inferred class name
         [cls.name]: function (...args) {
-            let this_class = new.target === result || !new.target
+            const this_class = new.target === result || !new.target
             return Reflect.construct(cls, args, this_class ? cls : new.target)
         }
     }
@@ -211,45 +213,11 @@ function _callable(cls) {
     return result[cls.name]
 }
 
-function _alias(object, from, to) {
-    try {
-        let name = object.constructor.name
-        Object.defineProperty(object, from, {
-            value: util.deprecate(object[to], sub('%s.%s() is renamed to %s.%s()',
-                name, from, name, to)),
-            enumerable: false
-        })
-    } catch {}
-}
-
-// decorator that allows snake_case class methods to be called with camelCase and vice versa
-function _camelcase_alias(_class) {
-    for (let name of Object.getOwnPropertyNames(_class.prototype)) {
-        let camelcase = name.replace(/\w_[a-z]/g, s => s[0] + s[2].toUpperCase())
-        if (camelcase !== name) _alias(_class.prototype, camelcase, name)
-    }
-    return _class
-}
-
-function _to_legacy_name(key) {
-    key = key.replace(/\w_[a-z]/g, s => s[0] + s[2].toUpperCase())
-    if (key === 'default') key = 'defaultValue'
-    if (key === 'const') key = 'constant'
-    return key
-}
-
-function _to_new_name(key) {
-    if (key === 'defaultValue') key = 'default'
-    if (key === 'constant') key = 'const'
-    key = key.replace(/[A-Z]/g, c => '_' + c.toLowerCase())
-    return key
-}
-
 // parse options
-let no_default = Symbol('no_default_value')
-function _parse_opts(args, descriptor) {
-    function get_name() {
-        let stack = new Error().stack.split('\n')
+const no_default = Symbol('no_default_value')
+function _parse_opts (args, descriptor) {
+    function get_name () {
+        const stack = new Error().stack.split('\n')
             .map(x => x.match(/^    at (.*) \(.*\)$/))
             .filter(Boolean)
             .map(m => m[1])
@@ -262,63 +230,23 @@ function _parse_opts(args, descriptor) {
 
     args = Array.from(args)
     let kwargs = {}
-    let result = []
-    let last_opt = args.length && args[args.length - 1]
+    const result = []
+    const last_opt = args.length && args[args.length - 1]
 
     if (typeof last_opt === 'object' && last_opt !== null && !Array.isArray(last_opt) &&
         (!last_opt.constructor || last_opt.constructor.name === 'Object')) {
         kwargs = Object.assign({}, args.pop())
     }
 
-    // LEGACY (v1 compatibility): camelcase
-    let renames = []
-    for (let key of Object.keys(descriptor)) {
-        let old_name = _to_legacy_name(key)
-        if (old_name !== key && (old_name in kwargs)) {
-            if (key in kwargs) {
-                // default and defaultValue specified at the same time, happens often in old tests
-                //throw new TypeError(sub('%s() got multiple values for argument %r', get_name(), key))
-            } else {
-                kwargs[key] = kwargs[old_name]
-            }
-            renames.push([ old_name, key ])
-            delete kwargs[old_name]
-        }
-    }
-    if (renames.length) {
-        let name = get_name()
-        deprecate('camelcase_' + name, sub('%s(): following options are renamed: %s',
-            name, renames.map(([ a, b ]) => sub('%r -> %r', a, b))))
-    }
-    // end
-
-    let missing_positionals = []
-    let positional_count = args.length
+    const missing_positionals = []
+    const positional_count = args.length
+    let keyword_only = false
 
-    for (let [ key, def ] of Object.entries(descriptor)) {
-        if (key[0] === '*') {
+    for (const [key, def] of Object.entries(descriptor)) {
+        if (key === '*') {
+            keyword_only = true
+        } else if (key[0] === '*') {
             if (key.length > 0 && key[1] === '*') {
-                // LEGACY (v1 compatibility): camelcase
-                let renames = []
-                for (let key of Object.keys(kwargs)) {
-                    let new_name = _to_new_name(key)
-                    if (new_name !== key && (key in kwargs)) {
-                        if (new_name in kwargs) {
-                            // default and defaultValue specified at the same time, happens often in old tests
-                            //throw new TypeError(sub('%s() got multiple values for argument %r', get_name(), new_name))
-                        } else {
-                            kwargs[new_name] = kwargs[key]
-                        }
-                        renames.push([ key, new_name ])
-                        delete kwargs[key]
-                    }
-                }
-                if (renames.length) {
-                    let name = get_name()
-                    deprecate('camelcase_' + name, sub('%s(): following options are renamed: %s',
-                        name, renames.map(([ a, b ]) => sub('%r -> %r', a, b))))
-                }
-                // end
                 result.push(kwargs)
                 kwargs = {}
             } else {
@@ -330,7 +258,7 @@ function _parse_opts(args, descriptor) {
         } else if (key in kwargs) {
             result.push(kwargs[key])
             delete kwargs[key]
-        } else if (args.length > 0) {
+        } else if (args.length > 0 && !keyword_only) {
             result.push(args.shift())
         } else if (def !== no_default) {
             result.push(def)
@@ -345,8 +273,12 @@ function _parse_opts(args, descriptor) {
     }
 
     if (args.length) {
-        let from = Object.entries(descriptor).filter(([ k, v ]) => k[0] !== '*' && v !== no_default).length
-        let to = Object.entries(descriptor).filter(([ k ]) => k[0] !== '*').length
+        const entries = Object.entries(descriptor)
+        const marker = entries.findIndex(([k]) => k === '*')
+        const positional_entries = (marker === -1 ? entries : entries.slice(0, marker))
+            .filter(([k]) => k[0] !== '*')
+        const from = positional_entries.filter(([, v]) => v !== no_default).length
+        const to = positional_entries.length
         throw new TypeError(sub('%s() takes %s positional argument%s but %s %s given',
             get_name(),
             from === to ? sub('from %s to %s', from, to) : to,
@@ -356,9 +288,9 @@ function _parse_opts(args, descriptor) {
     }
 
     if (missing_positionals.length) {
-        let strs = missing_positionals.map(repr)
+        const strs = missing_positionals.map(repr)
         if (strs.length > 1) strs[strs.length - 1] = 'and ' + strs[strs.length - 1]
-        let str_joined = strs.join(strs.length === 2 ? '' : ', ')
+        const str_joined = strs.join(strs.length === 2 ? '' : ', ')
         throw new TypeError(sub('%s() missing %i required positional argument%s: %s',
             get_name(), strs.length, strs.length === 1 ? '' : 's', str_joined))
     }
@@ -366,17 +298,10 @@ function _parse_opts(args, descriptor) {
     return result
 }
 
-let _deprecations = {}
-function deprecate(id, string) {
-    _deprecations[id] = _deprecations[id] || util.deprecate(() => {}, string)
-    _deprecations[id]()
-}
-
-
 // =============================
 // Utility functions and classes
 // =============================
-function _AttributeHolder(cls = Object) {
+function _AttributeHolder (cls = Object) {
     /*
      *  Abstract base class that provides __repr__.
      *
@@ -387,14 +312,14 @@ function _AttributeHolder(cls = Object) {
      */
 
     return class _AttributeHolder extends cls {
-        [util.inspect.custom]() {
-            let type_name = this.constructor.name
-            let arg_strings = []
-            let star_args = {}
-            for (let arg of this._get_args()) {
+        [util.inspect.custom] () {
+            const type_name = this.constructor.name
+            const arg_strings = []
+            const star_args = {}
+            for (const arg of this._get_args()) {
                 arg_strings.push(repr(arg))
             }
-            for (let [ name, value ] of this._get_kwargs()) {
+            for (const [name, value] of this._get_kwargs()) {
                 if (/^[a-z_][a-z0-9_$]*$/i.test(name)) {
                     arg_strings.push(sub('%s=%r', name, value))
                 } else {
@@ -407,33 +332,37 @@ function _AttributeHolder(cls = Object) {
             return sub('%s(%s)', type_name, arg_strings.join(', '))
         }
 
-        toString() {
+        toString () {
             return this[util.inspect.custom]()
         }
 
-        _get_kwargs() {
+        _get_kwargs () {
             return Object.entries(this)
         }
 
-        _get_args() {
+        _get_args () {
             return []
         }
     }
 }
 
 
-function _copy_items(items) {
-    if (items === undefined) {
+function _copy_items (items) {
+    if (items === undefined || items === null) {
         return []
     }
     return items.slice(0)
 }
 
+function _identity (value) {
+    return value
+}
+
 
 // ===============
 // Formatting Help
 // ===============
-const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
+const HelpFormatter = _callable(class HelpFormatter {
     /*
      *  Formatter for generating usage messages and argument help strings.
      *
@@ -441,17 +370,19 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
      *  provided by the class are considered an implementation detail.
      */
 
-    constructor() {
+    constructor () {
         let [
             prog,
             indent_increment,
             max_help_position,
-            width
+            width,
+            color
         ] = _parse_opts(arguments, {
             prog: no_default,
             indent_increment: 2,
             max_help_position: 24,
-            width: undefined
+            width: undefined,
+            color: true
         })
 
         // default setting for width
@@ -460,6 +391,7 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
             width -= 2
         }
 
+        this._set_color(color)
         this._prog = prog
         this._indent_increment = indent_increment
         this._max_help_position = Math.min(max_help_position,
@@ -477,64 +409,80 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
         this._long_break_matcher = /\n\n\n+/g
     }
 
+    _set_color (color) {
+        const { can_colorize, decolor, get_theme } = require('./_colorize')
+
+        if (color && can_colorize()) {
+            this._theme = get_theme({ force_color: true }).argparse
+            this._decolor = decolor
+        } else {
+            this._theme = get_theme({ force_no_color: true }).argparse
+            this._decolor = _identity
+        }
+    }
+
     // ===============================
     // Section and indentation methods
     // ===============================
-    _indent() {
+    _indent () {
         this._current_indent += this._indent_increment
         this._level += 1
     }
 
-    _dedent() {
+    _dedent () {
         this._current_indent -= this._indent_increment
         assert(this._current_indent >= 0, 'Indent decreased below 0.')
         this._level -= 1
     }
 
-    _add_item(func, args) {
-        this._current_section.items.push([ func, args ])
+    _add_item (func, args) {
+        this._current_section.items.push([func, args])
     }
 
     // ========================
     // Message building methods
     // ========================
-    start_section(heading) {
+    start_section (heading) {
         this._indent()
-        let section = this._Section(this, this._current_section, heading)
+        const section = this._Section(this, this._current_section, heading)
         this._add_item(section.format_help.bind(section), [])
         this._current_section = section
     }
 
-    end_section() {
+    end_section () {
         this._current_section = this._current_section.parent
         this._dedent()
     }
 
-    add_text(text) {
+    add_text (text) {
         if (text !== SUPPRESS && text !== undefined) {
             this._add_item(this._format_text.bind(this), [text])
         }
     }
 
-    add_usage(usage, actions, groups, prefix = undefined) {
+    add_usage (usage, actions, groups, prefix = undefined) {
         if (usage !== SUPPRESS) {
-            let args = [ usage, actions, groups, prefix ]
+            const args = [usage, actions, groups, prefix]
             this._add_item(this._format_usage.bind(this), args)
         }
     }
 
-    add_argument(action) {
+    add_argument (action) {
         if (action.help !== SUPPRESS) {
 
             // find all invocations
-            let invocations = [this._format_action_invocation(action)]
-            for (let subaction of this._iter_indented_subactions(action)) {
-                invocations.push(this._format_action_invocation(subaction))
+            const get_invocation = action => this._decolor(this._format_action_invocation(action))
+            const invocation_lengths = [
+                get_invocation(action).length + this._current_indent
+            ]
+            for (const subaction of this._iter_indented_subactions(action)) {
+                invocation_lengths.push(
+                    get_invocation(subaction).length + this._current_indent
+                )
             }
 
             // update the maximum item length
-            let invocation_length = Math.max(...invocations.map(invocation => invocation.length))
-            let action_length = invocation_length + this._current_indent
+            const action_length = Math.max(...invocation_lengths)
             this._action_max_length = Math.max(this._action_max_length,
                                                action_length)
 
@@ -543,8 +491,8 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
         }
     }
 
-    add_arguments(actions) {
-        for (let action of actions) {
+    add_arguments (actions) {
+        for (const action of actions) {
             this.add_argument(action)
         }
     }
@@ -552,7 +500,7 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
     // =======================
     // Help-formatting methods
     // =======================
-    format_help() {
+    format_help () {
         let help = this._root_section.format_help()
         if (help) {
             help = help.replace(this._long_break_matcher, '\n\n')
@@ -561,79 +509,69 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
         return help
     }
 
-    _join_parts(part_strings) {
+    _join_parts (part_strings) {
         return part_strings.filter(part => part && part !== SUPPRESS).join('')
     }
 
-    _format_usage(usage, actions, groups, prefix) {
+    _format_usage (usage, actions, groups, prefix) {
+        const t = this._theme
+
         if (prefix === undefined) {
             prefix = 'usage: '
         }
 
         // if usage is specified, use that
         if (usage !== undefined) {
-            usage = sub(usage, { prog: this._prog })
+            usage = t.prog_extra + sub(usage, {
+                prog: t.prog + this._prog + t.reset + t.prog_extra
+            }) + t.reset
 
         // if no optionals or positionals are available, usage is just prog
         } else if (usage === undefined && !actions.length) {
-            usage = sub('%(prog)s', { prog: this._prog })
+            usage = t.prog + this._prog + t.reset
 
         // if optionals and positionals are available, calculate usage
         } else if (usage === undefined) {
-            let prog = sub('%(prog)s', { prog: this._prog })
-
-            // split optionals from positionals
-            let optionals = []
-            let positionals = []
-            for (let action of actions) {
-                if (action.option_strings.length) {
-                    optionals.push(action)
-                } else {
-                    positionals.push(action)
-                }
-            }
+            const prog = sub('%(prog)s', { prog: this._prog })
 
+            const [parts, pos_start] = this._get_actions_usage_parts(actions, groups)
             // build full usage string
-            let action_usage = this._format_actions_usage([].concat(optionals).concat(positionals), groups)
-            usage = [ prog, action_usage ].map(String).join(' ')
+            usage = [prog].concat(parts).filter(Boolean).join(' ')
 
             // wrap the usage parts if it's too long
-            let text_width = this._width - this._current_indent
-            if (prefix.length + usage.length > text_width) {
+            const text_width = this._width - this._current_indent
+            if (prefix.length + this._decolor(usage).length > text_width) {
 
                 // break usage into wrappable parts
-                let part_regexp = /\(.*?\)+(?=\s|$)|\[.*?\]+(?=\s|$)|\S+/g
-                let opt_usage = this._format_actions_usage(optionals, groups)
-                let pos_usage = this._format_actions_usage(positionals, groups)
-                let opt_parts = opt_usage.match(part_regexp) || []
-                let pos_parts = pos_usage.match(part_regexp) || []
-                assert(opt_parts.join(' ') === opt_usage)
-                assert(pos_parts.join(' ') === pos_usage)
+                const opt_parts = parts.slice(0, pos_start)
+                const pos_parts = parts.slice(pos_start)
 
                 // helper for wrapping lines
-                let get_lines = (parts, indent, prefix = undefined) => {
-                    let lines = []
+                const get_lines = (parts, indent, prefix = undefined) => {
+                    const lines = []
                     let line = []
+                    const indent_length = indent.length
                     let line_len
                     if (prefix !== undefined) {
                         line_len = prefix.length - 1
                     } else {
-                        line_len = indent.length - 1
+                        line_len = indent_length - 1
                     }
-                    for (let part of parts) {
-                        if (line_len + 1 + part.length > text_width && line) {
+                    for (const part of parts) {
+                        const part_len = this._decolor(part).length
+                        if (line_len + 1 + part_len > text_width && line.length) {
                             lines.push(indent + line.join(' '))
                             line = []
-                            line_len = indent.length - 1
+                            line_len = indent_length - 1
                         }
                         line.push(part)
-                        line_len += part.length + 1
+                        line_len += part_len + 1
                     }
                     if (line.length) {
                         lines.push(indent + line.join(' '))
                     }
                     if (prefix !== undefined) {
-                        lines[0] = lines[0].slice(indent.length)
+                        lines[0] = lines[0].slice(indent_length)
                     }
                     return lines
                 }
@@ -641,8 +579,9 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
                 let lines
 
                 // if prog is short, follow it with optionals or positionals
-                if (prefix.length + prog.length <= 0.75 * text_width) {
-                    let indent = ' '.repeat(prefix.length + prog.length + 1)
+                const prog_len = this._decolor(prog).length
+                if (prefix.length + prog_len <= 0.75 * text_width) {
+                    const indent = ' '.repeat(prefix.length + prog_len + 1)
                     if (opt_parts.length) {
                         lines = get_lines([prog].concat(opt_parts), indent, prefix)
                         lines = lines.concat(get_lines(pos_parts, indent))
@@ -654,8 +593,8 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
 
                 // if prog is long, put it on its own line
                 } else {
-                    let indent = ' '.repeat(prefix.length)
-                    let parts = [].concat(opt_parts).concat(pos_parts)
+                    const indent = ' '.repeat(prefix.length)
+                    const parts = [].concat(opt_parts).concat(pos_parts)
                     lines = get_lines(parts, indent)
                     if (lines.length > 1) {
                         lines = []
@@ -668,178 +607,214 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
                 // join lines into usage
                 usage = lines.join('\n')
             }
+
+            if (usage.startsWith(prog)) usage = usage.slice(prog.length)
+            usage = t.prog + prog + t.reset + usage
         }
 
         // prefix with 'usage:'
-        return sub('%s%s\n\n', prefix, usage)
+        return t.usage + prefix + t.reset + usage + '\n\n'
     }
 
-    _format_actions_usage(actions, groups) {
-        // find group indices and identify actions in groups
-        let group_actions = new Set()
-        let inserts = {}
-        for (let group of groups) {
-            let start = actions.indexOf(group._group_actions[0])
-            if (start === -1) {
-                continue
-            } else {
-                let end = start + group._group_actions.length
-                if (_array_equal(actions.slice(start, end), group._group_actions)) {
-                    for (let action of group._group_actions) {
-                        group_actions.add(action)
-                    }
-                    if (!group.required) {
-                        if (start in inserts) {
-                            inserts[start] += ' ['
-                        } else {
-                            inserts[start] = '['
-                        }
-                        if (end in inserts) {
-                            inserts[end] += ']'
-                        } else {
-                            inserts[end] = ']'
-                        }
-                    } else {
-                        if (start in inserts) {
-                            inserts[start] += ' ('
-                        } else {
-                            inserts[start] = '('
-                        }
-                        if (end in inserts) {
-                            inserts[end] += ')'
-                        } else {
-                            inserts[end] = ')'
+    _is_long_option (string) {
+        return string.length > 2
+    }
+
+    _get_actions_usage_parts (actions, groups) {
+        /* Get usage parts with split index for optionals/positionals.
+
+         * Returns [parts, pos_start] where pos_start is the index in parts
+         * where positionals begin. This preserves mutually exclusive group
+         * formatting across the optionals/positionals boundary (gh-75949).
+         */
+        actions = actions.filter(action => action.help !== SUPPRESS)
+
+        // group actions by mutually exclusive groups
+        const action_groups = new Map(actions.map(action => [action, undefined]))
+        for (const group of groups) {
+            for (const action of group._group_actions) {
+                if (action_groups.has(action)) {
+                    action_groups.set(action, group)
+                }
+            }
+        }
+
+        // positional arguments keep their position
+        const positionals = []
+        for (const action of actions) {
+            if (!action.option_strings.length) {
+                const group = action_groups.get(action)
+                action_groups.delete(action)
+                if (group) {
+                    const group_actions = []
+                    for (const action2 of group._group_actions) {
+                        if (action2.option_strings.length && action_groups.has(action2)) {
+                            const action_group = action_groups.get(action2)
+                            action_groups.delete(action2)
+                            if (action_group) {
+                                group_actions.push(action2)
+                            }
                         }
                     }
-                    for (let i of range(start + 1, end)) {
-                        inserts[i] = '|'
+                    group_actions.push(action)
+                    positionals.push([group.required, group_actions])
+                } else {
+                    positionals.push([undefined, [action]])
+                }
+            }
+        }
+
+        // the remaining optional arguments are sorted by the position of
+        // the first option in the group
+        const optionals = []
+        for (const action of actions) {
+            if (action.option_strings.length && action_groups.has(action)) {
+                const group = action_groups.get(action)
+                action_groups.delete(action)
+                if (group) {
+                    const group_actions = [action]
+                    for (const action2 of group._group_actions) {
+                        if (action2.option_strings.length && action_groups.has(action2)) {
+                            const action_group = action_groups.get(action2)
+                            action_groups.delete(action2)
+                            if (action_group) {
+                                group_actions.push(action2)
+                            }
+                        }
                     }
+                    optionals.push([group.required, group_actions])
+                } else {
+                    optionals.push([undefined, [action]])
                 }
             }
         }
 
         // collect all actions format strings
-        let parts = []
-        for (let [ i, action ] of Object.entries(actions)) {
-
-            // suppressed arguments are marked with None
-            // remove | separators for suppressed arguments
-            if (action.help === SUPPRESS) {
-                parts.push(undefined)
-                if (inserts[+i] === '|') {
-                    delete inserts[+i]
-                } else if (inserts[+i + 1] === '|') {
-                    delete inserts[+i + 1]
-                }
+        const parts = []
+        const t = this._theme
+        let pos_start
+        const action_sets = optionals.concat(positionals)
+        for (let i = 0; i < action_sets.length; i++) {
+            const [required, group] = action_sets[i]
+            const start = parts.length
+            if (i === optionals.length) {
+                pos_start = start
+            }
+            const in_group = group.length > 1
+            for (const action of group) {
+                let part
 
-            // produce all arg strings
-            } else if (!action.option_strings.length) {
-                let default_value = this._get_default_metavar_for_positional(action)
-                let part = this._format_args(action, default_value)
+                // produce all arg strings
+                if (!action.option_strings.length) {
+                    const default_value = this._get_default_metavar_for_positional(action)
+                    part = this._format_args(action, default_value)
 
-                // if it's in a group, strip the outer []
-                if (group_actions.has(action)) {
-                    if (part[0] === '[' && part[part.length - 1] === ']') {
+                    // if it's in a group, strip the outer []
+                    if (in_group && part[0] === '[' && part[part.length - 1] === ']') {
                         part = part.slice(1, -1)
                     }
-                }
-
-                // add the action string to the list
-                parts.push(part)
-
-            // produce the first way to invoke the option in brackets
-            } else {
-                let option_string = action.option_strings[0]
-                let part
-
-                // if the Optional doesn't take a value, format is:
-                //    -s or --long
-                if (action.nargs === 0) {
-                    part = action.format_usage()
+                    part = t.summary_action + part + t.reset
 
-                // if the Optional takes a value, format is:
-                //    -s ARGS or --long ARGS
+                // produce the first way to invoke the option in brackets
                 } else {
-                    let default_value = this._get_default_metavar_for_optional(action)
-                    let args_string = this._format_args(action, default_value)
-                    part = sub('%s %s', option_string, args_string)
-                }
+                    const option_string = action.option_strings[0]
+                    const option_color = this._is_long_option(option_string)
+                        ? t.summary_long_option
+                        : t.summary_short_option
+
+                    // if the Optional doesn't take a value, format is:
+                    //    -s or --long
+                    if (action.nargs === 0) {
+                        part = action.format_usage()
+                        part = option_color + part + t.reset
+
+                    // if the Optional takes a value, format is:
+                    //    -s ARGS or --long ARGS
+                    } else {
+                        const default_value = this._get_default_metavar_for_optional(action)
+                        const args_string = this._format_args(action, default_value)
+                        part = option_color + option_string + ' ' +
+                            t.summary_label + args_string + t.reset
+                    }
 
-                // make it look optional if it's not required or in a group
-                if (!action.required && !group_actions.has(action)) {
-                    part = sub('[%s]', part)
+                    // make it look optional if it's not required or in a group
+                    if (!(action.required || required || in_group)) {
+                        part = sub('[%s]', part)
+                    }
                 }
 
                 // add the action string to the list
                 parts.push(part)
             }
-        }
 
-        // insert things at the necessary indices
-        for (let i of Object.keys(inserts).map(Number).sort((a, b) => b - a)) {
-            parts.splice(+i, 0, inserts[+i])
+            if (in_group) {
+                parts[start] = (required ? '(' : '[') + parts[start]
+                for (let i = start; i < parts.length - 1; i++) {
+                    parts[i] += ' |'
+                }
+                parts[parts.length - 1] += required ? ')' : ']'
+            }
         }
 
-        // join all the action items with spaces
-        let text = parts.filter(Boolean).join(' ')
-
-        // clean up separators for mutually exclusive groups
-        text = text.replace(/([\[(]) /g, '$1')
-        text = text.replace(/ ([\])])/g, '$1')
-        text = text.replace(/[\[(] *[\])]/g, '')
-        text = text.replace(/\(([^|]*)\)/g, '$1', text)
-        text = text.trim()
-
-        // return the text
-        return text
+        if (pos_start === undefined) {
+            pos_start = parts.length
+        }
+        return [parts, pos_start]
     }
 
-    _format_text(text) {
+    _format_text (text) {
         if (text.includes('%(prog)')) {
             text = sub(text, { prog: this._prog })
         }
-        let text_width = Math.max(this._width - this._current_indent, 11)
-        let indent = ' '.repeat(this._current_indent)
+        const text_width = Math.max(this._width - this._current_indent, 11)
+        const indent = ' '.repeat(this._current_indent)
         return this._fill_text(text, text_width, indent) + '\n\n'
     }
 
-    _format_action(action) {
+    _format_action (action) {
         // determine the required width and the entry label
-        let help_position = Math.min(this._action_max_length + 2,
+        const help_position = Math.min(this._action_max_length + 2,
                                      this._max_help_position)
-        let help_width = Math.max(this._width - help_position, 11)
-        let action_width = help_position - this._current_indent - 2
+        const help_width = Math.max(this._width - help_position, 11)
+        const action_width = help_position - this._current_indent - 2
         let action_header = this._format_action_invocation(action)
+        const action_header_no_color = this._decolor(action_header)
         let indent_first
 
         // no help; start on same line and add a final newline
         if (!action.help) {
-            let tup = [ this._current_indent, '', action_header ]
+            const tup = [this._current_indent, '', action_header]
             action_header = sub('%*s%s\n', ...tup)
 
         // short action name; start on the same line and pad two spaces
-        } else if (action_header.length <= action_width) {
-            let tup = [ this._current_indent, '', action_width, action_header ]
+        } else if (action_header_no_color.length <= action_width) {
+            // calculate widths without color codes
+            const action_header_color = action_header
+            const tup = [this._current_indent, '', action_width, action_header_no_color]
             action_header = sub('%*s%-*s  ', ...tup)
+            // swap in the colored header
+            action_header = action_header.replace(action_header_no_color, action_header_color)
             indent_first = 0
 
         // long action name; start on the next line
         } else {
-            let tup = [ this._current_indent, '', action_header ]
+            const tup = [this._current_indent, '', action_header]
             action_header = sub('%*s%s\n', ...tup)
             indent_first = help_position
         }
 
         // collect the pieces of the action help
-        let parts = [action_header]
+        const parts = [action_header]
 
         // if there was help for the action, add lines of help text
-        if (action.help) {
-            let help_text = this._expand_help(action)
-            let help_lines = this._split_lines(help_text, help_width)
-            parts.push(sub('%*s%s\n', indent_first, '', help_lines[0]))
-            for (let line of help_lines.slice(1)) {
-                parts.push(sub('%*s%s\n', help_position, '', line))
+        if (action.help && action.help.trim()) {
+            const help_text = this._expand_help(action)
+            if (help_text) {
+                const help_lines = this._split_lines(help_text, help_width)
+                parts.push(sub('%*s%s\n', indent_first, '', help_lines[0]))
+                for (const line of help_lines.slice(1)) {
+                    parts.push(sub('%*s%s\n', help_position, '', line))
+                }
             }
 
         // or add a newline if the description doesn't end with one
@@ -848,7 +823,7 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
         }
 
         // if there are any sub-actions, add their help as well
-        for (let subaction of this._iter_indented_subactions(action)) {
+        for (const subaction of this._iter_indented_subactions(action)) {
             parts.push(this._format_action(subaction))
         }
 
@@ -856,46 +831,49 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
         return this._join_parts(parts)
     }
 
-    _format_action_invocation(action) {
+    _format_action_invocation (action) {
+        const t = this._theme
+
         if (!action.option_strings.length) {
-            let default_value = this._get_default_metavar_for_positional(action)
-            let metavar = this._metavar_formatter(action, default_value)(1)[0]
-            return metavar
+            const default_value = this._get_default_metavar_for_positional(action)
+            return t.action +
+                this._metavar_formatter(action, default_value)(1).join(' ') +
+                t.reset
 
         } else {
-            let parts = []
+            const color_option_strings = strings => strings.map(string => {
+                const color = this._is_long_option(string) ? t.long_option : t.short_option
+                return color + string + t.reset
+            })
 
             // if the Optional doesn't take a value, format is:
             //    -s, --long
             if (action.nargs === 0) {
-                parts = parts.concat(action.option_strings)
+                return color_option_strings(action.option_strings).join(', ')
 
             // if the Optional takes a value, format is:
-            //    -s ARGS, --long ARGS
+            //    -s, --long ARGS
             } else {
-                let default_value = this._get_default_metavar_for_optional(action)
-                let args_string = this._format_args(action, default_value)
-                for (let option_string of action.option_strings) {
-                    parts.push(sub('%s %s', option_string, args_string))
-                }
+                const default_value = this._get_default_metavar_for_optional(action)
+                const option_strings = color_option_strings(action.option_strings)
+                const args_string = t.label + this._format_args(action, default_value) + t.reset
+                return option_strings.join(', ') + ' ' + args_string
             }
-
-            return parts.join(', ')
         }
     }
 
-    _metavar_formatter(action, default_metavar) {
+    _metavar_formatter (action, default_metavar) {
         let result
         if (action.metavar !== undefined) {
             result = action.metavar
         } else if (action.choices !== undefined) {
-            let choice_strs = _choices_to_array(action.choices).map(String)
+            const choice_strs = _choices_to_array(action.choices).map(String)
             result = sub('{%s}', choice_strs.join(','))
         } else {
             result = default_metavar
         }
 
-        function format(tuple_size) {
+        function format (tuple_size) {
             if (Array.isArray(result)) {
                 return result
             } else {
@@ -905,15 +883,15 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
         return format
     }
 
-    _format_args(action, default_metavar) {
-        let get_metavar = this._metavar_formatter(action, default_metavar)
+    _format_args (action, default_metavar) {
+        const get_metavar = this._metavar_formatter(action, default_metavar)
         let result
         if (action.nargs === undefined) {
             result = sub('%s', ...get_metavar(1))
         } else if (action.nargs === OPTIONAL) {
             result = sub('[%s]', ...get_metavar(1))
         } else if (action.nargs === ZERO_OR_MORE) {
-            let metavar = get_metavar(1)
+            const metavar = get_metavar(1)
             if (metavar.length === 2) {
                 result = sub('[%s [%s ...]]', ...metavar)
             } else {
@@ -939,85 +917,79 @@ const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
         return result
     }
 
-    _expand_help(action) {
-        let params = Object.assign({ prog: this._prog }, action)
-        for (let name of Object.keys(params)) {
-            if (params[name] === SUPPRESS) {
-                delete params[name]
-            }
+    _expand_help (action) {
+        const help_string = this._get_help_string(action)
+        if (!help_string.includes('%')) {
+            return help_string
         }
-        for (let name of Object.keys(params)) {
-            if (params[name] && params[name].name) {
-                params[name] = params[name].name
+        const params = Object.assign({}, action, { prog: this._prog })
+        for (const name of Object.keys(params)) {
+            const value = params[name]
+            if (value === SUPPRESS) {
+                delete params[name]
+            } else if (value !== undefined && value !== null && 'name' in Object(value)) {
+                params[name] = value.name
             }
         }
         if (params.choices !== undefined) {
-            let choices_str = _choices_to_array(params.choices).map(String).join(', ')
+            const choices_str = _choices_to_array(params.choices).map(String).join(', ')
             params.choices = choices_str
         }
-        // LEGACY (v1 compatibility): camelcase
-        for (let key of Object.keys(params)) {
-            let old_name = _to_legacy_name(key)
-            if (old_name !== key) {
-                params[old_name] = params[key]
-            }
-        }
-        // end
-        return sub(this._get_help_string(action), params)
+        return sub(help_string, params)
     }
 
-    * _iter_indented_subactions(action) {
+    * _iter_indented_subactions (action) {
         if (typeof action._get_subactions === 'function') {
             this._indent()
-            yield* action._get_subactions()
+            yield * action._get_subactions()
             this._dedent()
         }
     }
 
-    _split_lines(text, width) {
+    _split_lines (text, width) {
         text = text.replace(this._whitespace_matcher, ' ').trim()
         // The textwrap module is used only for formatting help.
         // Delay its import for speeding up the common usage of argparse.
-        let textwrap = require('./lib/textwrap')
+        const textwrap = require('./textwrap')
         return textwrap.wrap(text, { width })
     }
 
-    _fill_text(text, width, indent) {
+    _fill_text (text, width, indent) {
         text = text.replace(this._whitespace_matcher, ' ').trim()
-        let textwrap = require('./lib/textwrap')
+        const textwrap = require('./textwrap')
         return textwrap.fill(text, { width,
                                      initial_indent: indent,
                                      subsequent_indent: indent })
     }
 
-    _get_help_string(action) {
+    _get_help_string (action) {
         return action.help
     }
 
-    _get_default_metavar_for_optional(action) {
+    _get_default_metavar_for_optional (action) {
         return action.dest.toUpperCase()
     }
 
-    _get_default_metavar_for_positional(action) {
+    _get_default_metavar_for_positional (action) {
         return action.dest
     }
-}))
+})
 
 HelpFormatter.prototype._Section = _callable(class _Section {
 
-    constructor(formatter, parent, heading = undefined) {
+    constructor (formatter, parent, heading = undefined) {
         this.formatter = formatter
         this.parent = parent
         this.heading = heading
         this.items = []
     }
 
-    format_help() {
+    format_help () {
         // format the indented section
         if (this.parent !== undefined) {
             this.formatter._indent()
         }
-        let item_help = this.formatter._join_parts(this.items.map(([ func, args ]) => func.apply(null, args)))
+        const item_help = this.formatter._join_parts(this.items.map(([func, args]) => func.apply(null, args)))
         if (this.parent !== undefined) {
             this.formatter._dedent()
         }
@@ -1030,8 +1002,10 @@ HelpFormatter.prototype._Section = _callable(class _Section {
         // add the heading if the section was non-empty
         let heading
         if (this.heading !== SUPPRESS && this.heading !== undefined) {
-            let current_indent = this.formatter._current_indent
-            heading = sub('%*s%s:\n', current_indent, '', this.heading)
+            const current_indent = this.formatter._current_indent
+            const t = this.formatter._theme
+            const heading_text = this.heading + ':'
+            heading = ' '.repeat(current_indent) + t.heading + heading_text + t.reset + '\n'
         } else {
             heading = ''
         }
@@ -1042,7 +1016,7 @@ HelpFormatter.prototype._Section = _callable(class _Section {
 })
 
 
-const RawDescriptionHelpFormatter = _camelcase_alias(_callable(class RawDescriptionHelpFormatter extends HelpFormatter {
+const RawDescriptionHelpFormatter = _callable(class RawDescriptionHelpFormatter extends HelpFormatter {
     /*
      *  Help message formatter which retains any formatting in descriptions.
      *
@@ -1050,13 +1024,13 @@ const RawDescriptionHelpFormatter = _camelcase_alias(_callable(class RawDescript
      *  provided by the class are considered an implementation detail.
      */
 
-    _fill_text(text, width, indent) {
+    _fill_text (text, width, indent) {
         return splitlines(text, true).map(line => indent + line).join('')
     }
-}))
+})
 
 
-const RawTextHelpFormatter = _camelcase_alias(_callable(class RawTextHelpFormatter extends RawDescriptionHelpFormatter {
+const RawTextHelpFormatter = _callable(class RawTextHelpFormatter extends RawDescriptionHelpFormatter {
     /*
      *  Help message formatter which retains formatting of all help text.
      *
@@ -1064,13 +1038,13 @@ const RawTextHelpFormatter = _camelcase_alias(_callable(class RawTextHelpFormatt
      *  provided by the class are considered an implementation detail.
      */
 
-    _split_lines(text/*, width*/) {
+    _split_lines (text/*, width */) {
         return splitlines(text)
     }
-}))
+})
 
 
-const ArgumentDefaultsHelpFormatter = _camelcase_alias(_callable(class ArgumentDefaultsHelpFormatter extends HelpFormatter {
+const ArgumentDefaultsHelpFormatter = _callable(class ArgumentDefaultsHelpFormatter extends HelpFormatter {
     /*
      *  Help message formatter which adds default values to argument help.
      *
@@ -1078,23 +1052,26 @@ const ArgumentDefaultsHelpFormatter = _camelcase_alias(_callable(class ArgumentD
      *  provided by the class are considered an implementation detail.
      */
 
-    _get_help_string(action) {
+    _get_help_string (action) {
         let help = action.help
-        // LEGACY (v1 compatibility): additional check for defaultValue needed
-        if (!action.help.includes('%(default)') && !action.help.includes('%(defaultValue)')) {
-            if (action.default !== SUPPRESS) {
-                let defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
-                if (action.option_strings.length || defaulting_nargs.includes(action.nargs)) {
-                    help += ' (default: %(default)s)'
-                }
+        if (help === undefined) {
+            help = ''
+        }
+
+        if (!help.includes('%(default)') &&
+            action.default !== SUPPRESS &&
+            !action.required) {
+            const defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
+            if (action.option_strings.length || defaulting_nargs.includes(action.nargs)) {
+                help += ' (default: %(default)s)'
             }
         }
         return help
     }
-}))
+})
 
 
-const MetavarTypeHelpFormatter = _camelcase_alias(_callable(class MetavarTypeHelpFormatter extends HelpFormatter {
+const MetavarTypeHelpFormatter = _callable(class MetavarTypeHelpFormatter extends HelpFormatter {
     /*
      *  Help message formatter which uses the argument 'type' as the default
      *  metavar value (instead of the argument 'dest')
@@ -1103,31 +1080,45 @@ const MetavarTypeHelpFormatter = _camelcase_alias(_callable(class MetavarTypeHel
      *  provided by the class are considered an implementation detail.
      */
 
-    _get_default_metavar_for_optional(action) {
+    _get_default_metavar_for_optional (action) {
         return typeof action.type === 'function' ? action.type.name : action.type
     }
 
-    _get_default_metavar_for_positional(action) {
+    _get_default_metavar_for_positional (action) {
         return typeof action.type === 'function' ? action.type.name : action.type
     }
-}))
+})
 
 
 // =====================
 // Options and Arguments
 // =====================
-function _get_action_name(argument) {
+function _get_action_name (argument) {
     if (argument === undefined) {
         return undefined
     } else if (argument.option_strings.length) {
         return argument.option_strings.join('/')
-    } else if (![ undefined, SUPPRESS ].includes(argument.metavar)) {
-        return argument.metavar
-    } else if (![ undefined, SUPPRESS ].includes(argument.dest)) {
+    } else if (![undefined, SUPPRESS].includes(argument.metavar)) {
+        const metavar = argument.metavar
+        if (!Array.isArray(metavar)) {
+            return metavar
+        }
+        if (argument.nargs === ZERO_OR_MORE && metavar.length === 2) {
+            return sub('%s[, %s]', ...metavar)
+        } else if (argument.nargs === ONE_OR_MORE) {
+            return sub('%s[, %s]', ...metavar)
+        } else {
+            return metavar.join(', ')
+        }
+    } else if (![undefined, SUPPRESS].includes(argument.dest)) {
         return argument.dest
-    } else {
-        return undefined
+    } else if (argument.choices) {
+        const choices = _choices_to_array(argument.choices)
+        if (choices.length) {
+            return sub('{%s}', choices.map(String).join(','))
+        }
     }
+    return undefined
 }
 
 
@@ -1139,7 +1130,7 @@ const ArgumentError = _callable(class ArgumentError extends Error {
      *  information about the argument that caused it.
      */
 
-    constructor(argument, message) {
+    constructor (argument, message) {
         super()
         this.name = 'ArgumentError'
         this._argument_name = _get_action_name(argument)
@@ -1147,7 +1138,7 @@ const ArgumentError = _callable(class ArgumentError extends Error {
         this.message = this.str()
     }
 
-    str() {
+    str () {
         let format
         if (this._argument_name === undefined) {
             format = '%(message)s'
@@ -1165,7 +1156,7 @@ const ArgumentTypeError = _callable(class ArgumentTypeError extends Error {
      * An error from trying to convert a command line string to a type.
      */
 
-    constructor(message) {
+    constructor (message) {
         super(message)
         this.name = 'ArgumentTypeError'
     }
@@ -1175,7 +1166,7 @@ const ArgumentTypeError = _callable(class ArgumentTypeError extends Error {
 // ==============
 // Action classes
 // ==============
-const Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(Function) {
+const Action = _callable(class Action extends _AttributeHolder(Function) {
     /*
      *  Information about how to convert command line strings to Python objects.
      *
@@ -1227,8 +1218,8 @@ const Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(
      *          help string. If None, the 'dest' value will be used as the name.
      */
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             nargs,
@@ -1238,7 +1229,8 @@ const Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(
             choices,
             required,
             help,
-            metavar
+            metavar,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
@@ -1249,7 +1241,8 @@ const Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(
             choices: undefined,
             required: false,
             help: undefined,
-            metavar: undefined
+            metavar: undefined,
+            deprecated: false
         })
 
         // when this class is called as a function, redirect it to .call() method of itself
@@ -1265,10 +1258,11 @@ const Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(
         this.required = required
         this.help = help
         this.metavar = metavar
+        this.deprecated = deprecated
     }
 
-    _get_kwargs() {
-        let names = [
+    _get_kwargs () {
+        const names = [
             'option_strings',
             'dest',
             'nargs',
@@ -1276,88 +1270,84 @@ const Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(
             'default',
             'type',
             'choices',
+            'required',
             'help',
-            'metavar'
+            'metavar',
+            'deprecated'
         ]
-        return names.map(name => [ name, getattr(this, name) ])
+        return names.map(name => [name, getattr(this, name)])
     }
 
-    format_usage() {
+    format_usage () {
         return this.option_strings[0]
     }
 
-    call(/*parser, namespace, values, option_string = undefined*/) {
+    call (/* parser, namespace, values, option_string = undefined */) {
         throw new Error('.call() not defined')
     }
-}))
+})
 
 
-const BooleanOptionalAction = _camelcase_alias(_callable(class BooleanOptionalAction extends Action {
+const BooleanOptionalAction = _callable(class BooleanOptionalAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             default_value,
-            type,
-            choices,
             required,
             help,
-            metavar
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
             default: undefined,
-            type: undefined,
-            choices: undefined,
             required: false,
             help: undefined,
-            metavar: undefined
+            deprecated: false
         })
 
-        let _option_strings = []
+        const _option_strings = []
         for (let option_string of option_strings) {
             _option_strings.push(option_string)
 
             if (option_string.startsWith('--')) {
+                if (option_string.startsWith('--no-')) {
+                    throw new TypeError(sub('invalid option name %r ' +
+                                            'for BooleanOptionalAction', option_string))
+                }
                 option_string = '--no-' + option_string.slice(2)
                 _option_strings.push(option_string)
             }
         }
 
-        if (help !== undefined && default_value !== undefined) {
-            help += ` (default: ${default_value})`
-        }
-
         super({
             option_strings: _option_strings,
             dest,
             nargs: 0,
             default: default_value,
-            type,
-            choices,
             required,
             help,
-            metavar
+            deprecated
         })
     }
 
-    call(parser, namespace, values, option_string = undefined) {
+    call (parser, namespace, values, option_string = undefined) {
         if (this.option_strings.includes(option_string)) {
             setattr(namespace, this.dest, !option_string.startsWith('--no-'))
         }
     }
 
-    format_usage() {
+    format_usage () {
         return this.option_strings.join(' | ')
     }
-}))
+})
 
 
 const _StoreAction = _callable(class _StoreAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             nargs,
@@ -1367,7 +1357,8 @@ const _StoreAction = _callable(class _StoreAction extends Action {
             choices,
             required,
             help,
-            metavar
+            metavar,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
@@ -1378,7 +1369,8 @@ const _StoreAction = _callable(class _StoreAction extends Action {
             choices: undefined,
             required: false,
             help: undefined,
-            metavar: undefined
+            metavar: undefined,
+            deprecated: false
         })
 
         if (nargs === 0) {
@@ -1399,11 +1391,12 @@ const _StoreAction = _callable(class _StoreAction extends Action {
             choices,
             required,
             help,
-            metavar
+            metavar,
+            deprecated
         })
     }
 
-    call(parser, namespace, values/*, option_string = undefined*/) {
+    call (parser, namespace, values/*, option_string = undefined */) {
         setattr(namespace, this.dest, values)
     }
 })
@@ -1411,22 +1404,23 @@ const _StoreAction = _callable(class _StoreAction extends Action {
 
 const _StoreConstAction = _callable(class _StoreConstAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             const_value,
             default_value,
             required,
-            help
-            //, metavar
+            help,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
-            const: no_default,
+            const: undefined,
             default: undefined,
             required: false,
             help: undefined,
+            deprecated: false,
             metavar: undefined
         })
 
@@ -1437,11 +1431,12 @@ const _StoreConstAction = _callable(class _StoreConstAction extends Action {
             const: const_value,
             default: default_value,
             required,
-            help
+            help,
+            deprecated
         })
     }
 
-    call(parser, namespace/*, values, option_string = undefined*/) {
+    call (parser, namespace/*, values, option_string = undefined */) {
         setattr(namespace, this.dest, this.const)
     }
 })
@@ -1449,19 +1444,21 @@ const _StoreConstAction = _callable(class _StoreConstAction extends Action {
 
 const _StoreTrueAction = _callable(class _StoreTrueAction extends _StoreConstAction {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             default_value,
             required,
-            help
+            help,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
             default: false,
             required: false,
-            help: undefined
+            help: undefined,
+            deprecated: false
         })
 
         super({
@@ -1470,7 +1467,8 @@ const _StoreTrueAction = _callable(class _StoreTrueAction extends _StoreConstAct
             const: true,
             default: default_value,
             required,
-            help
+            help,
+            deprecated
         })
     }
 })
@@ -1478,19 +1476,21 @@ const _StoreTrueAction = _callable(class _StoreTrueAction extends _StoreConstAct
 
 const _StoreFalseAction = _callable(class _StoreFalseAction extends _StoreConstAction {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             default_value,
             required,
-            help
+            help,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
             default: true,
             required: false,
-            help: undefined
+            help: undefined,
+            deprecated: false
         })
 
         super({
@@ -1499,7 +1499,8 @@ const _StoreFalseAction = _callable(class _StoreFalseAction extends _StoreConstA
             const: false,
             default: default_value,
             required,
-            help
+            help,
+            deprecated
         })
     }
 })
@@ -1507,8 +1508,8 @@ const _StoreFalseAction = _callable(class _StoreFalseAction extends _StoreConstA
 
 const _AppendAction = _callable(class _AppendAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             nargs,
@@ -1518,7 +1519,8 @@ const _AppendAction = _callable(class _AppendAction extends Action {
             choices,
             required,
             help,
-            metavar
+            metavar,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
@@ -1529,7 +1531,8 @@ const _AppendAction = _callable(class _AppendAction extends Action {
             choices: undefined,
             required: false,
             help: undefined,
-            metavar: undefined
+            metavar: undefined,
+            deprecated: false
         })
 
         if (nargs === 0) {
@@ -1550,11 +1553,12 @@ const _AppendAction = _callable(class _AppendAction extends Action {
             choices,
             required,
             help,
-            metavar
+            metavar,
+            deprecated
         })
     }
 
-    call(parser, namespace, values/*, option_string = undefined*/) {
+    call (parser, namespace, values/*, option_string = undefined */) {
         let items = getattr(namespace, this.dest, undefined)
         items = _copy_items(items)
         items.push(values)
@@ -1565,23 +1569,25 @@ const _AppendAction = _callable(class _AppendAction extends Action {
 
 const _AppendConstAction = _callable(class _AppendConstAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             const_value,
             default_value,
             required,
             help,
-            metavar
+            metavar,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
-            const: no_default,
+            const: undefined,
             default: undefined,
             required: false,
             help: undefined,
-            metavar: undefined
+            metavar: undefined,
+            deprecated: false
         })
 
         super({
@@ -1592,11 +1598,12 @@ const _AppendConstAction = _callable(class _AppendConstAction extends Action {
             default: default_value,
             required,
             help,
-            metavar
+            metavar,
+            deprecated
         })
     }
 
-    call(parser, namespace/*, values, option_string = undefined*/) {
+    call (parser, namespace/*, values, option_string = undefined */) {
         let items = getattr(namespace, this.dest, undefined)
         items = _copy_items(items)
         items.push(this.const)
@@ -1607,19 +1614,21 @@ const _AppendConstAction = _callable(class _AppendConstAction extends Action {
 
 const _CountAction = _callable(class _CountAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             default_value,
             required,
-            help
+            help,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: no_default,
             default: undefined,
             required: false,
-            help: undefined
+            help: undefined,
+            deprecated: false
         })
 
         super({
@@ -1628,11 +1637,12 @@ const _CountAction = _callable(class _CountAction extends Action {
             nargs: 0,
             default: default_value,
             required,
-            help
+            help,
+            deprecated
         })
     }
 
-    call(parser, namespace/*, values, option_string = undefined*/) {
+    call (parser, namespace/*, values, option_string = undefined */) {
         let count = getattr(namespace, this.dest, undefined)
         if (count === undefined) {
             count = 0
@@ -1644,17 +1654,19 @@ const _CountAction = _callable(class _CountAction extends Action {
 
 const _HelpAction = _callable(class _HelpAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             dest,
             default_value,
-            help
+            help,
+            deprecated
         ] = _parse_opts(arguments, {
             option_strings: no_default,
             dest: SUPPRESS,
             default: SUPPRESS,
-            help: undefined
+            help: undefined,
+            deprecated: false
         })
 
         super({
@@ -1662,11 +1674,12 @@ const _HelpAction = _callable(class _HelpAction extends Action {
             dest,
             default: default_value,
             nargs: 0,
-            help
+            help,
+            deprecated
         })
     }
 
-    call(parser/*, namespace, values, option_string = undefined*/) {
+    call (parser/*, namespace, values, option_string = undefined */) {
         parser.print_help()
         parser.exit()
     }
@@ -1675,7 +1688,7 @@ const _HelpAction = _callable(class _HelpAction extends Action {
 
 const _VersionAction = _callable(class _VersionAction extends Action {
 
-    constructor() {
+    constructor () {
         let [
             option_strings,
             version,
@@ -1687,9 +1700,14 @@ const _VersionAction = _callable(class _VersionAction extends Action {
             version: undefined,
             dest: SUPPRESS,
             default: SUPPRESS,
-            help: "show program's version number and exit"
+            help: "show program's version number and exit",
+            deprecated: false
         })
 
+        if (help === undefined || help === null) {
+            help = "show program's version number and exit"
+        }
+
         super({
             option_strings,
             dest,
@@ -1700,12 +1718,12 @@ const _VersionAction = _callable(class _VersionAction extends Action {
         this.version = version
     }
 
-    call(parser/*, namespace, values, option_string = undefined*/) {
+    call (parser/*, namespace, values, option_string = undefined */) {
         let version = this.version
         if (version === undefined) {
             version = parser.version
         }
-        let formatter = parser._get_formatter()
+        const formatter = parser._get_formatter()
         formatter.add_text(version)
         parser._print_message(formatter.format_help(), process.stdout)
         parser.exit()
@@ -1713,10 +1731,10 @@ const _VersionAction = _callable(class _VersionAction extends Action {
 })
 
 
-const _SubParsersAction = _camelcase_alias(_callable(class _SubParsersAction extends Action {
+const _SubParsersAction = _callable(class _SubParsersAction extends Action {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             option_strings,
             prog,
             parser_class,
@@ -1734,7 +1752,7 @@ const _SubParsersAction = _camelcase_alias(_callable(class _SubParsersAction ext
             metavar: undefined
         })
 
-        let name_parser_map = {}
+        const name_parser_map = Object.create(null)
 
         super({
             option_strings,
@@ -1750,10 +1768,12 @@ const _SubParsersAction = _camelcase_alias(_callable(class _SubParsersAction ext
         this._parser_class = parser_class
         this._name_parser_map = name_parser_map
         this._choices_actions = []
+        this._deprecated = new Set()
+        this._color = true
     }
 
-    add_parser() {
-        let [
+    add_parser () {
+        const [
             name,
             kwargs
         ] = _parse_opts(arguments, {
@@ -1766,35 +1786,62 @@ const _SubParsersAction = _camelcase_alias(_callable(class _SubParsersAction ext
             kwargs.prog = sub('%s %s', this._prog_prefix, name)
         }
 
-        let aliases = getattr(kwargs, 'aliases', [])
+        // set color
+        if (kwargs.color === undefined) {
+            kwargs.color = this._color
+        }
+
+        const aliases = getattr(kwargs, 'aliases', [])
         delete kwargs.aliases
+        const deprecated = getattr(kwargs, 'deprecated', false)
+        delete kwargs.deprecated
+
+        if (hasattr(this._name_parser_map, name)) {
+            throw new TypeError(sub('conflicting subparser: %s', name))
+        }
+        for (const alias of aliases) {
+            if (hasattr(this._name_parser_map, alias)) {
+                throw new TypeError(sub('conflicting subparser alias: %s', alias))
+            }
+        }
 
         // create a pseudo-action to hold the choice help
+        let choice_action
         if ('help' in kwargs) {
-            let help = kwargs.help
+            const help = kwargs.help
             delete kwargs.help
-            let choice_action = this._ChoicesPseudoAction(name, aliases, help)
+            choice_action = this._ChoicesPseudoAction(name, aliases, help)
             this._choices_actions.push(choice_action)
         }
 
         // create the parser and add it to the map
-        let parser = new this._parser_class(kwargs)
+        const parser = new this._parser_class(kwargs)
+        if (choice_action !== undefined) {
+            parser._check_help(choice_action)
+        }
         this._name_parser_map[name] = parser
 
         // make parser available under aliases also
-        for (let alias of aliases) {
+        for (const alias of aliases) {
             this._name_parser_map[alias] = parser
         }
 
+        if (deprecated) {
+            this._deprecated.add(name)
+            for (const alias of aliases) {
+                this._deprecated.add(alias)
+            }
+        }
+
         return parser
     }
 
-    _get_subactions() {
+    _get_subactions () {
         return this._choices_actions
     }
 
-    call(parser, namespace, values/*, option_string = undefined*/) {
-        let parser_name = values[0]
+    call (parser, namespace, values/*, option_string = undefined */) {
+        const parser_name = values[0]
         let arg_strings = values.slice(1)
 
         // set the parser name if requested
@@ -1803,15 +1850,20 @@ const _SubParsersAction = _camelcase_alias(_callable(class _SubParsersAction ext
         }
 
         // select the parser
+        let subparser
         if (hasattr(this._name_parser_map, parser_name)) {
-            parser = this._name_parser_map[parser_name]
+            subparser = this._name_parser_map[parser_name]
         } else {
-            let args = {parser_name,
-                        choices: this._name_parser_map.join(', ')}
-            let msg = sub('unknown parser %(parser_name)r (choices: %(choices)s)', args)
+            const args = {parser_name,
+                        choices: Object.keys(this._name_parser_map).join(', ')}
+            const msg = sub('unknown parser %(parser_name)r (choices: %(choices)s)', args)
             throw new ArgumentError(this, msg)
         }
 
+        if (this._deprecated.has(parser_name)) {
+            parser._warning(sub("command '%(parser_name)s' is deprecated", { parser_name }))
+        }
+
         // parse all the remaining options into the namespace
         // store any unrecognized options on the object, so that the top
         // level parser can decide what to do with them
@@ -1820,22 +1872,25 @@ const _SubParsersAction = _camelcase_alias(_callable(class _SubParsersAction ext
         // in a new namespace object and then update the original
         // namespace for the relevant parts.
         let subnamespace
-        [ subnamespace, arg_strings ] = parser.parse_known_args(arg_strings, undefined)
-        for (let [ key, value ] of Object.entries(subnamespace)) {
+        [subnamespace, arg_strings] = subparser.parse_known_args(arg_strings, undefined)
+        for (const [key, value] of Object.entries(subnamespace)) {
             setattr(namespace, key, value)
         }
 
         if (arg_strings.length) {
-            setdefault(namespace, _UNRECOGNIZED_ARGS_ATTR, [])
+            if (!hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR)) {
+                setattr(namespace, _UNRECOGNIZED_ARGS_ATTR, [])
+            }
             getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).push(...arg_strings)
         }
     }
-}))
+})
 
 
 _SubParsersAction.prototype._ChoicesPseudoAction = _callable(class _ChoicesPseudoAction extends Action {
-    constructor(name, aliases, help) {
-        let metavar = name, dest = name
+    constructor (name, aliases, help) {
+        let metavar = name
+        const dest = name
         if (aliases.length) {
             metavar += sub(' (%s)', aliases.join(', '))
         }
@@ -1845,7 +1900,7 @@ _SubParsersAction.prototype._ChoicesPseudoAction = _callable(class _ChoicesPseud
 
 
 const _ExtendAction = _callable(class _ExtendAction extends _AppendAction {
-    call(parser, namespace, values/*, option_string = undefined*/) {
+    call (parser, namespace, values/*, option_string = undefined */) {
         let items = getattr(namespace, this.dest, undefined)
         items = _copy_items(items)
         items = items.concat(values)
@@ -1859,7 +1914,7 @@ const _ExtendAction = _callable(class _ExtendAction extends _AppendAction {
 // ==============
 const FileType = _callable(class FileType extends Function {
     /*
-     *  Factory for creating file object types
+     *  Deprecated factory for creating file object types
      *
      *  Instances of FileType are typically passed as type= arguments to the
      *  ArgumentParser add_argument() method.
@@ -1875,8 +1930,8 @@ const FileType = _callable(class FileType extends Function {
      *          be handled. Accepts the same value as the builtin open() function.
      */
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             flags,
             encoding,
             mode,
@@ -1898,11 +1953,15 @@ const FileType = _callable(class FileType extends Function {
             fs: undefined
         })
 
+        process.emitWarning(
+            'FileType is deprecated. Simply open files after parsing arguments.',
+            'PendingDeprecationWarning')
+
         // when this class is called as a function, redirect it to .call() method of itself
         super('return arguments.callee.call.apply(arguments.callee, arguments)')
 
         Object.defineProperty(this, 'name', {
-            get() {
+            get () {
                 return sub('FileType(%r)', flags)
             }
         })
@@ -1918,15 +1977,15 @@ const FileType = _callable(class FileType extends Function {
         if (fs !== undefined) this._options.fs = fs
     }
 
-    call(string) {
+    call (string) {
         // the special argument "-" means sys.std{in,out}
         if (string === '-') {
             if (this._flags.includes('r')) {
                 return process.stdin
-            } else if (this._flags.includes('w')) {
+            } else if ([...'wax'].some(flag => this._flags.includes(flag))) {
                 return process.stdout
             } else {
-                let msg = sub('argument "-" with mode %r', this._flags)
+                const msg = sub('argument "-" with mode %r', this._flags)
                 throw new TypeError(msg)
             }
         }
@@ -1936,37 +1995,45 @@ const FileType = _callable(class FileType extends Function {
         try {
             fd = fs.openSync(string, this._flags, this._options.mode)
         } catch (e) {
-            let args = { filename: string, error: e.message }
-            let message = "can't open '%(filename)s': %(error)s"
+            if (e instanceof TypeError) {
+                throw e
+            }
+            const args = { filename: string, error: e.message }
+            const message = "can't open '%(filename)s': %(error)s"
             throw new ArgumentTypeError(sub(message, args))
         }
 
-        let options = Object.assign({ fd, flags: this._flags }, this._options)
+        const options = Object.assign({ fd, flags: this._flags }, this._options)
         if (this._flags.includes('r')) {
-            return fs.createReadStream(undefined, options)
+            const file = fs.createReadStream(string, options)
+            file.path = string
+            return file
         } else if (this._flags.includes('w')) {
-            return fs.createWriteStream(undefined, options)
+            const file = fs.createWriteStream(string, options)
+            file.path = string
+            return file
         } else {
-            let msg = sub('argument "%s" with mode %r', string, this._flags)
+            fs.closeSync(fd)
+            const msg = sub('argument "%s" with mode %r', string, this._flags)
             throw new TypeError(msg)
         }
     }
 
-    [util.inspect.custom]() {
-        let args = [ this._flags ]
-        let kwargs = Object.entries(this._options).map(([ k, v ]) => {
-            if (k === 'mode') v = { value: v, [util.inspect.custom]() { return '0o' + this.value.toString(8) } }
-            return [ k, v ]
+    [util.inspect.custom] () {
+        const args = [this._flags]
+        const kwargs = Object.entries(this._options).map(([k, v]) => {
+            if (k === 'mode') v = { value: v, [util.inspect.custom] () { return '0o' + this.value.toString(8) } }
+            return [k, v]
         })
-        let args_str = []
+        const args_str = []
                 .concat(args.filter(arg => arg !== -1).map(repr))
-                .concat(kwargs.filter(([/*kw*/, arg]) => arg !== undefined)
+                .concat(kwargs.filter(([/* kw */, arg]) => arg !== undefined)
                     .map(([kw, arg]) => sub('%s=%r', kw, arg)))
                 .join(', ')
         return sub('%s(%s)', this.constructor.name, args_str)
     }
 
-    toString() {
+    toString () {
         return this[util.inspect.custom]()
     }
 })
@@ -1982,7 +2049,7 @@ const Namespace = _callable(class Namespace extends _AttributeHolder() {
      *  string representation.
      */
 
-    constructor(options = {}) {
+    constructor (options = {}) {
         super()
         Object.assign(this, options)
     }
@@ -1992,10 +2059,10 @@ const Namespace = _callable(class Namespace extends _AttributeHolder() {
 Namespace.prototype[Symbol.toStringTag] = undefined
 
 
-const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
+const _ActionsContainer = _callable(class _ActionsContainer {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             description,
             prefix_chars,
             argument_default,
@@ -2013,7 +2080,7 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         this.conflict_handler = conflict_handler
 
         // set up registries
-        this._registries = {}
+        this._registries = Object.create(null)
 
         // register actions
         this.register('action', undefined, _StoreAction)
@@ -2028,30 +2095,22 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         this.register('action', 'version', _VersionAction)
         this.register('action', 'parsers', _SubParsersAction)
         this.register('action', 'extend', _ExtendAction)
-        // LEGACY (v1 compatibility): camelcase variants
-        ;[ 'storeConst', 'storeTrue', 'storeFalse', 'appendConst' ].forEach(old_name => {
-            let new_name = _to_new_name(old_name)
-            this.register('action', old_name, util.deprecate(this._registry_get('action', new_name),
-                sub('{action: "%s"} is renamed to {action: "%s"}', old_name, new_name)))
-        })
-        // end
-
         // raise an exception if the conflict handler is invalid
         this._get_handler()
 
         // action storage
         this._actions = []
-        this._option_string_actions = {}
+        this._option_string_actions = Object.create(null)
 
         // groups
         this._action_groups = []
         this._mutually_exclusive_groups = []
 
         // defaults storage
-        this._defaults = {}
+        this._defaults = Object.create(null)
 
         // determines whether an "option" looks like a negative number
-        this._negative_number_matcher = /^-\d+$|^-\d*\.\d+$/
+        this._negative_number_matcher = /^-\.?\d/
 
         // whether or not there are any optionals that look like negative
         // numbers -- uses a list so it can be shared and edited
@@ -2061,32 +2120,32 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
     // ====================
     // Registration methods
     // ====================
-    register(registry_name, value, object) {
-        let registry = setdefault(this._registries, registry_name, {})
+    register (registry_name, value, object) {
+        const registry = setdefault(this._registries, registry_name, Object.create(null))
         registry[value] = object
     }
 
-    _registry_get(registry_name, value, default_value = undefined) {
+    _registry_get (registry_name, value, default_value = undefined) {
         return getattr(this._registries[registry_name], value, default_value)
     }
 
     // ==================================
     // Namespace default accessor methods
     // ==================================
-    set_defaults(kwargs) {
+    set_defaults (kwargs) {
         Object.assign(this._defaults, kwargs)
 
         // if these defaults match any existing arguments, replace
         // the previous default on the object with the new one
-        for (let action of this._actions) {
+        for (const action of this._actions) {
             if (action.dest in kwargs) {
                 action.default = kwargs[action.dest]
             }
         }
     }
 
-    get_default(dest) {
-        for (let action of this._actions) {
+    get_default (dest) {
+        for (const action of this._actions) {
             if (action.dest === dest && action.default !== undefined) {
                 return action.default
             }
@@ -2098,7 +2157,7 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
     // =======================
     // Adding argument actions
     // =======================
-    add_argument() {
+    add_argument () {
         /*
          *  add_argument(dest, ..., name=value, ...)
          *  add_argument(option_string, option_string, ..., name=value, ...)
@@ -2110,23 +2169,23 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
             '*args': no_default,
             '**kwargs': no_default
         })
-        // LEGACY (v1 compatibility), old-style add_argument([ args ], { options })
-        if (args.length === 1 && Array.isArray(args[0])) {
-            args = args[0]
-            deprecate('argument-array',
-                sub('use add_argument(%(args)s, {...}) instead of add_argument([ %(args)s ], { ... })', {
-                    args: args.map(repr).join(', ')
-                }))
+        // argparse v1 accepted an array of argument names here. Python argparse
+        // accepts only individual string names and rejects a list; reject it
+        // explicitly because JS would otherwise coerce the array to a string.
+        if (args.some(arg => typeof arg !== 'string')) {
+            throw new TypeError('argument name must be a string')
+        }
+        if (args.some(arg => !arg.length)) {
+            throw new TypeError('argument name must not be empty')
         }
-        // end
-
         // if no positional args are supplied or only one is supplied and
         // it doesn't look like an option string, parse a positional
         // argument
-        let chars = this.prefix_chars
+        const chars = this.prefix_chars
         if (!args.length || args.length === 1 && !chars.includes(args[0][0])) {
             if (args.length && 'dest' in kwargs) {
-                throw new TypeError('dest supplied twice for positional argument')
+                throw new TypeError('dest supplied twice for positional argument,' +
+                                    ' did you mean metavar?')
             }
             kwargs = this._get_positional_kwargs(...args, kwargs)
 
@@ -2137,7 +2196,7 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
 
         // if no default was supplied, use the parser-level default
         if (!('default' in kwargs)) {
-            let dest = kwargs.dest
+            const dest = kwargs.dest
             if (dest in this._defaults) {
                 kwargs.default = this._defaults[dest]
             } else if (this.argument_default !== undefined) {
@@ -2146,15 +2205,22 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         }
 
         // create the action object, and add it to the parser
-        let action_class = this._pop_action_class(kwargs)
+        const action_name = kwargs.action
+        const action_class = this._pop_action_class(kwargs)
         if (typeof action_class !== 'function') {
-            throw new TypeError(sub('unknown action "%s"', action_class))
+            throw new TypeError(sub('unknown action %r', action_class))
         }
         // eslint-disable-next-line new-cap
-        let action = new action_class(kwargs)
+        const action = new action_class(kwargs)
+
+        // raise an error if action for positional argument does not
+        // consume arguments
+        if (!action.option_strings.length && action.nargs === 0) {
+            throw new TypeError(sub('action %r is not valid for positional arguments', action_name))
+        }
 
         // raise an error if the action type is not callable
-        let type_func = this._registry_get('type', action.type, action.type)
+        const type_func = this._registry_get('type', action.type, action.type)
         if (typeof type_func !== 'function') {
             throw new TypeError(sub('%r is not callable', type_func))
         }
@@ -2165,9 +2231,10 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         }
 
         // raise an error if the metavar does not match the type
-        if ('_get_formatter' in this) {
+        if ('_get_validation_formatter' in this) {
+            const formatter = this._get_validation_formatter()
             try {
-                this._get_formatter()._format_args(action, undefined)
+                formatter._format_args(action, undefined)
             } catch (err) {
                 // check for 'invalid nargs value' is an artifact of TypeError and ValueError in js being the same
                 if (err instanceof TypeError && err.message !== 'invalid nargs value') {
@@ -2178,23 +2245,25 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
             }
         }
 
+        this._check_help(action)
+
         return this._add_action(action)
     }
 
-    add_argument_group() {
-        let group = _ArgumentGroup(this, ...arguments)
+    add_argument_group () {
+        const group = _ArgumentGroup(this, ...arguments)
         this._action_groups.push(group)
         return group
     }
 
-    add_mutually_exclusive_group() {
-        // eslint-disable-next-line no-use-before-define
-        let group = _MutuallyExclusiveGroup(this, ...arguments)
+    add_mutually_exclusive_group () {
+
+        const group = _MutuallyExclusiveGroup(this, ...arguments)
         this._mutually_exclusive_groups.push(group)
         return group
     }
 
-    _add_action(action) {
+    _add_action (action) {
         // resolve any conflicts
         this._check_conflict(action)
 
@@ -2203,12 +2272,12 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         action.container = this
 
         // index the action by any option strings it has
-        for (let option_string of action.option_strings) {
+        for (const option_string of action.option_strings) {
             this._option_string_actions[option_string] = action
         }
 
         // set the flag if any option strings look like negative numbers
-        for (let option_string of action.option_strings) {
+        for (const option_string of action.option_strings) {
             if (this._negative_number_matcher.test(option_string)) {
                 if (!this._has_negative_number_optionals.length) {
                     this._has_negative_number_optionals.push(true)
@@ -2220,24 +2289,26 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         return action
     }
 
-    _remove_action(action) {
+    _remove_action (action) {
         _array_remove(this._actions, action)
     }
 
-    _add_container_actions(container) {
+    _add_container_actions (container) {
         // collect groups by titles
-        let title_group_map = {}
-        for (let group of this._action_groups) {
+        const title_group_map = Object.create(null)
+        for (const group of this._action_groups) {
             if (group.title in title_group_map) {
-                let msg = 'cannot merge actions - two groups are named %r'
+                // This branch could happen if a derived class added
+                // groups with duplicated titles in constructor.
+                const msg = 'cannot merge actions - two groups are named %r'
                 throw new TypeError(sub(msg, group.title))
             }
             title_group_map[group.title] = group
         }
 
         // map each action to its group
-        let group_map = new Map()
-        for (let group of container._action_groups) {
+        const group_map = new Map()
+        for (const group of container._action_groups) {
 
             // if a group with the title exists, use that, otherwise
             // create a new group matching the container's group
@@ -2250,7 +2321,7 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
             }
 
             // map the actions to their new group
-            for (let action of group._group_actions) {
+            for (const action of group._group_actions) {
                 group_map.set(action, title_group_map[group.title])
             }
         }
@@ -2258,25 +2329,32 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         // add container's mutually exclusive groups
         // NOTE: if add_mutually_exclusive_group ever gains title= and
         // description= then this code will need to be expanded as above
-        for (let group of container._mutually_exclusive_groups) {
-            let mutex_group = this.add_mutually_exclusive_group({
+        for (const group of container._mutually_exclusive_groups) {
+            let cont
+            if (group._container === container) {
+                cont = this
+            } else {
+                cont = title_group_map[group._container.title]
+            }
+            const mutex_group = cont.add_mutually_exclusive_group({
                 required: group.required
             })
 
             // map the actions to their new mutex group
-            for (let action of group._group_actions) {
+            for (const action of group._group_actions) {
                 group_map.set(action, mutex_group)
             }
         }
 
         // add all actions to this container or their group
-        for (let action of container._actions) {
-            group_map.get(action)._add_action(action)
+        for (const action of container._actions) {
+            const action_group = group_map.get(action) || this
+            action_group._add_action(action)
         }
     }
 
-    _get_positional_kwargs() {
-        let [
+    _get_positional_kwargs () {
+        const [
             dest,
             kwargs
         ] = _parse_opts(arguments, {
@@ -2286,16 +2364,17 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
 
         // make sure required is not specified
         if ('required' in kwargs) {
-            let msg = "'required' is an invalid argument for positionals"
+            const msg = "'required' is an invalid argument for positionals"
             throw new TypeError(msg)
         }
 
         // mark positional arguments as required if at least one is
         // always required
-        if (![OPTIONAL, ZERO_OR_MORE].includes(kwargs.nargs)) {
-            kwargs.required = true
+        const nargs = kwargs.nargs
+        if (nargs === 0) {
+            throw new TypeError('nargs for positionals must be != 0')
         }
-        if (kwargs.nargs === ZERO_OR_MORE && !('default' in kwargs)) {
+        if (![OPTIONAL, ZERO_OR_MORE, REMAINDER, SUPPRESS].includes(nargs)) {
             kwargs.required = true
         }
 
@@ -2303,8 +2382,8 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         return Object.assign(kwargs, { dest, option_strings: [] })
     }
 
-    _get_optional_kwargs() {
-        let [
+    _get_optional_kwargs () {
+        const [
             args,
             kwargs
         ] = _parse_opts(arguments, {
@@ -2313,15 +2392,15 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         })
 
         // determine short and long option strings
-        let option_strings = []
-        let long_option_strings = []
+        const option_strings = []
+        const long_option_strings = []
         let option_string
         for (option_string of args) {
             // error on strings that don't start with an appropriate prefix
             if (!this.prefix_chars.includes(option_string[0])) {
-                let args = {option: option_string,
+                const args = {option: option_string,
                             prefix_chars: this.prefix_chars}
-                let msg = 'invalid option string %(option)r: ' +
+                const msg = 'invalid option string %(option)r: ' +
                           'must start with a character %(prefix_chars)r'
                 throw new TypeError(sub(msg, args))
             }
@@ -2345,7 +2424,7 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
             }
             dest = _string_lstrip(dest_option_string, this.prefix_chars)
             if (!dest) {
-                let msg = 'dest= is required for options like %r'
+                const msg = 'dest= is required for options like %r'
                 throw new TypeError(sub(msg, option_string))
             }
             dest = dest.replace(/-/g, '_')
@@ -2355,53 +2434,53 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
         return Object.assign(kwargs, { dest, option_strings })
     }
 
-    _pop_action_class(kwargs, default_value = undefined) {
-        let action = getattr(kwargs, 'action', default_value)
+    _pop_action_class (kwargs, default_value = undefined) {
+        const action = getattr(kwargs, 'action', default_value)
         delete kwargs.action
         return this._registry_get('action', action, action)
     }
 
-    _get_handler() {
+    _get_handler () {
         // determine function from conflict handler string
-        let handler_func_name = sub('_handle_conflict_%s', this.conflict_handler)
+        const handler_func_name = sub('_handle_conflict_%s', this.conflict_handler)
         if (typeof this[handler_func_name] === 'function') {
             return this[handler_func_name]
         } else {
-            let msg = 'invalid conflict_resolution value: %r'
+            const msg = 'invalid conflict_resolution value: %r'
             throw new TypeError(sub(msg, this.conflict_handler))
         }
     }
 
-    _check_conflict(action) {
+    _check_conflict (action) {
 
         // find all options that conflict with this option
-        let confl_optionals = []
-        for (let option_string of action.option_strings) {
+        const confl_optionals = []
+        for (const option_string of action.option_strings) {
             if (hasattr(this._option_string_actions, option_string)) {
-                let confl_optional = this._option_string_actions[option_string]
-                confl_optionals.push([ option_string, confl_optional ])
+                const confl_optional = this._option_string_actions[option_string]
+                confl_optionals.push([option_string, confl_optional])
             }
         }
 
         // resolve any conflicts
         if (confl_optionals.length) {
-            let conflict_handler = this._get_handler()
+            const conflict_handler = this._get_handler()
             conflict_handler.call(this, action, confl_optionals)
         }
     }
 
-    _handle_conflict_error(action, conflicting_actions) {
-        let message = conflicting_actions.length === 1 ?
+    _handle_conflict_error (action, conflicting_actions) {
+        const message = conflicting_actions.length === 1 ?
             'conflicting option string: %s' :
             'conflicting option strings: %s'
-        let conflict_string = conflicting_actions.map(([ option_string/*, action*/ ]) => option_string).join(', ')
+        const conflict_string = conflicting_actions.map(([option_string]) => option_string).join(', ')
         throw new ArgumentError(action, sub(message, conflict_string))
     }
 
-    _handle_conflict_resolve(action, conflicting_actions) {
+    _handle_conflict_resolve (action, conflicting_actions) {
 
         // remove all conflicting options
-        for (let [ option_string, action ] of conflicting_actions) {
+        for (const [option_string, action] of conflicting_actions) {
 
             // remove the conflicting option
             _array_remove(action.option_strings, option_string)
@@ -2414,13 +2493,27 @@ const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
             }
         }
     }
-}))
+
+    _check_help (action) {
+        if (action.help && '_get_validation_formatter' in this) {
+            const formatter = this._get_validation_formatter()
+            try {
+                formatter._expand_help(action)
+            } catch (err) {
+                if (err instanceof TypeError) {
+                    throw new TypeError('badly formed help string', { cause: err })
+                }
+                throw err
+            }
+        }
+    }
+})
 
 
 const _ArgumentGroup = _callable(class _ArgumentGroup extends _ActionsContainer {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             container,
             title,
             description,
@@ -2432,6 +2525,13 @@ const _ArgumentGroup = _callable(class _ArgumentGroup extends _ActionsContainer
             '**kwargs': no_default
         })
 
+        if ('prefix_chars' in kwargs) {
+            const depr_msg =
+                "The use of the undocumented 'prefix_chars' parameter in " +
+                'ArgumentParser.add_argument_group() is deprecated.'
+            process.emitWarning(depr_msg, 'DeprecationWarning')
+        }
+
         // add any missing keyword arguments by checking the container
         setdefault(kwargs, 'conflict_handler', container.conflict_handler)
         setdefault(kwargs, 'prefix_chars', container.prefix_chars)
@@ -2452,23 +2552,27 @@ const _ArgumentGroup = _callable(class _ArgumentGroup extends _ActionsContainer
         this._mutually_exclusive_groups = container._mutually_exclusive_groups
     }
 
-    _add_action(action) {
+    _add_action (action) {
         action = super._add_action(action)
         this._group_actions.push(action)
         return action
     }
 
-    _remove_action(action) {
+    _remove_action (action) {
         super._remove_action(action)
         _array_remove(this._group_actions, action)
     }
+
+    add_argument_group () {
+        throw new TypeError('argument groups cannot be nested')
+    }
 })
 
 
 const _MutuallyExclusiveGroup = _callable(class _MutuallyExclusiveGroup extends _ArgumentGroup {
 
-    constructor() {
-        let [
+    constructor () {
+        const [
             container,
             required
         ] = _parse_opts(arguments, {
@@ -2481,9 +2585,9 @@ const _MutuallyExclusiveGroup = _callable(class _MutuallyExclusiveGroup extends
         this._container = container
     }
 
-    _add_action(action) {
+    _add_action (action) {
         if (action.required) {
-            let msg = 'mutually exclusive arguments must be optional'
+            const msg = 'mutually exclusive arguments must be optional'
             throw new TypeError(msg)
         }
         action = this._container._add_action(action)
@@ -2491,14 +2595,18 @@ const _MutuallyExclusiveGroup = _callable(class _MutuallyExclusiveGroup extends
         return action
     }
 
-    _remove_action(action) {
+    _remove_action (action) {
         this._container._remove_action(action)
         _array_remove(this._group_actions, action)
     }
+
+    add_mutually_exclusive_group () {
+        throw new TypeError('mutually exclusive groups cannot be nested')
+    }
 })
 
 
-const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _AttributeHolder(_ActionsContainer) {
+const ArgumentParser = _callable(class ArgumentParser extends _AttributeHolder(_ActionsContainer) {
     /*
      *  Object for parsing command line strings into Python objects.
      *
@@ -2518,9 +2626,12 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
      *      - allow_abbrev -- Allow long options to be abbreviated unambiguously
      *      - exit_on_error -- Determines whether or not ArgumentParser exits with
      *          error info when an error occurs
+     *      - suggest_on_error - Enables suggestions for mistyped argument choices
+     *          and subparser names. (default: false)
+     *      - color - Allow color output in help messages (default: true)
      */
 
-    constructor() {
+    constructor () {
         let [
             prog,
             usage,
@@ -2535,8 +2646,8 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             add_help,
             allow_abbrev,
             exit_on_error,
-            debug, // LEGACY (v1 compatibility), debug mode
-            version // LEGACY (v1 compatibility), version
+            suggest_on_error,
+            color
         ] = _parse_opts(arguments, {
             prog: undefined,
             usage: undefined,
@@ -2551,26 +2662,11 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             add_help: true,
             allow_abbrev: true,
             exit_on_error: true,
-            debug: undefined, // LEGACY (v1 compatibility), debug mode
-            version: undefined // LEGACY (v1 compatibility), version
+            '*': no_default,
+            suggest_on_error: false,
+            color: true
         })
 
-        // LEGACY (v1 compatibility)
-        if (debug !== undefined) {
-            deprecate('debug',
-                'The "debug" argument to ArgumentParser is deprecated. Please ' +
-                'override ArgumentParser.exit function instead.'
-            )
-        }
-
-        if (version !== undefined) {
-            deprecate('version',
-                'The "version" argument to ArgumentParser is deprecated. Please use ' +
-                "add_argument(..., { action: 'version', version: 'N', ... }) instead."
-            )
-        }
-        // end
-
         super({
             description,
             prefix_chars,
@@ -2591,44 +2687,44 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         this.add_help = add_help
         this.allow_abbrev = allow_abbrev
         this.exit_on_error = exit_on_error
-        // LEGACY (v1 compatibility), debug mode
-        this.debug = debug
-        // end
+        this.suggest_on_error = suggest_on_error
+        this.color = color
+
+        // Cached formatter for validation (avoids repeated _set_color calls)
+        this._cached_formatter = undefined
 
         this._positionals = this.add_argument_group('positional arguments')
-        this._optionals = this.add_argument_group('optional arguments')
+        this._optionals = this.add_argument_group('options')
         this._subparsers = undefined
 
         // register types
-        function identity(string) {
+        function identity (string) {
             return string
         }
         this.register('type', undefined, identity)
         this.register('type', null, identity)
-        this.register('type', 'auto', identity)
         this.register('type', 'int', function (x) {
-            let result = Number(x)
+            if (typeof x === 'string' && !/^[+-]?\d+(?:_?\d+)*$/.test(x.trim())) {
+                throw new TypeError(sub('could not convert string to int: %r', x))
+            }
+            const result = _string_to_number(x)
             if (!Number.isInteger(result)) {
                 throw new TypeError(sub('could not convert string to int: %r', x))
             }
             return result
         })
         this.register('type', 'float', function (x) {
-            let result = Number(x)
+            const result = _string_to_number(x)
             if (isNaN(result)) {
                 throw new TypeError(sub('could not convert string to float: %r', x))
             }
             return result
         })
         this.register('type', 'str', String)
-        // LEGACY (v1 compatibility): custom types
-        this.register('type', 'string',
-            util.deprecate(String, 'use {type:"str"} or {type:String} instead of {type:"string"}'))
-        // end
 
         // add help argument if necessary
         // (using explicit default to override global argument_default)
-        let default_prefix = prefix_chars.includes('-') ? '-' : prefix_chars[0]
+        const default_prefix = prefix_chars.includes('-') ? '-' : prefix_chars[0]
         if (this.add_help) {
             this.add_argument(
                 default_prefix + 'h',
@@ -2640,23 +2736,11 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
                 }
             )
         }
-        // LEGACY (v1 compatibility), version
-        if (version) {
-            this.add_argument(
-                default_prefix + 'v',
-                default_prefix.repeat(2) + 'version',
-                {
-                    action: 'version',
-                    default: SUPPRESS,
-                    version: this.version,
-                    help: "show program's version number and exit"
-                }
-            )
-        }
-        // end
-
         // add parent arguments and defaults
-        for (let parent of parents) {
+        for (const parent of parents) {
+            if (!(parent instanceof ArgumentParser)) {
+                throw new TypeError('parents must be a list of ArgumentParser')
+            }
             this._add_container_actions(parent)
             Object.assign(this._defaults, parent._defaults)
         }
@@ -2665,8 +2749,8 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
     // =======================
     // Pretty __repr__ methods
     // =======================
-    _get_kwargs() {
-        let names = [
+    _get_kwargs () {
+        const names = [
             'prog',
             'usage',
             'description',
@@ -2674,29 +2758,29 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             'conflict_handler',
             'add_help'
         ]
-        return names.map(name => [ name, getattr(this, name) ])
+        return names.map(name => [name, getattr(this, name)])
     }
 
     // ==================================
     // Optional/Positional adding methods
     // ==================================
-    add_subparsers() {
-        let [
+    add_subparsers () {
+        const [
             kwargs
         ] = _parse_opts(arguments, {
             '**kwargs': no_default
         })
 
         if (this._subparsers !== undefined) {
-            this.error('cannot have multiple subparser arguments')
+            throw new TypeError('cannot have multiple subparser arguments')
         }
 
         // add the parser class to the arguments if it's not present
         setdefault(kwargs, 'parser_class', this.constructor)
 
         if ('title' in kwargs || 'description' in kwargs) {
-            let title = getattr(kwargs, 'title', 'subcommands')
-            let description = getattr(kwargs, 'description', undefined)
+            const title = getattr(kwargs, 'title', 'subcommands')
+            const description = getattr(kwargs, 'description', undefined)
             delete kwargs.title
             delete kwargs.description
             this._subparsers = this.add_argument_group(title, description)
@@ -2707,24 +2791,32 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         // prog defaults to the usage message of this parser, skipping
         // optional arguments and with no "usage:" prefix
         if (kwargs.prog === undefined) {
-            let formatter = this._get_formatter()
-            let positionals = this._get_positional_actions()
-            let groups = this._mutually_exclusive_groups
-            formatter.add_usage(this.usage, positionals, groups, '')
+            // Create formatter without color to avoid storing ANSI codes in prog
+            // eslint-disable-next-line new-cap
+            const formatter = new this.formatter_class({ prog: this.prog })
+            formatter._set_color(false)
+            const positionals = this._get_positional_actions()
+            const groups = this._mutually_exclusive_groups
+            formatter.add_usage(undefined, positionals, groups, '')
             kwargs.prog = formatter.format_help().trim()
         }
 
         // create the parsers action and add it to the positionals list
-        let parsers_class = this._pop_action_class(kwargs, 'parsers')
+        const parsers_class = this._pop_action_class(kwargs, 'parsers')
+        if (hasattr(kwargs, 'option_strings')) {
+            throw new TypeError("add_subparsers() got multiple values for argument 'option_strings'")
+        }
         // eslint-disable-next-line new-cap
-        let action = new parsers_class(Object.assign({ option_strings: [] }, kwargs))
+        const action = new parsers_class(Object.assign({ option_strings: [] }, kwargs))
+        action._color = this.color
+        this._check_help(action)
         this._subparsers._add_action(action)
 
         // return the created parsers action
         return action
     }
 
-    _add_action(action) {
+    _add_action (action) {
         if (action.option_strings.length) {
             this._optionals._add_action(action)
         } else {
@@ -2733,30 +2825,40 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         return action
     }
 
-    _get_optional_actions() {
+    _get_optional_actions () {
         return this._actions.filter(action => action.option_strings.length)
     }
 
-    _get_positional_actions() {
+    _get_positional_actions () {
         return this._actions.filter(action => !action.option_strings.length)
     }
 
     // =====================================
     // Command line argument parsing methods
     // =====================================
-    parse_args(args = undefined, namespace = undefined) {
+    parse_args (args = undefined, namespace = undefined) {
         let argv
-        [ args, argv ] = this.parse_known_args(args, namespace)
+        [args, argv] = this.parse_known_args(args, namespace)
         if (argv && argv.length > 0) {
-            let msg = 'unrecognized arguments: %s'
-            this.error(sub(msg, argv.join(' ')))
+            const msg = sub('unrecognized arguments: %s', argv.join(' '))
+            if (this.exit_on_error) {
+                this.error(msg)
+            } else {
+                throw new ArgumentError(undefined, msg)
+            }
         }
         return args
     }
 
-    parse_known_args(args = undefined, namespace = undefined) {
+    parse_known_args (args = undefined, namespace = undefined) {
+        return this._parse_known_args2(args, namespace, false)
+    }
+
+    _parse_known_args2 (args, namespace, intermixed) {
         if (args === undefined) {
             args = get_argv().slice(1)
+        } else {
+            args = Array.from(args)
         }
 
         // default Namespace built from parser defaults
@@ -2765,7 +2867,7 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         }
 
         // add any action defaults that aren't present
-        for (let action of this._actions) {
+        for (const action of this._actions) {
             if (action.dest !== SUPPRESS) {
                 if (!hasattr(namespace, action.dest)) {
                     if (action.default !== SUPPRESS) {
@@ -2776,7 +2878,7 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         }
 
         // add any parser defaults that aren't present
-        for (let dest of Object.keys(this._defaults)) {
+        for (const dest of Object.keys(this._defaults)) {
             if (!hasattr(namespace, dest)) {
                 setattr(namespace, dest, this._defaults[dest])
             }
@@ -2785,7 +2887,7 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         // parse the arguments and exit if there are any errors
         if (this.exit_on_error) {
             try {
-                [ namespace, args ] = this._parse_known_args(args, namespace)
+                [namespace, args] = this._parse_known_args(args, namespace, intermixed)
             } catch (err) {
                 if (err instanceof ArgumentError) {
                     this.error(err.message)
@@ -2794,7 +2896,7 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
                 }
             }
         } else {
-            [ namespace, args ] = this._parse_known_args(args, namespace)
+            [namespace, args] = this._parse_known_args(args, namespace, intermixed)
         }
 
         if (hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR)) {
@@ -2802,10 +2904,10 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
         }
 
-        return [ namespace, args ]
+        return [namespace, args]
     }
 
-    _parse_known_args(arg_strings, namespace) {
+    _parse_known_args (arg_strings, namespace, intermixed) {
         // replace arg strings that are file references
         if (this.fromfile_prefix_chars !== undefined) {
             arg_strings = this._read_args_from_files(arg_strings)
@@ -2813,10 +2915,10 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
 
         // map all mutually exclusive arguments to the other arguments
         // they can't occur with
-        let action_conflicts = new Map()
-        for (let mutex_group of this._mutually_exclusive_groups) {
-            let group_actions = mutex_group._group_actions
-            for (let [ i, mutex_action ] of Object.entries(mutex_group._group_actions)) {
+        const action_conflicts = new Map()
+        for (const mutex_group of this._mutually_exclusive_groups) {
+            const group_actions = mutex_group._group_actions
+            for (const [i, mutex_action] of Object.entries(mutex_group._group_actions)) {
                 let conflicts = action_conflicts.get(mutex_action) || []
                 conflicts = conflicts.concat(group_actions.slice(0, +i))
                 conflicts = conflicts.concat(group_actions.slice(+i + 1))
@@ -2827,27 +2929,27 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         // find all option indices, and determine the arg_string_pattern
         // which has an 'O' if there is an option at an index,
         // an 'A' if there is an argument, or a '-' if there is a '--'
-        let option_string_indices = {}
-        let arg_string_pattern_parts = []
-        let arg_strings_iter = Object.entries(arg_strings)[Symbol.iterator]()
-        for (let [ i, arg_string ] of arg_strings_iter) {
+        const option_string_indices = {}
+        const arg_string_pattern_parts = []
+        const arg_strings_iter = Object.entries(arg_strings)[Symbol.iterator]()
+        for (let [i, arg_string] of arg_strings_iter) {
 
             // all args after -- are non-options
             if (arg_string === '--') {
                 arg_string_pattern_parts.push('-')
-                for ([ i, arg_string ] of arg_strings_iter) {
+                for ([i, arg_string] of arg_strings_iter) {
                     arg_string_pattern_parts.push('A')
                 }
 
             // otherwise, add the arg to the arg strings
             // and note the index if it was an option
             } else {
-                let option_tuple = this._parse_optional(arg_string)
+                const option_tuples = this._parse_optional(arg_string)
                 let pattern
-                if (option_tuple === undefined) {
+                if (option_tuples === undefined) {
                     pattern = 'A'
                 } else {
-                    option_string_indices[i] = option_tuple
+                    option_string_indices[i] = option_tuples
                     pattern = 'O'
                 }
                 arg_string_pattern_parts.push(pattern)
@@ -2858,23 +2960,23 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         let arg_strings_pattern = arg_string_pattern_parts.join('')
 
         // converts arg strings to the appropriate and then takes the action
-        let seen_actions = new Set()
-        let seen_non_default_actions = new Set()
+        const seen_actions = new Set()
+        const seen_non_default_actions = new Set()
+        const warned = new Set()
         let extras
 
-        let take_action = (action, argument_strings, option_string = undefined) => {
+        const take_action = (action, argument_strings, option_string = undefined) => {
             seen_actions.add(action)
-            let argument_values = this._get_values(action, argument_strings)
+            const argument_values = this._get_values(action, argument_strings)
 
             // error if this argument is not allowed with other previously
-            // seen arguments, assuming that actions that use the default
-            // value don't really count as "present"
-            if (argument_values !== action.default) {
+            // seen arguments
+            if (action.option_strings.length || argument_strings.length) {
                 seen_non_default_actions.add(action)
-                for (let conflict_action of action_conflicts.get(action) || []) {
+                for (const conflict_action of action_conflicts.get(action) || []) {
                     if (seen_non_default_actions.has(conflict_action)) {
-                        let msg = 'not allowed with argument %s'
-                        let action_name = _get_action_name(conflict_action)
+                        const msg = 'not allowed with argument %s'
+                        const action_name = _get_action_name(conflict_action)
                         throw new ArgumentError(action, sub(msg, action_name))
                     }
                 }
@@ -2888,59 +2990,81 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         }
 
         // function to convert arg_strings into an optional action
-        let consume_optional = start_index => {
+        const consume_optional = start_index => {
 
             // get the optional identified at this index
-            let option_tuple = option_string_indices[start_index]
-            let [ action, option_string, explicit_arg ] = option_tuple
+            const option_tuples = option_string_indices[start_index]
+            if (option_tuples.length > 1) {
+                const options = option_tuples.map(([, option_string]) => option_string).join(', ')
+                const args = {option: arg_strings[start_index], matches: options}
+                const msg = 'ambiguous option: %(option)s could match %(matches)s'
+                throw new ArgumentError(undefined, sub(msg, args))
+            }
+            let [action, option_string, sep, explicit_arg] = option_tuples[0]
 
             // identify additional optionals in the same arg string
             // (e.g. -xyz is the same as -x -y -z if no args are required)
-            let action_tuples = []
+            const action_tuples = []
             let stop
             for (;;) {
 
                 // if we found no optional action, skip it
                 if (action === undefined) {
                     extras.push(arg_strings[start_index])
+                    extras_pattern.push('O')
                     return start_index + 1
                 }
 
                 // if there is an explicit argument, try to match the
                 // optional's string arguments to only this
                 if (explicit_arg !== undefined) {
-                    let arg_count = this._match_argument(action, 'A')
+                    const arg_count = this._match_argument(action, 'A')
 
                     // if the action is a single-dash option and takes no
                     // arguments, try to parse more single-dash options out
                     // of the tail of the option string
-                    let chars = this.prefix_chars
-                    if (arg_count === 0 && !chars.includes(option_string[1])) {
-                        action_tuples.push([ action, [], option_string ])
-                        let char = option_string[0]
+                    const chars = this.prefix_chars
+                    if (arg_count === 0 &&
+                        !chars.includes(option_string[1]) &&
+                        explicit_arg !== '') {
+                        if (sep || chars.includes(explicit_arg[0])) {
+                            const msg = 'ignored explicit argument %r'
+                            throw new ArgumentError(action, sub(msg, explicit_arg))
+                        }
+                        action_tuples.push([action, [], option_string])
+                        const char = option_string[0]
                         option_string = char + explicit_arg[0]
-                        let new_explicit_arg = explicit_arg.slice(1) || undefined
-                        let optionals_map = this._option_string_actions
+                        const optionals_map = this._option_string_actions
                         if (hasattr(optionals_map, option_string)) {
                             action = optionals_map[option_string]
-                            explicit_arg = new_explicit_arg
+                            explicit_arg = explicit_arg.slice(1)
+                            if (!explicit_arg) {
+                                sep = explicit_arg = undefined
+                            } else if (explicit_arg[0] === '=') {
+                                sep = '='
+                                explicit_arg = explicit_arg.slice(1)
+                            } else {
+                                sep = ''
+                            }
                         } else {
-                            let msg = 'ignored explicit argument %r'
-                            throw new ArgumentError(action, sub(msg, explicit_arg))
+                            extras.push(char + explicit_arg)
+                            extras_pattern.push('O')
+                            stop = start_index + 1
+                            break
                         }
 
                     // if the action expect exactly one argument, we've
                     // successfully matched the option; exit the loop
                     } else if (arg_count === 1) {
                         stop = start_index + 1
-                        let args = [ explicit_arg ]
-                        action_tuples.push([ action, args, option_string ])
+                        const args = [explicit_arg]
+                        action_tuples.push([action, args, option_string])
                         break
 
                     // error if a double-dash option did not use the
                     // explicit argument
                     } else {
-                        let msg = 'ignored explicit argument %r'
+                        const msg = 'ignored explicit argument %r'
                         throw new ArgumentError(action, sub(msg, explicit_arg))
                     }
 
@@ -2948,12 +3072,12 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
                 // optional's string arguments with the following strings
                 // if successful, exit the loop
                 } else {
-                    let start = start_index + 1
-                    let selected_patterns = arg_strings_pattern.slice(start)
-                    let arg_count = this._match_argument(action, selected_patterns)
+                    const start = start_index + 1
+                    const selected_patterns = arg_strings_pattern.slice(start)
+                    const arg_count = this._match_argument(action, selected_patterns)
                     stop = start + arg_count
-                    let args = arg_strings.slice(start, stop)
-                    action_tuples.push([ action, args, option_string ])
+                    const args = arg_strings.slice(start, stop)
+                    action_tuples.push([action, args, option_string])
                     break
                 }
             }
@@ -2961,7 +3085,13 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             // add the Optional to the list and return the index at which
             // the Optional's string args stopped
             assert(action_tuples.length)
-            for (let [ action, args, option_string ] of action_tuples) {
+            for (const [action, args, option_string] of action_tuples) {
+                if (action.deprecated && !warned.has(option_string)) {
+                    this._warning(sub("option '%(option)s' is deprecated", {
+                        option: option_string
+                    }))
+                    warned.add(option_string)
+                }
                 take_action(action, args, option_string)
             }
             return stop
@@ -2972,18 +3102,35 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         let positionals = this._get_positional_actions()
 
         // function to convert arg_strings into positional actions
-        let consume_positionals = start_index => {
+        const consume_positionals = start_index => {
             // match as many Positionals as possible
-            let selected_pattern = arg_strings_pattern.slice(start_index)
-            let arg_counts = this._match_arguments_partial(positionals, selected_pattern)
+            const selected_pattern = arg_strings_pattern.slice(start_index)
+            const arg_counts = this._match_arguments_partial(positionals, selected_pattern)
 
             // slice off the appropriate arg strings for each Positional
             // and add the Positional and its args to the list
             for (let i = 0; i < positionals.length && i < arg_counts.length; i++) {
-                let action = positionals[i]
-                let arg_count = arg_counts[i]
-                let args = arg_strings.slice(start_index, start_index + arg_count)
+                const action = positionals[i]
+                const arg_count = arg_counts[i]
+                const args = arg_strings.slice(start_index, start_index + arg_count)
+                // Strip out the first '--' if it is not in REMAINDER arg.
+                if (action.nargs === PARSER) {
+                    if (arg_strings_pattern[start_index] === '-') {
+                        assert(args[0] === '--')
+                        _array_remove(args, '--')
+                    }
+                } else if (action.nargs !== REMAINDER) {
+                    if (arg_strings_pattern.slice(start_index, start_index + arg_count).includes('-')) {
+                        _array_remove(args, '--')
+                    }
+                }
                 start_index += arg_count
+                if (args.length && action.deprecated && !warned.has(action.dest)) {
+                    this._warning(sub("argument '%(argument_name)s' is deprecated", {
+                        argument_name: action.dest
+                    }))
+                    warned.add(action.dest)
+                }
                 take_action(action, args)
             }
 
@@ -2996,17 +3143,21 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         // consume Positionals and Optionals alternately, until we have
         // passed the last option string
         extras = []
+        let extras_pattern = []
         let start_index = 0
-        let max_option_string_index = Math.max(-1, ...Object.keys(option_string_indices).map(Number))
+        const max_option_string_index = Math.max(-1, ...Object.keys(option_string_indices).map(Number))
         while (start_index <= max_option_string_index) {
 
             // consume any Positionals preceding the next option
-            let next_option_string_index = Math.min(
-                // eslint-disable-next-line no-loop-func
-                ...Object.keys(option_string_indices).map(Number).filter(index => index >= start_index)
-            )
-            if (start_index !== next_option_string_index) {
-                let positionals_end_index = consume_positionals(start_index)
+            let next_option_string_index = start_index
+            while (next_option_string_index <= max_option_string_index) {
+                if (next_option_string_index in option_string_indices) {
+                    break
+                }
+                next_option_string_index += 1
+            }
+            if (!intermixed && start_index !== next_option_string_index) {
+                const positionals_end_index = consume_positionals(start_index)
 
                 // only try to parse the next optional if we didn't consume
                 // the option string during the positionals parsing
@@ -3021,8 +3172,10 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             // if we consumed all the positionals we could and we're not
             // at the index of an option string, there were extra arguments
             if (!(start_index in option_string_indices)) {
-                let strings = arg_strings.slice(start_index, next_option_string_index)
+                const strings = arg_strings.slice(start_index, next_option_string_index)
                 extras = extras.concat(strings)
+                extras_pattern = extras_pattern.concat(
+                    arg_strings_pattern.slice(start_index, next_option_string_index).split(''))
                 start_index = next_option_string_index
             }
 
@@ -3030,16 +3183,37 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             start_index = consume_optional(start_index)
         }
 
-        // consume any positionals following the last Optional
-        let stop_index = consume_positionals(start_index)
+        if (!intermixed) {
+            // consume any positionals following the last Optional
+            const stop_index = consume_positionals(start_index)
 
-        // if we didn't consume all the argument strings, there were extras
-        extras = extras.concat(arg_strings.slice(stop_index))
+            // if we didn't consume all the argument strings, there were extras
+            extras = extras.concat(arg_strings.slice(stop_index))
+        } else {
+            extras = extras.concat(arg_strings.slice(start_index))
+            extras_pattern = extras_pattern.concat(
+                arg_strings_pattern.slice(start_index).split(''))
+            extras_pattern = extras_pattern.join('')
+            assert(extras_pattern.length === extras.length)
+            // consume all positionals
+            arg_strings = extras.filter((string, i) => extras_pattern[i] !== 'O')
+            arg_strings_pattern = extras_pattern.replace(/O/g, '')
+            let stop_index = consume_positionals(0)
+            // leave unknown optionals and non-consumed positionals in extras
+            for (let i = 0; i < extras_pattern.length; i++) {
+                if (!stop_index) break
+                if (extras_pattern[i] !== 'O') {
+                    stop_index -= 1
+                    extras[i] = undefined
+                }
+            }
+            extras = extras.filter(string => string !== undefined)
+        }
 
         // make sure all required actions were present and also convert
         // action defaults which were not given as arguments
-        let required_actions = []
-        for (let action of this._actions) {
+        const required_actions = []
+        for (const action of this._actions) {
             if (!seen_actions.has(action)) {
                 if (action.required) {
                     required_actions.push(_get_action_name(action))
@@ -3060,15 +3234,15 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         }
 
         if (required_actions.length) {
-            this.error(sub('the following arguments are required: %s',
-                       required_actions.join(', ')))
+            throw new ArgumentError(undefined,
+                sub('the following arguments are required: %s', required_actions.join(', ')))
         }
 
         // make sure all required groups had one option present
-        for (let group of this._mutually_exclusive_groups) {
+        for (const group of this._mutually_exclusive_groups) {
             if (group.required) {
                 let no_actions_used = true
-                for (let action of group._group_actions) {
+                for (const action of group._group_actions) {
                     if (seen_non_default_actions.has(action)) {
                         no_actions_used = false
                         break
@@ -3077,23 +3251,23 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
 
                 // if no actions were used, report the error
                 if (no_actions_used) {
-                    let names = group._group_actions
+                    const names = group._group_actions
                         .filter(action => action.help !== SUPPRESS)
                         .map(action => _get_action_name(action))
-                    let msg = 'one of the arguments %s is required'
-                    this.error(sub(msg, names.join(' ')))
+                    const msg = 'one of the arguments %s is required'
+                    throw new ArgumentError(undefined, sub(msg, names.join(' ')))
                 }
             }
         }
 
         // return the updated namespace and the extra arguments
-        return [ namespace, extras ]
+        return [namespace, extras]
     }
 
-    _read_args_from_files(arg_strings) {
+    _read_args_from_files (arg_strings) {
         // expand arguments referencing files
         let new_arg_strings = []
-        for (let arg_string of arg_strings) {
+        for (const arg_string of arg_strings) {
 
             // for regular arguments, just add them back into the list
             if (!arg_string || !this.fromfile_prefix_chars.includes(arg_string[0])) {
@@ -3101,19 +3275,20 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
 
             // replace arguments referencing files with the file content
             } else {
+                let args_file
                 try {
-                    let args_file = fs.readFileSync(arg_string.slice(1), 'utf8')
-                    let arg_strings = []
-                    for (let arg_line of splitlines(args_file)) {
-                        for (let arg of this.convert_arg_line_to_args(arg_line)) {
-                            arg_strings.push(arg)
-                        }
-                    }
-                    arg_strings = this._read_args_from_files(arg_strings)
-                    new_arg_strings = new_arg_strings.concat(arg_strings)
+                    args_file = fs.readFileSync(arg_string.slice(1), 'utf8')
                 } catch (err) {
-                    this.error(err.message)
+                    throw new ArgumentError(undefined, err.message)
                 }
+                let arg_strings = []
+                for (const arg_line of splitlines(args_file)) {
+                    for (const arg of this.convert_arg_line_to_args(arg_line)) {
+                        arg_strings.push(arg)
+                    }
+                }
+                arg_strings = this._read_args_from_files(arg_strings)
+                new_arg_strings = new_arg_strings.concat(arg_strings)
             }
         }
 
@@ -3121,18 +3296,18 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         return new_arg_strings
     }
 
-    convert_arg_line_to_args(arg_line) {
+    convert_arg_line_to_args (arg_line) {
         return [arg_line]
     }
 
-    _match_argument(action, arg_strings_pattern) {
+    _match_argument (action, arg_strings_pattern) {
         // match the pattern for this action to the arg strings
-        let nargs_pattern = this._get_nargs_pattern(action)
-        let match = arg_strings_pattern.match(new RegExp('^' + nargs_pattern))
+        const nargs_pattern = this._get_nargs_pattern(action)
+        const match = arg_strings_pattern.match(new RegExp('^' + nargs_pattern))
 
         // raise an exception if we weren't able to find a match
         if (match === null) {
-            let nargs_errors = {
+            const nargs_errors = {
                 undefined: 'expected one argument',
                 [OPTIONAL]: 'expected at most one argument',
                 [ONE_OR_MORE]: 'expected at least one argument'
@@ -3148,25 +3323,28 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         return match[1].length
     }
 
-    _match_arguments_partial(actions, arg_strings_pattern) {
+    _match_arguments_partial (actions, arg_strings_pattern) {
         // progressively shorten the actions list by slicing off the
         // final actions until we find a match
-        let result = []
-        for (let i of range(actions.length, 0, -1)) {
-            let actions_slice = actions.slice(0, i)
-            let pattern = actions_slice.map(action => this._get_nargs_pattern(action)).join('')
-            let match = arg_strings_pattern.match(new RegExp('^' + pattern))
+        for (const i of range(actions.length, 0, -1)) {
+            const actions_slice = actions.slice(0, i)
+            const pattern = actions_slice.map(action => this._get_nargs_pattern(action)).join('')
+            const match = arg_strings_pattern.match(new RegExp('^' + pattern))
             if (match !== null) {
-                result = result.concat(match.slice(1).map(string => string.length))
-                break
+                const result = match.slice(1).map(string => string.length)
+                if (match[0].length < arg_strings_pattern.length &&
+                    arg_strings_pattern[match[0].length] === 'O') {
+                    while (result.length && !result[result.length - 1]) {
+                        result.pop()
+                    }
+                }
+                return result
             }
         }
-
-        // return the list of arg string counts
-        return result
+        return []
     }
 
-    _parse_optional(arg_string) {
+    _parse_optional (arg_string) {
         // if it's an empty string, it was meant to be a positional
         if (!arg_string) {
             return undefined
@@ -3179,8 +3357,8 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
 
         // if the option string is present in the parser, return the action
         if (arg_string in this._option_string_actions) {
-            let action = this._option_string_actions[arg_string]
-            return [ action, arg_string, undefined ]
+            const action = this._option_string_actions[arg_string]
+            return [[action, arg_string, undefined, undefined]]
         }
 
         // if it's just a single character, it was meant to be positional
@@ -3190,29 +3368,20 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
 
         // if the option string before the "=" is present, return the action
         if (arg_string.includes('=')) {
-            let [ option_string, explicit_arg ] = _string_split(arg_string, '=', 1)
+            const [option_string, explicit_arg] = _string_split(arg_string, '=', 1)
             if (option_string in this._option_string_actions) {
-                let action = this._option_string_actions[option_string]
-                return [ action, option_string, explicit_arg ]
+                const action = this._option_string_actions[option_string]
+                return [[action, option_string, '=', explicit_arg]]
             }
         }
 
         // search through all possible prefixes of the option string
         // and all actions in the parser for possible interpretations
-        let option_tuples = this._get_option_tuples(arg_string)
-
-        // if multiple actions match, the option string was ambiguous
-        if (option_tuples.length > 1) {
-            let options = option_tuples.map(([ /*action*/, option_string/*, explicit_arg*/ ]) => option_string).join(', ')
-            let args = {option: arg_string, matches: options}
-            let msg = 'ambiguous option: %(option)s could match %(matches)s'
-            this.error(sub(msg, args))
+        const option_tuples = this._get_option_tuples(arg_string)
 
-        // if exactly one action matched, this segmentation is good,
-        // so return the parsed action
-        } else if (option_tuples.length === 1) {
-            let [ option_tuple ] = option_tuples
-            return option_tuple
+        // if at least one action matched, return the options
+        if (option_tuples.length) {
+            return option_tuples
         }
 
         // if it was not found as an option, but it looks like a negative
@@ -3231,28 +3400,30 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
 
         // it was meant to be an optional but there is no such option
         // in this parser (though it might be a valid option in a subparser)
-        return [ undefined, arg_string, undefined ]
+        return [[undefined, arg_string, undefined, undefined]]
     }
 
-    _get_option_tuples(option_string) {
-        let result = []
+    _get_option_tuples (option_string) {
+        const result = []
 
         // option strings starting with two prefix characters are only
         // split at the '='
-        let chars = this.prefix_chars
+        const chars = this.prefix_chars
         if (chars.includes(option_string[0]) && chars.includes(option_string[1])) {
             if (this.allow_abbrev) {
-                let option_prefix, explicit_arg
+                let option_prefix, sep, explicit_arg
                 if (option_string.includes('=')) {
-                    [ option_prefix, explicit_arg ] = _string_split(option_string, '=', 1)
+                    [option_prefix, explicit_arg] = _string_split(option_string, '=', 1)
+                    sep = '='
                 } else {
                     option_prefix = option_string
+                    sep = undefined
                     explicit_arg = undefined
                 }
-                for (let option_string of Object.keys(this._option_string_actions)) {
+                for (const option_string of Object.keys(this._option_string_actions)) {
                     if (option_string.startsWith(option_prefix)) {
-                        let action = this._option_string_actions[option_string]
-                        let tup = [ action, option_string, explicit_arg ]
+                        const action = this._option_string_actions[option_string]
+                        const tup = [action, option_string, sep, explicit_arg]
                         result.push(tup)
                     }
                 }
@@ -3262,75 +3433,78 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         // but multiple character options always have to have their argument
         // separate
         } else if (chars.includes(option_string[0]) && !chars.includes(option_string[1])) {
-            let option_prefix = option_string
-            let explicit_arg = undefined
-            let short_option_prefix = option_string.slice(0, 2)
-            let short_explicit_arg = option_string.slice(2)
+            let option_prefix, sep, explicit_arg
+            if (option_string.includes('=')) {
+                [option_prefix, explicit_arg] = _string_split(option_string, '=', 1)
+                sep = '='
+            } else {
+                option_prefix = option_string
+                sep = explicit_arg = undefined
+            }
+            const short_option_prefix = option_string.slice(0, 2)
+            const short_explicit_arg = option_string.slice(2)
 
-            for (let option_string of Object.keys(this._option_string_actions)) {
+            for (const option_string of Object.keys(this._option_string_actions)) {
                 if (option_string === short_option_prefix) {
-                    let action = this._option_string_actions[option_string]
-                    let tup = [ action, option_string, short_explicit_arg ]
+                    const action = this._option_string_actions[option_string]
+                    const tup = [action, option_string, '', short_explicit_arg]
                     result.push(tup)
-                } else if (option_string.startsWith(option_prefix)) {
-                    let action = this._option_string_actions[option_string]
-                    let tup = [ action, option_string, explicit_arg ]
+                } else if (this.allow_abbrev && option_string.startsWith(option_prefix)) {
+                    const action = this._option_string_actions[option_string]
+                    const tup = [action, option_string, sep, explicit_arg]
                     result.push(tup)
                 }
             }
 
         // shouldn't ever get here
         } else {
-            this.error(sub('unexpected option string: %s', option_string))
+            throw new ArgumentError(undefined, sub('unexpected option string: %s', option_string))
         }
 
         // return the collected option tuples
         return result
     }
 
-    _get_nargs_pattern(action) {
+    _get_nargs_pattern (action) {
         // in all examples below, we have to allow for '--' args
         // which are represented as '-' in the pattern
-        let nargs = action.nargs
+        const nargs = action.nargs
+        const option = action.option_strings.length
         let nargs_pattern
 
         // the default (None) is assumed to be a single argument
         if (nargs === undefined) {
-            nargs_pattern = '(-*A-*)'
+            nargs_pattern = option ? '([A])' : '(-*A-*)'
 
         // allow zero or one arguments
         } else if (nargs === OPTIONAL) {
-            nargs_pattern = '(-*A?-*)'
+            nargs_pattern = option ? '(A?)' : '(-*A?-*)'
 
         // allow zero or more arguments
         } else if (nargs === ZERO_OR_MORE) {
-            nargs_pattern = '(-*[A-]*)'
+            nargs_pattern = option ? '(A*)' : '(-*[A-]*)'
 
         // allow one or more arguments
         } else if (nargs === ONE_OR_MORE) {
-            nargs_pattern = '(-*A[A-]*)'
+            nargs_pattern = option ? '(A+)' : '(-*A[A-]*)'
 
         // allow any number of options or arguments
         } else if (nargs === REMAINDER) {
-            nargs_pattern = '([-AO]*)'
+            nargs_pattern = option ? '([AO]*)' : '(.*)'
 
         // allow one argument followed by any number of options or arguments
         } else if (nargs === PARSER) {
-            nargs_pattern = '(-*A[-AO]*)'
+            nargs_pattern = option ? '(A[AO]*)' : '(-*A[-AO]*)'
 
         // suppress action, like nargs=0
         } else if (nargs === SUPPRESS) {
-            nargs_pattern = '(-*-*)'
+            nargs_pattern = option ? '()' : '(-*)'
 
         // all others should be integers
         } else {
-            nargs_pattern = sub('(-*%s-*)', 'A'.repeat(nargs).split('').join('-*'))
-        }
-
-        // if this is an optional action, -- is not allowed
-        if (action.option_strings.length) {
-            nargs_pattern = nargs_pattern.replace(/-\*/g, '')
-            nargs_pattern = nargs_pattern.replace(/-/g, '')
+            nargs_pattern = option
+                ? sub('([AO]{%s})', nargs)
+                : sub('((?:-*A){%s}-*)', nargs)
         }
 
         // return the pattern
@@ -3341,17 +3515,21 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
     // Alt command line argument parsing, allowing free intermix
     // ========================
 
-    parse_intermixed_args(args = undefined, namespace = undefined) {
+    parse_intermixed_args (args = undefined, namespace = undefined) {
         let argv
-        [ args, argv ] = this.parse_known_intermixed_args(args, namespace)
+        [args, argv] = this.parse_known_intermixed_args(args, namespace)
         if (argv.length) {
-            let msg = 'unrecognized arguments: %s'
-            this.error(sub(msg, argv.join(' ')))
+            const msg = sub('unrecognized arguments: %s', argv.join(' '))
+            if (this.exit_on_error) {
+                this.error(msg)
+            } else {
+                throw new ArgumentError(undefined, msg)
+            }
         }
         return args
     }
 
-    parse_known_intermixed_args(args = undefined, namespace = undefined) {
+    parse_known_intermixed_args (args = undefined, namespace = undefined) {
         // returns a namespace and list of extras
         //
         // positional can be freely intermixed with optionals.  optionals are
@@ -3359,103 +3537,21 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         // are then parsed.  If the parser definition is incompatible with the
         // intermixed assumptions (e.g. use of REMAINDER, subparsers) a
         // TypeError is raised.
-        //
-        // positionals are 'deactivated' by setting nargs and default to
-        // SUPPRESS.  This blocks the addition of that positional to the
-        // namespace
 
-        let extras
-        let positionals = this._get_positional_actions()
-        let a = positionals.filter(action => [ PARSER, REMAINDER ].includes(action.nargs))
+        const positionals = this._get_positional_actions()
+        const a = positionals.filter(action => [PARSER, REMAINDER].includes(action.nargs))
         if (a.length) {
             throw new TypeError(sub('parse_intermixed_args: positional arg' +
                                     ' with nargs=%s', a[0].nargs))
         }
 
-        for (let group of this._mutually_exclusive_groups) {
-            for (let action of group._group_actions) {
-                if (positionals.includes(action)) {
-                    throw new TypeError('parse_intermixed_args: positional in' +
-                                        ' mutuallyExclusiveGroup')
-                }
-            }
-        }
-
-        let save_usage
-        try {
-            save_usage = this.usage
-            let remaining_args
-            try {
-                if (this.usage === undefined) {
-                    // capture the full usage for use in error messages
-                    this.usage = this.format_usage().slice(7)
-                }
-                for (let action of positionals) {
-                    // deactivate positionals
-                    action.save_nargs = action.nargs
-                    // action.nargs = 0
-                    action.nargs = SUPPRESS
-                    action.save_default = action.default
-                    action.default = SUPPRESS
-                }
-                [ namespace, remaining_args ] = this.parse_known_args(args,
-                                                                      namespace)
-                for (let action of positionals) {
-                    // remove the empty positional values from namespace
-                    let attr = getattr(namespace, action.dest)
-                    if (Array.isArray(attr) && attr.length === 0) {
-                        // eslint-disable-next-line no-console
-                        console.warn(sub('Do not expect %s in %s', action.dest, namespace))
-                        delattr(namespace, action.dest)
-                    }
-                }
-            } finally {
-                // restore nargs and usage before exiting
-                for (let action of positionals) {
-                    action.nargs = action.save_nargs
-                    action.default = action.save_default
-                }
-            }
-            let optionals = this._get_optional_actions()
-            try {
-                // parse positionals.  optionals aren't normally required, but
-                // they could be, so make sure they aren't.
-                for (let action of optionals) {
-                    action.save_required = action.required
-                    action.required = false
-                }
-                for (let group of this._mutually_exclusive_groups) {
-                    group.save_required = group.required
-                    group.required = false
-                }
-                [ namespace, extras ] = this.parse_known_args(remaining_args,
-                                                              namespace)
-            } finally {
-                // restore parser values before exiting
-                for (let action of optionals) {
-                    action.required = action.save_required
-                }
-                for (let group of this._mutually_exclusive_groups) {
-                    group.required = group.save_required
-                }
-            }
-        } finally {
-            this.usage = save_usage
-        }
-        return [ namespace, extras ]
+        return this._parse_known_args2(args, namespace, true)
     }
 
     // ========================
     // Value conversion methods
     // ========================
-    _get_values(action, arg_strings) {
-        // for everything but PARSER, REMAINDER args, strip out first '--'
-        if (![PARSER, REMAINDER].includes(action.nargs)) {
-            try {
-                _array_remove(arg_strings, '--')
-            } catch (err) {}
-        }
-
+    _get_values (action, arg_strings) {
         let value
         // optional argument produces a default when not present
         if (!arg_strings.length && action.nargs === OPTIONAL) {
@@ -3464,9 +3560,8 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             } else {
                 value = action.default
             }
-            if (typeof value === 'string') {
+            if (typeof value === 'string' && value !== SUPPRESS) {
                 value = this._get_value(action, value)
-                this._check_value(action, value)
             }
 
         // when nargs='*' on a positional, if there were no command-line
@@ -3476,13 +3571,12 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
             if (action.default !== undefined) {
                 value = action.default
             } else {
-                value = arg_strings
+                value = []
             }
-            this._check_value(action, value)
 
         // single argument or optional argument produces a single value
         } else if (arg_strings.length === 1 && [undefined, OPTIONAL].includes(action.nargs)) {
-            let arg_string = arg_strings[0]
+            const arg_string = arg_strings[0]
             value = this._get_value(action, arg_string)
             this._check_value(action, value)
 
@@ -3502,7 +3596,7 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         // all other types of nargs produce a list
         } else {
             value = arg_strings.map(v => this._get_value(action, v))
-            for (let v of value) {
+            for (const v of value) {
                 this._check_value(action, v)
             }
         }
@@ -3511,11 +3605,10 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         return value
     }
 
-    _get_value(action, arg_string) {
-        let type_func = this._registry_get('type', action.type, action.type)
+    _get_value (action, arg_string) {
+        const type_func = this._registry_get('type', action.type, action.type)
         if (typeof type_func !== 'function') {
-            let msg = '%r is not callable'
-            throw new ArgumentError(action, sub(msg, type_func))
+            throw new TypeError(sub('%r is not callable', type_func))
         }
 
         // convert the value to the appropriate type
@@ -3539,15 +3632,14 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         } catch (err) {
             // ArgumentTypeErrors indicate errors
             if (err instanceof ArgumentTypeError) {
-                //let name = getattr(action.type, 'name', repr(action.type))
-                let msg = err.message
+                const msg = err.message
                 throw new ArgumentError(action, msg)
 
             // TypeErrors or ValueErrors also indicate errors
             } else if (err instanceof TypeError) {
-                let name = getattr(action.type, 'name', repr(action.type))
-                let args = {type: name, value: arg_string}
-                let msg = 'invalid %(type)s value: %(value)r'
+                const name = getattr(action.type, 'name', repr(action.type))
+                const args = {type: name, value: arg_string}
+                const msg = 'invalid %(type)s value: %(value)r'
                 throw new ArgumentError(action, sub(msg, args))
             } else {
                 throw err
@@ -3558,28 +3650,44 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         return result
     }
 
-    _check_value(action, value) {
+    _check_value (action, value) {
         // converted value must be one of the choices (if specified)
-        if (action.choices !== undefined && !_choices_to_array(action.choices).includes(value)) {
-            let args = {value,
-                        choices: _choices_to_array(action.choices).map(repr).join(', ')}
-            let msg = 'invalid choice: %(value)r (choose from %(choices)s)'
-            throw new ArgumentError(action, sub(msg, args))
+        if (action.choices === undefined) return
+
+        const choices = _choices_to_array(action.choices)
+        if (choices.includes(value)) return
+
+        const args = {value: String(value),
+                    choices: choices.map(choice => repr(String(choice))).join(', ')}
+        let msg = 'invalid choice: %(value)r (choose from %(choices)s)'
+
+        if (this.suggest_on_error && typeof value === 'string') {
+            if (choices.every(choice => typeof choice === 'string')) {
+                const { get_close_matches } = require('./difflib')
+                const suggestions = get_close_matches(value, choices, 1)
+                if (suggestions.length) {
+                    args.closest = suggestions[0]
+                    msg = 'invalid choice: %(value)r, maybe you meant %(closest)r? ' +
+                          '(choose from %(choices)s)'
+                }
+            }
         }
+
+        throw new ArgumentError(action, sub(msg, args))
     }
 
     // =======================
     // Help-formatting methods
     // =======================
-    format_usage() {
-        let formatter = this._get_formatter()
+    format_usage () {
+        const formatter = this._get_formatter()
         formatter.add_usage(this.usage, this._actions,
                             this._mutually_exclusive_groups)
         return formatter.format_help()
     }
 
-    format_help() {
-        let formatter = this._get_formatter()
+    format_help () {
+        const formatter = this._get_formatter()
 
         // usage
         formatter.add_usage(this.usage, this._actions,
@@ -3589,7 +3697,7 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         formatter.add_text(this.description)
 
         // positionals, optionals and user-defined groups
-        for (let action_group of this._action_groups) {
+        for (const action_group of this._action_groups) {
             formatter.start_section(action_group.title)
             formatter.add_text(action_group.description)
             formatter.add_arguments(action_group._group_actions)
@@ -3603,42 +3711,55 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
         return formatter.format_help()
     }
 
-    _get_formatter() {
+    _get_formatter () {
         // eslint-disable-next-line new-cap
-        return new this.formatter_class({ prog: this.prog })
+        const formatter = new this.formatter_class({ prog: this.prog })
+        formatter._set_color(this.color)
+        return formatter
+    }
+
+    _get_validation_formatter () {
+        // Return cached formatter for read-only validation operations
+        // (_expand_help and _format_args). Avoids repeated slow _set_color calls.
+        if (this._cached_formatter === undefined) {
+            this._cached_formatter = this._get_formatter()
+        }
+        return this._cached_formatter
     }
 
     // =====================
     // Help-printing methods
     // =====================
-    print_usage(file = undefined) {
+    print_usage (file = undefined) {
         if (file === undefined) file = process.stdout
         this._print_message(this.format_usage(), file)
     }
 
-    print_help(file = undefined) {
+    print_help (file = undefined) {
         if (file === undefined) file = process.stdout
         this._print_message(this.format_help(), file)
     }
 
-    _print_message(message, file = undefined) {
+    _print_message (message, file = undefined) {
         if (message) {
-            if (file === undefined) file = process.stderr
-            file.write(message)
+            file = file || process.stderr
+            if (file && typeof file.write === 'function') {
+                file.write(message)
+            }
         }
     }
 
     // ===============
     // Exiting methods
     // ===============
-    exit(status = 0, message = undefined) {
+    exit (status = 0, message = undefined) {
         if (message) {
             this._print_message(message, process.stderr)
         }
         process.exit(status)
     }
 
-    error(message) {
+    error (message) {
         /*
          *  error(message: string)
          *
@@ -3649,14 +3770,16 @@ const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _
          *  should either exit or raise an exception.
          */
 
-        // LEGACY (v1 compatibility), debug mode
-        if (this.debug === true) throw new Error(message)
-        // end
         this.print_usage(process.stderr)
-        let args = {prog: this.prog, message: message}
+        const args = {prog: this.prog, message}
         this.exit(2, sub('%(prog)s: error: %(message)s\n', args))
     }
-}))
+
+    _warning (message) {
+        const args = { prog: this.prog, message }
+        this._print_message(sub('%(prog)s: warning: %(message)s\n', args), process.stderr)
+    }
+})
 
 
 module.exports = {
@@ -3679,29 +3802,3 @@ module.exports = {
     SUPPRESS,
     ZERO_OR_MORE
 }
-
-// LEGACY (v1 compatibility), Const alias
-Object.defineProperty(module.exports, 'Const', {
-    get() {
-        let result = {}
-        Object.entries({ ONE_OR_MORE, OPTIONAL, PARSER, REMAINDER, SUPPRESS, ZERO_OR_MORE }).forEach(([ n, v ]) => {
-            Object.defineProperty(result, n, {
-                get() {
-                    deprecate(n, sub('use argparse.%s instead of argparse.Const.%s', n, n))
-                    return v
-                }
-            })
-        })
-        Object.entries({ _UNRECOGNIZED_ARGS_ATTR }).forEach(([ n, v ]) => {
-            Object.defineProperty(result, n, {
-                get() {
-                    deprecate(n, sub('argparse.Const.%s is an internal symbol and will no longer be available', n))
-                    return v
-                }
-            })
-        })
-        return result
-    },
-    enumerable: false
-})
-// end