@jslint-org/jslint 2026.2.28 → 2026.6.30

package/jslint.mjs

@@ -90,50 +90,312 @@
 
 // WARNING: JSLint will hurt your feelings.
 
-/*jslint beta, node*/
+/*jslint beta, node, trace*/
 /*property
-    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_ignore_line, directive_list, directives,
-    dirname, disrupt, dot, edition, elem_list, ellipsis, else, end, endOffset,
-    endsWith, entries, env, error, eval, every, example_list, excludeList, exec,
-    execArgv, exit, exitCode, export_dict, exports, expression, extra, fart,
-    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, globExclude, global, global_dict, global_list,
-    holeList, htmlEscape, id, identifier, ignoreLine, import, import_list,
-    import_meta_url, inc, includeList, 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_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, nomen, noop, now, nr, nud_prefix,
-    objectDeepCopyWithKeysSorted, ok, on, open, opening, option, option_dict,
-    order, package_name, padEnd, padStart, parameters, parent, parentIi, parse,
-    pathname, pathnameList, 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,
-    shell, shift, signature, single, slice, some, sort, source, spawn, splice,
-    split, stack, stack_trace, start, startOffset, startsWith, statement,
-    statement_prv, stdio, stop, stop_at, stringify, subscript, switch,
-    syntax_dict, tenure, test, test_cause, test_internal_error, this, thru,
-    toLocaleString, 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
+    JSLINT_BETA,
+    NODE_V8_COVERAGE,
+    a,
+    all,
+    argv,
+    arity,
+    artifact,
+    assertErrorThrownAsync,
+    assertJsonEqual,
+    assertOrThrow,
+    assign,
+    assignment,
+    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_ignore_line,
+    directive_list,
+    directives,
+    dirname,
+    disrupt,
+    dot,
+    edition,
+    elem_list,
+    ellipsis,
+    else,
+    end,
+    endOffset,
+    endsWith,
+    entries,
+    env,
+    error,
+    eval,
+    every,
+    example_list,
+    excludeList,
+    exec,
+    execArgv,
+    exit,
+    exitCode,
+    export_dict,
+    exports,
+    expression,
+    extra,
+    fart,
+    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,
+    globExclude,
+    global,
+    global_dict,
+    global_list,
+    holeList,
+    htmlEscape,
+    id,
+    identifier,
+    ignoreLine,
+    import,
+    import_list,
+    import_meta_url,
+    inc,
+    includeList,
+    indent2,
+    indent_method,
+    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_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,
+    nomen,
+    noop,
+    now,
+    nr,
+    nud_prefix,
+    objectDeepCopyWithKeysSorted,
+    ok,
+    on,
+    open,
+    opening,
+    option,
+    option_dict,
+    order,
+    package_name,
+    padEnd,
+    padStart,
+    parameter_count,
+    parent,
+    parentIi,
+    parse,
+    pathname,
+    pathnameList,
+    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,
+    shell,
+    shift,
+    signature,
+    single,
+    slice,
+    some,
+    sort,
+    source,
+    spawn,
+    splice,
+    split,
+    stack,
+    stack_trace,
+    start,
+    startOffset,
+    startsWith,
+    statement,
+    statement_prv,
+    stdio,
+    stop,
+    stop_at,
+    stringify,
+    subscript,
+    switch,
+    syntax_dict,
+    tenure,
+    test,
+    test_cause,
+    test_internal_error,
+    this,
+    thru,
+    toLocaleString,
+    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
@@ -141,14 +403,14 @@ let debugInline = (function () {
     let __consoleError = function () {
         return;
     };
-    function debug(...argv) {
+    function debug(...argList) {
 
-// This function will print <argv> to stderr and then return <argv>[0].
+// This function will print <argList> to stderr and then return <argList>[0].
 
         __consoleError("\n\ndebugInline");
-        __consoleError(...argv);
+        __consoleError(...argList);
         __consoleError("\n");
-        return argv[0];
+        return argList[0];
     }
     debug(); // Coverage-hack.
     __consoleError = console.error; //jslint-ignore-line
@@ -163,7 +425,7 @@ let jslint_charset_ascii = (
     + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
     + "`abcdefghijklmnopqrstuvwxyz{|}~\u007f"
 );
-let jslint_edition = "v2026.2.28";
+let jslint_edition = "v2026.6.30";
 let jslint_export;                      // The jslint object to be exported.
 let jslint_fudge = 1;                   // Fudge starting line and starting
                                         // ... column to 1.
@@ -187,7 +449,7 @@ let jslint_rgx_digits_octals = (
     /^[0-7_]*/
 );
 let jslint_rgx_directive = (
-    /^(jslint|property|global)\s+(.*)$/
+    /^(jslint|property|global)\s+?(\S.*?)$/
 );
 let jslint_rgx_directive_part = (
     /([a-zA-Z$_][a-zA-Z0-9$_]*)(?::\s*(true|false))?,?\s*|$/g
@@ -228,6 +490,7 @@ let jslint_rgx_token = new RegExp(
     + "(\\s+)"
     + "|([a-zA-Z_$][a-zA-Z0-9_$]*)"
     + "|[(){}\\[\\],:;'\"~\\`]"
+    + "|\\?\\?="
     + "|\\?[?.]?"
     + "|=(?:==?|>)?"
     + "|\\.+"
@@ -236,9 +499,10 @@ let jslint_rgx_token = new RegExp(
     + "|\\+[=+]?"
     + "|-[=\\-]?"
     + "|[\\^%]=?"
+    + "|&&="
     + "|&[&=]?"
-    + "|\\"
-    + "|[|=]?"
+    + "|\\|\\|="
+    + "|\\|[|=]?"
     + "|>{1,3}=?"
     + "|<<?=?"
     + "|!(?:!|==?)?"
@@ -575,13 +839,10 @@ function htmlEscape(str) {
 
 // This function will make <str> html-safe by escaping & < >.
 
-    return String(str).replace((
-        /&/g
-    ), "&amp;").replace((
-        /</g
-    ), "&lt;").replace((
-        />/g
-    ), "&gt;");
+    return String(str)
+        .replace((/&/g), "&amp;")
+        .replace((/</g), "&lt;")
+        .replace((/>/g), "&gt;");
 }
 
 function jslint(
@@ -822,22 +1083,24 @@ function jslint(
 // This function will instrument <cause> to <cause_dict> for test-purposes.
 
         if (option_dict.test_cause) {
-            cause_dict[JSON.stringify([
-                String(new Error().stack).replace((
-                    /^    at (?:file|stop|stop_at|test_cause|warn|warn_at)\b.*?\n/gm
-                ), "").match(
-                    /\n    at ((?:Object\.\w+?_)?\w+?) /
-                )[1].replace((
-                    /^Object\./
-                ), ""),
-                code,
-                String(
-                    (aa === undefined || aa === token_global)
-                    ? ""
-                    : aa
-                ),
-                column || 0
-            ])] = true;
+            cause_dict[
+                JSON.stringify([
+                    String(new Error().stack)
+                        .replace(
+                            (/^    at (?:file|stop|stop_at|test_cause|warn|warn_at)\b.*?\n/gm),
+                            ""
+                        )
+                        .match(/\n    at ((?:Object\.\w+?_)?\w+?) /)[1]
+                        .replace((/^Object\./), ""),
+                    code,
+                    String(
+                        (aa === undefined || aa === token_global)
+                        ? ""
+                        : aa
+                    ),
+                    column || 0
+                ])
+            ] = true;
         }
     }
 
@@ -1006,7 +1269,7 @@ function jslint(
         case "infix_in":
             mm = (
                 `Unexpected 'in'. Compare with undefined,`
-                + ` or use the hasOwnProperty method instead.`
+                + ` or use Object.hasOwn() instead.`
             );
             break;
         case "label_a":
@@ -1479,13 +1742,10 @@ ${name}
             /(\([\S\s]*?\)) \{/
         ), function (match0, match1) {
             signature = htmlEscape(
-                match1.replace((
-                    / *?\/\*[\S\s]*?\*\/ */g
-                ), "").replace((
-                    / *?\/\/.*/g
-                ), "").replace((
-                    /\n{2,}/g
-                ), "\n")
+                match1
+                    .replace((/ *?\/\*[\S\s]*?\*\/ */g), "")
+                    .replace((/ *?\/\/.*/g), "")
+                    .replace((/\n{2,}/g), "\n")
             );
             return match0;
         });
@@ -2183,9 +2443,8 @@ function jslint_phase2_lex(state) {
                                 // ... literal.
     let mode_regexp;            // true if regular expression literal seen on
                                 // ... this line.
-    let paren_backtrack_list = [];      // List of most recent "(" tokens at any
-                                        // ... paren-depth.
-    let paren_depth = 0;        // Keeps track of current paren-depth.
+    let opener_popped = empty();        // Last token popped from opener_stack.
+    let opener_stack = [];      // Stack of opener tokens: (, [.
     let snippet = "";           // A piece of string.
     let token_1;                // The first token.
     let token_prv = token_global;       // The previous token including
@@ -2279,7 +2538,13 @@ function jslint_phase2_lex(state) {
 // test_cause:
 // ["\"\\u{12345\"", "char_after_escape", "expected_a_before_b", "\"", 10]
 
-                    stop_at("expected_a_before_b", line, column, "}", char);
+                    return stop_at(
+                        "expected_a_before_b",
+                        line,
+                        column,
+                        "}",
+                        char
+                    );
                 }
                 return char_after();
             }
@@ -2430,9 +2695,14 @@ function jslint_phase2_lex(state) {
 
 // Lex directives in comment.
 
-        [
-            the_comment.directive, body
-        ] = Array.from(snippet.match(jslint_rgx_directive) || []).slice(1);
+        snippet.replace(jslint_rgx_directive, function (
+            ignore,
+            match1,
+            match2
+        ) {
+            the_comment.directive = match1;
+            body = match2;
+        });
         if (the_comment.directive === undefined) {
             return the_comment;
         }
@@ -2825,14 +3095,55 @@ function jslint_phase2_lex(state) {
                     case "?":
                         char_after("?");
                         switch (char) {
+
+// ES1999-feature Negative lookahead assertion.
+
                         case "!":
 
 // PR-437 - Add grammar for regexp-named-capture-group.
 
                         case "<":
+
+// ES1999-feature Positive lookahead assertion.
+
                         case "=":
                             char_after();
                             break;
+
+// PR-499 - Add ES2025-feature RegExp Modifiers.
+
+                        case "-":
+                        case "i":
+                        case "m":
+                        case "s":
+                            char_after();
+                            while (true) {
+                                if (char === ":" && snippet.slice(-1) !== "-") {
+                                    char_after();
+                                    break;
+                                }
+                                switch (char) {
+                                case "-":
+                                case "i":
+                                case "m":
+                                case "s":
+                                    char_after();
+                                    break;
+                                default:
+
+// test_cause:
+// ["aa=/(?-.", "lex_regexp_group", "unexpected_a_after_b", "(?-", 8]
+
+                                    return stop_at(
+                                        "unexpected_a_after_b",
+                                        line,
+                                        column,
+                                        snippet.slice(-1),
+                                        snippet.slice(0, -1)
+                                    );
+                                }
+                            }
+                            break;
                         default:
                             char_after(":");
                         }
@@ -2993,14 +3304,29 @@ function jslint_phase2_lex(state) {
 // Process dangling flag letters.
 
             switch (!flag[char] && char) {
+
+// PR-499 - Add ES2022-feature RegExp Match Indices.
+
+            case "d":
+                break;
             case "g":
                 break;
             case "i":
                 break;
             case "m":
                 break;
+
+// PR-499 - Add ES2018-feature s (dotall) flag for regular expressions.
+
+            case "s":
+                break;
             case "u":
                 break;
+
+// PR-499 - Add ES2024-feature RegExp v flag with set-notation + str-properties.
+
+            case "v":
+                break;
             case "y":
 
 // test_cause:
@@ -3487,9 +3813,9 @@ import https from "https";
         });
     });
     result.replace((
-        /\n- \{\{JSxRef\("(?:Global_Objects\/)?([^"\/]+?)"/g
+        /\n- \{\{jsxref\("(?:global_objects\/)?([^"]+?)"/ig
     ), function (ignore, key) {
-        if (globalThis.hasOwnProperty(key)) {
+        if (Object.hasOwn(globalThis, key)) {
             dict[key] = true;
         }
         return "";
@@ -3513,6 +3839,7 @@ import https from "https";
                 "Date",
                 "Error",
                 "EvalError",
+                "Float16Array",
                 "Float32Array",
                 "Float64Array",
                 "Function",
@@ -3534,10 +3861,12 @@ import https from "https";
                 "Reflect",
                 "RegExp",
                 "Set",
+                "ShadowRealm",
                 "SharedArrayBuffer",
                 "String",
                 "Symbol",
                 "SyntaxError",
+                "Temporal",
                 "TypeError",
                 "URIError",
                 "Uint16Array",
@@ -3545,6 +3874,7 @@ import https from "https";
                 "Uint8Array",
                 "Uint8ClampedArray",
                 "WeakMap",
+                "WeakRef",
                 "WeakSet",
                 "WebAssembly",
                 "decodeURI",
@@ -3729,7 +4059,7 @@ import moduleHttps from "https";
 // test_cause:
 // ["/*jslint-enable*/", "read_line", "unopened_enable", "", 1]
 
-                stop_at("unopened_enable", line);
+                return stop_at("unopened_enable", line);
             }
             line_disable = undefined;
         } else if (
@@ -3833,21 +4163,34 @@ import moduleHttps from "https";
 
         switch (id) {
         case "(":
-            paren_backtrack_list[paren_depth] = the_token;
-            paren_depth += 1;
+        case "[":
+            opener_stack.push(the_token);
             break;
         case ")":
-            paren_depth -= 1;
-            break;
-        case "=>":
-            if (
-                token_prv_expr.id === ")"
-                && paren_backtrack_list[paren_depth]
-            ) {
-                paren_backtrack_list[paren_depth].fart = the_token;
+        case "]":
+            opener_popped = opener_stack.pop();
+            if (noop(
+                id === ")"
+                ? opener_popped.id !== "("
+                : opener_popped.id !== "["
+            )) {
+
+// test_cause:
+// [";(]", "token_create", "unexpected_a", "]", 3]
+// [";[)", "token_create", "unexpected_a", ")", 3]
+
+                return stop("unexpected_a", the_token);
             }
             break;
         }
+        switch (token_prv_expr.id + " " + id) {
+        case ") =>":
+            opener_popped.fart = the_token;
+            break;
+        case "] =":
+            opener_popped.assignment = the_token;
+            break;
+        }
 
 // The previous token is used to detect adjacency problems.
 
@@ -3938,6 +4281,7 @@ function jslint_phase3_parse(state) {
                                         // ... the parse.
     let token_nxt = token_global;       // The next token to be examined in
                                         // ... <token_list>.
+    let token_prv = token_global;       // The previous token examined.
 
     function advance(id, match) {
 
@@ -3985,6 +4329,7 @@ function jslint_phase3_parse(state) {
 
 // Promote the tokens, skipping comments.
 
+        token_prv = token_now;
         token_now = token_nxt;
         while (true) {
             token_nxt = token_list[token_ii];
@@ -4067,7 +4412,7 @@ function jslint_phase3_parse(state) {
         ) {
             token_nxt.statement = true;
             advance("(string)");
-            advance(";");
+            semicolon();
         }
         stmts = parse_statements();
         the_block.block = stmts;
@@ -4162,13 +4507,20 @@ function jslint_phase3_parse(state) {
 
 // This function will warn if <token_list> is unordered.
 
-        token_list.reduce(function (aa, token) {
-            const bb = artifact(token);
-            if (!option_dict.unordered && aa > bb) {
-                warn("expected_a_b_before_c_d", token, type, bb, type, aa);
-            }
-            return bb;
-        }, "");
+        token_list
+            .filter(function (token) {
+
+// Issue #401 - Regression - Ignore tokens prefixed by ellipsis for sorting.
+
+                return token && !token.ellipsis;
+            })
+            .reduce(function (aa, token) {
+                const bb = artifact(token);
+                if (!option_dict.unordered && aa > bb) {
+                    warn("expected_a_b_before_c_d", token, type, bb, type, aa);
+                }
+                return bb;
+            }, "");
     }
 
     function check_ordered_case(case_list) {
@@ -4527,7 +4879,7 @@ function jslint_phase3_parse(state) {
         the_symbol.led_infix = function (left) {
             const the_token = token_now;
             the_token.arity = "binary";
-            if (f !== undefined) {
+            if (f) {
                 return f(left);
             }
             the_token.expression = [left, parse_expression(bp)];
@@ -4542,17 +4894,39 @@ function jslint_phase3_parse(state) {
         if (
             (
                 left.id !== "(string)"
-                || (name.id !== "indexOf" && name.id !== "repeat")
+                || (
+                    name.id !== "at"
+                    && name.id !== "charCodeAt"
+                    && name.id !== "includes"
+                    && name.id !== "indexOf"
+                    && name.id !== "isWellFormed"
+                    && name.id !== "match"
+                    && name.id !== "repeat"
+                    && name.id !== "replace"
+                    && name.id !== "toLowerCase"
+                    && name.id !== "toUpperCase"
+                    && name.id !== "toWellFormed"
+                )
             )
             && (
                 left.id !== "["
                 || (
-                    name.id !== "concat"
+                    name.id !== "at"
+                    && name.id !== "concat"
+                    && name.id !== "every"
+                    && name.id !== "filter"
+                    && name.id !== "find"
+                    && name.id !== "findIndex"
                     && name.id !== "flat"
                     && name.id !== "flatMap"
                     && name.id !== "forEach"
+                    && name.id !== "includes"
                     && name.id !== "join"
                     && name.id !== "map"
+                    && name.id !== "reduce"
+                    && name.id !== "some"
+                    && name.id !== "toReversed"
+                    && name.id !== "toSorted"
                 )
             )
             && (left.id !== "+" || name.id !== "slice")
@@ -4563,16 +4937,36 @@ function jslint_phase3_parse(state) {
         ) {
 
 // test_cause:
+// ["(/./)?.0", "check_left", "unexpected_a", "?.", 6]
 // ["\"\".aa", "check_left", "unexpected_a", ".", 3]
+// ["\"aa\"?.0", "check_left", "unexpected_a", "?.", 5]
+// ["aa=[]?.aa", "check_left", "unexpected_a", "?.", 6]
 
             check_left(left, the_token);
         }
+
+// Issue #468 - Fix optional dynamic-property/function-call not recognized.
+
+        if (
+            the_token.id === "?."
+            && (name.id === "[" || name.id === "(")
+        ) {
+
+// test_cause:
+// ["aa?.(bb)", "infix_dot", "dyn_prop_or_call", "", 0]
+// ["aa?.[bb]", "infix_dot", "dyn_prop_or_call", "", 0]
+
+            test_cause("dyn_prop_or_call");
+            return left;
+        }
         if (!name.identifier) {
 
 // test_cause:
+// ["(0+0)?.0", "infix_dot", "expected_identifier_a", "0", 8]
 // ["aa.0", "infix_dot", "expected_identifier_a", "0", 4]
+// ["aa?.0", "infix_dot", "expected_identifier_a", "0", 5]
 
-            stop("expected_identifier_a");
+            return stop("expected_identifier_a", name);
         }
         advance();
         survey(name);
@@ -4585,11 +4979,7 @@ function jslint_phase3_parse(state) {
     }
 
     function infix_fart_unwrapped() {
-
-// test_cause:
-// ["aa=>0", "infix_fart_unwrapped", "wrap_fart_parameter", "=>", 3]
-
-        return stop("wrap_fart_parameter", token_now);
+        return parse_fart(token_now, true);
     }
 
     function infix_grave(left) {
@@ -4632,7 +5022,6 @@ function jslint_phase3_parse(state) {
 
     function infix_lparen(left) {
         const the_paren = token_now;
-        let ellipsis;
         let the_argument;
         if (left.id !== "function") {
 
@@ -4652,12 +5041,14 @@ function jslint_phase3_parse(state) {
 
             while (true) {
                 if (token_nxt.id === "...") {
-                    ellipsis = true;
-                    advance("...");
-                }
-                the_argument = parse_expression(10);
-                if (ellipsis) {
-                    the_argument.ellipsis = true;
+
+// test_cause:
+// ["aa(...aa)", "infix_lparen", "aa(...aa)", "", 0]
+
+                    test_cause("aa(...aa)");
+                    the_argument = prefix_ellipsis();
+                } else {
+                    the_argument = parse_expression(10);
                 }
                 the_paren.expression.push(the_argument);
                 if (token_nxt.id !== ",") {
@@ -4702,71 +5093,6 @@ function jslint_phase3_parse(state) {
         return the_paren;
     }
 
-    function infix_option_chain(left) {
-        const the_token = token_now;
-        let name = token_nxt;
-        if (
-            (
-                left.id !== "(string)"
-                || (name.id !== "indexOf" && name.id !== "repeat")
-            )
-            && (
-                left.id !== "["
-                || (
-                    name.id !== "concat"
-                    && name.id !== "forEach"
-                    && name.id !== "join"
-                    && name.id !== "map"
-                )
-            )
-
-// test_cause:
-// ["(0+0)?.0", "infix_option_chain", "check_left", "", 0]
-
-            && (left.id !== "+" || name.id !== "slice")
-            && (
-                left.id !== "(regexp)"
-                || (name.id !== "exec" && name.id !== "test")
-            )
-        ) {
-            test_cause("check_left");
-
-// test_cause:
-// ["(/./)?.0", "check_left", "unexpected_a", "?.", 6]
-// ["\"aa\"?.0", "check_left", "unexpected_a", "?.", 5]
-// ["aa=[]?.aa", "check_left", "unexpected_a", "?.", 6]
-
-            check_left(left, the_token);
-        }
-
-// Issue #468 - Fix optional dynamic-property/function-call not recognized.
-
-        if (name.id === "[" || name.id === "(") {
-            test_cause("dyn_prop_or_call");
-
-// test_cause:
-// ["aa?.(bb)", "infix_option_chain", "dyn_prop_or_call", "", 0]
-// ["aa?.[bb]", "infix_option_chain", "dyn_prop_or_call", "", 0]
-
-            return left;
-        }
-        if (!name.identifier) {
-
-// test_cause:
-// ["aa?.0", "infix_option_chain", "expected_identifier_a", "0", 5]
-
-            stop("expected_identifier_a");
-        }
-        advance();
-        survey(name);
-
-// The property name is not an expression.
-
-        the_token.name = name;
-        the_token.expression = left;
-        return the_token;
-    }
-
     function infixr(bp, id) {
 
 // Create a right associative infix operator.
@@ -4800,7 +5126,10 @@ function jslint_phase3_parse(state) {
 // .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.
+//  rbp         Right binding power. Parser will continue consuming tokens while
+//              next token's lbp > rbp.
+//  initial     Whether first token has already been advanced. If falsy,
+//              immediately calls advance().
 
 // 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
@@ -4903,7 +5232,7 @@ function jslint_phase3_parse(state) {
         return left;
     }
 
-    function parse_fart(the_fart) {
+    function parse_fart(the_fart, mode_infix) {
 
 // Give the function properties storing its names and for observing the depth
 // of loops and switches.
@@ -4934,11 +5263,34 @@ function jslint_phase3_parse(state) {
         function_list.push(the_fart);
         function_stack.push(functionage);
         functionage = the_fart;
+        if (mode_infix) {
+            if (!token_prv.identifier) {
+
+// test_cause:
+// ["0=>0", "parse_fart", "expected_identifier_a", "0", 1]
+
+                return stop("expected_identifier_a", token_prv);
+            }
+
+// PR-499 - Update ES2015-feature arrow, to continue parsing unwrapped-form
+// with warning, instead of stopping.
+
+// test_cause:
+// ["aa=>0", "parse_fart", "wrap_fart_parameter", "=>", 3]
+
+            warn("wrap_fart_parameter", token_now);
+            the_fart.name = "anonymous";
+            the_fart.names = [token_prv];
+            the_fart.parameter_count = 1;
+            the_fart.signature = token_prv.id;
+            enroll(token_prv, "parameter", false);
+        } else {
 
 // Parse the parameter list.
 
-        prefix_function_parameter(the_fart);
-        advance("=>");
+            prefix_function_parameter(the_fart);
+            advance("=>");
+        }
 
 // The function's body is a block.
 
@@ -4951,21 +5303,28 @@ function jslint_phase3_parse(state) {
                 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
-        ) {
+
+// The function's body is an expression.
+
+        } else {
 
 // PR-384 - Bugfix - Fixes issue #379 - warn against naked-statement in fart.
 
+            if (
+                syntax_dict[token_nxt.id] !== undefined
+                && syntax_dict[token_nxt.id].fud_stmt !== undefined
+            ) {
+
 // test_cause:
 // ["()=>delete aa", "parse_fart", "unexpected_a_after_b", "=>", 5]
 
-            stop("unexpected_a_after_b", token_nxt, token_nxt.id, "=>");
-
-// The function's body is an expression.
-
-        } else {
+                return stop(
+                    "unexpected_a_after_b",
+                    token_nxt,
+                    token_nxt.id,
+                    "=>"
+                );
+            }
             the_fart.expression = parse_expression(0);
         }
 
@@ -4987,8 +5346,10 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["[-.0]", "parse_json", "unexpected_a", ".", 3]
 // ["[-0x0]", "parse_json", "unexpected_a", "0x0", 3]
+// ["[...]", "parse_json", "unexpected_a", "...", 2]
 // ["[.0]", "parse_json", "unexpected_a", ".", 2]
 // ["[0x0]", "parse_json", "unexpected_a", "0x0", 2]
+// ["{...}", "parse_json", "unexpected_a", "...", 2]
 
                 warn("unexpected_a");
             }
@@ -5029,11 +5390,6 @@ function jslint_phase3_parse(state) {
 
                     container.expression.push(parse_json());
                     if (token_nxt.id !== ",") {
-
-// test_cause:
-// ["[0,0]", "parse_json", "comma", "", 0]
-
-                        test_cause("comma");
                         break;
                     }
                     advance(",");
@@ -5122,7 +5478,7 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["[undefined]", "parse_json", "unexpected_a", "undefined", 2]
 
-            stop("unexpected_a");
+            return stop("unexpected_a");
         }
     }
 
@@ -5303,7 +5659,7 @@ function jslint_phase3_parse(state) {
         the_symbol.nud_prefix = function () {
             const the_token = token_now;
             the_token.arity = "unary";
-            if (typeof f === "function") {
+            if (f) {
                 return f();
             }
             the_token.expression = parse_expression(150);
@@ -5317,7 +5673,7 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["/=", "prefix_assign_divide", "expected_a_b", "/=", 1]
 
-        stop("expected_a_b", token_now, "/\\=", "/=");
+        return stop("expected_a_b", token_now, "/\\=", "/=");
     }
 
     function prefix_async() {
@@ -5389,44 +5745,273 @@ function jslint_phase3_parse(state) {
         return the_await;
     }
 
-    function prefix_fart() {
+    function prefix_destructure(
+        enroll,
+        role,
+        readonly,
+        name_list,
+        the_function,
+        the_function_toplevel
+    ) {
+        const is_brace = token_now.id === "{";
+        const sub_list = [];
+        const the_destructure = token_now;
+        let optional;
+        function advance_and_signature_push(id) {
+            advance(id);
+            if (the_function?.signature) {
+                the_function.signature.push(id);
+                switch (id) {
+                case ",":
+                case ":":
+                    the_function.signature.push(" ");
+                    break;
+                }
+            }
+        }
+        function name_list_push(name) {
+            sub_list.push(name);
+
+// PR-500 - Fix false-warning "uninitialized_a" in statement ";[aa]=0;".
+
+            name.arity = role;
+            if (enroll) {
+                enroll(name, role, readonly);
+                name.init = true;
+            }
+        }
+        function name_parse() {
+            let name = token_nxt;
+            switch (name.id) {
+            case "...":
+                advance_and_signature_push("...");
+                name = token_nxt;
+                name.ellipsis = true;
+                if (name.id === "...") {
 
 // test_cause:
-// ["=>0", "prefix_fart", "expected_a_before_b", "=>", 1]
+// ["let[... ...]=0", "name_parse", "unexpected_a_after_b", "...", 9]
 
-        return stop("expected_a_before_b", token_now, "()", "=>");
-    }
+                    return stop("unexpected_a_after_b", name, name.id, "...");
+                }
+                if (optional) {
 
-    function prefix_function(the_function) {
-        let name = the_function && the_function.name;
-        if (the_function === undefined) {
-            the_function = token_now;
+// test_cause:
+// ["function aa(aa=0,...){}", "name_parse", "required_a_optional_b", "aa", 21]
 
-// A function statement must have a name that will be in the parent's scope.
+                    warn("required_a_optional_b", name, name.id, optional.id);
+                }
 
-            if (the_function.arity === "statement") {
-                if (!token_nxt.identifier) {
+// test_cause:
+// ["let[...aa]=0", "name_parse", "recurse_ellipsis", "", 0]
+// ["let{...aa}=0", "name_parse", "recurse_ellipsis", "", 0]
+
+                test_cause("recurse_ellipsis");
+                name_parse();
+                return true;
+            case "[":
+            case "{":
+                if (the_function?.id === "=>" && !option_dict.fart) {
 
 // test_cause:
-// ["function(){}", "prefix_function", "expected_identifier_a", "(", 9]
-// ["function*aa(){}", "prefix_function", "expected_identifier_a", "*", 9]
+// ["([aa])=>0", "name_parse", "use_function_not_fart", "=>", 7]
+// ["({aa})=>0", "name_parse", "use_function_not_fart", "=>", 7]
 
-                    return stop("expected_identifier_a");
+                    warn("use_function_not_fart", the_function);
                 }
-                name = token_nxt;
-                enroll(name, "variable", true);
-                the_function.name = Object.assign(name, {
-                    calls: empty(),
+                if (optional) {
 
-// PR-331 - Bugfix - Fixes issue #272 - function hoisting not allowed.
+// test_cause:
+// ["function aa(aa=0,[]){}", "name_parse", "required_a_optional_b", "aa", 18]
+// ["function aa(aa=0,{}){}", "name_parse", "required_a_optional_b", "aa", 18]
 
-                    dead: false,
-                    init: true
-                });
-                advance();
-            } else if (name === undefined) {
+                    warn("required_a_optional_b", name, name.id, optional.id);
+                }
 
-// A function expression may have an optional name.
+// test_cause:
+// ["let[[aa]]=0", "name_parse", "recurse_element", "", 0]
+// ["let[{aa}]=0", "name_parse", "recurse_element", "", 0]
+
+                test_cause("recurse_element");
+                advance_and_signature_push(token_nxt.id);
+                prefix_destructure(
+                    enroll,             // enroll
+                    role,               // role
+                    readonly,           // readonly
+                    name_list,          // name_list
+                    the_function,       // the_function
+                    false               // the_function_toplevel
+                );
+                return;
+            }
+            if (!name.identifier) {
+
+// test_cause:
+// ["function aa(...0){}", "name_parse", "expected_identifier_a", "0", 16]
+// ["function aa(0){}", "name_parse", "expected_identifier_a", "0", 13]
+// ["function aa([0]){}", "name_parse", "expected_identifier_a", "0", 14]
+// ["function aa({0}){}", "name_parse", "expected_identifier_a", "0", 14]
+// ["function aa({aa:0}){}", "name_parse", "expected_identifier_a", "0", 17]
+// ["let[...0]=0", "name_parse", "expected_identifier_a", "0", 8]
+// ["let[0]=0", "name_parse", "expected_identifier_a", "0", 5]
+// ["let{0}=0", "name_parse", "expected_identifier_a", "0", 5]
+
+                return stop("expected_identifier_a", name);
+            }
+            if (is_brace) {
+                survey(name);
+            }
+            advance_and_signature_push(token_nxt.id);
+            if (is_brace && token_nxt.id === ":") {
+                advance_and_signature_push(":");
+                if (!the_function_toplevel) {
+                    the_destructure.open = true;
+                }
+                if (token_nxt.id === "...") {
+
+// test_cause:
+// ["let{aa:...aa}=0", "name_parse", "unexpected_a", "...", 8]
+
+                    return stop("unexpected_a", token_nxt);
+                }
+                if (!token_nxt.identifier) {
+
+// test_cause:
+// ["let{aa:[aa]}=0", "name_parse", "recurse_property", "", 0]
+// ["let{aa:{aa}}=0", "name_parse", "recurse_property", "", 0]
+
+                    test_cause("recurse_property");
+                    name_parse();
+                    return;
+                }
+                token_nxt.label = name;
+                name = token_nxt;
+                name_list_push(name);
+                advance_and_signature_push(token_nxt.id);
+                return;
+            }
+            name_list_push(name);
+
+// test_cause:
+// ["const[aa]=bb;\nconst bb=0;", "lookup", "out_of_scope_a", "bb", 11]
+// ["const{aa}=bb;\nconst bb=0;", "lookup", "out_of_scope_a", "bb", 11]
+
+            if (token_nxt.id === "=") {
+                optional = the_function_toplevel && token_now;
+                advance_and_signature_push("=");
+                if (!the_function_toplevel) {
+                    the_destructure.open = true;
+                }
+                name.expression = parse_expression(0);
+
+// test_cause:
+// ["function aa([aa=aa]){}", "name_parse", "optional", "", 0]
+// ["function aa({aa=aa}){}", "name_parse", "optional", "", 0]
+// ["let[aa=0]=0", "name_parse", "optional", "", 0]
+// ["let{aa=0}=0", "name_parse", "optional", "", 0]
+
+                test_cause("optional");
+                return;
+            }
+            if (optional) {
+
+// test_cause:
+// ["function aa(aa=0,bb){}", "name_parse", "required_a_optional_b", "aa", 18]
+
+                warn("required_a_optional_b", name, name.id, optional.id);
+            }
+        }
+        while (true) {
+            if (!is_brace && !the_function_toplevel && token_nxt.id === ",") {
+
+// test_cause:
+// ["(,aa)=>0", "name_parse", "expected_identifier_a", ",", 2]
+// ["([,aa])=>0", "prefix_destructure", "ignore", "", 0]
+// [";[,aa]=0", "prefix_destructure", "ignore", "", 0]
+// ["let[,aa]=0", "prefix_destructure", "ignore", "", 0]
+
+                test_cause("ignore");
+                advance_and_signature_push(",");
+            }
+            if (the_function_toplevel) {
+                the_function.parameter_count += 1;
+            }
+            if (name_parse()) {
+
+// Break early from ellipsis.
+
+                break;
+            }
+            if (token_nxt.id !== ",") {
+                break;
+            }
+            advance_and_signature_push(",");
+        }
+        name_list.push(...sub_list);
+        if (the_function_toplevel) {
+            advance_and_signature_push(")");
+        } else if (is_brace) {
+
+// test_cause:
+// ["
+// function aa({bb,aa}){}
+// ", "check_ordered", "expected_a_b_before_c_d", "aa", 17]
+// ["let{bb,aa}=0", "check_ordered", "expected_a_b_before_c_d", "aa", 8]
+
+            check_ordered(role, sub_list);
+            advance_and_signature_push("}");
+        } else {
+            advance_and_signature_push("]");
+        }
+        return the_destructure;
+    }
+
+    function prefix_ellipsis() {
+        let after_ellipsis;
+        advance("...");
+        after_ellipsis = parse_expression(0);
+        after_ellipsis.ellipsis = true;
+        return after_ellipsis;
+    }
+
+    function prefix_fart() {
+
+// test_cause:
+// ["=>0", "prefix_fart", "expected_a_before_b", "=>", 1]
+
+        return stop("expected_a_before_b", token_now, "()", "=>");
+    }
+
+    function prefix_function(the_function) {
+        let name = the_function && the_function.name;
+        if (the_function === undefined) {
+            the_function = token_now;
+
+// A function statement must have a name that will be in the parent's scope.
+
+            if (the_function.arity === "statement") {
+                if (!token_nxt.identifier) {
+
+// test_cause:
+// ["function(){}", "prefix_function", "expected_identifier_a", "(", 9]
+// ["function*aa(){}", "prefix_function", "expected_identifier_a", "*", 9]
+
+                    return stop("expected_identifier_a", token_nxt);
+                }
+                name = token_nxt;
+                enroll(name, "variable", true);
+                the_function.name = Object.assign(name, {
+                    calls: empty(),
+
+// PR-331 - Bugfix - Fixes issue #272 - function hoisting not allowed.
+
+                    dead: false,
+                    init: true
+                });
+                advance();
+            } else if (name === undefined) {
+
+// A function expression may have an optional name.
 
                 the_function.name = anon;
                 if (token_nxt.identifier) {
@@ -5551,375 +6136,174 @@ function jslint_phase3_parse(state) {
 
 // This function will parse input <parameters> at beginning of <the_function>
 
-        let optional;
-        let parameters = [];
-        let signature = ["("];
-        let subparam;
-        function param_enroll(name) {
-            if (name.identifier) {
-                enroll(name, "parameter", false);
-            } else {
-
-// test_cause:
-// ["([aa])=>0", "param_enroll", "use_function_not_fart", "=>", 7]
-// ["({aa})=>0", "param_enroll", "use_function_not_fart", "=>", 7]
-
-                if (the_function.id === "=>" && !option_dict.fart) {
-                    warn("use_function_not_fart", the_function);
-                }
+        the_function.names = [];
+        the_function.parameter_count = 0;
+        the_function.signature = ["("];
+        token_now.free = false;
+        if (token_nxt.id !== ")" && token_nxt.id !== "(end)") {
 
-// Recurse param_enroll().
+// PR-500 - Unify ES2015-destructure-logic. - function([aa]) {...}
 
-                name.names.forEach(param_enroll);
-            }
+            prefix_destructure(
+                enroll,                 // enroll
+                "parameter",            // role
+                false,                  // readonly
+                the_function.names,     // name_list
+                the_function,           // the_function
+                true                    // the_function_toplevel
+            );
+        } else {
+            advance(")");
+            the_function.signature.push(")");
         }
-        function param_parse() {
-            let ellipsis = false;
-            let param;
-            if (token_nxt.id === "{") {
-                if (optional !== undefined) {
+        the_function.signature = the_function.signature.join("");
+    }
+
+    function prefix_lbrace() {
+        const seen = empty();
+        const the_brace = token_now;
+        function property_parse() {
+            let extra;
+            let full;
+            let id;
+            let name = token_nxt;
+            let the_colon;
+            let value;
+            if (!name.identifier && name.id === "`") {
 
 // test_cause:
-// ["function aa(aa=0,{}){}", "param_parse", "required_a_optional_b", "aa", 18]
+// ["aa={`aa`:0}", "property_parse", "unexpected_a", "`", 5]
 
-                    warn(
-                        "required_a_optional_b",
-                        token_nxt,
-                        token_nxt.id,
-                        optional.id
-                    );
-                }
-                param = token_nxt;
-                param.names = [];
-                advance("{");
-                signature.push("{");
-                while (true) {
-                    subparam = token_nxt;
-                    if (!subparam.identifier) {
+                return stop("unexpected_a", name);
+            }
 
-// test_cause:
-// ["function aa(aa=0,{}){}", "param_parse", "expected_identifier_a", "}", 19]
-// ["function aa({0}){}", "param_parse", "expected_identifier_a", "0", 14]
+// Issue #401 - Add ES2018-syntax for object-literal-spread-operator.
 
-                        return stop("expected_identifier_a");
-                    }
-                    survey(subparam);
-                    advance();
-                    signature.push(subparam.id);
-                    if (token_nxt.id === ":") {
-                        advance(":");
-                        advance();
-                        token_now.label = subparam;
-                        subparam = token_now;
-                        if (!subparam.identifier) {
+            if (!name.identifier && token_nxt.id === "...") {
 
 // test_cause:
-// ["function aa({aa:0}){}", "param_parse", "expected_identifier_a", "}", 18]
+// ["aa={...aa}", "property_parse", "ellipsis", "", 0]
 
-                            return stop(
-                                "expected_identifier_a",
-                                token_nxt
-                            );
-                        }
-                    }
+                test_cause("ellipsis");
+                value = prefix_ellipsis();
+                return value;
+            }
+            advance();
+            if (
+                (name.id === "get" || name.id === "set")
+                && token_nxt.identifier
+            ) {
+                if (!option_dict.getset) {
 
 // test_cause:
-// ["function aa({aa=aa},aa){}", "param_parse", "equal", "", 0]
+// ["aa={get aa(){}}", "property_parse", "unexpected_a", "get", 5]
 
-                    test_cause("equal");
-                    if (token_nxt.id === "=") {
-                        advance("=");
-                        subparam.expression = parse_expression();
-                        param.open = true;
-                    }
-                    param.names.push(subparam);
-                    if (token_nxt.id === ",") {
-                        advance(",");
-                        signature.push(", ");
-                    } else {
-                        break;
-                    }
+                    warn("unexpected_a", name);
                 }
-                parameters.push(param);
+                extra = name.id;
+                full = extra + " " + token_nxt.id;
+                name = token_nxt;
+                advance();
+                id = survey(name);
+                if (seen[full] === true || seen[id] === true) {
 
 // test_cause:
-// ["
-// function aa({bb,aa}){}
-// ", "check_ordered", "expected_a_b_before_c_d", "aa", 17]
+// ["aa={get aa(){},get aa(){}}", "property_parse", "duplicate_a", "aa", 20]
 
-                check_ordered("parameter", param.names);
-                advance("}");
-                signature.push("}");
-                if (token_nxt.id === ",") {
-                    advance(",");
-                    signature.push(", ");
-                    param_parse();
-                    return;
+                    warn("duplicate_a", name);
                 }
-            } else if (token_nxt.id === "[") {
-                if (optional !== undefined) {
+                seen[id] = false;
+                seen[full] = true;
+            } else {
+                id = survey(name);
+                if (typeof seen[id] === "boolean") {
 
 // test_cause:
-// ["function aa(aa=0,[]){}", "param_parse", "required_a_optional_b", "aa", 18]
+// ["aa={aa,aa}", "property_parse", "duplicate_a", "aa", 8]
 
-                    warn(
-                        "required_a_optional_b",
-                        token_nxt,
-                        token_nxt.id,
-                        optional.id
-                    );
+                    warn("duplicate_a", name);
                 }
-                param = token_nxt;
-                param.names = [];
-                advance("[");
-                signature.push("[]");
-                while (true) {
-                    subparam = token_nxt;
-                    if (!subparam.identifier) {
+                seen[id] = true;
+            }
+            if (!name.identifier) {
 
 // test_cause:
-// ["function aa(aa=0,[]){}", "param_parse", "expected_identifier_a", "]", 19]
+// ["aa={\"aa\":0}", "property_parse", "colon", "", 0]
 
-                        return stop("expected_identifier_a");
-                    }
-                    advance();
-                    param.names.push(subparam);
+                test_cause("colon");
+                advance(":");
+                value = parse_expression(0);
+                value.label = name;
+                return value;
+            }
+            if (token_nxt.id === "}" || token_nxt.id === ",") {
+                if (typeof extra === "string") {
 
 // test_cause:
-// ["function aa([aa=aa],aa){}", "param_parse", "id", "", 0]
+// ["aa={get aa}", "property_parse", "closer", "", 0]
 
-                    test_cause("id");
-                    if (token_nxt.id === "=") {
-                        advance("=");
-                        subparam.expression = parse_expression();
-                        param.open = true;
-                    }
-                    if (token_nxt.id === ",") {
-                        advance(",");
-                    } else {
-                        break;
-                    }
-                }
-                parameters.push(param);
-                advance("]");
-                if (token_nxt.id === ",") {
-                    advance(",");
-                    signature.push(", ");
-                    param_parse();
-                    return;
+                    test_cause("closer");
+                    advance("(");
                 }
+                value = parse_expression(Infinity, true);
+            } else if (token_nxt.id === "(") {
+
+// test_cause:
+// ["aa={aa()}", "property_parse", "paren", "", 0]
+// ["aa={get aa(){}}", "property_parse", "paren", "", 0]
+
+                test_cause("paren");
+                value = prefix_function({
+                    arity: "unary",
+                    from: name.from,
+                    id: "function",
+                    line: name.line,
+                    name: (
+                        typeof extra === "string"
+                        ? extra
+                        : id
+                    ),
+                    thru: name.from
+                });
             } else {
-                if (token_nxt.id === "...") {
-                    ellipsis = true;
-                    signature.push("...");
-                    advance("...");
-                    if (optional !== undefined) {
+                if (typeof extra === "string") {
 
 // test_cause:
-// ["function aa(aa=0,...){}", "param_parse", "required_a_optional_b", "aa", 21]
+// ["aa={get aa.aa}", "property_parse", "paren", "", 0]
 
-                        warn(
-                            "required_a_optional_b",
-                            token_nxt,
-                            token_nxt.id,
-                            optional.id
-                        );
-                    }
-                }
-                if (!token_nxt.identifier) {
-
-// test_cause:
-// ["function aa(0){}", "param_parse", "expected_identifier_a", "0", 13]
-
-                    return stop("expected_identifier_a");
+                    test_cause("paren");
+                    advance("(");
                 }
-                param = token_nxt;
-                parameters.push(param);
-                advance();
-                signature.push(param.id);
-                if (ellipsis) {
-                    param.ellipsis = true;
-                } else {
-                    if (token_nxt.id === "=") {
-                        optional = param;
-                        advance("=");
-                        param.expression = parse_expression(0);
-                    } else {
-                        if (optional !== undefined) {
+                the_colon = token_nxt;
+                advance(":");
+                value = parse_expression(0);
+                if (
+                    value.id === name.id
+                    && value.id !== "function"
+                ) {
 
 // test_cause:
-// ["function aa(aa=0,bb){}", "param_parse", "required_a_optional_b", "aa", 18]
+// ["aa={aa:aa}", "property_parse", "unexpected_a", ": aa", 7]
 
-                            warn(
-                                "required_a_optional_b",
-                                param,
-                                param.id,
-                                optional.id
-                            );
-                        }
-                    }
-                    if (token_nxt.id === ",") {
-                        advance(",");
-                        signature.push(", ");
-                        param_parse();
-                        return;
-                    }
+                    warn("unexpected_a", the_colon, ": " + name.id);
                 }
             }
+            value.label = name;
+            if (typeof extra === "string") {
+                value.extra = extra;
+            }
+            return value;
         }
-
-// test_cause:
-// ["function aa(){}", "prefix_function_parameter", "opener", "(", 0]
-
-        test_cause("opener", token_now.id);
-        token_now.free = false;
-        if (token_nxt.id !== ")" && token_nxt.id !== "(end)") {
-            param_parse();
-        }
-        advance(")");
-        signature.push(")");
-        parameters.forEach(param_enroll);
-        the_function.parameters = parameters;
-        the_function.signature = signature.join("");
-    }
-
-    function prefix_lbrace() {
-        const seen = empty();
-        const the_brace = token_now;
-        let extra;
-        let full;
-        let id;
-        let name;
-        let the_colon;
-        let value;
         the_brace.expression = [];
         if (token_nxt.id !== "}") {
 
 // Parse/loop through each property in {...}.
 
             while (true) {
-                name = token_nxt;
-                advance();
-                if (
-                    (name.id === "get" || name.id === "set")
-                    && token_nxt.identifier
-                ) {
-                    if (!option_dict.getset) {
-
-// test_cause:
-// ["aa={get aa(){}}", "prefix_lbrace", "unexpected_a", "get", 5]
-
-                        warn("unexpected_a", name);
-                    }
-                    extra = name.id;
-                    full = extra + " " + token_nxt.id;
-                    name = token_nxt;
-                    advance();
-                    id = survey(name);
-                    if (seen[full] === true || seen[id] === true) {
-
-// test_cause:
-// ["aa={get aa(){},get aa(){}}", "prefix_lbrace", "duplicate_a", "aa", 20]
-
-                        warn("duplicate_a", name);
-                    }
-                    seen[id] = false;
-                    seen[full] = true;
-                } else if (name.id === "`") {
-
-// test_cause:
-// ["aa={`aa`:0}", "prefix_lbrace", "unexpected_a", "`", 5]
-
-                    stop("unexpected_a", name);
-
-                } else {
-                    id = survey(name);
-                    if (typeof seen[id] === "boolean") {
-
-// test_cause:
-// ["aa={aa,aa}", "prefix_lbrace", "duplicate_a", "aa", 8]
-
-                        warn("duplicate_a", name);
-                    }
-                    seen[id] = true;
-                }
-                if (name.identifier) {
-                    if (token_nxt.id === "}" || token_nxt.id === ",") {
-                        if (typeof extra === "string") {
-
-// test_cause:
-// ["aa={get aa}", "prefix_lbrace", "closer", "", 0]
-
-                            test_cause("closer");
-                            advance("(");
-                        }
-                        value = parse_expression(Infinity, true);
-                    } else if (token_nxt.id === "(") {
-
-// test_cause:
-// ["aa={aa()}", "prefix_lbrace", "paren", "", 0]
-// ["aa={get aa(){}}", "prefix_lbrace", "paren", "", 0]
-
-                        test_cause("paren");
-                        value = prefix_function({
-                            arity: "unary",
-                            from: name.from,
-                            id: "function",
-                            line: name.line,
-                            name: (
-                                typeof extra === "string"
-                                ? extra
-                                : id
-                            ),
-                            thru: name.from
-                        });
-                    } else {
-                        if (typeof extra === "string") {
-
-// test_cause:
-// ["aa={get aa.aa}", "prefix_lbrace", "paren", "", 0]
-
-                            test_cause("paren");
-                            advance("(");
-                        }
-                        the_colon = token_nxt;
-                        advance(":");
-                        value = parse_expression(0);
-                        if (
-                            value.id === name.id
-                            && value.id !== "function"
-                        ) {
-
-// test_cause:
-// ["aa={aa:aa}", "prefix_lbrace", "unexpected_a", ": aa", 7]
-
-                            warn("unexpected_a", the_colon, ": " + name.id);
-                        }
-                    }
-                    value.label = name;
-                    if (typeof extra === "string") {
-                        value.extra = extra;
-                    }
-                    the_brace.expression.push(value);
-                } else {
-
-// test_cause:
-// ["aa={\"aa\":0}", "prefix_lbrace", "colon", "", 0]
-
-                    test_cause("colon");
-                    advance(":");
-                    value = parse_expression(0);
-                    value.label = name;
-                    the_brace.expression.push(value);
-                }
+                the_brace.expression.push(property_parse());
                 if (token_nxt.id !== ",") {
                     break;
                 }
-
-// test_cause:
-// ["aa={\"aa\":0,\"bb\":0}", "prefix_lbrace", "comma", "", 0]
-
-                test_cause("comma");
                 advance(",");
                 if (token_nxt.id === "}") {
 
@@ -5948,25 +6332,45 @@ function jslint_phase3_parse(state) {
     }
 
     function prefix_lbracket() {
-        const the_token = token_now;
         let element;
-        let ellipsis;
+        let the_token = token_now;
         the_token.expression = [];
+        if (the_token.assignment) {
+            the_token = token_now.assignment;
+            the_token.names = [];
+
+// PR-500 - Unify ES2015-destructure-logic. - [aa] = ...;
+
+            element = prefix_destructure(
+                undefined,              // enroll
+                "variable",             // role
+                false,                  // readonly
+                the_token.names,        // name_list
+                undefined,              // the_function
+                false                   // the_function_toplevel
+            );
+            advance("=");
+            symbol("=").led_infix(element);
+            return the_token;
+        }
         if (token_nxt.id !== "]") {
 
 // Parse/loop through each element in [...].
 
             while (true) {
-                ellipsis = false;
-                if (token_nxt.id === "...") {
-                    ellipsis = true;
-                    advance("...");
-                }
-                element = parse_expression(10);
-                if (ellipsis) {
-                    element.ellipsis = true;
+                if (!state.mode_json && token_nxt.id === "...") {
+
+// test_cause:
+// ["aa=[...aa]", "prefix_lbracket", "ellipsis", "...", 0]
+
+                    test_cause("ellipsis", token_nxt.id);
+                    the_token.expression.push(prefix_ellipsis());
+
+// Issue #401 - Regression - Allow multiple-ellipsis in array-literal.
+
+                } else {
+                    the_token.expression.push(parse_expression(10));
                 }
-                the_token.expression.push(element);
                 if (token_nxt.id !== ",") {
                     break;
                 }
@@ -5974,7 +6378,7 @@ function jslint_phase3_parse(state) {
                 if (token_nxt.id === "]") {
 
 // test_cause:
-// ["let aa=[0,]", "prefix_lbracket", "unexpected_a", ",", 10]
+// ["aa=[0,]", "prefix_lbracket", "unexpected_a", ",", 6]
 
                     warn("unexpected_a", token_now);
                     break;
@@ -6139,7 +6543,7 @@ function jslint_phase3_parse(state) {
             the_break.label = token_nxt;
             advance();
         }
-        advance(";");
+        semicolon();
         return the_break;
     }
 
@@ -6158,7 +6562,7 @@ function jslint_phase3_parse(state) {
         check_not_top_level(the_continue);
         the_continue.disrupt = true;
         warn("unexpected_a", the_continue);
-        advance(";");
+        semicolon();
         return the_continue;
     }
 
@@ -6186,7 +6590,7 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["delete 0", "stmt_delete", "expected_a_b", "0", 8]
 
-            stop("expected_a_b", the_value, ".", artifact(the_value));
+            return stop("expected_a_b", the_value, ".", artifact(the_value));
         }
         the_token.expression = the_value;
         semicolon();
@@ -6311,7 +6715,7 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["export {}", "stmt_export", "expected_identifier_a", "}", 9]
 
-                        stop("expected_identifier_a");
+                        return stop("expected_identifier_a", token_nxt);
                     }
                     the_id = token_nxt.id;
                     export_list.push(token_nxt);
@@ -6335,11 +6739,10 @@ function jslint_phase3_parse(state) {
                     }
                     advance();
                     the_export.expression.push(the_thing);
-                    if (token_nxt.id === ",") {
-                        advance(",");
-                    } else {
+                    if (token_nxt.id !== ",") {
                         break;
                     }
+                    advance(",");
                 }
 
 // PR-439 - Check exported properties are ordered.
@@ -6355,7 +6758,7 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["export", "stmt_export", "unexpected_a", "(end)", 1]
 
-                stop("unexpected_a");
+                return stop("unexpected_a");
             }
         }
         state.mode_module = true;
@@ -6477,83 +6880,103 @@ function jslint_phase3_parse(state) {
     function stmt_import() {
         const the_import = token_now;
         let name;
-        let names;
-
-// PR-347 - Disable warning "unexpected_directive_a".
-//
-//         if (typeof state.mode_module === "object") {
-//
-// // test_cause:
-// // ["
-// // /*global aa*/
-// // import aa from "aa"
-// // ", "stmt_import", "unexpected_directive_a", "global", 1]
-//
-//             warn(
-//                 "unexpected_directive_a",
-//                 state.mode_module,
-//                 state.mode_module.directive
-//             );
-//         }
-
+        the_import.name = [];
         state.mode_module = true;
+        while (true) {
 
 // PR-436 - Add grammar for side-effect import-statement.
 
-        if (token_nxt.id === "(string)") {
+            if (token_nxt.id === "(string)") {
 
 // test_cause:
-// ["import \"./aa.mjs\";", "stmt_import", "import_side_effect", "", 0]
+// ["import \"aa\"", "stmt_import", "import_side_effect", "", 0]
 
-            test_cause("import_side_effect");
-            warn("expected_a_b", token_nxt, "{", artifact());
-            advance();
-            semicolon();
-            return the_import;
-        }
-        if (token_nxt.identifier) {
-            name = token_nxt;
-            advance();
-            if (name.id === "ignore") {
+                test_cause("import_side_effect");
+                warn("expected_a_b", token_nxt, "{", artifact());
+                advance();
+                semicolon();
+                return the_import;
+            }
+            if (token_nxt.id === "*") {
+                advance("*");
+                advance("as");
+                if (!token_nxt.identifier) {
 
 // test_cause:
-// ["import ignore from \"aa\"", "stmt_import", "unexpected_a", "ignore", 8]
+// ["import * as", "stmt_import", "expected_identifier_a", "(end)", 1]
 
-                warn("unexpected_a", name);
+                    return stop("expected_identifier_a", token_nxt);
+                }
             }
-            enroll(name, "variable", true);
-            the_import.name = name;
-        } else {
-            names = [];
-            advance("{");
-            if (token_nxt.id !== "}") {
-                while (true) {
-                    if (!token_nxt.identifier) {
+            if (token_nxt.identifier) {
+                name = token_nxt;
+                advance();
+                if (name.id === "ignore") {
+
+// test_cause:
+// ["import ignore from \"aa\"", "stmt_import", "unexpected_a", "ignore", 8]
+
+                    warn("unexpected_a", name);
+                }
+                enroll(name, "variable", true);
+                the_import.name.push(name);
+            } else {
+                advance("{");
+                if (token_nxt.id !== "}") {
+                    while (true) {
+                        if (!token_nxt.identifier) {
 
 // test_cause:
 // ["import {", "stmt_import", "expected_identifier_a", "(end)", 1]
 
-                        stop("expected_identifier_a");
-                    }
-                    name = token_nxt;
-                    advance();
-                    if (name.id === "ignore") {
+                            return stop("expected_identifier_a", token_nxt);
+                        }
+                        name = token_nxt;
+                        advance();
+                        if (token_nxt.id === "as") {
+                            advance("as");
+                            name = token_nxt;
+                            advance();
+                        }
+                        if (name.id === "ignore") {
 
 // test_cause:
 // ["import {ignore} from \"aa\"", "stmt_import", "unexpected_a", "ignore", 9]
 
-                        warn("unexpected_a", name);
-                    }
-                    enroll(name, "variable", true);
-                    names.push(name);
-                    if (token_nxt.id !== ",") {
-                        break;
+                            warn("unexpected_a", name);
+                        }
+                        enroll(name, "variable", true);
+                        the_import.name.push(name);
+                        if (token_nxt.id !== ",") {
+                            break;
+                        }
+                        advance(",");
                     }
-                    advance(",");
                 }
+                advance("}");
+            }
+
+// PR-347 - Disable warning "unexpected_directive_a".
+//
+//         if (typeof state.mode_module === "object") {
+//
+// // test_cause:
+// // ["
+// // /*global aa*/
+// // import aa from "aa"
+// // ", "stmt_import", "unexpected_directive_a", "global", 1]
+//
+//             warn(
+//                 "unexpected_directive_a",
+//                 state.mode_module,
+//                 state.mode_module.directive
+//             );
+//         }
+
+            if (token_nxt.id !== ",") {
+                break;
             }
-            advance("}");
-            the_import.name = names;
+            advance(",");
         }
         advance("from");
         advance("(string)");
@@ -6566,6 +6989,14 @@ function jslint_phase3_parse(state) {
             warn("bad_module_name_a", token_now);
         }
         import_list.push(token_now.value);
+
+// Issue #495 - Add ES2025-syntax "import ... with {...}".
+
+        if (token_nxt.id === "with") {
+            advance("with");
+            advance("{");
+            prefix_lbrace();
+        }
         semicolon();
         return the_import;
     }
@@ -6596,7 +7027,7 @@ function jslint_phase3_parse(state) {
         if (token_nxt.id !== ";" && the_return.line === token_nxt.line) {
             the_return.expression = parse_expression(10);
         }
-        advance(";");
+        semicolon();
         return the_return;
     }
 
@@ -6834,7 +7265,7 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["try{}catch(){}", "stmt_try", "expected_identifier_a", ")", 12]
 
-                    return stop("expected_identifier_a");
+                    return stop("expected_identifier_a", token_nxt);
                 }
                 if (token_nxt.id !== "ignore") {
                     ignored = undefined;
@@ -6876,19 +7307,15 @@ function jslint_phase3_parse(state) {
     }
 
     function stmt_var() {
-        let ellipsis;
-        let mode_const;
+        const readonly = token_now.id === "const";
         let name;
-        let the_brace;
-        let the_bracket;
         let the_variable = token_now;
         let variable_prv;
-        mode_const = the_variable.id === "const";
         the_variable.names = [];
 
 // A program may use var or let, but not both.
 
-        if (!mode_const) {
+        if (!readonly) {
             if (mode_var === undefined) {
                 mode_var = the_variable.id;
             } else if (the_variable.id !== mode_var) {
@@ -6950,142 +7377,27 @@ function jslint_phase3_parse(state) {
             }
         }
         while (true) {
-            if (token_nxt.id === "{") {
-                if (the_variable.id === "var") {
-
-// test_cause:
-// ["var{aa}=0", "stmt_var", "unexpected_a", "var", 1]
-
-                    warn("unexpected_a", the_variable);
-                }
-                the_brace = token_nxt;
-                advance("{");
-                while (true) {
-                    name = token_nxt;
-                    if (!name.identifier) {
-
-// test_cause:
-// ["let {0}", "stmt_var", "expected_identifier_a", "0", 6]
-
-                        return stop("expected_identifier_a");
-                    }
-                    survey(name);
-                    advance();
-                    if (token_nxt.id === ":") {
-                        advance(":");
-                        if (!token_nxt.identifier) {
-
-// test_cause:
-// ["let {aa:0}", "stmt_var", "expected_identifier_a", "0", 9]
-// ["let {aa:{aa}}", "stmt_var", "expected_identifier_a", "{", 9]
-
-                            return stop("expected_identifier_a");
-                        }
-
-// PR-363 - Bugfix
-// Add test against false-warning <uninitialized 'bb'> in code
-// '/*jslint node*/\nlet {aa:bb} = {}; bb();'.
-//
-//                         token_nxt.label = name;
-//                         the_variable.names.push(token_nxt);
-//                         enroll(token_nxt, "variable", mode_const);
-
-                        name = token_nxt;
-                        the_variable.names.push(name);
-                        survey(name);
-                        enroll(name, "variable", mode_const);
-
-                        advance();
-                        the_brace.open = true;
-                    } else {
-                        the_variable.names.push(name);
-                        enroll(name, "variable", mode_const);
-                    }
-
-// Issue #458 - Regression - Warn about variable usage before initialization.
-
-//                    name.dead = false;
-
-                    name.init = true;
-
-// test_cause:
-// ["const {aa}=bb;\nconst bb=0;", "lookup", "out_of_scope_a", "bb", 12]
-
-                    if (token_nxt.id === "=") {
-
-// test_cause:
-// ["let {aa=0}", "stmt_var", "assign", "", 0]
-
-                        test_cause("assign");
-                        advance("=");
-                        name.expression = parse_expression();
-                        the_brace.open = true;
-                    }
-                    if (token_nxt.id !== ",") {
-                        break;
-                    }
-                    advance(",");
-                }
-
-// test_cause:
-// ["let{bb,aa}", "check_ordered", "expected_a_b_before_c_d", "aa", 8]
-
-                check_ordered(the_variable.id, the_variable.names);
-                advance("}");
-                advance("=");
-                the_variable.expression = parse_expression(0);
-            } else if (token_nxt.id === "[") {
+            if (token_nxt.id === "{" || token_nxt.id === "[") {
                 if (the_variable.id === "var") {
 
 // test_cause:
 // ["var[aa]=0", "stmt_var", "unexpected_a", "var", 1]
+// ["var{aa}=0", "stmt_var", "unexpected_a", "var", 1]
 
                     warn("unexpected_a", the_variable);
                 }
-                the_bracket = token_nxt;
-                advance("[");
-                while (true) {
-                    ellipsis = false;
-                    if (token_nxt.id === "...") {
-                        ellipsis = true;
-                        advance("...");
-                    }
-                    if (!token_nxt.identifier) {
-
-// test_cause:
-// ["let[]", "stmt_var", "expected_identifier_a", "]", 5]
-
-                        return stop("expected_identifier_a");
-                    }
-                    name = token_nxt;
-                    advance();
-                    the_variable.names.push(name);
-                    enroll(name, "variable", mode_const);
-
-// Issue #458 - Regression - Warn about variable usage before initialization.
-
-//                    name.dead = false;
-
-                    name.init = true;
+                advance();
 
-// test_cause:
-// ["const [aa]=bb;\nconst bb=0;", "lookup", "out_of_scope_a", "bb", 12]
+// PR-500 - Unify ES2015-destructure-logic. - let [aa] = ...;
 
-                    if (ellipsis) {
-                        name.ellipsis = true;
-                        break;
-                    }
-                    if (token_nxt.id === "=") {
-                        advance("=");
-                        name.expression = parse_expression();
-                        the_bracket.open = true;
-                    }
-                    if (token_nxt.id !== ",") {
-                        break;
-                    }
-                    advance(",");
-                }
-                advance("]");
+                prefix_destructure(
+                    enroll,             // enroll
+                    "variable",         // role
+                    readonly,           // readonly
+                    the_variable.names, // name_list
+                    undefined,          // the_function
+                    false               // the_function_toplevel
+                );
                 advance("=");
                 the_variable.expression = parse_expression(0);
             } else if (token_nxt.identifier) {
@@ -7100,8 +7412,8 @@ function jslint_phase3_parse(state) {
 
                     warn("unexpected_a", name);
                 }
-                enroll(name, "variable", mode_const);
-                if (token_nxt.id === "=" || mode_const) {
+                enroll(name, "variable", readonly);
+                if (token_nxt.id === "=" || readonly) {
                     advance("=");
 
 // Issue #458 - Regression - Warn about variable usage before initialization.
@@ -7120,9 +7432,8 @@ function jslint_phase3_parse(state) {
 
 // test_cause:
 // ["let 0", "stmt_var", "expected_identifier_a", "0", 5]
-// ["var{aa:{aa}}", "stmt_var", "expected_identifier_a", "{", 8]
 
-                return stop("expected_identifier_a");
+                return stop("expected_identifier_a", token_nxt);
             }
             if (token_nxt.id !== ",") {
                 break;
@@ -7188,7 +7499,7 @@ function jslint_phase3_parse(state) {
 // test_cause:
 // ["with", "stmt_with", "unexpected_a", "with", 1]
 
-        stop("unexpected_a", token_now);
+        return stop("unexpected_a", token_now);
     }
 
     function survey(name) {
@@ -7197,49 +7508,55 @@ function jslint_phase3_parse(state) {
 // Tally the property name. If it is a string, only tally strings that conform
 // to the identifier rules.
 
-        if (id === "(string)") {
+        switch (id) {
+        case "(string)":
             id = name.value;
             if (!jslint_rgx_identifier.test(id)) {
                 return id;
             }
-        } else if (id === "`") {
+            break;
+        case "`":
             if (name.value.length === 1) {
                 id = name.value[0].value;
                 if (!jslint_rgx_identifier.test(id)) {
                     return id;
                 }
             }
-        } else if (!name.identifier) {
+            break;
+        default:
+            if (!name.identifier) {
 
 // test_cause:
 // ["let aa={0:0}", "survey", "expected_identifier_a", "0", 9]
 
-            return stop("expected_identifier_a", name);
+                return stop("expected_identifier_a", name);
+            }
         }
 
 // If we have seen this name before, increment its count.
 
         if (typeof property_dict[id] === "number") {
             property_dict[id] += 1;
+            return id;
+        }
 
 // If this is the first time seeing this property name, and if there is a
 // tenure list, then it must be on the list. Otherwise, it must conform to
 // the rules for good property names.
 
-        } else {
-            if (state.mode_property) {
-                if (tenure[id] !== true) {
+        if (state.mode_property) {
+            if (tenure[id] !== true) {
 
 // test_cause:
 // ["/*property aa*/\naa.bb", "survey", "unregistered_property_a", "bb", 4]
 
-                    warn("unregistered_property_a", name);
-                }
-            } else if (
-                !option_dict.nomen
-                && name.identifier
-                && jslint_rgx_weird_property.test(id)
-            ) {
+                warn("unregistered_property_a", name);
+            }
+        } else if (
+            !option_dict.nomen
+            && name.identifier
+            && jslint_rgx_weird_property.test(id)
+        ) {
 
 // test_cause:
 // ["aa.$", "survey", "weird_property_a", "$", 4]
@@ -7248,10 +7565,9 @@ function jslint_phase3_parse(state) {
 // ["aa.aaSync", "survey", "weird_property_a", "aaSync", 4]
 // ["aa.aa_", "survey", "weird_property_a", "aa_", 4]
 
-                warn("weird_property_a", name);
-            }
-            property_dict[id] = 1;
+            warn("weird_property_a", name);
         }
+        property_dict[id] = 1;
         return id;
     }
 
@@ -7300,6 +7616,7 @@ function jslint_phase3_parse(state) {
 // Begin defining the language.
 
     assignment("%=");
+    assignment("&&=");
     assignment("&=");
     assignment("*=");
     assignment("+=");
@@ -7309,8 +7626,10 @@ function jslint_phase3_parse(state) {
     assignment("=");
     assignment(">>=");
     assignment(">>>=");
+    assignment("??=");
     assignment("^=");
     assignment("|=");
+    assignment("||=");
     constant("(number)", "number");
     constant("(regexp)", "regexp");
     constant("(string)", "string");
@@ -7349,7 +7668,7 @@ function jslint_phase3_parse(state) {
     infix(160, "`", infix_grave);
     infix(170, ".", infix_dot);
     infix(170, "=>", infix_fart_unwrapped);
-    infix(170, "?.", infix_option_chain);
+    infix(170, "?.", infix_dot);
     infix(170, "[", infix_lbracket);
     infix(35, "??");
     infix(40, "||");
@@ -7454,7 +7773,7 @@ function jslint_phase3_parse(state) {
 
     } else if (token_nxt.value === "use strict") {
         advance("(string)");
-        advance(";");
+        semicolon();
     }
     state.token_tree = parse_statements();
     advance("(end)");
@@ -7672,7 +7991,9 @@ function jslint_phase4_walk(state) {
         ) {
 
 // test_cause:
+// ["(aa=aa)=>0", "lookup", "out_of_scope_a", "aa", 5]
 // ["let aa;if(aa){let bb;}bb;", "lookup", "out_of_scope_a", "bb", 23]
+// ["let aa=bb;let bb=0;", "lookup", "out_of_scope_a", "bb", 8]
 
             warn("out_of_scope_a", thing);
         }
@@ -7689,24 +8010,23 @@ function jslint_phase4_walk(state) {
         let right;
         if (thing.id === "=") {
             if (thing.names !== undefined) {
+                if (Array.isArray(thing.names)) {
+
+// PR-500 - Fix false-warning "uninitialized_a" in statement ";[aa]=0;".
 
 // test_cause:
-// ["if(0){aa=0}", "post_a", "=", "", 0]
+// [";[aa]=0", "post_a", ";[aa]=0", "", 0]
 
-                test_cause("=");
+                    test_cause(";[aa]=0");
+                    thing.names.forEach(init_variable);
+                } else {
 
-// Probably deadcode.
-// if (Array.isArray(thing.names)) {
-//     thing.names.forEach(init_variable);
-// } else {
-//     init_variable(thing.names);
-// }
+// test_cause:
+// ["aa=0", "post_a", "aa=0", "", 0]
 
-                jslint_assert(
-                    !Array.isArray(thing.names),
-                    `Expected !Array.isArray(thing.names).`
-                );
-                init_variable(thing.names);
+                    test_cause("aa=0");
+                    init_variable(thing.names);
+                }
             } else {
                 if (lvalue.id === "[" || lvalue.id === "{") {
                     lvalue.expression.forEach(function (thing) {
@@ -7827,10 +8147,15 @@ function jslint_phase4_walk(state) {
         } else if (thing.id === "." || thing.id === "?.") {
             if (thing.expression.id === "RegExp") {
 
+// PR-499 - Relax warning for ES2025-feature RegExp.escape().
+
+                if (!thing.name || thing.name.id !== "escape") {
+
 // test_cause:
 // ["aa=RegExp.aa", "post_b", "weird_expression_a", ".", 10]
 
-                warn("weird_expression_a", thing);
+                    warn("weird_expression_a", thing);
+                }
             }
         } else if (thing.id !== "=>" && thing.id !== "(") {
             right = thing.expression[1];
@@ -8096,21 +8421,12 @@ function jslint_phase4_walk(state) {
     }
 
     function post_s_import(the_thing) {
-        const name = the_thing.name;
-        if (name) {
-            if (Array.isArray(name)) {
-                name.forEach(function (name) {
-                    name.dead = false;
-                    name.init = true;
-                    blockage.live.push(name);
-                });
-            } else {
-                name.dead = false;
-                name.init = true;
-                blockage.live.push(name);
-            }
-            return post_s_export(the_thing);
-        }
+        the_thing.name.forEach(function (name) {
+            name.dead = false;
+            name.init = true;
+            blockage.live.push(name);
+        });
+        return post_s_export(the_thing);
     }
 
     function post_s_lbrace() {
@@ -8143,7 +8459,12 @@ function jslint_phase4_walk(state) {
     function post_s_var(thing) {
         thing.names.forEach(function (name) {
             name.dead = false;
-            if (name.expression !== undefined) {
+            if (name.expression) {
+
+// test_cause:
+// ["let aa=0", "post_s_var", "let aa=0", "", 0]
+
+                test_cause("let aa=0");
                 walk_expression(name.expression);
 
 // Probably deadcode.
@@ -8153,11 +8474,20 @@ function jslint_phase4_walk(state) {
 //     name.init = true;
 // }
 
-                jslint_assert(
-                    !(name.id === "{" || name.id === "["),
-                    `Expected !(name.id === "{" || name.id === "[").`
-                );
+// PR-500 - Unify property the_function.parameters into the_function.names.
+
+// jslint_assert(
+// !(name.id === "{" || name.id === "["),
+// `Expected !(name.id === "{" || name.id === "[").`
+// );
+
                 name.init = true;
+            } else {
+
+// test_cause:
+// ["let aa", "post_s_var", "let aa", "", 0]
+
+                test_cause("let aa");
             }
             blockage.live.push(name);
         });
@@ -8499,7 +8829,7 @@ function jslint_phase4_walk(state) {
             thing.name.init = true;
         }
         if (thing.extra === "get") {
-            if (thing.parameters.length !== 0) {
+            if (thing.parameter_count !== 0) {
 
 // test_cause:
 // ["
@@ -8507,28 +8837,51 @@ function jslint_phase4_walk(state) {
 // aa={get aa(aa){}}
 // ", "pre_s_function", "bad_get", "function", 9]
 
-                warn("bad_get", thing);
-            }
-        } else if (thing.extra === "set") {
-            if (thing.parameters.length !== 1) {
+                warn("bad_get", thing);
+            }
+        } else if (thing.extra === "set") {
+            if (thing.parameter_count !== 1) {
+
+// test_cause:
+// ["
+// /*jslint getset*/
+// aa={set aa(){}}
+// ", "pre_s_function", "bad_set", "function", 9]
+
+                warn("bad_set", thing);
+            }
+        }
+
+// PR-500 - Unify property the_function.parameters into the_function.names.
+
+// thing.parameters.forEach(function (name) {
+//     walk_expression(name.expression);
+//     if (name.id === "{" || name.id === "[") {
+//         name.names.forEach(subactivate);
+//     } else {
+//         name.dead = false;
+//         name.init = true;
+//     }
+// });
+
+        thing.names.forEach(function (name) {
+            if (name.expression) {
+
+// test_cause:
+// ["(aa=0)=>0", "pre_s_function", "(aa=0)=>0", "", 0]
+
+                test_cause("(aa=0)=>0");
+            } else {
 
 // test_cause:
-// ["
-// /*jslint getset*/
-// aa={set aa(){}}
-// ", "pre_s_function", "bad_set", "function", 9]
+// ["(aa)=>0", "pre_s_function", "(aa)=>0", "", 0]
+// ["aa=>0", "pre_s_function", "(aa)=>0", "", 0]
 
-                warn("bad_set", thing);
+                test_cause("(aa)=>0");
             }
-        }
-        thing.parameters.forEach(function (name) {
             walk_expression(name.expression);
-            if (name.id === "{" || name.id === "[") {
-                name.names.forEach(subactivate);
-            } else {
-                name.dead = false;
-                name.init = true;
-            }
+            name.dead = false;
+            name.init = true;
         });
     }
 
@@ -8556,11 +8909,13 @@ function jslint_phase4_walk(state) {
         }
     }
 
-    function subactivate(name) {
-        name.init = true;
-        name.dead = false;
-        blockage.live.push(name);
-    }
+// PR-500 - Unify property the_function.parameters into the_function.names.
+
+// function subactivate(name) {
+//     name.init = true;
+//     name.dead = false;
+//     blockage.live.push(name);
+// }
 
     function walk_expression(thing) {
         if (thing) {
@@ -8752,6 +9107,8 @@ function jslint_phase5_whitage(state) {
 // "switch(){}"
 // "while(){}"
 
+    let indent_method_dict = empty();
+    let indentage;
     let left = token_global;
     let margin = 0;
     let mode_indent = (
@@ -8770,9 +9127,19 @@ function jslint_phase5_whitage(state) {
 // This is the set of infix operators that require a space on each side.
 
     let spaceop = object_assign_from_list(empty(), [
-        "!=", "!==", "%", "%=", "&", "&&", "&=", "*", "*=", "+=", "-=", "/",
-        "/=", "<", "<<", "<<=", "<=", "=", "==", "===", "=>", ">", ">=", ">>",
-        ">>=", ">>>", ">>>=", "^", "^=", "|", "|=", "||"
+        "!=", "!==",
+        "%", "%=",
+        "&", "&&", "&&=", "&=",
+        "*", "*=",
+        "+=",
+        "-=",
+        "/", "/=",
+        "<", "<<", "<<=", "<=",
+        "=", "==", "===", "=>",
+        ">", ">=", ">>", ">>=", ">>>", ">>>=",
+        "??", "??=",
+        "^", "^=",
+        "|", "|=", "||", "||="
     ], true);
 
     function at_margin(fit) {
@@ -8946,148 +9313,106 @@ function jslint_phase5_whitage(state) {
         }
     }
 
-    function pop() {
-        const previous = function_stack.pop();
-        closer = previous.closer;
-        free = previous.free;
-        margin = previous.margin;
-        open = previous.open;
-        opening = previous.opening;
-    }
-
-    function push() {
-        function_stack.push({
-            closer,
-            free,
-            margin,
-            open,
-            opening
-        });
-    }
-
-// uninitialized_and_unused();
-// Delve into the functions looking for variables that were not initialized
-// or used. If the file imports or exports, then its global object is also
-// delved.
-
-    if (state.mode_module === true || option_dict.node) {
-        delve(token_global);
-    }
-    catch_list.forEach(delve);
-    function_list.forEach(delve);
-
-    if (option_dict.white) {
-        return;
-    }
-
-// whitage();
-// Go through the token list, looking at usage of whitespace.
-
-    token_list.forEach(function whitage(the_token) {
-        right = the_token;
-        if (right.id === "(comment)" || right.id === "(end)") {
-            nr_comments_skipped += 1;
-        } else {
-
-// If left is an opener and right is not the closer, then push the previous
-// state. If the token following the opener is on the next line, then this is
-// an open form. If the tokens are on the same line, then it is a closed form.
-// Open form is more readable, with each item (statement, argument, parameter,
-// etc) starting on its own line. Closed form is more compact. Statement blocks
-// are always in open form.
-
-// The open and close pairs.
-
-            switch (left.id) {
-            case "${":
-            case "(":
-            case "[":
-            case "{":
+    function whitage_case() {
 
 // test_cause:
-// ["let aa=[];", "whitage", "opener", "", 0]
-// ["let aa=`${0}`;", "whitage", "opener", "", 0]
-// ["let aa=aa();", "whitage", "opener", "", 0]
-// ["let aa={};", "whitage", "opener", "", 0]
+// ["let aa=[];", "whitage_case", "opener", "", 0]
+// ["let aa=`${0}`;", "whitage_case", "opener", "", 0]
+// ["let aa=aa();", "whitage_case", "opener", "", 0]
+// ["let aa={};", "whitage_case", "opener", "", 0]
 
-                test_cause("opener");
+        test_cause("opener");
 
 // Probably deadcode.
 // case "${}":
 
-                jslint_assert(
-                    !(left.id + right.id === "${}"),
-                    "Expected !(left.id + right.id === \"${}\")."
-                );
-                switch (left.id + right.id) {
-                case "()":
-                case "[]":
-                case "{}":
+        jslint_assert(
+            !(left.id + right.id === "${}"),
+            "Expected !(left.id + right.id === \"${}\")."
+        );
+        switch (left.id + right.id) {
+        case "()":
+        case "[]":
+        case "{}":
 
 // If left and right are opener and closer, then the placement of right depends
 // on the openness. Illegal pairs (like '{]') have already been detected.
 
 // test_cause:
-// ["let aa=[];", "whitage", "opener_closer", "", 0]
-// ["let aa=aa();", "whitage", "opener_closer", "", 0]
-// ["let aa={};", "whitage", "opener_closer", "", 0]
+// ["let aa=[];", "whitage_case", "opener_closer", "", 0]
+// ["let aa=aa();", "whitage_case", "opener_closer", "", 0]
+// ["let aa={};", "whitage_case", "opener_closer", "", 0]
 
-                    test_cause("opener_closer");
-                    if (left.line === right.line) {
+            test_cause("opener_closer");
+            if (left.line === right.line) {
 
 // test_cause:
 // ["let aa = aa( );", "no_space", "unexpected_space_a_b", ")", 14]
 
-                        no_space();
-                    } else {
+                no_space();
+            } else {
 
 // test_cause:
 // ["let aa = aa(\n );", "expected_at", "expected_a_at_b_c", "1", 2]
 
-                        at_margin(0);
-                    }
-                    break;
-                default:
+                at_margin(0);
+            }
+            break;
+        default:
 
 // test_cause:
-// ["let aa=(0);", "whitage", "opener_operand", "", 0]
-// ["let aa=[0];", "whitage", "opener_operand", "", 0]
-// ["let aa=`${0}`;", "whitage", "opener_operand", "", 0]
-// ["let aa=aa(0);", "whitage", "opener_operand", "", 0]
-// ["let aa={aa:0};", "whitage", "opener_operand", "", 0]
-
-                    test_cause("opener_operand");
-                    opening = left.open || (left.line !== right.line);
-                    push();
-                    switch (left.id) {
-                    case "${":
-                        closer = "}";
-                        break;
-                    case "(":
-                        closer = ")";
-                        break;
-                    case "[":
-                        closer = "]";
-                        break;
-                    case "{":
-                        closer = "}";
-                        break;
-                    }
-                    if (opening) {
+// ["let aa=(0);", "whitage_case", "opener_operand", "", 0]
+// ["let aa=[0];", "whitage_case", "opener_operand", "", 0]
+// ["let aa=`${0}`;", "whitage_case", "opener_operand", "", 0]
+// ["let aa=aa(0);", "whitage_case", "opener_operand", "", 0]
+// ["let aa={aa:0};", "whitage_case", "opener_operand", "", 0]
+
+            test_cause("opener_operand");
+            opening = left.open || (left.line !== right.line);
+            indentage = {
+                closer,
+                free,
+                margin,
+                open,
+                opening
+            };
+            function_stack.push(indentage);
+            switch (left.id) {
+            case "${":
+                closer = "}";
+                break;
+            case "(":
+                closer = ")";
+                break;
+            case "[":
+                closer = "]";
+                break;
+            case "{":
+                closer = "}";
+                break;
+            }
+            if (opening) {
 
 // test_cause:
-// ["function aa(){\nreturn;\n}", "whitage", "opening", "", 0]
-// ["let aa=(\n0\n);", "whitage", "opening", "", 0]
-// ["let aa=[\n0\n];", "whitage", "opening", "", 0]
-// ["let aa=`${\n0\n}`;", "whitage", "opening", "", 0]
-// ["let aa={\naa:0\n};", "whitage", "opening", "", 0]
+// ["function aa(){\nreturn;\n}", "whitage_case", "opening", "", 0]
+// ["let aa=(\n0\n);", "whitage_case", "opening", "", 0]
+// ["let aa=[\n0\n];", "whitage_case", "opening", "", 0]
+// ["let aa=`${\n0\n}`;", "whitage_case", "opening", "", 0]
+// ["let aa={\naa:0\n};", "whitage_case", "opening", "", 0]
+
+                test_cause("opening");
+                free = closer === ")" && left.free;
+                open = true;
+                margin += mode_indent;
+                if (indent_method_dict[left.line]) {
 
-                        test_cause("opening");
-                        free = closer === ")" && left.free;
-                        open = true;
-                        margin += mode_indent;
-                        if (right.role === "label") {
-                            if (right.from !== 0) {
+// PR-498 - Relax warning on multiline-method-chaining.
+
+                    margin += mode_indent;
+                    indentage.indent_method = true;
+                }
+                if (right.role === "label") {
+                    if (right.from !== 0) {
 
 // test_cause:
 // ["
@@ -9101,15 +9426,16 @@ function jslint_phase5_whitage(state) {
 // }
 // ", "expected_at", "expected_a_at_b_c", "1", 2]
 
-                                expected_at(0);
-                            }
-                        } else if (right.switch) {
-                            at_margin(-mode_indent);
-                        } else {
-                            at_margin(0);
-                        }
-                    } else {
-                        if (right.statement || right.role === "label") {
+                        expected_at(0);
+                    }
+                } else if (right.switch) {
+                    at_margin(-mode_indent);
+                } else {
+                    at_margin(0);
+                }
+                break;
+            }
+            if (right.statement || right.role === "label") {
 
 // test_cause:
 // ["
@@ -9118,36 +9444,36 @@ function jslint_phase5_whitage(state) {
 //         aa();
 //     }
 // }
-// ", "whitage", "expected_line_break_a_b", "bb", 16]
+// ", "whitage_case", "expected_line_break_a_b", "bb", 16]
 
-                            warn(
-                                "expected_line_break_a_b",
-                                right,
-                                artifact(left),
-                                artifact(right)
-                            );
-                        }
+                warn(
+                    "expected_line_break_a_b",
+                    right,
+                    artifact(left),
+                    artifact(right)
+                );
+            }
 
 // test_cause:
-// ["let aa=(0);", "whitage", "not_free", "", 0]
-// ["let aa=[0];", "whitage", "not_free", "", 0]
-// ["let aa=`${0}`;", "whitage", "not_free", "", 0]
-// ["let aa={aa:0};", "whitage", "not_free", "", 0]
+// ["let aa=(0);", "whitage_case", "not_free", "", 0]
+// ["let aa=[0];", "whitage_case", "not_free", "", 0]
+// ["let aa=`${0}`;", "whitage_case", "not_free", "", 0]
+// ["let aa={aa:0};", "whitage_case", "not_free", "", 0]
 
-                        test_cause("not_free");
-                        free = false;
-                        open = false;
+            test_cause("not_free");
+            free = false;
+            open = false;
 
 // test_cause:
 // ["let aa = ( 0 );", "no_space_only", "unexpected_space_a_b", "0", 12]
 
-                        no_space_only();
-                    }
-                }
-                break;
-            default:
-                if (right.statement === true) {
-                    if (left.id === "else") {
+            no_space_only();
+        }
+    }
+
+    function whitage_default() {
+        if (right.statement === true) {
+            if (left.id === "else") {
 
 // test_cause:
 // ["
@@ -9159,26 +9485,41 @@ function jslint_phase5_whitage(state) {
 // }
 // ", "one_space_only", "expected_space_a_b", "if", 9]
 
-                        one_space_only();
-                    } else {
+                one_space_only();
+            } else {
 
 // test_cause:
 // [" let aa = 0;", "expected_at", "expected_a_at_b_c", "1", 2]
 
-                        at_margin(0);
-                        open = false;
-                    }
+                at_margin(0);
+                open = false;
+            }
+            return;
+        }
 
 // If right is a closer, then pop the previous state.
 
-                } else if (right.id === closer) {
-                    pop();
-                    if (opening && right.id !== ";") {
-                        at_margin(0);
-                    } else {
-                        no_space_only();
-                    }
-                } else {
+        if (right.id === closer) {
+            indentage = function_stack.pop();
+            closer = indentage.closer;
+            free = indentage.free;
+            margin = indentage.margin;
+            open = indentage.open;
+            opening = indentage.opening;
+            if (opening && right.id !== ";") {
+                at_margin(
+                    indentage.indent_method
+
+// PR-498 - Relax warning on multiline-method-chaining.
+
+                    ? mode_indent
+                    : 0
+                );
+            } else {
+                no_space_only();
+            }
+            return;
+        }
 
 // Left is not an opener, and right is not a closer.
 // The nature of left and right will determine the space between them.
@@ -9186,10 +9527,12 @@ function jslint_phase5_whitage(state) {
 // If left is ',' or ';' or right is a statement then if open,
 // right must go at the margin, or if closed, a space between.
 
-                    if (right.switch) {
-                        at_margin(-mode_indent);
-                    } else if (right.role === "label") {
-                        if (right.from !== 0) {
+        if (right.switch) {
+            at_margin(-mode_indent);
+            return;
+        }
+        if (right.role === "label") {
+            if (right.from !== 0) {
 
 // test_cause:
 // ["
@@ -9203,19 +9546,21 @@ function jslint_phase5_whitage(state) {
 // }
 // ", "expected_at", "expected_a_at_b_c", "1", 10]
 
-                            expected_at(0);
-                        }
-                    } else if (left.id === ",") {
-                        if (!open || (
-                            (free || closer === "]")
-                            && left.line === right.line
-                        )) {
+                expected_at(0);
+            }
+            return;
+        }
+        if (left.id === ",") {
+            if (!open || (
+                (free || closer === "]")
+                && left.line === right.line
+            )) {
 
 // test_cause:
-// ["let {aa,bb} = 0;", "one_space", "expected_space_a_b", "bb", 9]
+// ["let{aa,bb} = 0;", "one_space", "expected_space_a_b", "bb", 8]
 
-                            one_space();
-                        } else {
+                one_space();
+            } else {
 
 // test_cause:
 // ["
@@ -9226,13 +9571,15 @@ function jslint_phase5_whitage(state) {
 // }
 // ", "expected_at", "expected_a_at_b_c", "9", 11]
 
-                            at_margin(0);
-                        }
+                at_margin(0);
+            }
+            return;
+        }
 
 // If right is a ternary operator, line it up on the margin.
 
-                    } else if (right.arity === "ternary") {
-                        if (open) {
+        if (right.arity === "ternary") {
+            if (open) {
 
 // test_cause:
 // ["
@@ -9243,48 +9590,68 @@ function jslint_phase5_whitage(state) {
 // );
 // ", "expected_at", "expected_a_at_b_c", "5", 1]
 
-                            at_margin(0);
-                        } else {
+                at_margin(0);
+            } else {
 
 // test_cause:
-// ["let aa = (aa ? 0 : 1);", "whitage", "use_open", "?", 14]
+// ["let aa = (aa ? 0 : 1);", "whitage_default", "use_open", "?", 14]
 
-                            warn("use_open", right);
-                        }
-                    } else if (
-                        right.arity === "binary"
-                        && right.id === "("
-                        && free
-                    ) {
+                warn("use_open", right);
+            }
+            return;
+        }
+        if (
+            right.arity === "binary"
+            && right.id === "("
+            && free
+        ) {
 
 // test_cause:
 // ["let aa = aa(\naa ()\n);", "no_space", "unexpected_space_a_b", "(", 4]
 
-                        no_space();
-                    } else if (
-                        left.id === "."
-                        || left.id === "?."
-                        || left.id === "..."
-                        || right.id === ","
-                        || right.id === ";"
-                        || right.id === ":"
-                        || (
-                            right.arity === "binary"
-                            && (right.id === "(" || right.id === "[")
-                        )
-                        || (
-                            right.arity === "function"
-                            && left.id !== "function"
-                        )
-                        || (right.id === "." || right.id === "?.")
-                    ) {
+            no_space();
+            return;
+        }
+        if (
+            left.id === "."
+            || left.id === "?."
+            || left.id === "..."
+            || right.id === ","
+            || right.id === ";"
+            || right.id === ":"
+            || (
+                right.arity === "binary"
+                && (right.id === "(" || right.id === "[")
+            )
+            || (
+                right.arity === "function"
+                && left.id !== "function"
+            )
+        ) {
 
 // test_cause:
 // ["let aa = 0 ;", "no_space_only", "unexpected_space_a_b", ";", 12]
+
+            no_space_only();
+            return;
+        }
+        if (right.id === "." || right.id === "?.") {
+            if (left.line === right.line) {
+
+// test_cause:
 // ["let aa = aa ?.aa;", "no_space_only", "unexpected_space_a_b", "?.", 13]
 
-                        no_space_only();
-                    } else if (left.id === ";") {
+                no_space_only();
+            } else {
+
+// PR-498 - Relax warning on multiline-method-chaining.
+
+                indent_method_dict[right.line] = true;
+                at_margin(mode_indent);
+            }
+            return;
+        }
+        if (left.id === ";") {
 
 // test_cause:
 // ["
@@ -9300,23 +9667,25 @@ function jslint_phase5_whitage(state) {
 // }
 // ", "expected_at", "expected_a_at_b_c", "9", 1]
 
-                        if (open) {
-                            at_margin(0);
-                        }
-                    } else if (
-                        left.arity === "ternary"
-                        || left.id === "case"
-                        || left.id === "catch"
-                        || left.id === "else"
-                        || left.id === "finally"
-                        || left.id === "while"
-                        || left.id === "await"
-                        || right.id === "catch"
-                        || right.id === "else"
-                        || right.id === "finally"
-                        || (right.id === "while" && !right.statement)
-                        || (left.id === ")" && right.id === "{")
-                    ) {
+            if (open) {
+                at_margin(0);
+            }
+            return;
+        }
+        if (
+            left.arity === "ternary"
+            || left.id === "case"
+            || left.id === "catch"
+            || left.id === "else"
+            || left.id === "finally"
+            || left.id === "while"
+            || left.id === "await"
+            || right.id === "catch"
+            || right.id === "else"
+            || right.id === "finally"
+            || (right.id === "while" && !right.statement)
+            || (left.id === ")" && right.id === "{")
+        ) {
 
 // test_cause:
 // ["
@@ -9327,58 +9696,106 @@ function jslint_phase5_whitage(state) {
 // }
 // ", "one_space_only", "expected_space_a_b", "(", 12]
 
-                        one_space_only();
-                    } else if (
+            one_space_only();
+            return;
+        }
+        if (
 
 // There is a space between left and right.
 
-                        spaceop[left.id] === true
-                        || spaceop[right.id] === true
-                        || (
-                            left.arity === "binary"
-                            && (left.id === "+" || left.id === "-")
-                        )
-                        || (
-                            right.arity === "binary"
-                            && (right.id === "+" || right.id === "-")
-                        )
-                        || left.id === "function"
-                        || left.id === ":"
-                        || left.id === "async"
-                        || (
-                            (
-                                left.identifier
-                                || left.id === "(string)"
-                                || left.id === "(number)"
-                            )
-                            && (
-                                right.identifier
-                                || right.id === "(string)"
-                                || right.id === "(number)"
-                            )
-                        )
-                        || (left.arity === "statement" && right.id !== ";")
-                    ) {
+            spaceop[left.id] === true
+            || spaceop[right.id] === true
+            || (
+                left.arity === "binary"
+                && (left.id === "+" || left.id === "-")
+            )
+            || (
+                right.arity === "binary"
+                && (right.id === "+" || right.id === "-")
+            )
+            || left.id === "function"
+            || left.id === ":"
+            || left.id === "async"
+            || (
+                (
+                    left.identifier
+                    || left.id === "(string)"
+                    || left.id === "(number)"
+                )
+                && (
+                    right.identifier
+                    || right.id === "(string)"
+                    || right.id === "(number)"
+                )
+            )
+            || (left.arity === "statement" && right.id !== ";")
+        ) {
 
 // test_cause:
 // ["let aa=0;", "one_space", "expected_space_a_b", "0", 8]
 // ["let aa={\naa:\n0\n};", "expected_at", "expected_a_at_b_c", "5", 1]
 
-                        one_space();
-                    } else if (left.arity === "unary" && left.id !== "`") {
-                        no_space_only();
-                    }
-                }
-            }
-            nr_comments_skipped = 0;
-            delete left.calls;
-            delete left.dead;
-            delete left.free;
-            delete left.init;
-            delete left.open;
-            delete left.used;
-            left = right;
+            one_space();
+            return;
+        }
+        if (left.arity === "unary" && left.id !== "`") {
+            no_space_only();
+            return;
+        }
+    }
+
+// uninitialized_and_unused();
+// Delve into the functions looking for variables that were not initialized
+// or used. If the file imports or exports, then its global object is also
+// delved.
+
+    if (state.mode_module === true || option_dict.node) {
+        delve(token_global);
+    }
+    catch_list.forEach(delve);
+    function_list.forEach(delve);
+
+    if (option_dict.white) {
+        return;
+    }
+
+// whitage();
+// Go through the token list, looking at usage of whitespace.
+
+    token_list.forEach(function (the_token) {
+        right = the_token;
+        if (right.id === "(comment)" || right.id === "(end)") {
+            nr_comments_skipped += 1;
+            return;
         }
+
+// If left is an opener and right is not the closer, then push the previous
+// state. If the token following the opener is on the next line, then this is
+// an open form. If the tokens are on the same line, then it is a closed form.
+// Open form is more readable, with each item (statement, argument, parameter,
+// etc) starting on its own line. Closed form is more compact. Statement blocks
+// are always in open form.
+
+// The open and close pairs.
+
+        switch (left.id) {
+        case "${":
+        case "(":
+        case "[":
+        case "{":
+            whitage_case();
+            break;
+        default:
+            whitage_default();
+        }
+        nr_comments_skipped = 0;
+        delete left.calls;
+        delete left.dead;
+        delete left.free;
+        delete left.init;
+        delete left.open;
+        delete left.used;
+        left = right;
     });
 }
 
@@ -9420,10 +9837,10 @@ function jslint_report({
 // Google Lighthouse Accessibility - <dl>'s do not contain only properly-ordered
 // <dt> and <dd> groups, <script>, <template> or <div> elements.
 
-                "<dl>"
-                + "<dt>" + htmlEscape(title) + "</dt>"
-                + "<dd>" + list.join(", ") + "</dd>"
-                + "</dl>"
+                "<dl>" +
+                "<dt>" + htmlEscape(title) + "</dt>" +
+                "<dd>" + list.map(htmlEscape).join(", ") + "</dd>" +
+                "</dl>"
             )
             : ""
         );
@@ -9905,14 +10322,10 @@ pyNj+JctcQLXenBOCms46aMkenIx45WpXqxxVJQLz/vgpmAVa0fmDv6Pue9xVTBPfVxCUGfj\
             level,
             line,
             name,
-
-// Bugfix - fix html-report from crashing if parameters is undefined.
-
-            parameters = [],
+            names = [],
             signature
         } = the_function;
         let list = Object.keys(context);
-        let params;
         html += (
             "<div class=\"level level" + htmlEscape(level) + "\">"
             + address(line, from + 1)
@@ -9932,26 +10345,9 @@ pyNj+JctcQLXenBOCms46aMkenIx45WpXqxxVJQLz/vgpmAVa0fmDv6Pue9xVTBPfVxCUGfj\
             )
             + "</dfn>"
         );
-        params = [];
-        parameters.forEach(function extract({
-            id,
-            names
-        }) {
-            switch (id) {
-            case "[":
-            case "{":
-
-// Recurse extract().
-
-                names.forEach(extract);
-                break;
-            case "ignore":
-                break;
-            default:
-                params.push(id);
-            }
-        });
-        html += detail("parameter", params.sort());
+        html += detail("parameter", names.map(function ({id}) {
+            return id;
+        }).sort());
         list.sort();
         html += detail("variable", list.filter(function (id) {
             return (
@@ -11354,13 +11750,9 @@ function sentinel() {}
 // Coverage-hack - Ugly-hack to get test-coverage under both win32 and linux.
 
             if (processArgv0 === "npm") {
-                processArgv0 = process.platform.replace(
-                    "win32",
-                    "npm.cmd"
-                ).replace(
-                    process.platform,
-                    "npm"
-                );
+                processArgv0 = process.platform
+                    .replace("win32", "npm.cmd")
+                    .replace(process.platform, "npm");
             }
             moduleChildProcess.spawn(
                 processArgv0,