sqlmath 2021.11.20 → 2022.5.20

package/jslint.mjs

@@ -1,14 +1,15 @@
 // #!/usr/bin/env node
 // JSLint
-// Original Author: Douglas Crockford (https://www.jslint.com).
 
+// The Unlicense
+//
 // This is free and unencumbered software released into the public domain.
-
+//
 // Anyone is free to copy, modify, publish, use, compile, sell, or
 // distribute this software, either in source code form or as a compiled
 // binary, for any purpose, commercial or non-commercial, and by any
 // means.
-
+//
 // In jurisdictions that recognize copyright laws, the author or authors
 // of this software dedicate any and all copyright interest in the
 // software to the public domain. We make this dedication for the benefit
@@ -16,7 +17,7 @@
 // successors. We intend this dedication to be an overt act of
 // relinquishment in perpetuity of all present and future rights to this
 // software under copyright law.
-
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -24,7 +25,7 @@
 // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
-
+//
 // For more information, please refer to <https://unlicense.org/>
 
 
@@ -92,50 +93,52 @@
 // WARNING: JSLint will hurt your feelings.
 
 /*jslint beta, node*/
-
 /*property
-    mode_conditional,
+    excludeList,
+    globExclude,
+    import_meta_url, includeList,
+    pathnameList,
     JSLINT_BETA, NODE_V8_COVERAGE, a, all, argv, arity, artifact,
     assertErrorThrownAsync, assertJsonEqual, assertOrThrow, assign, async, b,
     beta, bitwise, block, body, browser, c, calls, catch, catch_list,
-    catch_stack, causes, char, children, clear, closer,
-    closure, code, column, concat, consoleError, console_error, console_log,
-    constant, context, convert, count, coverageDir, create, cwd, d, dead,
-    debugInline, default, delta, devel, directive, directive_list,
-    directive_quiet, directives, dirname, disrupt, dot, edition, elem_list,
-    ellipsis, else, end, endOffset, endsWith, entries, env, error, eval, every,
-    example_list, exec, execArgv, exit, export_dict, exports, expression, extra,
-    file, fileList, fileURLToPath, filter, finally, flag, floor, for, forEach,
-    formatted_message, free, freeze, from, froms,
-    fsWriteFileWithParents, fud, functionName, function_list, function_stack,
-    functions, get, getset, github_repo, global, global_dict, global_list,
-    holeList, htmlEscape, id, identifier, import, import_list, inc, indent2,
-    index, indexOf, init, initial, isArray, isBlockCoverage, isHole, isNaN,
-    is_equal, is_weird, join, jslint, jslint_apidoc, jslint_assert,
-    jslint_charset_ascii, jslint_cli, jslint_edition, jslint_phase1_split,
-    jslint_phase2_lex, jslint_phase3_parse, jslint_phase4_walk,
-    jslint_phase5_whitage, jslint_report, json, jstestDescribe, jstestIt,
-    jstestOnExit, keys, label, lbp, led, length, level, line, lineList,
-    line_list, line_offset, line_source, lines, linesCovered, linesTotal, live,
-    log, long, loop, m, main, map, margin, match, max, message, meta, min,
-    mkdir, modeCoverageIgnoreFile, modeIndex, mode_cli, mode_json, mode_module,
-    mode_noop, mode_property, mode_shebang, mode_stop, module, moduleFsInit,
-    moduleName, module_list, name, names, node, noop, now,
-    nr, nud, objectDeepCopyWithKeysSorted, ok, on, open, opening, option,
-    option_dict, order, package_name, padEnd, padStart, parameters, parent,
-    parentIi, parse, pathname, platform, pop, processArgv, process_argv,
-    process_env, process_exit, process_version, promises, property,
-    property_dict, push, quote, ranges, readFile, readdir, readonly, recursive,
-    reduce, repeat, replace, resolve, result, reverse, rm, rmdir, role, round,
-    scriptId, search, set, shebang, shift, signature, single, slice, some, sort,
-    source, spawn, splice, split, stack, stack_trace, start, startOffset,
-    startsWith, statement, statement_prv, stdio, stop, stop_at, stringify,
-    switch, syntax_dict, tenure, test, test_cause, test_internal_error, this,
-    thru, toString, token, token_global, token_list, token_nxt, token_tree,
-    tokens, trace, tree, trim, trimEnd, trimRight, try, type, unlink, unordered,
-    unshift, url, used, v8CoverageListMerge, v8CoverageReportCreate, value,
-    variable, version, versions, warn, warn_at, warning, warning_list, warnings,
-    white, wrapped, writeFile
+    catch_stack, causes, char, children, clear, closer, closure, code, column,
+    concat, consoleError, console_error, console_log, constant, context,
+    convert, count, coverageDir, create, cwd, d, dead, debugInline, default,
+    delta, devel, directive, directive_list, directive_quiet, directives,
+    dirname, disrupt, dot, edition, elem_list, ellipsis, else, end, endOffset,
+    endsWith, entries, env, error, eval, every, example_list, exec, execArgv,
+    exit, exitCode, export_dict, exports, expression, extra, file, fileList,
+    fileURLToPath, filter, finally, flag, floor, for, forEach,
+    formatted_message, free, freeze, from, froms, fsWriteFileWithParents,
+    fud_stmt, functionName, function_list, function_stack, functions, get,
+    getset, github_repo, global, global_dict, global_list, holeList, htmlEscape,
+    id, identifier, import, import_list, inc, indent2, index, indexOf, init,
+    initial, isArray, isBlockCoverage, isHole, isNaN, is_equal, is_fart,
+    is_weird, join, jslint, jslint_apidoc, jslint_assert, jslint_charset_ascii,
+    jslint_cli, jslint_edition, jslint_phase1_split, jslint_phase2_lex,
+    jslint_phase3_parse, jslint_phase4_walk, jslint_phase5_whitage,
+    jslint_report, json, jstestDescribe, jstestIt, jstestOnExit, keys, label,
+    lbp, led_infix, length, level, line, lineList, line_list, line_offset,
+    line_source, lines, linesCovered, linesTotal, live, log, long, loop, m, map,
+    margin, match, max, message, meta, min, mkdir, modeCoverageIgnoreFile,
+    modeIndex, mode_cli, mode_conditional, mode_json, mode_module, mode_noop,
+    mode_property, mode_shebang, mode_stop, module, moduleFsInit, moduleName,
+    module_list, name, names, node, noop, now, nr, nud_prefix,
+    objectDeepCopyWithKeysSorted, ok, on, open, opening, option, option_dict,
+    order, package_name, padEnd, padStart, parameters, parent, parentIi, parse,
+    pathname, platform, pop, processArgv, process_argv, process_env,
+    process_exit, promises, property, property_dict, push, quote, ranges,
+    readFile, readdir, readonly, recursive, reduce, repeat, replace, resolve,
+    result, reverse, role, round, scriptId, search, set, shebang, shift,
+    signature, single, slice, some, sort, source, spawn, splice, split, stack,
+    stack_trace, start, startOffset, startsWith, statement, statement_prv,
+    stdio, stop, stop_at, stringify, switch, syntax_dict, tenure, test,
+    test_cause, test_internal_error, this, thru, toString, token, token_global,
+    token_list, token_nxt, token_tree, tokens, trace, tree, trim, trimEnd,
+    trimRight, try, type, unlink, unordered, unshift, url, used,
+    v8CoverageListMerge, v8CoverageReportCreate, value, variable, version,
+    versions, warn, warn_at, warning, warning_list, warnings, white, wrapped,
+    writeFile
 */
 
 // init debugInline
@@ -165,11 +168,99 @@ let jslint_charset_ascii = (
     + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
     + "`abcdefghijklmnopqrstuvwxyz{|}~\u007f"
 );
-let jslint_edition = "v2021.12.1-beta";
+let jslint_edition = "v2022.6.1-beta";
 let jslint_export;                      // The jslint object to be exported.
 let jslint_fudge = 1;                   // Fudge starting line and starting
                                         // ... column to 1.
 let jslint_import_meta_url = "";        // import.meta.url used by cli.
+let jslint_rgx_cap = (
+    /^[A-Z]/
+);
+let jslint_rgx_crlf = (
+    /\n|\r\n?/
+);
+let jslint_rgx_digits_bits = (
+    /^[01_]*/
+);
+let jslint_rgx_digits_decimals = (
+    /^[0-9_]*/
+);
+let jslint_rgx_digits_hexs = (
+    /^[0-9A-F_]*/i
+);
+let jslint_rgx_digits_octals = (
+    /^[0-7_]*/
+);
+let jslint_rgx_directive = (
+    /^(jslint|property|global)\s+(.*)$/
+);
+let jslint_rgx_directive_part = (
+    /([a-zA-Z$_][a-zA-Z0-9$_]*)(?::\s*(true|false))?,?\s*|$/g
+);
+let jslint_rgx_identifier = (
+    /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/
+);
+let jslint_rgx_json_number = (
+
+// https://datatracker.ietf.org/doc/html/rfc7159#section-6
+// number = [ minus ] int [ frac ] [ exp ]
+
+    /^-?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][\-+]?\d+)?$/
+);
+let jslint_rgx_mega = (
+
+// Vim-hack - vim-editor has trouble parsing naked '`' in regexp
+
+    /[\u0060\\]|\$\{/
+);
+let jslint_rgx_module = (
+    /^[a-zA-Z0-9_$:.@\-\/]+$/
+);
+let jslint_rgx_numeric_separator_illegal = (
+    /__|_$|_n$/m
+);
+let jslint_rgx_slash_star_or_slash = (
+    /\/\*|\/$/
+);
+let jslint_rgx_tab = (
+    /\t/g
+);
+let jslint_rgx_todo = (
+    /\b(?:todo|TO\s?DO|HACK)\b/
+);
+let jslint_rgx_token = new RegExp(
+    "^("
+    + "(\\s+)"
+    + "|([a-zA-Z_$][a-zA-Z0-9_$]*)"
+    + "|[(){}\\[\\],:;'\"~\\`]"
+    + "|\\?[?.]?"
+    + "|=(?:==?|>)?"
+    + "|\\.+"
+    + "|\\*[*\\/=]?"
+    + "|\\/[*\\/]?"
+    + "|\\+[=+]?"
+    + "|-[=\\-]?"
+    + "|[\\^%]=?"
+    + "|&[&=]?"
+    + "|\\"
+    + "|[|=]?"
+    + "|>{1,3}=?"
+    + "|<<?=?"
+    + "|!(?:!|==?)?"
+
+// PR-351 - Add BigInt support.
+// PR-390 - Add numeric-separator support.
+
+    + "|((?:0_?|[1-9][0-9_]*)n?)"
+    + ")"
+    + "(.*)$"
+);
+let jslint_rgx_url_search_window_jslint = (
+    /[&?]window_jslint=1(?:$|&)/m
+);
+let jslint_rgx_weird_property = (
+    /^_|\$|Sync$|_$/m
+);
 let jstestCountFailed = 0;
 let jstestCountTotal = 0;
 let jstestItCount = 0;
@@ -202,11 +293,12 @@ function assertJsonEqual(aa, bb, message) {
 
 // This function will assert JSON.stringify(<aa>) === JSON.stringify(<bb>).
 
-    aa = JSON.stringify(objectDeepCopyWithKeysSorted(aa));
-    bb = JSON.stringify(objectDeepCopyWithKeysSorted(bb));
+    aa = JSON.stringify(objectDeepCopyWithKeysSorted(aa), undefined, 1);
+    bb = JSON.stringify(objectDeepCopyWithKeysSorted(bb), undefined, 1);
     if (aa !== bb) {
         throw new Error(
-            JSON.stringify(aa) + " !== " + JSON.stringify(bb) + (
+            "\n" + aa + "\n!==\n" + bb
+            + (
                 typeof message === "string"
                 ? " - " + message
                 : message
@@ -264,6 +356,224 @@ async function fsWriteFileWithParents(pathname, data) {
     console.error("wrote file " + pathname);
 }
 
+function globExclude({
+    excludeList = [],
+    includeList = [],
+    pathnameList = []
+}) {
+
+// This function will
+// 1. Exclude pathnames in <pathnameList> that don't match glob-patterns in
+//    <includeList>.
+// 2. Exclude pathnames in <pathnameList> that match glob-patterns in
+//    <excludeList>.
+
+    function globAssertNotWeird(list, name) {
+
+// This function will check if <list> of strings contain weird characters.
+
+        [
+            [
+                "\n", (
+                    /^.*?([\u0000-\u0007\r]).*/gm
+                )
+            ],
+            [
+                "\r", (
+                    /^.*?([\n]).*/gm
+                )
+            ]
+        ].forEach(function ([
+            separator, rgx
+        ]) {
+            list.join(separator).replace(rgx, function (match0, char) {
+                throw new Error(
+                    "Weird character "
+                    + JSON.stringify(char)
+                    + " found in " + name + " "
+                    + JSON.stringify(match0)
+                );
+            });
+        });
+    }
+
+    function globToRegexp(pattern) {
+
+// This function will translate glob <pattern> to javascript-regexp,
+// which javascript can then use to "glob" pathnames.
+
+        let ii = 0;
+        let isClass = false;
+        let strClass = "";
+        let strRegex = "";
+        pattern = pattern.replace((
+            /\/\/+/g
+        ), "/");
+        pattern = pattern.replace((
+            /\*\*\*+/g
+        ), "**");
+        pattern.replace((
+            /\\\\|\\\[|\\\]|\[|\]|./g
+        ), function (match0) {
+            switch (match0) {
+            case "[":
+                if (isClass) {
+                    strClass += "[";
+                    return;
+                }
+                strClass += "\u0000";
+                strRegex += "\u0000";
+                isClass = true;
+                return;
+            case "]":
+                if (isClass) {
+                    isClass = false;
+                    return;
+                }
+                strRegex += "]";
+                return;
+            default:
+                if (isClass) {
+                    strClass += match0;
+                    return;
+                }
+                strRegex += match0;
+            }
+            return "";
+        });
+        strClass += "\u0000";
+
+// An expression "[!...]" matches a single character, namely any character that
+// is not matched by the expression obtained by removing the first '!' from it.
+// (Thus, "[!a-]" matches any single character except 'a', and '-'.)
+
+        strClass = strClass.replace((
+            /\u0000!/g
+        ), "\u0000^");
+
+// One may include '-' in its literal meaning by making it the first or last
+// character between the brackets.
+
+        strClass = strClass.replace((
+            /\u0000-/g
+        ), "\u0000\\-");
+        strClass = strClass.replace((
+            /-\u0000/g
+        ), "\\-\u0000");
+
+// Escape brackets '[', ']' in character class.
+
+        strClass = strClass.replace((
+            /[\[\]]/g
+        ), "\\$&");
+
+// https://stackoverflow.com/questions/3561493
+// /is-there-a-regexp-escape-function-in-javascript
+// $()*+-./?[\]^{|}
+
+        strRegex = strRegex.replace((
+            // ignore [-/]
+            /[$()*+.?\[\\\]\^{|}]/g
+        ), "\\$&");
+
+// Expand wildcard '**/*'.
+
+        strRegex = strRegex.replace((
+            /\\\*\\\*\/(?:\\\*)+/g
+        ), ".*?");
+
+// Expand wildcard '**'.
+
+        strRegex = strRegex.replace((
+            /(^|\/)\\\*\\\*(\/|$)/gm
+        ), "$1.*?$2");
+
+// Expand wildcard '*'.
+
+        strRegex = strRegex.replace((
+            /(?:\\\*)+/g
+        ), "[^\\/]*?");
+
+// Expand wildcard '?'.
+
+        strRegex = strRegex.replace((
+            /\\\?/g
+        ), "[^\\/]");
+
+// Expand directory-with-trailing-slash '.../'.
+
+        strRegex = strRegex.replace((
+            /\/$/gm
+        ), "\\/.*?");
+
+// Merge strClass into strRegex.
+
+        ii = 0;
+        strClass = strClass.split("\u0000");
+        strRegex = strRegex.replace((
+            /\u0000/g
+        ), function () {
+            ii += 1;
+            if (strClass[ii] === "") {
+                return "";
+            }
+            return "[" + strClass[ii] + "]";
+        });
+
+// Change strRegex from string to regexp.
+
+        strRegex = new RegExp("^" + strRegex + "$", "gm");
+        return strRegex;
+    }
+
+// Validate excludeList, includeList, pathnameList.
+
+    globAssertNotWeird(excludeList, "pattern");
+    globAssertNotWeird(includeList, "pattern");
+    globAssertNotWeird(pathnameList, "pathname");
+
+// Optimization
+// Concat pathnames into a single, newline-separated string,
+// whose pathnames can all be filtered with a single, regexp-pass.
+
+    pathnameList = pathnameList.join("\n");
+
+// 1. Exclude pathnames in <pathnameList> that don't match glob-patterns in
+//    <includeList>.
+
+    if (includeList.length > 0) {
+        includeList = includeList.map(globToRegexp);
+        includeList.forEach(function (pattern) {
+            pathnameList = pathnameList.replace(pattern, "\u0000$&");
+        });
+        pathnameList = pathnameList.replace((
+            /^[^\u0000].*/gm
+        ), "");
+        pathnameList = pathnameList.replace((
+            /^\u0000+/gm
+        ), "");
+    }
+
+// 2. Exclude pathnames in <pathnameList> that match glob-patterns in
+//    <excludeList>.
+
+    excludeList = excludeList.map(globToRegexp);
+    excludeList.forEach(function (pattern) {
+        pathnameList = pathnameList.replace(pattern, "");
+    });
+
+// Split newline-separated pathnames back to list.
+
+    pathnameList = pathnameList.split("\n").filter(function (elem) {
+        return elem;
+    });
+    return {
+        excludeList,
+        includeList,
+        pathnameList
+    };
+}
+
 function htmlEscape(str) {
 
 // This function will make <str> html-safe by escaping & < >.
@@ -304,10 +614,7 @@ function jslint(
     let import_list = [];       // The array collecting all import-from strings.
     let line_list = String(     // The array containing source lines.
         "\n" + source
-    ).split(
-        // rx_crlf
-        /\n|\r\n?/
-    ).map(function (line_source) {
+    ).split(jslint_rgx_crlf).map(function (line_source) {
         return {
             line_source
         };
@@ -352,8 +659,6 @@ function jslint(
     }
 
     function is_equal(aa, bb) {
-        let aa_value;
-        let bb_value;
 
 // test_cause:
 // ["0&&0", "is_equal", "", "", 0]
@@ -374,6 +679,7 @@ function jslint(
 
 // test_cause:
 // ["`${0}`&&`${0}`", "is_equal", "recurse_isArray", "", 0]
+// ["`${0}`&&`${1}`", "is_equal", "recurse_isArray", "", 0]
 
                     test_cause("recurse_isArray");
                     return is_equal(value, bb[index]);
@@ -387,21 +693,19 @@ function jslint(
 // }
 
         jslint_assert(!Array.isArray(bb), `Expected !Array.isArray(bb).`);
-        if (aa.id === "(number)" && bb.id === "(number)") {
+        switch (aa.id === bb.id && aa.id) {
+        case "(number)":
+        case "(string)":
             return aa.value === bb.value;
-        }
-        if (aa.id === "(string)") {
-            aa_value = aa.value;
-        } else if (aa.id === "`" && aa.constant) {
-            aa_value = aa.value[0];
-        }
-        if (bb.id === "(string)") {
-            bb_value = bb.value;
-        } else if (bb.id === "`" && bb.constant) {
-            bb_value = bb.value[0];
-        }
-        if (typeof aa_value === "string") {
-            return aa_value === bb_value;
+
+// PR-394 - Bugfix
+// Fix jslint falsely believing megastring literals `0` and `1` are similar.
+
+        case "`":
+            if (!is_equal(aa.value, bb.value)) {
+                return false;
+            }
+            break;
         }
         if (is_weird(aa) || is_weird(bb)) {
 
@@ -678,8 +982,17 @@ function jslint(
                 `Expected 'Object.freeze('. All export values should be frozen.`
             );
             break;
-        case "function_in_loop":
-            mm = `Don't create functions within a loop.`;
+
+// PR-378 - Relax warning "function_in_loop".
+//
+//         case "function_in_loop":
+//             mm = `Don't create functions within a loop.`;
+//             break;
+
+// PR-390 - Add numeric-separator check.
+
+        case "illegal_num_separator":
+            mm = `Illegal numeric separator '_' at column ${column}.`;
             break;
         case "infix_in":
             mm = (
@@ -833,6 +1146,15 @@ function jslint(
         case "use_double":
             mm = `Use double quotes, not single quotes.`;
             break;
+
+// PR-386 - Fix issue #382 - Make fart-related warnings more readable.
+
+        case "use_function_not_fart":
+            mm = (
+                `Use 'function (...)', not '(...) =>' when arrow functions`
+                + ` become too complex.`
+            );
+            break;
         case "use_open":
             mm = (
                 `Wrap a ternary expression in parens,`
@@ -866,6 +1188,12 @@ function jslint(
         case "wrap_condition":
             mm = `Wrap the condition in parens.`;
             break;
+
+// PR-386 - Fix issue #382 - Make fart-related warnings more readable.
+
+        case "wrap_fart_parameter":
+            mm = `Wrap the parameter before '=>' in parens.`;
+            break;
         case "wrap_immediate":
             mm = (
                 `Wrap an immediate function invocation in parentheses to assist`
@@ -873,9 +1201,6 @@ function jslint(
                 + ` result of a function, and not the function itself.`
             );
             break;
-        case "wrap_parameter":
-            mm = `Wrap the parameter in parens.`;
-            break;
         case "wrap_regexp":
             mm = `Wrap this regexp in parens to avoid confusion.`;
             break;
@@ -1437,6 +1762,7 @@ async function jslint_cli({
     console_error,
     console_log,
     file,
+    import_meta_url,
     mode_cli,
     mode_noop,
     option,
@@ -1451,8 +1777,8 @@ async function jslint_cli({
     let command;
     let data;
     let exit_code = 0;
-    let mode_plugin_vim;
     let mode_report;
+    let mode_wrapper_vim;
     let result;
 
     function jslint_from_file({
@@ -1525,7 +1851,7 @@ async function jslint_cli({
         if (result_from_file.warnings.length > 0) {
             exit_code = 1;
             console_error(
-                mode_plugin_vim
+                mode_wrapper_vim
 
 // PR-349 - Print warnings in format readable by vim.
 
@@ -1605,11 +1931,26 @@ async function jslint_cli({
         return count;
     }
 
+// PR-396 - window.jslint
+// Check import.meta.url for directive to export jslint to window-object.
+// Useful for ES5-era browser-scripts that rely on window.jslint,
+// like CodeMirror.
+//
+// Example usage:
+// <script type="module" src="./jslint.mjs?window_jslint=1"></script>
+
+    import_meta_url = import_meta_url || jslint_import_meta_url;
+    if (
+        jslint_rgx_url_search_window_jslint.test(import_meta_url)
+        && (typeof globalThis === "object" && globalThis)
+    ) {
+        globalThis.jslint = jslint;
+    }
+
 // Feature-detect nodejs.
 
     if (!(
-        typeof process === "object"
-        && process
+        (typeof process === "object" && process)
         && process.versions
         && typeof process.versions.node === "string"
         && !mode_noop
@@ -1635,7 +1976,7 @@ async function jslint_cli({
                 ).test(process_argv[1])
                 || mode_cli
             )
-            && moduleUrl.fileURLToPath(jslint_import_meta_url)
+            && moduleUrl.fileURLToPath(import_meta_url)
             === modulePath.resolve(process_argv[1])
         )
         && !mode_cli
@@ -1658,17 +1999,17 @@ async function jslint_cli({
         }));
         return;
 
-// COMMIT-b26d6df2 - Add command jslint_plugin_vim.
+// PR-363 - Add command jslint_report.
 
-    case "jslint_plugin_vim":
-        mode_plugin_vim = true;
+    case "jslint_report":
+        mode_report = command[1];
         process_argv = process_argv.slice(1);
         break;
 
-// PR-363 - Add command jslint_report.
+// COMMIT-b26d6df2 - Add command jslint_wrapper_vim.
 
-    case "jslint_report":
-        mode_report = command[1];
+    case "jslint_wrapper_vim":
+        mode_wrapper_vim = true;
         process_argv = process_argv.slice(1);
         break;
 
@@ -1676,6 +2017,7 @@ async function jslint_cli({
 
     case "v8_coverage_report":
         await v8CoverageReportCreate({
+            consoleError: console_error,
             coverageDir: command[1],
             processArgv: process_argv.slice(3)
         });
@@ -1684,9 +2026,9 @@ async function jslint_cli({
 
 // PR-349 - Detect cli-option --mode-vim-plugin.
 
-    mode_plugin_vim = (
+    mode_wrapper_vim = (
         process_argv.slice(2).indexOf("--mode-vim-plugin") >= 0
-        || mode_plugin_vim
+        || mode_wrapper_vim
     );
 
 // Normalize file relative to process.cwd().
@@ -1780,7 +2122,9 @@ async function jslint_cli({
         option
     });
     if (mode_report) {
-        await fsWriteFileWithParents(mode_report, jslint_report(result));
+        result = jslint.jslint_report(result);
+        result = `<body class="JSLINT_ JSLINT_REPORT_">\n${result}</body>\n`;
+        await fsWriteFileWithParents(mode_report, result);
     }
     process_exit(exit_code);
     return exit_code;
@@ -1822,37 +2166,16 @@ function jslint_phase2_lex(state) {
     let line_mega;              // The starting line of megastring.
     let line_source = "";       // The remaining line source string.
     let line_whole = "";        // The whole line source string.
+    let mode_digits_empty_string = 1;
+    let mode_digits_numeric_separator = 2;
     let mode_directive = true;  // true if directives are still allowed.
     let mode_mega = false;      // true if currently parsing a megastring
                                 // ... literal.
     let mode_regexp;            // true if regular expression literal seen on
                                 // ... this line.
-    let rx_token = new RegExp(
-        "^("
-        + "(\\s+)"
-        + "|([a-zA-Z_$][a-zA-Z0-9_$]*)"
-        + "|[(){}\\[\\],:;'\"~\\`]"
-        + "|\\?[?.]?"
-        + "|=(?:==?|>)?"
-        + "|\\.+"
-        + "|\\*[*\\/=]?"
-        + "|\\/[*\\/]?"
-        + "|\\+[=+]?"
-        + "|-[=\\-]?"
-        + "|[\\^%]=?"
-        + "|&[&=]?"
-        + "|\\"
-        + "|[|=]?"
-        + "|>{1,3}=?"
-        + "|<<?=?"
-        + "|!(?:!|==?)?"
-
-// PR-351 - Add BigInt support.
-
-        + "|(0n?|[1-9][0-9]*n?)"
-        + ")"
-        + "(.*)$"
-    );
+    let paren_backtrack_list = [];      // List of most recent "(" tokens at any
+                                        // ... paren-depth.
+    let paren_depth = 0;        // Keeps track of current paren-depth.
     let snippet = "";           // A piece of string.
     let token_1;                // The first token.
     let token_prv = token_global;       // The previous token including
@@ -1934,7 +2257,7 @@ function jslint_phase2_lex(state) {
 
                     warn_at("unexpected_a", line, column, char);
                 }
-                if (read_digits("x") > 5) {
+                if (read_digits("x", undefined) > 5) {
 
 // test_cause:
 // ["\"\\u{123456}\"", "char_after_escape", "too_many_digits", "", 11]
@@ -1951,7 +2274,7 @@ function jslint_phase2_lex(state) {
                 return char_after();
             }
             char_before();
-            if (read_digits("x", true) < 4) {
+            if (read_digits("x", mode_digits_empty_string) < 4) {
 
 // test_cause:
 // ["\"\\u0\"", "char_after_escape", "expected_four_digits", "", 5]
@@ -1986,6 +2309,26 @@ function jslint_phase2_lex(state) {
         return char;
     }
 
+    function check_numeric_separator(digits, column) {
+
+// This function will check for illegal numeric-separator in <digits>.
+
+        digits.replace((
+            jslint_rgx_numeric_separator_illegal
+        ), function (ignore, ii) {
+
+// test_cause:
+// ["0x0_0_;", "check_numeric_separator", "illegal_num_separator", "", 6]
+// ["0x0_0__0;", "check_numeric_separator", "illegal_num_separator", "", 6]
+// ["aa=1_2_;", "check_numeric_separator", "illegal_num_separator", "", 7]
+// ["aa=1_2__3;", "check_numeric_separator", "illegal_num_separator", "", 7]
+// ["aa=1_2_n;", "check_numeric_separator", "illegal_num_separator", "", 7]
+
+            warn_at("illegal_num_separator", line, column + ii + 1);
+            return "";
+        });
+    }
+
     function lex_comment() {
         let body;
         let ii = 0;
@@ -2024,12 +2367,12 @@ function jslint_phase2_lex(state) {
 // Lex/loop through each line until "*/".
 
             while (true) {
-                // rx_star_slash
+                // jslint_rgx_star_slash
                 ii = line_source.indexOf("*/");
                 if (ii >= 0) {
                     break;
                 }
-                // rx_slash_star
+                // jslint_rgx_slash_star
                 ii = line_source.indexOf("/*");
                 if (ii >= 0) {
 
@@ -2049,8 +2392,7 @@ function jslint_phase2_lex(state) {
                 }
             }
             jj = line_source.slice(0, ii).search(
-                // rx_slash_star_or_slash
-                /\/\*|\/$/
+                jslint_rgx_slash_star_or_slash
             );
             if (jj >= 0) {
 
@@ -2068,13 +2410,7 @@ function jslint_phase2_lex(state) {
 
 // Uncompleted work comment.
 
-        if (
-            !option_dict.devel
-            && (
-                // rx_todo
-                /\b(?:todo|TO\s?DO|HACK)\b/
-            ).test(snippet)
-        ) {
+        if (!option_dict.devel && jslint_rgx_todo.test(snippet)) {
 
 // test_cause:
 // ["//todo", "lex_comment", "todo_comment", "(comment)", 1] //jslint-quiet
@@ -2086,10 +2422,7 @@ function jslint_phase2_lex(state) {
 
         [
             the_comment.directive, body
-        ] = Array.from(snippet.match(
-            // rx_directive
-            /^(jslint|property|global)\s+(.*)$/
-        ) || []).slice(1);
+        ] = Array.from(snippet.match(jslint_rgx_directive) || []).slice(1);
         if (the_comment.directive === undefined) {
             return the_comment;
         }
@@ -2111,10 +2444,12 @@ function jslint_phase2_lex(state) {
 // Lex/loop through each directive in /*...*/
 
         ii = 0;
-        body.replace((
-            // rx_directive_part
-            /([a-zA-Z$_][a-zA-Z0-9$_]*)(?::\s*(true|false))?,?\s*|$/g
-        ), function (match0, key, val, jj) {
+        body.replace(jslint_rgx_directive_part, function (
+            match0,
+            key,
+            val,
+            jj
+        ) {
             if (ii !== jj) {
 
 // test_cause:
@@ -2188,13 +2523,7 @@ function jslint_phase2_lex(state) {
 // string.
 
         while (true) {
-            match = line_source.match(
-
-// Vim-hack - vim-editor has trouble parsing '`' in regexp
-
-                // rx_mega
-                /[\u0060\\]|\$\{/
-            ) || {
+            match = line_source.match(jslint_rgx_mega) || {
                 "0": "",
                 index: 0
             };
@@ -2271,12 +2600,16 @@ function jslint_phase2_lex(state) {
 
     function lex_number() {
         let prefix = snippet;
+
+// PR-390 - Add numeric-separator check.
+
+        check_numeric_separator(prefix, column - prefix.length);
         char_after();
         switch (prefix === "0" && char) {
         case "b":
         case "o":
         case "x":
-            read_digits(char);
+            read_digits(char, mode_digits_numeric_separator);
 
 // PR-351 - Ignore BigInt suffix 'n'.
 
@@ -2286,14 +2619,14 @@ function jslint_phase2_lex(state) {
             break;
         default:
             if (char === ".") {
-                read_digits("d");
+                read_digits("d", mode_digits_numeric_separator);
             }
             if (char === "E" || char === "e") {
                 char_after(char);
                 if (char !== "+" && char !== "-") {
                     char_before();
                 }
-                read_digits("d");
+                read_digits("d", mode_digits_numeric_separator);
             }
         }
 
@@ -2563,7 +2896,7 @@ function jslint_phase2_lex(state) {
                     }
                     break;
                 case "{":
-                    if (read_digits("d", true) === 0) {
+                    if (read_digits("d", mode_digits_empty_string) === 0) {
 
 // test_cause:
 // ["aa=/aa{/", "lex_regexp_group", "expected_a_before_b", ",", 8]
@@ -2576,7 +2909,7 @@ function jslint_phase2_lex(state) {
 // ["aa=/.{,/", "lex_regexp_group", "comma", "", 0]
 
                         test_cause("comma");
-                        read_digits("d", true);
+                        read_digits("d", mode_digits_empty_string);
                     }
                     if (char_after("}") === "?") {
 
@@ -2869,7 +3202,7 @@ function jslint_phase2_lex(state) {
                 }
             }
             from = column;
-            match = line_source.match(rx_token);
+            match = line_source.match(jslint_rgx_token);
 
 // match[1] token
 // match[2] whitespace
@@ -3189,7 +3522,7 @@ node --input-type=module --eval '
 // /\*jslint beta, node*\/
 import moduleHttps from "https";
 (async function () {
-    let dict = {};
+    let dict = Object.create(null);
     let result = "";
     await new Promise(function (resolve) {
         moduleHttps.get((
@@ -3252,41 +3585,48 @@ import moduleHttps from "https";
         return true;
     }
 
-    function read_digits(base, quiet) {
+    function read_digits(base, mode) {
         let digits = line_source.match(
             base === "b"
-            ? (
-                // rx_bits
-                /^[01]*/
-            )
+            ? jslint_rgx_digits_bits
             : base === "o"
-            ? (
-                // rx_octals
-                /^[0-7]*/
-            )
+            ? jslint_rgx_digits_octals
             : base === "x"
-            ? (
-                // rx_hexs
-                /^[0-9A-F]*/i
-            )
-            : (
-                // rx_digits
-                /^[0-9]*/
-            )
+            ? jslint_rgx_digits_hexs
+            : jslint_rgx_digits_decimals
         )[0];
-        let length = digits.length;
-        if (!quiet && length === 0) {
+        if (
+            (mode !== mode_digits_empty_string && digits.length === 0)
+            || digits[0] === "_"
+        ) {
 
 // test_cause:
 // ["0x", "read_digits", "expected_digits_after_a", "0x", 2]
+// ["0x_", "read_digits", "expected_digits_after_a", "0x", 2]
 
             warn_at("expected_digits_after_a", line, column, snippet);
         }
-        column += length;
-        line_source = line_source.slice(length);
+
+// PR-390 - Add numeric-separator check.
+
+        if (mode === mode_digits_numeric_separator) {
+            check_numeric_separator(digits, column);
+        } else if (digits.indexOf("_") >= 0) {
+
+// test_cause:
+// ["\"\\u{1_2}\"", "read_digits", "illegal_num_separator", "", 6]
+
+            warn_at(
+                "illegal_num_separator",
+                line,
+                column + digits.indexOf("_") + 1
+            );
+        }
+        column += digits.length;
+        line_source = line_source.slice(digits.length);
         snippet += digits;
         char_after();
-        return length;
+        return digits.length;
     }
 
     function read_line() {
@@ -3357,6 +3697,7 @@ import moduleHttps from "https";
             test_cause("line_disable");
             line_source = "";
         }
+        // jslint_rgx_tab
         if (line_source.indexOf("\t") >= 0) {
             if (!option_dict.white) {
 
@@ -3365,10 +3706,7 @@ import moduleHttps from "https";
 
                 warn_at("use_spaces", line, line_source.indexOf("\t") + 1);
             }
-            line_source = line_source.replace((
-                // rx_tab
-                /\t/g
-            ), " ");
+            line_source = line_source.replace(jslint_rgx_tab, " ");
         }
         if (!option_dict.white && line_source.endsWith(" ")) {
 
@@ -3388,9 +3726,11 @@ import moduleHttps from "https";
             from,
             id,
             identifier: Boolean(identifier),
+            is_fart: false,
             line,
             nr: token_list.length,
-            thru: column
+            thru: column,
+            value
         };
         token_list.push(the_token);
 
@@ -3400,12 +3740,6 @@ import moduleHttps from "https";
             mode_directive = false;
         }
 
-// If the token is to have a value, give it one.
-
-        if (value !== undefined) {
-            the_token.value = value;
-        }
-
 // If this token is an identifier that touches a preceding number, or
 // a "/", comment, or regular expression literal that touches a preceding
 // comment or regular expression literal, then give a missing space warning.
@@ -3439,6 +3773,29 @@ import moduleHttps from "https";
             the_token.dot = true;
         }
 
+// PR-385 - Bugfix - Fixes issue #382 - failure to detect destructured fart.
+// Farts are now detected by keeping a list of most recent "(" tokens at any
+// given depth. When a "=>" token is encountered, the most recent "(" token at
+// current depth is marked as a fart.
+
+        switch (id) {
+        case "(":
+            paren_backtrack_list[paren_depth] = the_token;
+            paren_depth += 1;
+            break;
+        case ")":
+            paren_depth -= 1;
+            break;
+        case "=>":
+            if (
+                token_prv_expr.id === ")"
+                && paren_backtrack_list[paren_depth]
+            ) {
+                paren_backtrack_list[paren_depth].is_fart = true;
+            }
+            break;
+        }
+
 // The previous token is used to detect adjacency problems.
 
         token_prv = the_token;
@@ -3523,9 +3880,6 @@ function jslint_phase3_parse(state) {
     let catchage = catch_stack[0];      // The current catch-block.
     let functionage = token_global;     // The current function.
     let mode_var;               // "var" if using var; "let" if using let.
-    let rx_identifier = (
-        /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/
-    );
     let token_ii = 0;           // The number of the next token.
     let token_now = token_global;       // The current token being examined in
                                         // ... the parse.
@@ -3542,7 +3896,7 @@ function jslint_phase3_parse(state) {
             anon = token_now.id;
         } else if (
             token_now.id === "(string)"
-            && rx_identifier.test(token_now.value)
+            && jslint_rgx_identifier.test(token_now.value)
         ) {
             anon = token_now.value;
         }
@@ -3554,7 +3908,7 @@ function jslint_phase3_parse(state) {
                 match === undefined
 
 // test_cause:
-// ["()", "advance", "expected_a_b", "(end)", 1]
+// ["{0:0}", "advance", "expected_a_b", "0", 2]
 
                 ? stop("expected_a_b", token_nxt, id, artifact())
 
@@ -3603,7 +3957,7 @@ function jslint_phase3_parse(state) {
 // other assignment operators can modify, but they cannot initialize.
 
         const the_symbol = symbol(id, 20);
-        the_symbol.led = function (left) {
+        the_symbol.led_infix = function (left) {
             const the_token = token_now;
             let right;
             the_token.arity = "assignment";
@@ -3915,7 +4269,7 @@ function jslint_phase3_parse(state) {
 
         const the_symbol = symbol(id);
         the_symbol.constant = true;
-        the_symbol.nud = (
+        the_symbol.nud_prefix = (
             typeof value === "function"
             ? value
             : function () {
@@ -4109,7 +4463,7 @@ function jslint_phase3_parse(state) {
 // Create an infix operator.
 
         const the_symbol = symbol(id, bp);
-        the_symbol.led = function (left) {
+        the_symbol.led_infix = function (left) {
             const the_token = token_now;
             the_token.arity = "binary";
             if (f !== undefined) {
@@ -4167,12 +4521,12 @@ function jslint_phase3_parse(state) {
         return the_token;
     }
 
-    function infix_fart_unwrapped(left) {
+    function infix_fart_unwrapped() {
 
 // test_cause:
-// ["aa=>0", "infix_fart_unwrapped", "wrap_parameter", "aa", 1]
+// ["aa=>0", "infix_fart_unwrapped", "wrap_fart_parameter", "=>", 3]
 
-        return stop("wrap_parameter", left);
+        return stop("wrap_fart_parameter", token_now);
     }
 
     function infix_grave(left) {
@@ -4192,7 +4546,7 @@ function jslint_phase3_parse(state) {
         let the_subscript = parse_expression(0);
         if (the_subscript.id === "(string)" || the_subscript.id === "`") {
             name = survey(the_subscript);
-            if (rx_identifier.test(name)) {
+            if (jslint_rgx_identifier.test(name)) {
 
 // test_cause:
 // ["aa[`aa`]", "infix_lbracket", "subscript_a", "aa", 4]
@@ -4335,13 +4689,13 @@ function jslint_phase3_parse(state) {
 // Create a right associative infix operator.
 
         const the_symbol = symbol(id, bp);
-        the_symbol.led = function parse_infixr_led(left) {
+        the_symbol.led_infix = function parse_infixr_led(left) {
             const the_token = token_now;
 
 // test_cause:
-// ["0**0", "parse_infixr_led", "led", "", 0]
+// ["0**0", "parse_infixr_led", "led_infix", "", 0]
 
-            test_cause("led");
+            test_cause("led_infix");
             the_token.arity = "binary";
             the_token.expression = [left, parse_expression(bp - 1)];
             return the_token;
@@ -4349,39 +4703,70 @@ function jslint_phase3_parse(state) {
         return the_symbol;
     }
 
-    function lookahead() {
-
-// Look ahead one token without advancing, skipping comments.
-
-        let cadet;
-        let ii = token_ii;
-        while (true) {
-            cadet = token_list[ii];
-            if (cadet.id !== "(comment)") {
-                return cadet;
-            }
-            ii += 1;
-        }
-    }
-
     function parse_expression(rbp, initial) {
 
 // This is the heart of JSLINT, the Pratt parser. In addition to parsing, it
-// is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
-// like .nud except that it is only used on the first token of a statement.
-// Having .fud makes it much easier to define statement-oriented languages like
-// JavaScript. I retained Pratt's nomenclature.
+// is looking for ad hoc lint patterns. We add .fud_stmt to Pratt's model, which
+// is like .nud_prefix except that it is only used on the first token of a
+// statement. Having .fud_stmt makes it much easier to define statement-oriented
+// languages like JavaScript. I retained Pratt's nomenclature.
 // They are elements of the parsing method called Top Down Operator Precedence.
 
-// .nud     Null denotation
-// .fud     First null denotation
-// .led     Left denotation
-//  lbp     Left binding power
-//  rbp     Right binding power
-
-// It processes a nud (variable, constant, prefix operator). It will then
-// process leds (infix operators) until the bind powers cause it to stop. It
-// returns the expression's parse tree.
+// .nud_prefix  Null denotation. The prefix handler.
+// .fud_stmt    First null denotation. The statement handler.
+// .led_infix   Left denotation. The infix/postfix handler.
+//  lbp         Left binding power of infix operator. It tells us how strongly
+//              the operator binds to the argument at its left.
+//  rbp         Right binding power.
+
+// It processes a nud_prefix (variable, constant, prefix operator). It will then
+// process leds (infix operators) until the bind powers cause it to stop (it
+// consumes tokens until it meets a token whose lbp <= rbp). Specifically, it
+// means that it collects all tokens that bind together before returning to the
+// operator that called it. It returns the expression's parse tree.
+
+// For example, "3 + 1 * 2 * 4 + 5"
+// parses into
+// {
+//     "id": "+",
+//     "expression": [
+//         {
+//             "id": "+",
+//             "expression": [
+//                 {
+//                     "id": "(number)",
+//                     "value": "3"
+//                 },
+//                 {
+//                     "id": "*",
+//                     "expression": [
+//                         {
+//                             "id": "*",
+//                             "expression": [
+//                                 {
+//                                     "id": "(number)",
+//                                     "value": "1"
+//                                 },
+//                                 {
+//                                     "id": "(number)",
+//                                     "value": "2"
+//                                 }
+//                             ]
+//                         },
+//                         {
+//                             "id": "(number)",
+//                             "value": "4"
+//                         }
+//                     ]
+//                 }
+//             ]
+//         },
+//         {
+//             "id": "(number)",
+//             "value": "5"
+//         }
+//     ]
+// }
 
         let left;
         let the_symbol;
@@ -4393,13 +4778,13 @@ function jslint_phase3_parse(state) {
             advance();
         }
         the_symbol = syntax_dict[token_now.id];
-        if (the_symbol !== undefined && the_symbol.nud !== undefined) {
+        if (the_symbol !== undefined && the_symbol.nud_prefix !== undefined) {
 
 // test_cause:
 // ["0", "parse_expression", "symbol", "", 0]
 
             test_cause("symbol");
-            left = the_symbol.nud();
+            left = the_symbol.nud_prefix();
         } else if (token_now.identifier) {
 
 // test_cause:
@@ -4424,32 +4809,38 @@ function jslint_phase3_parse(state) {
             the_symbol = syntax_dict[token_nxt.id];
             if (
                 the_symbol === undefined
-                || the_symbol.led === undefined
+                || the_symbol.led_infix === undefined
                 || the_symbol.lbp <= rbp
             ) {
                 break;
             }
             advance();
-            left = the_symbol.led(left);
+            left = the_symbol.led_infix(left);
         }
         return left;
     }
 
-    function parse_fart(pl) {
+    function parse_fart() {
+        let parameters;
+        let signature;
         let the_fart;
+        [parameters, signature] = prefix_function_arg();
         advance("=>");
         the_fart = token_now;
         the_fart.arity = "binary";
         the_fart.name = "=>";
         the_fart.level = functionage.level + 1;
         function_list.push(the_fart);
-        if (functionage.loop > 0) {
 
-// test_cause:
-// ["while(0){aa.map(()=>0);}", "parse_fart", "function_in_loop", "=>", 19]
+// PR-384 - Relax warning "function_in_loop".
+//
+//         if (functionage.loop > 0) {
 
-            warn("function_in_loop", the_fart);
-        }
+// // test_cause:
+// // ["while(0){aa.map(()=>0);}", "parse_fart", "function_in_loop", "=>", 19]
+//
+//             warn("function_in_loop", the_fart);
+//         }
 
 // Give the function properties storing its names and for observing the depth
 // of loops and switches.
@@ -4457,6 +4848,8 @@ function jslint_phase3_parse(state) {
         the_fart.context = empty();
         the_fart.finally = 0;
         the_fart.loop = 0;
+        the_fart.parameters = parameters;
+        the_fart.signature = signature;
         the_fart.switch = 0;
         the_fart.try = 0;
 
@@ -4464,23 +4857,42 @@ function jslint_phase3_parse(state) {
 
         function_stack.push(functionage);
         functionage = the_fart;
-        the_fart.parameters = pl[0];
-        the_fart.signature = pl[1];
-        the_fart.parameters.forEach(function (name) {
+        the_fart.parameters.forEach(function enroll_parameter(name) {
+            if (name.identifier) {
+                enroll(name, "parameter", true);
+            } else {
+
+// PR-385 - Bugfix - Fixes issue #382 - fix warnings against destructured fart.
 
 // test_cause:
-// ["(aa)=>{}", "parse_fart", "parameter", "", 0]
+// ["([aa])=>0", "enroll_parameter", "use_function_not_fart", "=>", 7]
+// ["({aa})=>0", "enroll_parameter", "use_function_not_fart", "=>", 7]
+
+                warn("use_function_not_fart", the_fart);
 
-            test_cause("parameter");
-            enroll(name, "parameter", true);
+// Recurse enroll_parameter().
+
+                name.names.forEach(enroll_parameter);
+            }
         });
         if (token_nxt.id === "{") {
 
 // test_cause:
-// ["()=>{}", "parse_fart", "expected_a_b", "=>", 3]
+// ["()=>{}", "parse_fart", "use_function_not_fart", "=>", 3]
 
-            warn("expected_a_b", the_fart, "function", "=>");
+            warn("use_function_not_fart", the_fart);
             the_fart.block = block("body");
+        } else if (
+            syntax_dict[token_nxt.id] !== undefined
+            && syntax_dict[token_nxt.id].fud_stmt !== undefined
+        ) {
+
+// PR-384 - Bugfix - Fixes issue #379 - warn against naked-statement in fart.
+
+// test_cause:
+// ["()=>delete aa", "parse_fart", "unexpected_a_after_b", "=>", 5]
+
+            stop("unexpected_a_after_b", token_nxt, token_nxt.id, "=>");
         } else {
             the_fart.expression = parse_expression(0);
         }
@@ -4495,13 +4907,7 @@ function jslint_phase3_parse(state) {
         let negative;
         switch (token_nxt.id) {
         case "(number)":
-            if (!(
-
-// https://datatracker.ietf.org/doc/html/rfc7159#section-6
-// number = [ minus ] int [ frac ] [ exp ]
-
-                /^-?(?:0|[1-9]\d*?)(?:\.\d*?)?(?:[eE][+\-]?\d+?)?$/
-            ).test(token_nxt.value)) {
+            if (!jslint_rgx_json_number.test(token_nxt.value)) {
 
 // test_cause:
 // ["[-.0]", "parse_json", "unexpected_a", ".", 3]
@@ -4703,7 +5109,7 @@ function jslint_phase3_parse(state) {
         the_symbol = syntax_dict[first.id];
         if (
             the_symbol !== undefined
-            && the_symbol.fud !== undefined
+            && the_symbol.fud_stmt !== undefined
 
 // PR-318 - Bugfix - Fixes issues #316, #317 - dynamic-import().
 
@@ -4712,7 +5118,7 @@ function jslint_phase3_parse(state) {
             the_symbol.disrupt = false;
             the_symbol.statement = true;
             token_now.arity = "statement";
-            the_statement = the_symbol.fud();
+            the_statement = the_symbol.fud_stmt();
             functionage.statement_prv = the_statement;
         } else {
 
@@ -4782,7 +5188,7 @@ function jslint_phase3_parse(state) {
 // Create one of the postassign operators.
 
         const the_symbol = symbol(id, 150);
-        the_symbol.led = function (left) {
+        the_symbol.led_infix = function (left) {
             token_now.expression = left;
             token_now.arity = "postassign";
             check_mutation(token_now.expression);
@@ -4796,7 +5202,7 @@ function jslint_phase3_parse(state) {
 // Create one of the preassign operators.
 
         const the_symbol = symbol(id);
-        the_symbol.nud = function () {
+        the_symbol.nud_prefix = function () {
             const the_token = token_now;
             the_token.arity = "preassign";
             the_token.expression = parse_expression(150);
@@ -4811,7 +5217,7 @@ function jslint_phase3_parse(state) {
 // Create a prefix operator.
 
         const the_symbol = symbol(id);
-        the_symbol.nud = function () {
+        the_symbol.nud_prefix = function () {
             const the_token = token_now;
             the_token.arity = "unary";
             if (typeof f === "function") {
@@ -4932,18 +5338,20 @@ function jslint_phase3_parse(state) {
 //  }
 //  jslint_assert(!mode_mega, `Expected !mode_mega.`);
 
-// Don't create functions in loops. It is inefficient, and it can lead to
-// scoping errors.
-
-        if (functionage.loop > 0) {
-
-// test_cause:
-// ["
-// while(0){aa.map(function(){});}
-// ", "prefix_function", "function_in_loop", "function", 17]
-
-            warn("function_in_loop", the_function);
-        }
+// PR-378 - Relax warning "function_in_loop".
+//
+// // Don't create functions in loops. It is inefficient, and it can lead to
+// // scoping errors.
+//
+//         if (functionage.loop > 0) {
+//
+// // test_cause:
+// // ["
+// // while(0){aa.map(function(){});}
+// // ", "prefix_function", "function_in_loop", "function", 17]
+//
+//             warn("function_in_loop", the_function);
+//         }
 
 // Give the function properties for storing its names and for observing the
 // depth of loops and switches.
@@ -4991,6 +5399,9 @@ function jslint_phase3_parse(state) {
             if (name.identifier) {
                 enroll(name, "parameter", false);
             } else {
+
+// Recurse enroll_parameter().
+
                 name.names.forEach(enroll_parameter);
             }
         });
@@ -5451,25 +5862,14 @@ function jslint_phase3_parse(state) {
     }
 
     function prefix_lparen() {
-        const cadet = lookahead().id;
-        const the_paren = token_now;
+        let the_paren = token_now;
         let the_value;
 
-// We can distinguish between a parameter list for => and a wrapped expression
-// with one token of lookahead.
+// PR-385 - Bugfix - Fixes issue #382 - failure to detect destructured fart.
 
-        if (
-            token_nxt.id === ")"
-            || token_nxt.id === "..."
-            || (token_nxt.identifier && (cadet === "," || cadet === "="))
-        ) {
-
-// test_cause:
-// ["()=>0", "prefix_lparen", "fart", "", 0]
-
-            test_cause("fart");
+        if (token_now.is_fart) {
             the_paren.free = false;
-            return parse_fart(prefix_function_arg());
+            return parse_fart();
         }
 
 // test_cause:
@@ -5487,31 +5887,6 @@ function jslint_phase3_parse(state) {
         }
         the_value.wrapped = true;
         advance(")", the_paren);
-        if (token_nxt.id === "=>") {
-            if (the_value.arity !== "variable") {
-                if (the_value.id === "{" || the_value.id === "[") {
-
-// test_cause:
-// ["([])=>0", "prefix_lparen", "expected_a_before_b", "(", 1]
-// ["({})=>0", "prefix_lparen", "expected_a_before_b", "(", 1]
-
-                    warn("expected_a_before_b", the_paren, "function", "(");
-
-// test_cause:
-// ["([])=>0", "prefix_lparen", "expected_a_b", "=>", 5]
-// ["({})=>0", "prefix_lparen", "expected_a_b", "=>", 5]
-
-                    return stop("expected_a_b", token_nxt, "{", "=>");
-                }
-
-// test_cause:
-// ["(0)=>0", "prefix_lparen", "expected_identifier_a", "0", 2]
-
-                return stop("expected_identifier_a", the_value);
-            }
-            the_paren.expression = [the_value];
-            return parse_fart([the_paren.expression, "(" + the_value.id + ")"]);
-        }
         return the_value;
     }
 
@@ -5592,12 +5967,12 @@ function jslint_phase3_parse(state) {
         anon = "anonymous";
     }
 
-    function stmt(id, fud) {
+    function stmt(id, fud_stmt) {
 
 // Create a statement.
 
         const the_symbol = symbol(id);
-        the_symbol.fud = fud;
+        the_symbol.fud_stmt = fud_stmt;
         return the_symbol;
     }
 
@@ -6032,10 +6407,7 @@ function jslint_phase3_parse(state) {
         advance("from");
         advance("(string)");
         the_import.import = token_now;
-        if (!(
-            // rx_module
-            /^[a-zA-Z0-9_$:.@\-\/]+$/
-        ).test(token_now.value)) {
+        if (!jslint_rgx_module.test(token_now.value)) {
 
 // test_cause:
 // ["import aa from \"!aa\"", "stmt_import", "bad_module_name_a", "!aa", 16]
@@ -6646,13 +7018,13 @@ function jslint_phase3_parse(state) {
 
         if (id === "(string)") {
             id = name.value;
-            if (!rx_identifier.test(id)) {
+            if (!jslint_rgx_identifier.test(id)) {
                 return id;
             }
         } else if (id === "`") {
             if (name.value.length === 1) {
                 id = name.value[0].value;
-                if (!rx_identifier.test(id)) {
+                if (!jslint_rgx_identifier.test(id)) {
                     return id;
                 }
             }
@@ -6685,10 +7057,7 @@ function jslint_phase3_parse(state) {
             } else if (
                 !option_dict.name
                 && name.identifier
-                && (
-                    // rx_weird_property
-                    /^_|\$|Sync$|_$/m
-                ).test(id)
+                && jslint_rgx_weird_property.test(id)
             ) {
 
 // test_cause:
@@ -6726,7 +7095,7 @@ function jslint_phase3_parse(state) {
 // Create a ternary operator.
 
         const the_symbol = symbol(id1, 30);
-        the_symbol.led = function parse_ternary_led(left) {
+        the_symbol.led_infix = function parse_ternary_led(left) {
             const the_token = token_now;
             let second;
             second = parse_expression(20);
@@ -7442,10 +7811,7 @@ function jslint_phase4_walk(state) {
                 test_cause("cack");
                 cack = !cack;
             }
-            if ((
-                // rx_cap
-                /^[A-Z]/
-            ).test(left.name.id) !== cack) {
+            if (jslint_rgx_cap.test(left.name.id) !== cack) {
                 if (the_new !== undefined) {
 
 // test_cause:
@@ -7622,6 +7988,11 @@ function jslint_phase4_walk(state) {
             || thing.expression[0].constant === true
             || is_equal(thing.expression[1], thing.expression[2])
         ) {
+
+// test_cause:
+// ["let aa=(aa?`${0}`:`${0}`);", "post_t", "unexpected_a", "?", 11]
+// ["let aa=(aa?`0`:`0`);", "post_t", "unexpected_a", "?", 11]
+
             warn("unexpected_a", thing);
         } else if (is_equal(thing.expression[0], thing.expression[1])) {
 
@@ -8841,6 +9212,7 @@ function jslint_report({
 
 // This function will create human-readable, html-report
 // for warnings, properties, and functions from jslint-result-object.
+//
 // Example usage:
 //  let result = jslint("console.log('hello world')");
 //  let html = jslint_report(result);
@@ -8873,7 +9245,6 @@ function jslint_report({
         );
     }
 
-    html += "<div class=\"JSLINT_\" id=\"JSLINT_REPORT_HTML\">\n";
     html += String(`
 <style class="JSLINT_REPORT_STYLE">
 /* jslint utility2:true */
@@ -9022,19 +9393,38 @@ pyNj+JctcQLXenBOCms46aMkenIx45WpXqxxVJQLz/vgpmAVa0fmDv6Pue9xVTBPfVxCUGfj\
 /7xoEqvL+2E8VOyCTuT/7j269Zy4jUtN+g4="
     ) format("woff2");
 }
-*,
-*:after,
-*:before {
+.JSLINT_,
+.JSLINT_ address,
+.JSLINT_ button,
+.JSLINT_ cite,
+.JSLINT_ dd,
+.JSLINT_ dfn,
+.JSLINT_ dl,
+.JSLINT_ dt,
+.JSLINT_ fieldset,
+.JSLINT_ fieldset > div,
+.JSLINT_ input,
+.JSLINT_ label,
+.JSLINT_ legend,
+.JSLINT_ ol,
+.JSLINT_ samp,
+.JSLINT_ style,
+.JSLINT_ textarea,
+.JSLINT_ ul {
     border: 0;
     box-sizing: border-box;
     margin: 0;
     padding: 0;
 }
+/* disable text inflation algorithm used on some smartphones and tablets */
 .JSLINT_ {
     -ms-text-size-adjust: none;
     -webkit-text-size-adjust: none;
     text-size-adjust: none;
 }
+.JSLINT_REPORT_ div {
+    box-sizing: border-box;
+}
 /*csslint ignore:end*/
 
 /* css - jslint_report - font */
@@ -9068,7 +9458,7 @@ pyNj+JctcQLXenBOCms46aMkenIx45WpXqxxVJQLz/vgpmAVa0fmDv6Pue9xVTBPfVxCUGfj\
 }
 
 /* css - jslint_report - general */
-body {
+.JSLINT_ {
     background: antiquewhite;
 }
 .JSLINT_ fieldset {
@@ -9314,6 +9704,9 @@ body {
         : "global"
     );
     if (global.length + froms.length + exports.length > 0) {
+        if (functions.length === 0) {
+            html += "<br>\n";
+        }
         html += "<div class=\"level level0\">\n";
         html += detail(module, global);
         html += detail("import from", froms);
@@ -9402,7 +9795,6 @@ body {
     });
     html += "</div>\n";
     html += "</fieldset>\n";
-    html += "</div>\n";
     return html;
 }
 
@@ -9478,14 +9870,14 @@ function jstestIt(description, testFunction, mode) {
     }));
 }
 
-function jstestOnExit(exitCode, processExit, countFailed) {
+function jstestOnExit(exitCode, mode) {
 
 // This function will on process-exit, print test-report
 // and exit with non-zero exit-code if any test failed.
 
     let message = (
         (
-            (jstestCountFailed || countFailed)
+            (jstestCountFailed || mode === "testsFailed")
             ? "\n\u001b[31m"
             : "\n\u001b[32m"
         )
@@ -9493,11 +9885,10 @@ function jstestOnExit(exitCode, processExit, countFailed) {
         + "  tests failed - " + jstestCountFailed + "\n"
         + "\u001b[39m"
     );
-    if (!processExit) {
+    if (mode !== "testsFailed") {
         console.error(message);
-        processExit = process.exit;
     }
-    processExit(exitCode || jstestCountFailed);
+    process.exitCode = exitCode || jstestCountFailed;
     return message;
 }
 
@@ -9563,7 +9954,7 @@ function objectDeepCopyWithKeysSorted(obj) {
 
 // Recursively deep-copy obj with keys sorted.
 
-    sorted = {};
+    sorted = Object.create(null);
     Object.keys(obj).sort().forEach(function (key) {
         sorted[key] = objectDeepCopyWithKeysSorted(obj[key]);
     });
@@ -10219,11 +10610,11 @@ async function v8CoverageReportCreate({
 // 3. Create html-coverage-reports in <coverageDir>.
 
     let cwd;
+    let excludeList = [];
     let exitCode = 0;
     let fileDict;
-    let fileExcludeList = [];
-    let fileIncludeList = [];
-    let fileIncludeNodeModules;
+    let includeList = [];
+    let modeIncludeNodeModules;
     let processArgElem;
     let promiseList = [];
     let v8CoverageObj;
@@ -10248,9 +10639,19 @@ async function v8CoverageReportCreate({
 <style>
 /* jslint utility2:true */
 /*csslint ignore:start*/
-* {
-box-sizing: border-box;
-    font-family: consolas, menlo, monospace;
+.coverage,
+.coverage a,
+.coverage div,
+.coverage pre,
+.coverage span,
+.coverage table,
+.coverage tbody,
+.coverage td,
+.coverage th,
+.coverage thead,
+.coverage tr {
+    box-sizing: border-box;
+    font-family: monospace;
 }
 /*csslint ignore:end*/
 
@@ -10396,6 +10797,7 @@ body {
         }
         txtBorder = (
             "+" + "-".repeat(padPathname + 2) + "+"
+            + "-".repeat(padLines + 2) + "+"
             + "-".repeat(padLines + 2) + "+\n"
         );
         txt = "";
@@ -10403,7 +10805,8 @@ body {
         txt += txtBorder;
         txt += (
             "| " + String("Files covered").padEnd(padPathname, " ") + " | "
-            + String("Lines").padStart(padLines, " ") + " |\n"
+            + String("Lines").padStart(padLines, " ") + " | "
+            + String("Remaining").padStart(padLines, " ") + " |\n"
         );
         txt += txtBorder;
         fileList.forEach(function ({
@@ -10483,7 +10886,8 @@ body {
                 + String("./" + pathname).padEnd(padPathname, " ") + " | "
                 + String(
                     modeCoverageIgnoreFile + " " + coveragePct + " %"
-                ).padStart(padLines, " ") + " |\n"
+                ).padStart(padLines, " ") + " | "
+                + " ".repeat(padLines) + " |\n"
             );
             txt += (
                 "| " + "*".repeat(
@@ -10491,6 +10895,9 @@ body {
                 ).padEnd(padPathname, "_") + " | "
                 + String(
                     linesCovered + " / " + linesTotal
+                ).padStart(padLines, " ") + " | "
+                + String(
+                    (linesTotal - linesCovered) + " / " + linesTotal
                 ).padStart(padLines, " ") + " |\n"
             );
             txt += txtBorder;
@@ -10654,21 +11061,6 @@ ${String(count || "-0").padStart(7, " ")}
         ), txt));
     }
 
-    function pathnameRelativeCwd(pathname) {
-
-// This function will if <pathname> is inside <cwd>,
-// return it relative to <cwd>, else empty-string.
-
-        pathname = modulePath.resolve(pathname).replace((
-            /\\/g
-        ), "/");
-        if (!pathname.startsWith(cwd)) {
-            return;
-        }
-        pathname = pathname.slice(cwd.length);
-        return pathname;
-    }
-
 /*
 function sentinel() {}
 */
@@ -10700,28 +11092,28 @@ function sentinel() {}
         processArgElem[1] = processArgElem.slice(1).join("=");
         switch (processArgElem[0]) {
 
-// PR-371 - add cli-option `--exclude=aa,bb`
+// PR-371
+// Add cli-option `--exclude=...`.
 
         case "--exclude":
-            fileExcludeList = fileExcludeList.concat(
-                processArgElem[1].split(",")
-            );
+            excludeList.push(processArgElem[1]);
             break;
 
-// PR-371 - add cli-option `--exclude-node-modules=false`
+// PR-371
+// Add cli-option `--include=...`
 
-        case "--exclude-node-modules":
-            fileIncludeNodeModules = (
-                /0|false|null|undefined/
-            ).test(processArgElem[1]);
+        case "--include":
+            includeList.push(processArgElem[1]);
             break;
 
-// PR-371 - add cli-option `--include=aa,bb`
+// PR-400
+// Disable default-coverage of directory `node_modules`,
+// but allow override with cli-option `--include-node-modules=1`.
 
-        case "--include":
-            fileIncludeList = fileIncludeList.concat(
-                processArgElem[1].split(",")
-            );
+        case "--include-node-modules":
+            modeIncludeNodeModules = !(
+                /0|false|null|undefined/
+            ).test(processArgElem[1]);
             break;
         }
     }
@@ -10775,9 +11167,11 @@ function sentinel() {}
         ).test(file);
     });
     v8CoverageObj = await Promise.all(v8CoverageObj.map(async function (file) {
-        let data = await moduleFs.promises.readFile(coverageDir + file, "utf8");
+        let data;
+        let pathnameDict = Object.create(null);
+        data = await moduleFs.promises.readFile(coverageDir + file, "utf8");
         data = JSON.parse(data);
-        data.result = data.result.filter(function (scriptCov) {
+        data.result.forEach(function (scriptCov) {
             let pathname = scriptCov.url;
 
 // Filter out internal coverages.
@@ -10788,38 +11182,40 @@ function sentinel() {}
 
 // Normalize pathname.
 
-            pathname = pathnameRelativeCwd(moduleUrl.fileURLToPath(pathname));
-            if (
+            pathname = moduleUrl.fileURLToPath(pathname);
+            pathname = modulePath.resolve(pathname).replace((
+                /\\/g
+            ), "/");
 
 // Filter files outside of cwd.
 
-                !pathname
-                || pathname.startsWith("[")
+            if (pathname.indexOf("[") >= 0 || !pathname.startsWith(cwd)) {
+                return;
+            }
 
-// PR-371 - Filter directory node_modules.
+// Normalize pathname relative to cwd.
 
-                || (
-                    !fileIncludeNodeModules
-                    && (
-                        /(?:^|\/)node_modules\//m
-                    ).test(pathname)
-                )
+            pathname = pathname.slice(cwd.length);
+            scriptCov.url = pathname;
+            pathnameDict[pathname] = scriptCov;
+        });
 
-// PR-371 - Filter fileExcludeList.
+// PR-400
+// Filter directory `node_modules`.
 
-                || fileExcludeList.indexOf(pathname) >= 0
+        if (!modeIncludeNodeModules) {
+            excludeList.push("node_modules/");
+        }
 
-// PR-371 - Filter fileIncludeList.
+// PR-400
+// Filter files by glob-patterns in excludeList, includeList.
 
-                || (
-                    fileIncludeList.length > 0
-                    && fileIncludeList.indexOf(pathname) === -1
-                )
-            ) {
-                return;
-            }
-            scriptCov.url = pathname;
-            return true;
+        data.result = globExclude({
+            excludeList,
+            includeList,
+            pathnameList: Object.keys(pathnameDict)
+        }).pathnameList.map(function (pathname) {
+            return pathnameDict[pathname];
         });
         return data;
     }));
@@ -10828,7 +11224,7 @@ function sentinel() {}
 
     v8CoverageObj = v8CoverageListMerge(v8CoverageObj);
 
-// debug v8CoverageObj.
+// Debug v8CoverageObj.
 
     await fsWriteFileWithParents(
         coverageDir + "v8_coverage_merged.json",
@@ -10837,7 +11233,7 @@ function sentinel() {}
 
 // 3. Create html-coverage-reports in <coverageDir>.
 
-    fileDict = {};
+    fileDict = Object.create(null);
     await Promise.all(v8CoverageObj.result.map(async function ({
         functions,
         url: pathname
@@ -10968,6 +11364,7 @@ jslint_export = Object.freeze(Object.assign(jslint, {
     assertOrThrow,
     debugInline,
     fsWriteFileWithParents,
+    globExclude,
     htmlEscape,
     jslint,
     jslint_apidoc,