eslint 9.0.0-alpha.1 → 9.0.0-beta.0

package/README.md

@@ -117,7 +117,7 @@ Yes, ESLint natively supports parsing JSX syntax (this must be enabled in [confi
 
 ### What ECMAScript versions does ESLint support?
 
-ESLint has full support for ECMAScript 3, 5 (default), 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, and 2023. You can set your desired ECMAScript syntax (and other settings, like global variables or your target environments) through [configuration](https://eslint.org/docs/latest/use/configure).
+ESLint has full support for ECMAScript 3, 5, and every year from 2015 up until the most recent stage 4 specification (the default). You can set your desired ECMAScript syntax and other settings (like global variables) through [configuration](https://eslint.org/docs/latest/use/configure).
 
 ### What about experimental features?
 
@@ -255,11 +255,6 @@ Josh Goldberg ✨
 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" alt="Yosuke Ota's Avatar"><br />
-Yosuke Ota
-</a>
-</td><td align="center" valign="top" width="11%">
 <a href="https://github.com/Tanujkanti4441">
 <img src="https://github.com/Tanujkanti4441.png?s=75" width="75" height="75" alt="Tanuj Kanti's Avatar"><br />
 Tanuj Kanti
@@ -299,7 +294,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://www.jetbrains.com/"><img src="https://images.opencollective.com/jetbrains/eb04ddc/logo.png" alt="JetBrains" 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> <a href="https://www.workleap.com"><img src="https://avatars.githubusercontent.com/u/53535748?u=d1e55d7661d724bf2281c1bfd33cb8f99fe2465f&v=4" alt="Workleap" height="64"></a></p><h3>Bronze Sponsors</h3>
-<p><a href="https://themeisle.com"><img src="https://images.opencollective.com/themeisle/d5592fe/logo.png" alt="ThemeIsle" 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" 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://nx.dev"><img src="https://avatars.githubusercontent.com/u/23692104?v=4" alt="Nx" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774?v=4" alt="HeroCoders" 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://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" 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://nx.dev"><img src="https://avatars.githubusercontent.com/u/23692104?v=4" alt="Nx" 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://usenextbase.com"><img src="https://avatars.githubusercontent.com/u/145838380?v=4" alt="Nextbase Starter Kit" height="32"></a></p>
 <!--sponsorsend-->
 
 ## Technology Sponsors

package/lib/api.js

@@ -9,17 +9,41 @@
 // Requirements
 //-----------------------------------------------------------------------------
 
-const { ESLint } = require("./eslint/eslint");
+const { ESLint, shouldUseFlatConfig } = require("./eslint/eslint");
+const { LegacyESLint } = require("./eslint/legacy-eslint");
 const { Linter } = require("./linter");
 const { RuleTester } = require("./rule-tester");
 const { SourceCode } = require("./source-code");
 
+//-----------------------------------------------------------------------------
+// Functions
+//-----------------------------------------------------------------------------
+
+/**
+ * Loads the correct ESLint constructor given the options.
+ * @param {Object} [options] The options object
+ * @param {boolean} [options.useFlatConfig] Whether or not to use a flat config
+ * @returns {Promise<ESLint|LegacyESLint>} The ESLint constructor
+ */
+async function loadESLint({ useFlatConfig } = {}) {
+
+    /*
+     * Note: The v8.x version of this function also accepted a `cwd` option, but
+     * it is not used in this implementation so we silently ignore it.
+     */
+
+    const shouldESLintUseFlatConfig = useFlatConfig ?? (await shouldUseFlatConfig());
+
+    return shouldESLintUseFlatConfig ? ESLint : LegacyESLint;
+}
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
 
 module.exports = {
     Linter,
+    loadESLint,
     ESLint,
     RuleTester,
     SourceCode

package/lib/eslint/eslint.js

@@ -565,6 +565,12 @@ function createExtraneousResultsError() {
  */
 class ESLint {
 
+    /**
+     * The type of configuration used by this class.
+     * @type {string}
+     */
+    static configType = "flat";
+
     /**
      * Creates a new instance of the main ESLint API.
      * @param {ESLintOptions} options The options for this instance.
@@ -613,6 +619,13 @@ class ESLint {
             });
         }
 
+        // Check for the .eslintignore file, and warn if it's present.
+        if (existsSync(path.resolve(processedOptions.cwd, ".eslintignore"))) {
+            process.emitWarning(
+                "The \".eslintignore\" file is no longer supported. Switch to using the \"ignores\" property in \"eslint.config.js\": https://eslint.org/docs/latest/use/configure/migration-guide#ignoring-files",
+                "ESLintIgnoreWarning"
+            );
+        }
     }
 
     /**

package/lib/eslint/legacy-eslint.js

@@ -438,6 +438,12 @@ function compareResultsByFilePath(a, b) {
  */
 class LegacyESLint {
 
+    /**
+     * The type of configuration used by this class.
+     * @type {string}
+     */
+    static configType = "eslintrc";
+
     /**
      * Creates a new instance of the main ESLint API.
      * @param {LegacyESLintOptions} options The options for this instance.

package/lib/linter/code-path-analysis/code-path.js

@@ -177,8 +177,8 @@ class CodePath {
         // tracks the traversal steps
         const stack = [[startSegment, 0]];
 
-        // tracks the last skipped segment during traversal
-        let skippedSegment = null;
+        // segments that have been skipped during traversal
+        const skipped = new Set();
 
         // indicates if we exited early from the traversal
         let broken = false;
@@ -193,11 +193,7 @@ class CodePath {
              * @returns {void}
              */
             skip() {
-                if (stack.length <= 1) {
-                    broken = true;
-                } else {
-                    skippedSegment = stack.at(-2)[0];
-                }
+                skipped.add(segment);
             },
 
             /**
@@ -222,6 +218,18 @@ class CodePath {
             );
         }
 
+        /**
+         * Checks if a given previous segment has been skipped.
+         * @param {CodePathSegment} prevSegment A previous segment to check.
+         * @returns {boolean} `true` if the segment has been skipped.
+         */
+        function isSkipped(prevSegment) {
+            return (
+                skipped.has(prevSegment) ||
+                segment.isLoopedPrevSegment(prevSegment)
+            );
+        }
+
         // the traversal
         while (stack.length > 0) {
 
@@ -258,17 +266,21 @@ class CodePath {
                     continue;
                 }
 
-                // Reset the skipping flag if all branches have been skipped.
-                if (skippedSegment && segment.prevSegments.includes(skippedSegment)) {
-                    skippedSegment = null;
-                }
                 visited.add(segment);
 
+
+                // Skips the segment if all previous segments have been skipped.
+                const shouldSkip = (
+                    skipped.size > 0 &&
+                    segment.prevSegments.length > 0 &&
+                    segment.prevSegments.every(isSkipped)
+                );
+
                 /*
                  * If the most recent segment hasn't been skipped, then we call
                  * the callback, passing in the segment and the controller.
                  */
-                if (!skippedSegment) {
+                if (!shouldSkip) {
                     resolvedCallback.call(this, segment, controller);
 
                     // exit if we're at the last segment
@@ -284,6 +296,10 @@ class CodePath {
                     if (broken) {
                         break;
                     }
+                } else {
+
+                    // If the most recent segment has been skipped, then mark it as skipped.
+                    skipped.add(segment);
                 }
             }
 

package/lib/linter/index.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const { Linter } = require("./linter");
-const interpolate = require("./interpolate");
+const { interpolate } = require("./interpolate");
 const SourceCodeFixer = require("./source-code-fixer");
 
 module.exports = {

package/lib/linter/interpolate.js

@@ -9,13 +9,30 @@
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = (text, data) => {
+/**
+ * Returns a global expression matching placeholders in messages.
+ * @returns {RegExp} Global regular expression matching placeholders
+ */
+function getPlaceholderMatcher() {
+    return /\{\{([^{}]+?)\}\}/gu;
+}
+
+/**
+ * Replaces {{ placeholders }} in the message with the provided data.
+ * Does not replace placeholders not available in the data.
+ * @param {string} text Original message with potential placeholders
+ * @param {Record<string, string>} data Map of placeholder name to its value
+ * @returns {string} Message with replaced placeholders
+ */
+function interpolate(text, data) {
     if (!data) {
         return text;
     }
 
+    const matcher = getPlaceholderMatcher();
+
     // Substitution content for any {{ }} markers.
-    return text.replace(/\{\{([^{}]+?)\}\}/gu, (fullMatch, termWithWhitespace) => {
+    return text.replace(matcher, (fullMatch, termWithWhitespace) => {
         const term = termWithWhitespace.trim();
 
         if (term in data) {
@@ -25,4 +42,9 @@ module.exports = (text, data) => {
         // Preserve old behavior: If parameter name not provided, don't replace it.
         return fullMatch;
     });
+}
+
+module.exports = {
+    getPlaceholderMatcher,
+    interpolate
 };

package/lib/linter/report-translator.js

@@ -11,7 +11,7 @@
 
 const assert = require("assert");
 const ruleFixer = require("./rule-fixer");
-const interpolate = require("./interpolate");
+const { interpolate } = require("./interpolate");
 
 //------------------------------------------------------------------------------
 // Typedefs

package/lib/rule-tester/rule-tester.js

@@ -13,10 +13,13 @@
 const
     assert = require("assert"),
     util = require("util"),
+    path = require("path"),
     equal = require("fast-deep-equal"),
     Traverser = require("../shared/traverser"),
     { getRuleOptionsSchema } = require("../config/flat-config-helpers"),
-    { Linter, SourceCodeFixer, interpolate } = require("../linter");
+    { Linter, SourceCodeFixer } = require("../linter"),
+    { interpolate, getPlaceholderMatcher } = require("../linter/interpolate"),
+    stringify = require("json-stable-stringify-without-jsonify");
 
 const { FlatConfigArray } = require("../config/flat-config-array");
 const { defaultConfig } = require("../config/default-config");
@@ -26,6 +29,7 @@ const ajv = require("../shared/ajv")({ strictDefaults: true });
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 const { SourceCode } = require("../source-code");
 const { ConfigArraySymbol } = require("@humanwhocodes/config-array");
+const { isSerializable } = require("../shared/serialization");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -301,6 +305,39 @@ function throwForbiddenMethodError(methodName, prototype) {
     };
 }
 
+/**
+ * Extracts names of {{ placeholders }} from the reported message.
+ * @param   {string} message Reported message
+ * @returns {string[]} Array of placeholder names
+ */
+function getMessagePlaceholders(message) {
+    const matcher = getPlaceholderMatcher();
+
+    return Array.from(message.matchAll(matcher), ([, name]) => name.trim());
+}
+
+/**
+ * Returns the placeholders in the reported messages but
+ * only includes the placeholders available in the raw message and not in the provided data.
+ * @param {string} message The reported message
+ * @param {string} raw The raw message specified in the rule meta.messages
+ * @param {undefined|Record<unknown, unknown>} data The passed
+ * @returns {string[]} Missing placeholder names
+ */
+function getUnsubstitutedMessagePlaceholders(message, raw, data = {}) {
+    const unsubstituted = getMessagePlaceholders(message);
+
+    if (unsubstituted.length === 0) {
+        return [];
+    }
+
+    // Remove false positives by only counting placeholders in the raw message, which were not provided in the data matcher or added with a data property
+    const known = getMessagePlaceholders(raw);
+    const provided = Object.keys(data);
+
+    return unsubstituted.filter(name => known.includes(name) && !provided.includes(name));
+}
+
 const metaSchemaDescription = `
 \t- If the rule has options, set \`meta.schema\` to an array or non-empty object to enable options validation.
 \t- If the rule doesn't have options, omit \`meta.schema\` to enforce that no options can be passed to the rule.
@@ -499,6 +536,9 @@ class RuleTester {
             linter = this.linter,
             ruleId = `rule-to-test/${ruleName}`;
 
+        const seenValidTestCases = new Set();
+        const seenInvalidTestCases = new Set();
+
         if (!rule || typeof rule !== "object" || typeof rule.create !== "function") {
             throw new TypeError("Rule must be an object with a `create` method");
         }
@@ -577,7 +617,15 @@ class RuleTester {
          * @private
          */
         function runRuleForItem(item) {
-            const configs = new FlatConfigArray(testerConfig, { baseConfig });
+            const flatConfigArrayOptions = {
+                baseConfig
+            };
+
+            if (item.filename) {
+                flatConfigArrayOptions.basePath = path.parse(item.filename).root;
+            }
+
+            const configs = new FlatConfigArray(testerConfig, flatConfigArrayOptions);
 
             /*
              * Modify the returned config so that the parser is wrapped to catch
@@ -631,7 +679,11 @@ class RuleTester {
                 configs.push(itemConfig);
             }
 
-            if (item.filename) {
+            if (hasOwnProperty(item, "only")) {
+                assert.ok(typeof item.only === "boolean", "Optional test case property 'only' must be a boolean");
+            }
+            if (hasOwnProperty(item, "filename")) {
+                assert.ok(typeof item.filename === "string", "Optional test case property 'filename' must be a string");
                 filename = item.filename;
             }
 
@@ -794,6 +846,32 @@ class RuleTester {
             }
         }
 
+        /**
+         * Check if this test case is a duplicate of one we have seen before.
+         * @param {Object} item test case object
+         * @param {Set<string>} seenTestCases set of serialized test cases we have seen so far (managed by this function)
+         * @returns {void}
+         * @private
+         */
+        function checkDuplicateTestCase(item, seenTestCases) {
+            if (!isSerializable(item)) {
+
+                /*
+                 * If we can't serialize a test case (because it contains a function, RegExp, etc), skip the check.
+                 * This might happen with properties like: options, plugins, settings, languageOptions.parser, languageOptions.parserOptions.
+                 */
+                return;
+            }
+
+            const serializedTestCase = stringify(item);
+
+            assert(
+                !seenTestCases.has(serializedTestCase),
+                "detected duplicate test case"
+            );
+            seenTestCases.add(serializedTestCase);
+        }
+
         /**
          * Check if the template is valid or not
          * all valid cases go through this
@@ -809,6 +887,8 @@ class RuleTester {
                 assert.ok(typeof item.name === "string", "Optional test case property 'name' must be a string");
             }
 
+            checkDuplicateTestCase(item, seenValidTestCases);
+
             const result = runRuleForItem(item);
             const messages = result.messages;
 
@@ -860,6 +940,8 @@ class RuleTester {
                 assert.fail("Invalid cases must have at least one error");
             }
 
+            checkDuplicateTestCase(item, seenInvalidTestCases);
+
             const ruleHasMetaMessages = hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages");
             const friendlyIDList = ruleHasMetaMessages ? `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]` : null;
 
@@ -916,6 +998,7 @@ class RuleTester {
 
                         // Just an error message.
                         assertMessageMatches(message.message, error);
+                        assert.ok(message.suggestions === void 0, `Error at index ${i} has suggestions. Please convert the test error into an object and specify 'suggestions' property on it to test suggestions.`);
                     } else if (typeof error === "object" && error !== null) {
 
                         /*
@@ -948,6 +1031,18 @@ class RuleTester {
                                 error.messageId,
                                 `messageId '${message.messageId}' does not match expected messageId '${error.messageId}'.`
                             );
+
+                            const unsubstitutedPlaceholders = getUnsubstitutedMessagePlaceholders(
+                                message.message,
+                                rule.meta.messages[message.messageId],
+                                error.data
+                            );
+
+                            assert.ok(
+                                unsubstitutedPlaceholders.length === 0,
+                                `The reported message has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property in the context.report() call.`
+                            );
+
                             if (hasOwnProperty(error, "data")) {
 
                                 /*
@@ -964,13 +1059,10 @@ class RuleTester {
                                     `Hydrated message "${rehydratedMessage}" does not match "${message.message}"`
                                 );
                             }
+                        } else {
+                            assert.fail("Test error must specify either a 'messageId' or 'message'.");
                         }
 
-                        assert.ok(
-                            hasOwnProperty(error, "data") ? hasOwnProperty(error, "messageId") : true,
-                            "Error must specify 'messageId' if 'data' is used."
-                        );
-
                         if (error.type) {
                             assert.strictEqual(message.nodeType, error.type, `Error type should be ${error.type}, found ${message.nodeType}`);
                         }
@@ -991,81 +1083,103 @@ class RuleTester {
                             assert.strictEqual(message.endColumn, error.endColumn, `Error endColumn should be ${error.endColumn}`);
                         }
 
+                        assert.ok(!message.suggestions || hasOwnProperty(error, "suggestions"), `Error at index ${i} has suggestions. Please specify 'suggestions' property on the test error object.`);
                         if (hasOwnProperty(error, "suggestions")) {
 
                             // Support asserting there are no suggestions
-                            if (!error.suggestions || (Array.isArray(error.suggestions) && error.suggestions.length === 0)) {
-                                if (Array.isArray(message.suggestions) && message.suggestions.length > 0) {
-                                    assert.fail(`Error should have no suggestions on error with message: "${message.message}"`);
-                                }
-                            } else {
-                                assert.strictEqual(Array.isArray(message.suggestions), true, `Error should have an array of suggestions. Instead received "${message.suggestions}" on error with message: "${message.message}"`);
-                                assert.strictEqual(message.suggestions.length, error.suggestions.length, `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`);
-
-                                error.suggestions.forEach((expectedSuggestion, index) => {
-                                    assert.ok(
-                                        typeof expectedSuggestion === "object" && expectedSuggestion !== null,
-                                        "Test suggestion in 'suggestions' array must be an object."
-                                    );
-                                    Object.keys(expectedSuggestion).forEach(propertyName => {
+                            const expectsSuggestions = Array.isArray(error.suggestions) ? error.suggestions.length > 0 : Boolean(error.suggestions);
+                            const hasSuggestions = message.suggestions !== void 0;
+
+                            if (!hasSuggestions && expectsSuggestions) {
+                                assert.ok(!error.suggestions, `Error should have suggestions on error with message: "${message.message}"`);
+                            } else if (hasSuggestions) {
+                                assert.ok(expectsSuggestions, `Error should have no suggestions on error with message: "${message.message}"`);
+                                if (typeof error.suggestions === "number") {
+                                    assert.strictEqual(message.suggestions.length, error.suggestions, `Error should have ${error.suggestions} suggestions. Instead found ${message.suggestions.length} suggestions`);
+                                } else if (Array.isArray(error.suggestions)) {
+                                    assert.strictEqual(message.suggestions.length, error.suggestions.length, `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`);
+
+                                    error.suggestions.forEach((expectedSuggestion, index) => {
                                         assert.ok(
-                                            suggestionObjectParameters.has(propertyName),
-                                            `Invalid suggestion property name '${propertyName}'. Expected one of ${friendlySuggestionObjectParameterList}.`
+                                            typeof expectedSuggestion === "object" && expectedSuggestion !== null,
+                                            "Test suggestion in 'suggestions' array must be an object."
                                         );
-                                    });
-
-                                    const actualSuggestion = message.suggestions[index];
-                                    const suggestionPrefix = `Error Suggestion at index ${index} :`;
-
-                                    if (hasOwnProperty(expectedSuggestion, "desc")) {
-                                        assert.ok(
-                                            !hasOwnProperty(expectedSuggestion, "data"),
-                                            `${suggestionPrefix} Test should not specify both 'desc' and 'data'.`
-                                        );
-                                        assert.strictEqual(
-                                            actualSuggestion.desc,
-                                            expectedSuggestion.desc,
-                                            `${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`
-                                        );
-                                    }
+                                        Object.keys(expectedSuggestion).forEach(propertyName => {
+                                            assert.ok(
+                                                suggestionObjectParameters.has(propertyName),
+                                                `Invalid suggestion property name '${propertyName}'. Expected one of ${friendlySuggestionObjectParameterList}.`
+                                            );
+                                        });
 
-                                    if (hasOwnProperty(expectedSuggestion, "messageId")) {
-                                        assert.ok(
-                                            ruleHasMetaMessages,
-                                            `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`
-                                        );
-                                        assert.ok(
-                                            hasOwnProperty(rule.meta.messages, expectedSuggestion.messageId),
-                                            `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`
-                                        );
-                                        assert.strictEqual(
-                                            actualSuggestion.messageId,
-                                            expectedSuggestion.messageId,
-                                            `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`
-                                        );
-                                        if (hasOwnProperty(expectedSuggestion, "data")) {
-                                            const unformattedMetaMessage = rule.meta.messages[expectedSuggestion.messageId];
-                                            const rehydratedDesc = interpolate(unformattedMetaMessage, expectedSuggestion.data);
+                                        const actualSuggestion = message.suggestions[index];
+                                        const suggestionPrefix = `Error Suggestion at index ${index}:`;
 
+                                        if (hasOwnProperty(expectedSuggestion, "desc")) {
+                                            assert.ok(
+                                                !hasOwnProperty(expectedSuggestion, "data"),
+                                                `${suggestionPrefix} Test should not specify both 'desc' and 'data'.`
+                                            );
+                                            assert.ok(
+                                                !hasOwnProperty(expectedSuggestion, "messageId"),
+                                                `${suggestionPrefix} Test should not specify both 'desc' and 'messageId'.`
+                                            );
                                             assert.strictEqual(
                                                 actualSuggestion.desc,
-                                                rehydratedDesc,
-                                                `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`
+                                                expectedSuggestion.desc,
+                                                `${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`
+                                            );
+                                        } else if (hasOwnProperty(expectedSuggestion, "messageId")) {
+                                            assert.ok(
+                                                ruleHasMetaMessages,
+                                                `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`
+                                            );
+                                            assert.ok(
+                                                hasOwnProperty(rule.meta.messages, expectedSuggestion.messageId),
+                                                `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`
+                                            );
+                                            assert.strictEqual(
+                                                actualSuggestion.messageId,
+                                                expectedSuggestion.messageId,
+                                                `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`
+                                            );
+
+                                            const unsubstitutedPlaceholders = getUnsubstitutedMessagePlaceholders(
+                                                actualSuggestion.desc,
+                                                rule.meta.messages[expectedSuggestion.messageId],
+                                                expectedSuggestion.data
+                                            );
+
+                                            assert.ok(
+                                                unsubstitutedPlaceholders.length === 0,
+                                                `The message of the suggestion has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property for the suggestion in the context.report() call.`
+                                            );
+
+                                            if (hasOwnProperty(expectedSuggestion, "data")) {
+                                                const unformattedMetaMessage = rule.meta.messages[expectedSuggestion.messageId];
+                                                const rehydratedDesc = interpolate(unformattedMetaMessage, expectedSuggestion.data);
+
+                                                assert.strictEqual(
+                                                    actualSuggestion.desc,
+                                                    rehydratedDesc,
+                                                    `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`
+                                                );
+                                            }
+                                        } else if (hasOwnProperty(expectedSuggestion, "data")) {
+                                            assert.fail(
+                                                `${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`
+                                            );
+                                        } else {
+                                            assert.fail(
+                                                `${suggestionPrefix} Test must specify either 'messageId' or 'desc'.`
                                             );
                                         }
-                                    } else {
-                                        assert.ok(
-                                            !hasOwnProperty(expectedSuggestion, "data"),
-                                            `${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`
-                                        );
-                                    }
 
-                                    if (hasOwnProperty(expectedSuggestion, "output")) {
+                                        assert.ok(hasOwnProperty(expectedSuggestion, "output"), `${suggestionPrefix} The "output" property is required.`);
                                         const codeWithAppliedSuggestion = SourceCodeFixer.applyFixes(item.code, [actualSuggestion]).output;
 
                                         // Verify if suggestion fix makes a syntax error or not.
                                         const errorMessageInSuggestion =
-                                            linter.verify(codeWithAppliedSuggestion, result.configs, result.filename).find(m => m.fatal);
+                                                linter.verify(codeWithAppliedSuggestion, result.configs, result.filename).find(m => m.fatal);
 
                                         assert(!errorMessageInSuggestion, [
                                             "A fatal parsing error occurred in suggestion fix.",
@@ -1075,8 +1189,11 @@ class RuleTester {
                                         ].join("\n"));
 
                                         assert.strictEqual(codeWithAppliedSuggestion, expectedSuggestion.output, `Expected the applied suggestion fix to match the test suggestion output for suggestion at index: ${index} on error with message: "${message.message}"`);
-                                    }
-                                });
+                                        assert.notStrictEqual(expectedSuggestion.output, item.code, `The output of a suggestion should differ from the original source code for suggestion at index: ${index} on error with message: "${message.message}"`);
+                                    });
+                                } else {
+                                    assert.fail("Test error object property 'suggestions' should be an array or a number");
+                                }
                             }
                         }
                     } else {
@@ -1096,6 +1213,7 @@ class RuleTester {
                     );
                 } else {
                     assert.strictEqual(result.output, item.output, "Output is incorrect.");
+                    assert.notStrictEqual(item.code, item.output, "Test property 'output' matches 'code'. If no autofix is expected, then omit the 'output' property or set it to null.");
                 }
             } else {
                 assert.strictEqual(

package/lib/rules/no-implicit-coercion.js

@@ -188,6 +188,7 @@ function getNonEmptyOperand(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        hasSuggestions: true,
         type: "suggestion",
 
         docs: {
@@ -229,7 +230,8 @@ module.exports = {
         }],
 
         messages: {
-            useRecommendation: "use `{{recommendation}}` instead."
+            implicitCoercion: "Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.",
+            useRecommendation: "Use `{{recommendation}}` instead."
         }
     },
 
@@ -241,32 +243,54 @@ module.exports = {
          * Reports an error and autofixes the node
          * @param {ASTNode} node An ast node to report the error on.
          * @param {string} recommendation The recommended code for the issue
+         * @param {bool} shouldSuggest Whether this report should offer a suggestion
          * @param {bool} shouldFix Whether this report should fix the node
          * @returns {void}
          */
-        function report(node, recommendation, shouldFix) {
+        function report(node, recommendation, shouldSuggest, shouldFix) {
+
+            /**
+             * Fix function
+             * @param {RuleFixer} fixer The fixer to fix.
+             * @returns {Fix} The fix object.
+             */
+            function fix(fixer) {
+                const tokenBefore = sourceCode.getTokenBefore(node);
+
+                if (
+                    tokenBefore?.range[1] === node.range[0] &&
+                    !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
+                ) {
+                    return fixer.replaceText(node, ` ${recommendation}`);
+                }
+
+                return fixer.replaceText(node, recommendation);
+            }
+
             context.report({
                 node,
-                messageId: "useRecommendation",
-                data: {
-                    recommendation
-                },
+                messageId: "implicitCoercion",
+                data: { recommendation },
                 fix(fixer) {
                     if (!shouldFix) {
                         return null;
                     }
 
-                    const tokenBefore = sourceCode.getTokenBefore(node);
-
-                    if (
-                        tokenBefore &&
-                        tokenBefore.range[1] === node.range[0] &&
-                        !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
-                    ) {
-                        return fixer.replaceText(node, ` ${recommendation}`);
+                    return fix(fixer);
+                },
+                suggest: [
+                    {
+                        messageId: "useRecommendation",
+                        data: { recommendation },
+                        fix(fixer) {
+                            if (shouldFix || !shouldSuggest) {
+                                return null;
+                            }
+
+                            return fix(fixer);
+                        }
                     }
-                    return fixer.replaceText(node, recommendation);
-                }
+                ]
             });
         }
 
@@ -278,8 +302,10 @@ module.exports = {
                 operatorAllowed = options.allow.includes("!!");
                 if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
                     const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+                    const variable = astUtils.getVariableByName(sourceCode.getScope(node), "Boolean");
+                    const booleanExists = variable?.identifiers.length === 0;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, booleanExists);
                 }
 
                 // ~foo.indexOf(bar)
@@ -290,7 +316,7 @@ module.exports = {
                     const comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
                     const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
 
-                    report(node, recommendation, false);
+                    report(node, recommendation, false, false);
                 }
 
                 // +foo
@@ -298,7 +324,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
                     const recommendation = `Number(${sourceCode.getText(node.argument)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // -(-foo)
@@ -306,7 +332,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "-" && node.argument.type === "UnaryExpression" && node.argument.operator === "-" && !isNumeric(node.argument.argument)) {
                     const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
 
-                    report(node, recommendation, false);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -322,7 +348,7 @@ module.exports = {
                 if (nonNumericOperand) {
                     const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // foo - 0
@@ -330,7 +356,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "-" && node.right.type === "Literal" && node.right.value === 0 && !isNumeric(node.left)) {
                     const recommendation = `Number(${sourceCode.getText(node.left)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // "" + foo
@@ -338,7 +364,7 @@ module.exports = {
                 if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
                     const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -351,7 +377,7 @@ module.exports = {
                     const code = sourceCode.getText(getNonEmptyOperand(node));
                     const recommendation = `${code} = String(${code})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -389,7 +415,7 @@ module.exports = {
                 const code = sourceCode.getText(node.expressions[0]);
                 const recommendation = `String(${code})`;
 
-                report(node, recommendation, true);
+                report(node, recommendation, true, false);
             }
         };
     }

package/lib/rules/no-restricted-imports.js

@@ -161,17 +161,25 @@ module.exports = {
             (Object.hasOwn(options[0], "paths") || Object.hasOwn(options[0], "patterns"));
 
         const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
-        const restrictedPathMessages = restrictedPaths.reduce((memo, importSource) => {
+        const groupedRestrictedPaths = restrictedPaths.reduce((memo, importSource) => {
+            const path = typeof importSource === "string"
+                ? importSource
+                : importSource.name;
+
+            if (!memo[path]) {
+                memo[path] = [];
+            }
+
             if (typeof importSource === "string") {
-                memo[importSource] = { message: null };
+                memo[path].push({});
             } else {
-                memo[importSource.name] = {
+                memo[path].push({
                     message: importSource.message,
                     importNames: importSource.importNames
-                };
+                });
             }
             return memo;
-        }, {});
+        }, Object.create(null));
 
         // Handle patterns too, either as strings or groups
         let restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
@@ -203,57 +211,59 @@ module.exports = {
          * @private
          */
         function checkRestrictedPathAndReport(importSource, importNames, node) {
-            if (!Object.hasOwn(restrictedPathMessages, importSource)) {
+            if (!Object.hasOwn(groupedRestrictedPaths, importSource)) {
                 return;
             }
 
-            const customMessage = restrictedPathMessages[importSource].message;
-            const restrictedImportNames = restrictedPathMessages[importSource].importNames;
+            groupedRestrictedPaths[importSource].forEach(restrictedPathEntry => {
+                const customMessage = restrictedPathEntry.message;
+                const restrictedImportNames = restrictedPathEntry.importNames;
 
-            if (restrictedImportNames) {
-                if (importNames.has("*")) {
-                    const specifierData = importNames.get("*")[0];
+                if (restrictedImportNames) {
+                    if (importNames.has("*")) {
+                        const specifierData = importNames.get("*")[0];
+
+                        context.report({
+                            node,
+                            messageId: customMessage ? "everythingWithCustomMessage" : "everything",
+                            loc: specifierData.loc,
+                            data: {
+                                importSource,
+                                importNames: restrictedImportNames,
+                                customMessage
+                            }
+                        });
+                    }
 
+                    restrictedImportNames.forEach(importName => {
+                        if (importNames.has(importName)) {
+                            const specifiers = importNames.get(importName);
+
+                            specifiers.forEach(specifier => {
+                                context.report({
+                                    node,
+                                    messageId: customMessage ? "importNameWithCustomMessage" : "importName",
+                                    loc: specifier.loc,
+                                    data: {
+                                        importSource,
+                                        customMessage,
+                                        importName
+                                    }
+                                });
+                            });
+                        }
+                    });
+                } else {
                     context.report({
                         node,
-                        messageId: customMessage ? "everythingWithCustomMessage" : "everything",
-                        loc: specifierData.loc,
+                        messageId: customMessage ? "pathWithCustomMessage" : "path",
                         data: {
                             importSource,
-                            importNames: restrictedImportNames,
                             customMessage
                         }
                     });
                 }
-
-                restrictedImportNames.forEach(importName => {
-                    if (importNames.has(importName)) {
-                        const specifiers = importNames.get(importName);
-
-                        specifiers.forEach(specifier => {
-                            context.report({
-                                node,
-                                messageId: customMessage ? "importNameWithCustomMessage" : "importName",
-                                loc: specifier.loc,
-                                data: {
-                                    importSource,
-                                    customMessage,
-                                    importName
-                                }
-                            });
-                        });
-                    }
-                });
-            } else {
-                context.report({
-                    node,
-                    messageId: customMessage ? "pathWithCustomMessage" : "path",
-                    data: {
-                        importSource,
-                        customMessage
-                    }
-                });
-            }
+            });
         }
 
         /**

package/lib/rules/no-this-before-super.js

@@ -197,11 +197,26 @@ module.exports = {
                     return;
                 }
 
+                /**
+                 * A collection of nodes to avoid duplicate reports.
+                 * @type {Set<ASTNode>}
+                 */
+                const reported = new Set();
+
                 codePath.traverseSegments((segment, controller) => {
                     const info = segInfoMap[segment.id];
+                    const invalidNodes = info.invalidNodes
+                        .filter(
+
+                            /*
+                             * Avoid duplicate reports.
+                             * When there is a `finally`, invalidNodes may contain already reported node.
+                             */
+                            node => !reported.has(node)
+                        );
 
-                    for (let i = 0; i < info.invalidNodes.length; ++i) {
-                        const invalidNode = info.invalidNodes[i];
+                    for (const invalidNode of invalidNodes) {
+                        reported.add(invalidNode);
 
                         context.report({
                             messageId: "noBeforeSuper",
@@ -273,14 +288,12 @@ module.exports = {
                         const info = segInfoMap[segment.id];
 
                         if (info.superCalled) {
-                            info.invalidNodes = [];
                             controller.skip();
                         } else if (
                             segment.prevSegments.length > 0 &&
                             segment.prevSegments.every(isCalled)
                         ) {
                             info.superCalled = true;
-                            info.invalidNodes = [];
                         }
                     }
                 );

package/lib/rules/no-unused-vars.js

@@ -92,7 +92,7 @@ module.exports = {
             vars: "all",
             args: "after-used",
             ignoreRestSiblings: false,
-            caughtErrors: "none"
+            caughtErrors: "all"
         };
 
         const firstOption = context.options[0];

package/lib/rules/no-useless-computed-key.js

@@ -101,7 +101,7 @@ module.exports = {
             properties: {
                 enforceForClassMembers: {
                     type: "boolean",
-                    default: false
+                    default: true
                 }
             },
             additionalProperties: false
@@ -114,7 +114,7 @@ module.exports = {
     },
     create(context) {
         const sourceCode = context.sourceCode;
-        const enforceForClassMembers = context.options[0] && context.options[0].enforceForClassMembers;
+        const enforceForClassMembers = context.options[0]?.enforceForClassMembers ?? true;
 
         /**
          * Reports a given node if it violated this rule.

package/lib/rules/use-isnan.js

@@ -21,9 +21,17 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} `true` if the node is 'NaN' identifier.
  */
 function isNaNIdentifier(node) {
-    return Boolean(node) && (
-        astUtils.isSpecificId(node, "NaN") ||
-        astUtils.isSpecificMemberAccess(node, "Number", "NaN")
+    if (!node) {
+        return false;
+    }
+
+    const nodeToCheck = node.type === "SequenceExpression"
+        ? node.expressions.at(-1)
+        : node;
+
+    return (
+        astUtils.isSpecificId(nodeToCheck, "NaN") ||
+        astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN")
     );
 }
 
@@ -34,6 +42,7 @@ function isNaNIdentifier(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        hasSuggestions: true,
         type: "problem",
 
         docs: {
@@ -63,7 +72,9 @@ module.exports = {
             comparisonWithNaN: "Use the isNaN function to compare with NaN.",
             switchNaN: "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",
             caseNaN: "'case NaN' can never match. Use Number.isNaN before the switch.",
-            indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN."
+            indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN.",
+            replaceWithIsNaN: "Replace with Number.isNaN.",
+            replaceWithCastingAndIsNaN: "Replace with Number.isNaN cast to a Number."
         }
     },
 
@@ -71,6 +82,35 @@ module.exports = {
 
         const enforceForSwitchCase = !context.options[0] || context.options[0].enforceForSwitchCase;
         const enforceForIndexOf = context.options[0] && context.options[0].enforceForIndexOf;
+        const sourceCode = context.sourceCode;
+
+        const fixableOperators = new Set(["==", "===", "!=", "!=="]);
+        const castableOperators = new Set(["==", "!="]);
+
+        /**
+         * Get a fixer for a binary expression that compares to NaN.
+         * @param  {ASTNode} node The node to fix.
+         * @param {function(string): string} wrapValue A function that wraps the compared value with a fix.
+         * @returns {function(Fixer): Fix} The fixer function.
+         */
+        function getBinaryExpressionFixer(node, wrapValue) {
+            return fixer => {
+                const comparedValue = isNaNIdentifier(node.left) ? node.right : node.left;
+                const shouldWrap = comparedValue.type === "SequenceExpression";
+                const shouldNegate = node.operator[0] === "!";
+
+                const negation = shouldNegate ? "!" : "";
+                let comparedValueText = sourceCode.getText(comparedValue);
+
+                if (shouldWrap) {
+                    comparedValueText = `(${comparedValueText})`;
+                }
+
+                const fixedValue = wrapValue(comparedValueText);
+
+                return fixer.replaceText(node, `${negation}${fixedValue}`);
+            };
+        }
 
         /**
          * Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons.
@@ -82,7 +122,32 @@ module.exports = {
                 /^(?:[<>]|[!=]=)=?$/u.test(node.operator) &&
                 (isNaNIdentifier(node.left) || isNaNIdentifier(node.right))
             ) {
-                context.report({ node, messageId: "comparisonWithNaN" });
+                const suggestedFixes = [];
+                const NaNNode = isNaNIdentifier(node.left) ? node.left : node.right;
+
+                const isSequenceExpression = NaNNode.type === "SequenceExpression";
+                const isFixable = fixableOperators.has(node.operator) && !isSequenceExpression;
+                const isCastable = castableOperators.has(node.operator);
+
+                if (isFixable) {
+                    suggestedFixes.push({
+                        messageId: "replaceWithIsNaN",
+                        fix: getBinaryExpressionFixer(node, value => `Number.isNaN(${value})`)
+                    });
+
+                    if (isCastable) {
+                        suggestedFixes.push({
+                            messageId: "replaceWithCastingAndIsNaN",
+                            fix: getBinaryExpressionFixer(node, value => `Number.isNaN(Number(${value}))`)
+                        });
+                    }
+                }
+
+                context.report({
+                    node,
+                    messageId: "comparisonWithNaN",
+                    suggest: suggestedFixes
+                });
             }
         }
 

package/lib/shared/serialization.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Serialization utils.
+ * @author Bryan Mishkin
+ */
+
+"use strict";
+
+/**
+ * Check if a value is a primitive or plain object created by the Object constructor.
+ * @param {any} val the value to check
+ * @returns {boolean} true if so
+ * @private
+ */
+function isSerializablePrimitiveOrPlainObject(val) {
+    return (
+        val === null ||
+        typeof val === "string" ||
+         typeof val === "boolean" ||
+         typeof val === "number" ||
+         (typeof val === "object" && val.constructor === Object) ||
+         Array.isArray(val)
+    );
+}
+
+/**
+ * Check if a value is serializable.
+ * Functions or objects like RegExp cannot be serialized by JSON.stringify().
+ * Inspired by: https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript
+ * @param {any} val the value
+ * @returns {boolean} true if the value is serializable
+ */
+function isSerializable(val) {
+    if (!isSerializablePrimitiveOrPlainObject(val)) {
+        return false;
+    }
+    if (typeof val === "object") {
+        for (const property in val) {
+            if (Object.hasOwn(val, property)) {
+                if (!isSerializablePrimitiveOrPlainObject(val[property])) {
+                    return false;
+                }
+                if (typeof val[property] === "object") {
+                    if (!isSerializable(val[property])) {
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    return true;
+}
+
+module.exports = {
+    isSerializable
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.0.0-alpha.1",
+  "version": "9.0.0-beta.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -65,8 +65,8 @@
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
-    "@eslint/eslintrc": "^3.0.0",
-    "@eslint/js": "9.0.0-alpha.0",
+    "@eslint/eslintrc": "^3.0.1",
+    "@eslint/js": "9.0.0-beta.0",
     "@humanwhocodes/config-array": "^0.11.14",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -76,12 +76,12 @@
     "debug": "^4.3.2",
     "escape-string-regexp": "^4.0.0",
     "eslint-scope": "^8.0.0",
-    "eslint-visitor-keys": "^3.4.3",
-    "espree": "^9.6.1",
+    "eslint-visitor-keys": "^4.0.0",
+    "espree": "^10.0.1",
     "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
-    "file-entry-cache": "^6.0.1",
+    "file-entry-cache": "^8.0.0",
     "find-up": "^5.0.0",
     "glob-parent": "^6.0.2",
     "globals": "^13.19.0",
@@ -135,8 +135,8 @@
     "load-perf": "^0.2.0",
     "markdown-it": "^12.2.0",
     "markdown-it-container": "^3.0.0",
-    "markdownlint": "^0.32.0",
-    "markdownlint-cli": "^0.38.0",
+    "markdownlint": "^0.33.0",
+    "markdownlint-cli": "^0.39.0",
     "marked": "^4.0.8",
     "memfs": "^3.0.1",
     "metascraper": "^5.25.7",
@@ -155,7 +155,7 @@
     "regenerator-runtime": "^0.14.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
     "semver": "^7.5.3",
-    "shelljs": "^0.8.2",
+    "shelljs": "^0.8.5",
     "sinon": "^11.0.0",
     "vite-plugin-commonjs": "^0.10.0",
     "webdriverio": "^8.14.6",