eslint 8.45.0 → 8.47.0

package/README.md

@@ -249,6 +249,11 @@ Bryan Mishkin
 <img src="https://github.com/fasttime.png?s=75" width="75" height="75"><br />
 Francesco Trotta
 </a>
+</td><td align="center" valign="top" width="11%">
+<a href="https://github.com/ota-meshi">
+<img src="https://github.com/ota-meshi.png?s=75" width="75" height="75"><br />
+Yosuke Ota
+</a>
 </td></tr></tbody></table>
 
 ### Website Team
@@ -284,7 +289,7 @@ The following companies, organizations, and individuals support ESLint's ongoing
 <p><a href="#"><img src="https://images.opencollective.com/2021-frameworks-fund/logo.png" alt="Chrome Frameworks Fund" height="undefined"></a> <a href="https://automattic.com"><img src="https://images.opencollective.com/automattic/d0ef3e1/logo.png" alt="Automattic" height="undefined"></a></p><h3>Gold Sponsors</h3>
 <p><a href="https://engineering.salesforce.com"><img src="https://images.opencollective.com/salesforce/ca8f997/logo.png" alt="Salesforce" height="96"></a> <a href="https://www.airbnb.com/"><img src="https://images.opencollective.com/airbnb/d327d66/logo.png" alt="Airbnb" height="96"></a></p><h3>Silver Sponsors</h3>
 <p><a href="https://sentry.io"><img src="https://avatars.githubusercontent.com/u/1396951?v=4" alt="Sentry" height="64"></a> <a href="https://liftoff.io/"><img src="https://images.opencollective.com/liftoff/5c4fa84/logo.png" alt="Liftoff" height="64"></a> <a href="https://americanexpress.io"><img src="https://avatars.githubusercontent.com/u/3853301?v=4" alt="American Express" height="64"></a></p><h3>Bronze Sponsors</h3>
-<p><a href="https://iboysoft.com/"><img src="https://images.opencollective.com/iboysoft-software/7f9d60e/avatar.png" alt="iBoysoft" height="32"></a> <a href="https://themeisle.com"><img src="https://images.opencollective.com/themeisle/d5592fe/logo.png" alt="ThemeIsle" height="32"></a> <a href="https://nx.dev"><img src="https://images.opencollective.com/nx/0efbe42/logo.png" alt="Nx (by Nrwl)" height="32"></a> <a href="https://www.crosswordsolver.org/anagram-solver/"><img src="https://images.opencollective.com/anagram-solver/2666271/logo.png" alt="Anagram Solver" height="32"></a> <a href="https://icons8.com"><img src="https://images.opencollective.com/icons8/7fa1641/logo.png" alt="Icons8: free icons, photos, illustrations, and music" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://transloadit.com/"><img src="https://avatars.githubusercontent.com/u/125754?v=4" alt="Transloadit" height="32"></a> <a href="https://www.ignitionapp.com"><img src="https://avatars.githubusercontent.com/u/5753491?v=4" alt="Ignition" height="32"></a> <a href="https://opensource.mercedes-benz.com/"><img src="https://avatars.githubusercontent.com/u/34240465?v=4" alt="Mercedes-Benz Group" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774?v=4" alt="HeroCoders" height="32"></a> <a href="https://quickbookstoolhub.com"><img src="https://avatars.githubusercontent.com/u/95090305?u=e5bc398ef775c9ed19f955c675cdc1fb6abf01df&v=4" alt="QuickBooks Tool hub" height="32"></a></p>
+<p><a href="https://themeisle.com"><img src="https://images.opencollective.com/themeisle/d5592fe/logo.png" alt="ThemeIsle" height="32"></a> <a href="https://nx.dev"><img src="https://images.opencollective.com/nx/0efbe42/logo.png" alt="Nx (by Nrwl)" height="32"></a> <a href="https://www.crosswordsolver.org/anagram-solver/"><img src="https://images.opencollective.com/anagram-solver/2666271/logo.png" alt="Anagram Solver" height="32"></a> <a href="https://icons8.com"><img src="https://images.opencollective.com/icons8/7fa1641/logo.png" alt="Icons8: free icons, photos, illustrations, and music" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://github.com/about"><img src="https://avatars.githubusercontent.com/u/9919?v=4" alt="GitHub" height="32"></a> <a href="https://transloadit.com/"><img src="https://avatars.githubusercontent.com/u/125754?v=4" alt="Transloadit" height="32"></a> <a href="https://www.ignitionapp.com"><img src="https://avatars.githubusercontent.com/u/5753491?v=4" alt="Ignition" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774?v=4" alt="HeroCoders" height="32"></a> <a href="https://quickbookstoolhub.com"><img src="https://avatars.githubusercontent.com/u/95090305?u=e5bc398ef775c9ed19f955c675cdc1fb6abf01df&v=4" alt="QuickBooks Tool hub" height="32"></a></p>
 <!--sponsorsend-->
 
 ## Technology Sponsors

package/lib/config/flat-config-schema.js

@@ -212,6 +212,38 @@ function assertIsObject(value) {
     }
 }
 
+/**
+ * The error type when there's an eslintrc-style options in a flat config.
+ */
+class IncompatibleKeyError extends Error {
+
+    /**
+     * @param {string} key The invalid key.
+     */
+    constructor(key) {
+        super("This appears to be in eslintrc format rather than flat config format.");
+        this.messageTemplate = "eslintrc-incompat";
+        this.messageData = { key };
+    }
+}
+
+/**
+ * The error type when there's an eslintrc-style plugins array found.
+ */
+class IncompatiblePluginsError extends Error {
+
+    /**
+     * Creates a new instance.
+     * @param {Array<string>} plugins The plugins array.
+     */
+    constructor(plugins) {
+        super("This appears to be in eslintrc format (array of strings) rather than flat config format (object).");
+        this.messageTemplate = "eslintrc-plugins";
+        this.messageData = { plugins };
+    }
+}
+
+
 //-----------------------------------------------------------------------------
 // Low-Level Schemas
 //-----------------------------------------------------------------------------
@@ -303,6 +335,11 @@ const pluginsSchema = {
             throw new TypeError("Expected an object.");
         }
 
+        // make sure it's not an array, which would mean eslintrc-style is used
+        if (Array.isArray(value)) {
+            throw new IncompatiblePluginsError(value);
+        }
+
         // second check the keys to make sure they are objects
         for (const key of Object.keys(value)) {
 
@@ -438,11 +475,44 @@ const sourceTypeSchema = {
     }
 };
 
+/**
+ * Creates a schema that always throws an error. Useful for warning
+ * about eslintrc-style keys.
+ * @param {string} key The eslintrc key to create a schema for.
+ * @returns {ObjectPropertySchema} The schema.
+ */
+function createEslintrcErrorSchema(key) {
+    return {
+        merge: "replace",
+        validate() {
+            throw new IncompatibleKeyError(key);
+        }
+    };
+}
+
+const eslintrcKeys = [
+    "env",
+    "extends",
+    "globals",
+    "ignorePatterns",
+    "noInlineConfig",
+    "overrides",
+    "parser",
+    "parserOptions",
+    "reportUnusedDisableDirectives",
+    "root"
+];
+
 //-----------------------------------------------------------------------------
 // Full schema
 //-----------------------------------------------------------------------------
 
 exports.flatConfigSchema = {
+
+    // eslintrc-style keys that should always error
+    ...Object.fromEntries(eslintrcKeys.map(key => [key, createEslintrcErrorSchema(key)])),
+
+    // flat config keys
     settings: deepObjectAssignSchema,
     linterOptions: {
         schema: {

package/lib/eslint/flat-eslint.js

@@ -714,12 +714,10 @@ class FlatESLint {
                 }
                 const rule = getRuleFromConfig(ruleId, config);
 
-                // ensure the rule exists
-                if (!rule) {
-                    throw new TypeError(`Could not find the rule "${ruleId}".`);
+                // ignore unknown rules
+                if (rule) {
+                    resultRules.set(ruleId, rule);
                 }
-
-                resultRules.set(ruleId, rule);
             }
         }
 

package/lib/rules/no-control-regex.js

@@ -14,6 +14,16 @@ const collector = new (class {
     }
 
     onPatternEnter() {
+
+        /*
+         * `RegExpValidator` may parse the pattern twice in one `validatePattern`.
+         * So `this._controlChars` should be cleared here as well.
+         *
+         * For example, the `/(?<a>\x1f)/` regex will parse the pattern twice.
+         * This is based on the content described in Annex B.
+         * If the regex contains a `GroupName` and the `u` flag is not used, `ParseText` will be called twice.
+         * See https://tc39.es/ecma262/2023/multipage/additional-ecmascript-features-for-web-browsers.html#sec-parsepattern-annexb
+         */
         this._controlChars = [];
     }
 
@@ -32,10 +42,13 @@ const collector = new (class {
 
     collectControlChars(regexpStr, flags) {
         const uFlag = typeof flags === "string" && flags.includes("u");
+        const vFlag = typeof flags === "string" && flags.includes("v");
+
+        this._controlChars = [];
+        this._source = regexpStr;
 
         try {
-            this._source = regexpStr;
-            this._validator.validatePattern(regexpStr, void 0, void 0, uFlag); // Call onCharacter hook
+            this._validator.validatePattern(regexpStr, void 0, void 0, { unicode: uFlag, unicodeSets: vFlag }); // Call onCharacter hook
         } catch {
 
             // Ignore syntax errors in RegExp.

package/lib/rules/no-empty-character-class.js

@@ -5,20 +5,18 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-/*
- * plain-English description of the following regexp:
- * 0. `^` fix the match at the beginning of the string
- * 1. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
- * 1.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
- * 1.1. `\\.`: an escape sequence
- * 1.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
- * 2. `$`: fix the match at the end of the string
- */
-const regex = /^([^\\[]|\\.|\[([^\\\]]|\\.)+\])*$/u;
+const parser = new RegExpParser();
+const QUICK_TEST_REGEX = /\[\]/u;
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -45,9 +43,32 @@ module.exports = {
     create(context) {
         return {
             "Literal[regex]"(node) {
-                if (!regex.test(node.regex.pattern)) {
-                    context.report({ node, messageId: "unexpected" });
+                const { pattern, flags } = node.regex;
+
+                if (!QUICK_TEST_REGEX.test(pattern)) {
+                    return;
                 }
+
+                let regExpAST;
+
+                try {
+                    regExpAST = parser.parsePattern(pattern, 0, pattern.length, {
+                        unicode: flags.includes("u"),
+                        unicodeSets: flags.includes("v")
+                    });
+                } catch {
+
+                    // Ignore regular expressions that regexpp cannot parse
+                    return;
+                }
+
+                visitRegExpAST(regExpAST, {
+                    onCharacterClassEnter(characterClass) {
+                        if (!characterClass.negate && characterClass.elements.length === 0) {
+                            context.report({ node, messageId: "unexpected" });
+                        }
+                    }
+                });
             }
         };
 

package/lib/rules/no-empty-pattern.js

@@ -4,6 +4,8 @@
  */
 "use strict";
 
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -19,7 +21,18 @@ module.exports = {
             url: "https://eslint.org/docs/latest/rules/no-empty-pattern"
         },
 
-        schema: [],
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowObjectPatternsAsParameters: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
 
         messages: {
             unexpected: "Unexpected empty {{type}} pattern."
@@ -27,11 +40,33 @@ module.exports = {
     },
 
     create(context) {
+        const options = context.options[0] || {},
+            allowObjectPatternsAsParameters = options.allowObjectPatternsAsParameters || false;
+
         return {
             ObjectPattern(node) {
-                if (node.properties.length === 0) {
-                    context.report({ node, messageId: "unexpected", data: { type: "object" } });
+
+                if (node.properties.length > 0) {
+                    return;
                 }
+
+                // Allow {} and {} = {} empty object patterns as parameters when allowObjectPatternsAsParameters is true
+                if (
+                    allowObjectPatternsAsParameters &&
+                    (
+                        astUtils.isFunction(node.parent) ||
+                        (
+                            node.parent.type === "AssignmentPattern" &&
+                            astUtils.isFunction(node.parent.parent) &&
+                            node.parent.right.type === "ObjectExpression" &&
+                            node.parent.right.properties.length === 0
+                        )
+                    )
+                ) {
+                    return;
+                }
+
+                context.report({ node, messageId: "unexpected", data: { type: "object" } });
             },
             ArrayPattern(node) {
                 if (node.elements.length === 0) {

package/lib/rules/no-invalid-regexp.js

@@ -10,7 +10,7 @@
 
 const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
 const validator = new RegExpValidator();
-const validFlags = /[dgimsuy]/gu;
+const validFlags = /[dgimsuvy]/gu;
 const undefined1 = void 0;
 
 //------------------------------------------------------------------------------
@@ -108,12 +108,14 @@ module.exports = {
         /**
          * Check syntax error in a given pattern.
          * @param {string} pattern The RegExp pattern to validate.
-         * @param {boolean} uFlag The Unicode flag.
+         * @param {Object} flags The RegExp flags to validate.
+         * @param {boolean} [flags.unicode] The Unicode flag.
+         * @param {boolean} [flags.unicodeSets] The UnicodeSets flag.
          * @returns {string|null} The syntax error.
          */
-        function validateRegExpPattern(pattern, uFlag) {
+        function validateRegExpPattern(pattern, flags) {
             try {
-                validator.validatePattern(pattern, undefined1, undefined1, uFlag);
+                validator.validatePattern(pattern, undefined1, undefined1, flags);
                 return null;
             } catch (err) {
                 return err.message;
@@ -131,10 +133,19 @@ module.exports = {
             }
             try {
                 validator.validateFlags(flags);
-                return null;
             } catch {
                 return `Invalid flags supplied to RegExp constructor '${flags}'`;
             }
+
+            /*
+             * `regexpp` checks the combination of `u` and `v` flags when parsing `Pattern` according to `ecma262`,
+             * but this rule may check only the flag when the pattern is unidentifiable, so check it here.
+             * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern
+             */
+            if (flags.includes("u") && flags.includes("v")) {
+                return "Regex 'u' and 'v' flags cannot be used together";
+            }
+            return null;
         }
 
         return {
@@ -166,8 +177,12 @@ module.exports = {
 
                     // If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
                     flags === null
-                        ? validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)
-                        : validateRegExpPattern(pattern, flags.includes("u"))
+                        ? (
+                            validateRegExpPattern(pattern, { unicode: true, unicodeSets: false }) &&
+                            validateRegExpPattern(pattern, { unicode: false, unicodeSets: true }) &&
+                            validateRegExpPattern(pattern, { unicode: false, unicodeSets: false })
+                        )
+                        : validateRegExpPattern(pattern, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") })
                 );
 
                 if (message) {

package/lib/rules/no-loop-func.js

@@ -186,7 +186,7 @@ module.exports = {
             }
 
             const references = sourceCode.getScope(node).through;
-            const unsafeRefs = references.filter(r => !isSafe(loopNode, r)).map(r => r.identifier.name);
+            const unsafeRefs = references.filter(r => r.resolved && !isSafe(loopNode, r)).map(r => r.identifier.name);
 
             if (unsafeRefs.length > 0) {
                 context.report({

package/lib/rules/no-misleading-character-class.js

@@ -18,7 +18,7 @@ const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
  *
  * CharacterClassRange syntax can steal a part of character sequence,
  * so this function reverts CharacterClassRange syntax and restore the sequence.
- * @param {regexpp.AST.CharacterClassElement[]} nodes The node list to iterate character sequences.
+ * @param {import('@eslint-community/regexpp').AST.CharacterClassElement[]} nodes The node list to iterate character sequences.
  * @returns {IterableIterator<number[]>} The list of character sequences.
  */
 function *iterateCharacterSequence(nodes) {
@@ -37,6 +37,9 @@ function *iterateCharacterSequence(nodes) {
                 break;
 
             case "CharacterSet":
+            case "CharacterClass": // [[]] nesting character class
+            case "ClassStringDisjunction": // \q{...}
+            case "ExpressionCharacterClass": // [A--B]
                 if (seq.length > 0) {
                     yield seq;
                     seq = [];
@@ -144,7 +147,10 @@ module.exports = {
                     pattern,
                     0,
                     pattern.length,
-                    flags.includes("u")
+                    {
+                        unicode: flags.includes("u"),
+                        unicodeSets: flags.includes("v")
+                    }
                 );
             } catch {
 

package/lib/rules/no-new-wrappers.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { getVariableByName } = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -28,18 +34,24 @@ module.exports = {
     },
 
     create(context) {
+        const { sourceCode } = context;
 
         return {
 
             NewExpression(node) {
                 const wrapperObjects = ["String", "Number", "Boolean"];
-
-                if (wrapperObjects.includes(node.callee.name)) {
-                    context.report({
-                        node,
-                        messageId: "noConstructor",
-                        data: { fn: node.callee.name }
-                    });
+                const { name } = node.callee;
+
+                if (wrapperObjects.includes(name)) {
+                    const variable = getVariableByName(sourceCode.getScope(node), name);
+
+                    if (variable && variable.identifiers.length === 0) {
+                        context.report({
+                            node,
+                            messageId: "noConstructor",
+                            data: { fn: name }
+                        });
+                    }
                 }
             }
         };

package/lib/rules/no-regex-spaces.js

@@ -77,7 +77,7 @@ module.exports = {
             let regExpAST;
 
             try {
-                regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, flags.includes("u"));
+                regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
             } catch {
 
                 // Ignore regular expressions with syntax errors
@@ -155,13 +155,28 @@ module.exports = {
             const regExpVar = astUtils.getVariableByName(scope, "RegExp");
             const shadowed = regExpVar && regExpVar.defs.length > 0;
             const patternNode = node.arguments[0];
-            const flagsNode = node.arguments[1];
 
             if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(patternNode) && !shadowed) {
                 const pattern = patternNode.value;
                 const rawPattern = patternNode.raw.slice(1, -1);
                 const rawPatternStartRange = patternNode.range[0] + 1;
-                const flags = isString(flagsNode) ? flagsNode.value : "";
+                let flags;
+
+                if (node.arguments.length < 2) {
+
+                    // It has no flags.
+                    flags = "";
+                } else {
+                    const flagsNode = node.arguments[1];
+
+                    if (isString(flagsNode)) {
+                        flags = flagsNode.value;
+                    } else {
+
+                        // The flags cannot be determined.
+                        return;
+                    }
+                }
 
                 checkRegex(
                     node,

package/lib/rules/no-return-await.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Disallows unnecessary `return await`
  * @author Jordan Harband
+ * @deprecated in ESLint v8.46.0
  */
 "use strict";
 
@@ -26,6 +27,10 @@ module.exports = {
 
         fixable: null,
 
+        deprecated: true,
+
+        replacedBy: [],
+
         schema: [
         ],
 

package/lib/rules/no-useless-backreference.js

@@ -95,7 +95,7 @@ module.exports = {
             let regExpAST;
 
             try {
-                regExpAST = parser.parsePattern(pattern, 0, pattern.length, flags.includes("u"));
+                regExpAST = parser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
             } catch {
 
                 // Ignore regular expressions with syntax errors

package/lib/rules/no-useless-escape.js

@@ -6,7 +6,12 @@
 "use strict";
 
 const astUtils = require("./utils/ast-utils");
+const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
 
+/**
+ * @typedef {import('@eslint-community/regexpp').AST.CharacterClass} CharacterClass
+ * @typedef {import('@eslint-community/regexpp').AST.ExpressionCharacterClass} ExpressionCharacterClass
+ */
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -28,55 +33,17 @@ const VALID_STRING_ESCAPES = union(new Set("\\nrvtbfux"), astUtils.LINEBREAKS);
 const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnpPrsStvwWxu0123456789]");
 const REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("^/.$*+?[{}|()Bk"));
 
-/**
- * Parses a regular expression into a list of characters with character class info.
- * @param {string} regExpText The raw text used to create the regular expression
- * @returns {Object[]} A list of characters, each with info on escaping and whether they're in a character class.
- * @example
- *
- * parseRegExp("a\\b[cd-]");
- *
- * // returns:
- * [
- *     { text: "a", index: 0, escaped: false, inCharClass: false, startsCharClass: false, endsCharClass: false },
- *     { text: "b", index: 2, escaped: true, inCharClass: false, startsCharClass: false, endsCharClass: false },
- *     { text: "c", index: 4, escaped: false, inCharClass: true, startsCharClass: true, endsCharClass: false },
- *     { text: "d", index: 5, escaped: false, inCharClass: true, startsCharClass: false, endsCharClass: false },
- *     { text: "-", index: 6, escaped: false, inCharClass: true, startsCharClass: false, endsCharClass: false }
- * ];
- *
+/*
+ * Set of characters that require escaping in character classes in `unicodeSets` mode.
+ * ( ) [ ] { } / - \ | are ClassSetSyntaxCharacter
  */
-function parseRegExp(regExpText) {
-    const charList = [];
+const REGEX_CLASSSET_CHARACTER_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("q/[{}|()-"));
 
-    regExpText.split("").reduce((state, char, index) => {
-        if (!state.escapeNextChar) {
-            if (char === "\\") {
-                return Object.assign(state, { escapeNextChar: true });
-            }
-            if (char === "[" && !state.inCharClass) {
-                return Object.assign(state, { inCharClass: true, startingCharClass: true });
-            }
-            if (char === "]" && state.inCharClass) {
-                if (charList.length && charList[charList.length - 1].inCharClass) {
-                    charList[charList.length - 1].endsCharClass = true;
-                }
-                return Object.assign(state, { inCharClass: false, startingCharClass: false });
-            }
-        }
-        charList.push({
-            text: char,
-            index,
-            escaped: state.escapeNextChar,
-            inCharClass: state.inCharClass,
-            startsCharClass: state.startingCharClass,
-            endsCharClass: false
-        });
-        return Object.assign(state, { escapeNextChar: false, startingCharClass: false });
-    }, { escapeNextChar: false, inCharClass: false, startingCharClass: false });
-
-    return charList;
-}
+/*
+ * A single character set of ClassSetReservedDoublePunctuator.
+ * && !! ## $$ %% ** ++ ,, .. :: ;; << == >> ?? @@ ^^ `` ~~ are ClassSetReservedDoublePunctuator
+ */
+const REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR = new Set("!#$%&*+,.:;<=>?@^`~");
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
@@ -103,15 +70,17 @@ module.exports = {
 
     create(context) {
         const sourceCode = context.sourceCode;
+        const parser = new RegExpParser();
 
         /**
          * Reports a node
          * @param {ASTNode} node The node to report
          * @param {number} startOffset The backslash's offset from the start of the node
          * @param {string} character The uselessly escaped character (not including the backslash)
+         * @param {boolean} [disableEscapeBackslashSuggest] `true` if escapeBackslash suggestion should be turned off.
          * @returns {void}
          */
-        function report(node, startOffset, character) {
+        function report(node, startOffset, character, disableEscapeBackslashSuggest) {
             const rangeStart = node.range[0] + startOffset;
             const range = [rangeStart, rangeStart + 1];
             const start = sourceCode.getLocFromIndex(rangeStart);
@@ -134,12 +103,16 @@ module.exports = {
                             return fixer.removeRange(range);
                         }
                     },
-                    {
-                        messageId: "escapeBackslash",
-                        fix(fixer) {
-                            return fixer.insertTextBeforeRange(range, "\\");
-                        }
-                    }
+                    ...disableEscapeBackslashSuggest
+                        ? []
+                        : [
+                            {
+                                messageId: "escapeBackslash",
+                                fix(fixer) {
+                                    return fixer.insertTextBeforeRange(range, "\\");
+                                }
+                            }
+                        ]
                 ]
             });
         }
@@ -182,6 +155,133 @@ module.exports = {
             }
         }
 
+        /**
+         * Checks if the escape character in given regexp is unnecessary.
+         * @private
+         * @param {ASTNode} node node to validate.
+         * @returns {void}
+         */
+        function validateRegExp(node) {
+            const { pattern, flags } = node.regex;
+            let patternNode;
+            const unicode = flags.includes("u");
+            const unicodeSets = flags.includes("v");
+
+            try {
+                patternNode = parser.parsePattern(pattern, 0, pattern.length, { unicode, unicodeSets });
+            } catch {
+
+                // Ignore regular expressions with syntax errors
+                return;
+            }
+
+            /** @type {(CharacterClass | ExpressionCharacterClass)[]} */
+            const characterClassStack = [];
+
+            visitRegExpAST(patternNode, {
+                onCharacterClassEnter: characterClassNode => characterClassStack.unshift(characterClassNode),
+                onCharacterClassLeave: () => characterClassStack.shift(),
+                onExpressionCharacterClassEnter: characterClassNode => characterClassStack.unshift(characterClassNode),
+                onExpressionCharacterClassLeave: () => characterClassStack.shift(),
+                onCharacterEnter(characterNode) {
+                    if (!characterNode.raw.startsWith("\\")) {
+
+                        // It's not an escaped character.
+                        return;
+                    }
+
+                    const escapedChar = characterNode.raw.slice(1);
+
+                    if (escapedChar !== String.fromCodePoint(characterNode.value)) {
+
+                        // It's a valid escape.
+                        return;
+                    }
+                    let allowedEscapes;
+
+                    if (characterClassStack.length) {
+                        allowedEscapes = unicodeSets ? REGEX_CLASSSET_CHARACTER_ESCAPES : REGEX_GENERAL_ESCAPES;
+                    } else {
+                        allowedEscapes = REGEX_NON_CHARCLASS_ESCAPES;
+                    }
+                    if (allowedEscapes.has(escapedChar)) {
+                        return;
+                    }
+
+                    const reportedIndex = characterNode.start + 1;
+                    let disableEscapeBackslashSuggest = false;
+
+                    if (characterClassStack.length) {
+                        const characterClassNode = characterClassStack[0];
+
+                        if (escapedChar === "^") {
+
+                            /*
+                             * The '^' character is also a special case; it must always be escaped outside of character classes, but
+                             * it only needs to be escaped in character classes if it's at the beginning of the character class. To
+                             * account for this, consider it to be a valid escape character outside of character classes, and filter
+                             * out '^' characters that appear at the start of a character class.
+                             */
+                            if (characterClassNode.start + 1 === characterNode.start) {
+
+                                return;
+                            }
+                        }
+                        if (!unicodeSets) {
+                            if (escapedChar === "-") {
+
+                                /*
+                                 * The '-' character is a special case, because it's only valid to escape it if it's in a character
+                                 * class, and is not at either edge of the character class. To account for this, don't consider '-'
+                                 * characters to be valid in general, and filter out '-' characters that appear in the middle of a
+                                 * character class.
+                                 */
+                                if (characterClassNode.start + 1 !== characterNode.start && characterNode.end !== characterClassNode.end - 1) {
+
+                                    return;
+                                }
+                            }
+                        } else { // unicodeSets mode
+                            if (REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR.has(escapedChar)) {
+
+                                // Escaping is valid if it is a ClassSetReservedDoublePunctuator.
+                                if (pattern[characterNode.end] === escapedChar) {
+                                    return;
+                                }
+                                if (pattern[characterNode.start - 1] === escapedChar) {
+                                    if (escapedChar !== "^") {
+                                        return;
+                                    }
+
+                                    // If the previous character is a `negate` caret(`^`), escape to caret is unnecessary.
+
+                                    if (!characterClassNode.negate) {
+                                        return;
+                                    }
+                                    const negateCaretIndex = characterClassNode.start + 1;
+
+                                    if (negateCaretIndex < characterNode.start - 1) {
+                                        return;
+                                    }
+                                }
+                            }
+
+                            if (characterNode.parent.type === "ClassIntersection" || characterNode.parent.type === "ClassSubtraction") {
+                                disableEscapeBackslashSuggest = true;
+                            }
+                        }
+                    }
+
+                    report(
+                        node,
+                        reportedIndex,
+                        escapedChar,
+                        disableEscapeBackslashSuggest
+                    );
+                }
+            });
+        }
+
         /**
          * Checks if a node has an escape.
          * @param {ASTNode} node node to check.
@@ -220,32 +320,7 @@ module.exports = {
                     validateString(node, match);
                 }
             } else if (node.regex) {
-                parseRegExp(node.regex.pattern)
-
-                    /*
-                     * The '-' character is a special case, because it's only valid to escape it if it's in a character
-                     * class, and is not at either edge of the character class. To account for this, don't consider '-'
-                     * characters to be valid in general, and filter out '-' characters that appear in the middle of a
-                     * character class.
-                     */
-                    .filter(charInfo => !(charInfo.text === "-" && charInfo.inCharClass && !charInfo.startsCharClass && !charInfo.endsCharClass))
-
-                    /*
-                     * The '^' character is also a special case; it must always be escaped outside of character classes, but
-                     * it only needs to be escaped in character classes if it's at the beginning of the character class. To
-                     * account for this, consider it to be a valid escape character outside of character classes, and filter
-                     * out '^' characters that appear at the start of a character class.
-                     */
-                    .filter(charInfo => !(charInfo.text === "^" && charInfo.startsCharClass))
-
-                    // Filter out characters that aren't escaped.
-                    .filter(charInfo => charInfo.escaped)
-
-                    // Filter out characters that are valid to escape, based on their position in the regular expression.
-                    .filter(charInfo => !(charInfo.inCharClass ? REGEX_GENERAL_ESCAPES : REGEX_NON_CHARCLASS_ESCAPES).has(charInfo.text))
-
-                    // Report all the remaining characters.
-                    .forEach(charInfo => report(node, charInfo.index, charInfo.text));
+                validateRegExp(node);
             }
 
         }

package/lib/rules/prefer-named-capture-group.js

@@ -112,14 +112,17 @@ module.exports = {
          * @param {string} pattern The regular expression pattern to be checked.
          * @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
          * @param {ASTNode} regexNode AST node which contains the regular expression.
-         * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.
+         * @param {string|null} flags The regular expression flags to be checked.
          * @returns {void}
          */
-        function checkRegex(pattern, node, regexNode, uFlag) {
+        function checkRegex(pattern, node, regexNode, flags) {
             let ast;
 
             try {
-                ast = parser.parsePattern(pattern, 0, pattern.length, uFlag);
+                ast = parser.parsePattern(pattern, 0, pattern.length, {
+                    unicode: Boolean(flags && flags.includes("u")),
+                    unicodeSets: Boolean(flags && flags.includes("v"))
+                });
             } catch {
 
                 // ignore regex syntax errors
@@ -148,7 +151,7 @@ module.exports = {
         return {
             Literal(node) {
                 if (node.regex) {
-                    checkRegex(node.regex.pattern, node, node, node.regex.flags.includes("u"));
+                    checkRegex(node.regex.pattern, node, node, node.regex.flags);
                 }
             },
             Program(node) {
@@ -166,7 +169,7 @@ module.exports = {
                     const flags = getStringIfConstant(refNode.arguments[1]);
 
                     if (regex) {
-                        checkRegex(regex, refNode, refNode.arguments[0], flags && flags.includes("u"));
+                        checkRegex(regex, refNode, refNode.arguments[0], flags);
                     }
                 }
             }

package/lib/rules/prefer-regex-literals.js

@@ -241,7 +241,7 @@ module.exports = {
         /**
          * Returns a ecmaVersion compatible for regexpp.
          * @param {number} ecmaVersion The ecmaVersion to convert.
-         * @returns {import("regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
+         * @returns {import("@eslint-community/regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
          */
         function getRegexppEcmaVersion(ecmaVersion) {
             if (ecmaVersion <= 5) {
@@ -297,7 +297,10 @@ module.exports = {
             const validator = new RegExpValidator({ ecmaVersion: regexppEcmaVersion });
 
             try {
-                validator.validatePattern(pattern, 0, pattern.length, flags ? flags.includes("u") : false);
+                validator.validatePattern(pattern, 0, pattern.length, {
+                    unicode: flags ? flags.includes("u") : false,
+                    unicodeSets: flags ? flags.includes("v") : false
+                });
                 if (flags) {
                     validator.validateFlags(flags);
                 }
@@ -461,7 +464,10 @@ module.exports = {
                         if (regexContent && !noFix) {
                             let charIncrease = 0;
 
-                            const ast = new RegExpParser({ ecmaVersion: regexppEcmaVersion }).parsePattern(regexContent, 0, regexContent.length, flags ? flags.includes("u") : false);
+                            const ast = new RegExpParser({ ecmaVersion: regexppEcmaVersion }).parsePattern(regexContent, 0, regexContent.length, {
+                                unicode: flags ? flags.includes("u") : false,
+                                unicodeSets: flags ? flags.includes("v") : false
+                            });
 
                             visitRegExpAST(ast, {
                                 onCharacterEnter(characterNode) {

package/lib/rules/require-unicode-regexp.js

@@ -28,7 +28,7 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "Enforce the use of `u` flag on RegExp",
+            description: "Enforce the use of `u` or `v` flag on RegExp",
             recommended: false,
             url: "https://eslint.org/docs/latest/rules/require-unicode-regexp"
         },
@@ -51,7 +51,7 @@ module.exports = {
             "Literal[regex]"(node) {
                 const flags = node.regex.flags || "";
 
-                if (!flags.includes("u")) {
+                if (!flags.includes("u") && !flags.includes("v")) {
                     context.report({
                         messageId: "requireUFlag",
                         node,
@@ -85,7 +85,7 @@ module.exports = {
                     const pattern = getStringIfConstant(patternNode, scope);
                     const flags = getStringIfConstant(flagsNode, scope);
 
-                    if (!flagsNode || (typeof flags === "string" && !flags.includes("u"))) {
+                    if (!flagsNode || (typeof flags === "string" && !flags.includes("u") && !flags.includes("v"))) {
                         context.report({
                             messageId: "requireUFlag",
                             node: refNode,

package/lib/rules/utils/ast-utils.js

@@ -26,8 +26,8 @@ const {
 
 const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
 const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;
+const arrayMethodWithThisArgPattern = /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|some)$/u;
 const arrayOrTypedArrayPattern = /Array$/u;
-const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u;
 const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;
 const thisTagPattern = /^[\s*]*@this/mu;
 
@@ -467,12 +467,12 @@ function isArrayFromMethod(node) {
 }
 
 /**
- * Checks whether or not a node is a method which has `thisArg`.
+ * Checks whether or not a node is a method which expects a function as a first argument, and `thisArg` as a second argument.
  * @param {ASTNode} node A node to check.
- * @returns {boolean} Whether or not the node is a method which has `thisArg`.
+ * @returns {boolean} Whether or not the node is a method which expects a function as a first argument, and `thisArg` as a second argument.
  */
 function isMethodWhichHasThisArg(node) {
-    return isSpecificMemberAccess(node, null, arrayMethodPattern);
+    return isSpecificMemberAccess(node, null, arrayMethodWithThisArgPattern);
 }
 
 /**

package/lib/rules/utils/regular-expressions.js

@@ -8,7 +8,7 @@
 
 const { RegExpValidator } = require("@eslint-community/regexpp");
 
-const REGEXPP_LATEST_ECMA_VERSION = 2022;
+const REGEXPP_LATEST_ECMA_VERSION = 2024;
 
 /**
  * Checks if the given regular expression pattern would be valid with the `u` flag.
@@ -28,7 +28,7 @@ function isValidWithUnicodeFlag(ecmaVersion, pattern) {
     });
 
     try {
-        validator.validatePattern(pattern, void 0, void 0, /* uFlag = */ true);
+        validator.validatePattern(pattern, void 0, void 0, { unicode: /* uFlag = */ true });
     } catch {
         return false;
     }

package/messages/eslintrc-incompat.js

@@ -0,0 +1,98 @@
+"use strict";
+
+/* eslint consistent-return: 0 -- no default case */
+
+const messages = {
+
+    env: `
+A config object is using the "env" key, which is not supported in flat config system.
+
+Flat config uses "languageOptions.globals" to define global variables for your files.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#configuring-language-options
+`,
+
+    extends: `
+A config object is using the "extends" key, which is not supported in flat config system.
+
+Instead of "extends", you can include config objects that you'd like to extend from directly in the flat config array.
+
+Please see the following page for more information:
+https://eslint.org/docs/latest/use/configure/migration-guide#predefined-configs
+`,
+
+    globals: `
+A config object is using the "globals" key, which is not supported in flat config system.
+
+Flat config uses "languageOptions.globals" to define global variables for your files.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#configuring-language-options
+`,
+
+    ignorePatterns: `
+A config object is using the "ignorePatterns" key, which is not supported in flat config system.
+
+Flat config uses "ignores" to specify files to ignore.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#ignoring-files
+`,
+
+    noInlineConfig: `
+A config object is using the "noInlineConfig" key, which is not supported in flat config system.
+
+Flat config uses "linterOptions.noInlineConfig" to specify files to ignore.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#linter-options
+`,
+
+    overrides: `
+A config object is using the "overrides" key, which is not supported in flat config system.
+
+Flat config is an array that acts like the eslintrc "overrides" array.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#glob-based-configs
+`,
+
+    parser: `
+A config object is using the "parser" key, which is not supported in flat config system.
+
+Flat config uses "languageOptions.parser" to override the default parser.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#custom-parsers
+`,
+
+    parserOptions: `
+A config object is using the "parserOptions" key, which is not supported in flat config system.
+
+Flat config uses "languageOptions.parserOptions" to specify parser options.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#configuring-language-options
+`,
+
+    reportUnusedDisableDirectives: `
+A config object is using the "reportUnusedDisableDirectives" key, which is not supported in flat config system.
+
+Flat config uses "linterOptions.reportUnusedDisableDirectives" to specify files to ignore.
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#linter-options
+`,
+
+    root: `
+A config object is using the "root" key, which is not supported in flat config system.
+
+Flat configs always act as if they are the root config file, so this key can be safely removed.
+`
+};
+
+module.exports = function({ key }) {
+
+    return messages[key].trim();
+};

package/messages/eslintrc-plugins.js

@@ -0,0 +1,24 @@
+"use strict";
+
+module.exports = function({ plugins }) {
+
+    const isArrayOfStrings = typeof plugins[0] === "string";
+
+    return `
+A config object has a "plugins" key defined as an array${isArrayOfStrings ? " of strings" : ""}.
+
+Flat config requires "plugins" to be an object in this form:
+
+    {
+        plugins: {
+            ${isArrayOfStrings && plugins[0] ? plugins[0] : "namespace"}: pluginObject
+        }
+    }
+
+Please see the following page for information on how to convert your config object into the correct format:
+https://eslint.org/docs/latest/use/configure/migration-guide#importing-plugins-and-custom-parsers
+
+If you're using a shareable config that you cannot rewrite in flat config format, then use the compatibility utility:
+https://eslint.org/docs/latest/use/configure/migration-guide#using-eslintrc-configs-in-flat-config
+`;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.45.0",
+  "version": "8.47.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -61,21 +61,21 @@
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
-    "@eslint-community/regexpp": "^4.4.0",
-    "@eslint/eslintrc": "^2.1.0",
-    "@eslint/js": "8.44.0",
+    "@eslint-community/regexpp": "^4.6.1",
+    "@eslint/eslintrc": "^2.1.2",
+    "@eslint/js": "^8.47.0",
     "@humanwhocodes/config-array": "^0.11.10",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
-    "ajv": "^6.10.0",
+    "ajv": "^6.12.4",
     "chalk": "^4.0.0",
     "cross-spawn": "^7.0.2",
     "debug": "^4.3.2",
     "doctrine": "^3.0.0",
     "escape-string-regexp": "^4.0.0",
-    "eslint-scope": "^7.2.0",
-    "eslint-visitor-keys": "^3.4.1",
-    "espree": "^9.6.0",
+    "eslint-scope": "^7.2.2",
+    "eslint-visitor-keys": "^3.4.3",
+    "espree": "^9.6.1",
     "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",