npm - claude-flow - Versions diffs - 2.0.0-alpha.8 → 2.0.0-alpha.80 - Mend

claude-flow 2.0.0-alpha.8 → 2.0.0-alpha.80

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3446) hide show

package/src/ui/extension/node_modules/eslint/lib/linter/linter.js CHANGED Viewed

@@ -3,13 +3,10 @@
  * @author Gyandeep Singh
  * @author aladdin-add
  */
 "use strict";
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 const
     path = require("path"),
     eslintScope = require("eslint-scope"),
@@ -52,11 +49,9 @@ const DEFAULT_ECMA_VERSION = 5;
 const commentParser = new ConfigCommentParser();
 const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } };
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 /** @typedef {InstanceType<import("../cli-engine/config-array").ConfigArray>} ConfigArray */
 /** @typedef {InstanceType<import("../cli-engine/config-array").ExtractedConfig>} ExtractedConfig */
 /** @typedef {import("../shared/types").ConfigData} ConfigData */
@@ -68,14 +63,12 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 /** @typedef {import("../shared/types").LanguageOptions} LanguageOptions */
 /** @typedef {import("../shared/types").Processor} Processor */
 /** @typedef {import("../shared/types").Rule} Rule */
 /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */
 /**
  * @template T
  * @typedef {{ [P in keyof T]-?: T[P] }} Required
  */
 /* eslint-enable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */
 /**
  * @typedef {Object} DisableDirective
  * @property {("disable"|"enable"|"disable-line"|"disable-next-line")} type Type of directive
@@ -84,7 +77,6 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
  * @property {(string|null)} ruleId The rule ID
  * @property {string} justification The justification of directive
  */
 /**
  * The private data for `Linter` instance.
  * @typedef {Object} LinterInternalSlots
@@ -94,7 +86,6 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
  * @property {Map<string, Parser>} parserMap The loaded parsers.
  * @property {Rules} ruleMap The loaded rules.
  */
 /**
  * @typedef {Object} VerifyOptions
  * @property {boolean} [allowInlineConfig] Allow/disallow inline comments' ability
@@ -106,7 +97,6 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
  * @property {boolean | "off" | "warn" | "error"} [reportUnusedDisableDirectives] Adds reported errors for
  *      unused `eslint-disable` directives.
  */
 /**
  * @typedef {Object} ProcessorOptions
  * @property {(filename:string, text:string) => boolean} [filterCodeBlock] the
@@ -120,23 +110,19 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
  *      If provided, this should accept a string of source text, and return an
  *      array of code blocks to lint.
  */
 /**
  * @typedef {Object} FixOptions
  * @property {boolean | ((message: LintMessage) => boolean)} [fix] Determines
  *      whether fixes should be applied.
  */
 /**
  * @typedef {Object} InternalOptions
  * @property {string | null} warnInlineConfig The config name what `noInlineConfig` setting came from. If `noInlineConfig` setting didn't exist, this is null. If this is a config name, then the linter warns directive comments.
  * @property {"off" | "warn" | "error"} reportUnusedDisableDirectives (boolean values were normalized)
  */
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 /**
  * Determines if a given object is Espree.
  * @param {Object} parser The parser to check.
@@ -145,7 +131,6 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 function isEspree(parser) {
     return !!(parser === espree || parser[parserSymbol] === espree);
 }
 /**
  * Ensures that variables representing built-in properties of the Global Object,
  * and any globals declared by special block comments, are present in the global
@@ -156,10 +141,8 @@ function isEspree(parser) {
  * @returns {void}
  */
 function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, enabledGlobals }) {
     // Define configured global variables.
     for (const id of new Set([...Object.keys(configGlobals), ...Object.keys(enabledGlobals)])) {
         /*
          * `ConfigOps.normalizeConfigGlobal` will throw an error if a configured global value is invalid. However, these errors would
          * typically be caught when validating a config anyway (validity for inline global comments is checked separately).
@@ -168,36 +151,28 @@ function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, ena
         const commentValue = enabledGlobals[id] && enabledGlobals[id].value;
         const value = commentValue || configValue;
         const sourceComments = enabledGlobals[id] && enabledGlobals[id].comments;
         if (value === "off") {
             continue;
         }
         let variable = globalScope.set.get(id);
         if (!variable) {
             variable = new eslintScope.Variable(id, globalScope);
             globalScope.variables.push(variable);
             globalScope.set.set(id, variable);
         }
         variable.eslintImplicitGlobalSetting = configValue;
         variable.eslintExplicitGlobal = sourceComments !== void 0;
         variable.eslintExplicitGlobalComments = sourceComments;
         variable.writeable = (value === "writable");
     }
     // mark all exported variables as such
     Object.keys(exportedVariables).forEach(name => {
         const variable = globalScope.set.get(name);
         if (variable) {
             variable.eslintUsed = true;
             variable.eslintExported = true;
         }
     });
     /*
      * "through" contains all references which definitions cannot be found.
      * Since we augment the global scope using configuration, we need to update
@@ -206,23 +181,18 @@ function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, ena
     globalScope.through = globalScope.through.filter(reference => {
         const name = reference.identifier.name;
         const variable = globalScope.set.get(name);
         if (variable) {
             /*
              * Links the variable and the reference.
              * And this reference is removed from `Scope#through`.
              */
             reference.resolved = variable;
             variable.references.push(reference);
             return false;
         }
         return true;
     });
 }
 /**
  * creates a missing-rule message.
  * @param {string} ruleId the ruleId to create
@@ -234,7 +204,6 @@ function createMissingRuleMessage(ruleId) {
         ? `Rule '${ruleId}' was removed and replaced by: ${ruleReplacements.rules[ruleId].join(", ")}`
         : `Definition for rule '${ruleId}' was not found.`;
 }
 /**
  * creates a linting problem
  * @param {Object} options to create linting error
@@ -246,13 +215,12 @@ function createMissingRuleMessage(ruleId) {
  * @private
  */
 function createLintingProblem(options) {
-    const {
+    const { // TODO: Remove if unused
         ruleId = null,
         loc = DEFAULT_ERROR_LOC,
         message = createMissingRuleMessage(options.ruleId),
         severity = 2
     } = options;
     return {
         ruleId,
         message,
@@ -264,7 +232,6 @@ function createLintingProblem(options) {
         nodeType: null
     };
 }
 /**
  * Creates a collection of disable directives from a comment
  * @param {Object} options to create disable directives
@@ -284,11 +251,8 @@ function createDisableDirectives(options) {
         directives: [], // valid disable directives
         directiveProblems: [] // problems in directives
     };
     const parentComment = { commentToken, ruleIds };
     for (const ruleId of directiveRules) {
         // push to directives, if the rule is defined(including null, e.g. /*eslint enable*/)
         if (ruleId === null || !!ruleMapper(ruleId)) {
             if (type === "disable-next-line") {
@@ -316,7 +280,6 @@ function createDisableDirectives(options) {
     }
     return result;
 }
 /**
  * Parses comments in file to extract file-specific config of rules, globals
  * and environments and merges them with global config; also code blocks
@@ -336,25 +299,19 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
     const validator = new ConfigValidator({
         builtInRules: Rules
     });
     sourceCode.getInlineConfigNodes().filter(token => token.type !== "Shebang").forEach(comment => {
         const { directivePart, justificationPart } = commentParser.extractDirectiveComment(comment.value);
         const match = directivesPattern.exec(directivePart);
         if (!match) {
             return;
         }
         const directiveText = match[1];
         const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
         if (comment.type === "Line" && !lineCommentSupported) {
             return;
         }
         if (warnInlineConfig) {
             const kind = comment.type === "Block" ? `/*${directiveText}*/` : `//${directiveText}`;
             problems.push(createLintingProblem({
                 ruleId: null,
                 message: `'${kind}' has no effect because you have 'noInlineConfig' setting in ${warnInlineConfig}.`,
@@ -363,10 +320,8 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
             }));
             return;
         }
         if (directiveText === "eslint-disable-line" && comment.loc.start.line !== comment.loc.end.line) {
             const message = `${directiveText} comment should not span multiple lines.`;
             problems.push(createLintingProblem({
                 ruleId: null,
                 message,
@@ -374,9 +329,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
             }));
             return;
         }
         const directiveValue = directivePart.slice(match.index + directiveText.length);
         switch (directiveText) {
             case "eslint-disable":
             case "eslint-enable":
@@ -385,21 +338,17 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                 const directiveType = directiveText.slice("eslint-".length);
                 const options = { commentToken: comment, type: directiveType, value: directiveValue, justification: justificationPart, ruleMapper };
                 const { directives, directiveProblems } = createDisableDirectives(options);
                 disableDirectives.push(...directives);
                 problems.push(...directiveProblems);
                 break;
             }
             case "exported":
                 Object.assign(exportedVariables, commentParser.parseStringConfig(directiveValue, comment));
                 break;
             case "globals":
             case "global":
                 for (const [id, { value }] of Object.entries(commentParser.parseStringConfig(directiveValue, comment))) {
-                    let normalizedValue;
+                    let normalizedValue; // TODO: Remove if unused
                     try {
                         normalizedValue = ConfigOps.normalizeConfigGlobal(value);
                     } catch (err) {
@@ -410,7 +359,6 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                         }));
                         continue;
                     }
                     if (enabledGlobals[id]) {
                         enabledGlobals[id].comments.push(comment);
                         enabledGlobals[id].value = normalizedValue;
@@ -422,20 +370,16 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                     }
                 }
                 break;
             case "eslint": {
                 const parseResult = commentParser.parseJsonConfig(directiveValue, comment.loc);
                 if (parseResult.success) {
                     Object.keys(parseResult.config).forEach(name => {
                         const rule = ruleMapper(name);
                         const ruleValue = parseResult.config[name];
                         if (!rule) {
                             problems.push(createLintingProblem({ ruleId: name, loc: comment.loc }));
                             return;
                         }
                         try {
                             validator.validateRuleOptions(rule, name, ruleValue);
                         } catch (err) {
@@ -444,24 +388,19 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
                                 message: err.message,
                                 loc: comment.loc
                             }));
                             // do not apply the config, if found invalid options.
                             return;
                         }
                         configuredRules[name] = ruleValue;
                     });
                 } else {
                     problems.push(parseResult.error);
                 }
                 break;
             }
             // no default
         }
     });
     return {
         configuredRules,
         enabledGlobals,
@@ -470,7 +409,6 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
         disableDirectives
     };
 }
 /**
  * Parses comments in file to extract disable directives.
  * @param {SourceCode} sourceCode The SourceCode object to get comments from.
@@ -481,25 +419,19 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig) {
 function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper) {
     const problems = [];
     const disableDirectives = [];
     sourceCode.getInlineConfigNodes().filter(token => token.type !== "Shebang").forEach(comment => {
         const { directivePart, justificationPart } = commentParser.extractDirectiveComment(comment.value);
         const match = directivesPattern.exec(directivePart);
         if (!match) {
             return;
         }
         const directiveText = match[1];
         const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
         if (comment.type === "Line" && !lineCommentSupported) {
             return;
         }
         if (directiveText === "eslint-disable-line" && comment.loc.start.line !== comment.loc.end.line) {
             const message = `${directiveText} comment should not span multiple lines.`;
             problems.push(createLintingProblem({
                 ruleId: null,
                 message,
@@ -507,9 +439,7 @@ function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper) {
             }));
             return;
         }
         const directiveValue = directivePart.slice(match.index + directiveText.length);
         switch (directiveText) {
             case "eslint-disable":
             case "eslint-enable":
@@ -518,22 +448,18 @@ function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper) {
                 const directiveType = directiveText.slice("eslint-".length);
                 const options = { commentToken: comment, type: directiveType, value: directiveValue, justification: justificationPart, ruleMapper };
                 const { directives, directiveProblems } = createDisableDirectives(options);
                 disableDirectives.push(...directives);
                 problems.push(...directiveProblems);
                 break;
             }
             // no default
         }
     });
     return {
         problems,
         disableDirectives
     };
 }
 /**
  * Normalize ECMAScript version from the initial config
  * @param {Parser} parser The parser which uses this options.
@@ -541,20 +467,17 @@ function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper) {
  * @returns {number} normalized ECMAScript version
  */
 function normalizeEcmaVersion(parser, ecmaVersion) {
     if (isEspree(parser)) {
         if (ecmaVersion === "latest") {
             return espree.latestEcmaVersion;
         }
     }
     /*
      * Calculate ECMAScript edition number from official year version starting with
      * ES2015, which corresponds with ES6 (or a difference of 2009).
      */
     return ecmaVersion >= 2015 ? ecmaVersion - 2009 : ecmaVersion;
 }
 /**
  * Normalize ECMAScript version from the initial config into languageOptions (year)
  * format.
@@ -562,22 +485,18 @@ function normalizeEcmaVersion(parser, ecmaVersion) {
  * @returns {number} normalized ECMAScript version
  */
 function normalizeEcmaVersionForLanguageOptions(ecmaVersion) {
     switch (ecmaVersion) {
         case 3:
             return 3;
         // void 0 = no ecmaVersion specified so use the default
         case 5:
         case void 0:
             return 5;
         default:
             if (typeof ecmaVersion === "number") {
                 return ecmaVersion >= 2015 ? ecmaVersion : ecmaVersion + 2009;
             }
     }
     /*
      * We default to the latest supported ecmaVersion for everything else.
      * Remember, this is for languageOptions.ecmaVersion, which sets the version
@@ -586,19 +505,15 @@ function normalizeEcmaVersionForLanguageOptions(ecmaVersion) {
      */
     return espree.latestEcmaVersion + 2009;
 }
 const eslintEnvPattern = /\/\*\s*eslint-env\s(.+?)(?:\*\/|$)/gsu;
 /**
  * Checks whether or not there is a comment which has "eslint-env *" in a given text.
  * @param {string} text A source code text to check.
  * @returns {Object|null} A result of parseListConfig() with "eslint-env *" comment.
  */
 function findEslintEnv(text) {
-    let match, retv;
+    let match, retv; // TODO: Remove if unused
     eslintEnvPattern.lastIndex = 0;
     while ((match = eslintEnvPattern.exec(text)) !== null) {
         if (match[0].endsWith("*/")) {
             retv = Object.assign(
@@ -607,10 +522,8 @@ function findEslintEnv(text) {
             );
         }
     }
     return retv;
 }
 /**
  * Convert "/path/to/<text>" to "<text>".
  * `CLIEngine#executeOnText()` method gives "/path/to/<text>" if the filename
@@ -626,10 +539,8 @@ function findEslintEnv(text) {
 function normalizeFilename(filename) {
     const parts = filename.split(path.sep);
     const index = parts.lastIndexOf("<text>");
     return index === -1 ? filename : parts.slice(index).join(path.sep);
 }
 /**
  * Normalizes the possible options for `linter.verify` and `linter.verifyAndFix` to a
  * consistent shape.
@@ -638,18 +549,14 @@ function normalizeFilename(filename) {
  * @returns {Required<VerifyOptions> & InternalOptions} Normalized options
  */
 function normalizeVerifyOptions(providedOptions, config) {
     const linterOptions = config.linterOptions || config;
     // .noInlineConfig for eslintrc, .linterOptions.noInlineConfig for flat
     const disableInlineConfig = linterOptions.noInlineConfig === true;
     const ignoreInlineConfig = providedOptions.allowInlineConfig === false;
     const configNameOfNoInlineConfig = config.configNameOfNoInlineConfig
         ? ` (${config.configNameOfNoInlineConfig})`
         : "";
     let reportUnusedDisableDirectives = providedOptions.reportUnusedDisableDirectives;
     if (typeof reportUnusedDisableDirectives === "boolean") {
         reportUnusedDisableDirectives = reportUnusedDisableDirectives ? "error" : "off";
     }
@@ -660,7 +567,6 @@ function normalizeVerifyOptions(providedOptions, config) {
             reportUnusedDisableDirectives = linterOptions.reportUnusedDisableDirectives === void 0 ? "off" : normalizeSeverityToString(linterOptions.reportUnusedDisableDirectives);
         }
     }
     return {
         filename: normalizeFilename(providedOptions.filename || "<input>"),
         allowInlineConfig: !ignoreInlineConfig,
@@ -671,7 +577,6 @@ function normalizeVerifyOptions(providedOptions, config) {
         disableFixes: Boolean(providedOptions.disableFixes)
     };
 }
 /**
  * Combines the provided parserOptions with the options from environments
  * @param {Parser} parser The parser which uses this options.
@@ -680,27 +585,21 @@ function normalizeVerifyOptions(providedOptions, config) {
  * @returns {ParserOptions} Resulting parser options after merge
  */
 function resolveParserOptions(parser, providedOptions, enabledEnvironments) {
     const parserOptionsFromEnv = enabledEnvironments
         .filter(env => env.parserOptions)
         .reduce((parserOptions, env) => merge(parserOptions, env.parserOptions), {});
     const mergedParserOptions = merge(parserOptionsFromEnv, providedOptions || {});
     const isModule = mergedParserOptions.sourceType === "module";
     if (isModule) {
         /*
          * can't have global return inside of modules
          * TODO: espree validate parserOptions.globalReturn when sourceType is setting to module.(@aladdin-add)
          */
         mergedParserOptions.ecmaFeatures = Object.assign({}, mergedParserOptions.ecmaFeatures, { globalReturn: false });
     }
     mergedParserOptions.ecmaVersion = normalizeEcmaVersion(parser, mergedParserOptions.ecmaVersion);
     return mergedParserOptions;
 }
 /**
  * Converts parserOptions to languageOptions for backwards compatibility with eslintrc.
  * @param {ConfigData} config Config object.
@@ -710,12 +609,10 @@ function resolveParserOptions(parser, providedOptions, enabledEnvironments) {
  * @returns {LanguageOptions} The languageOptions equivalent.
  */
 function createLanguageOptions({ globals: configuredGlobals, parser, parserOptions }) {
-    const {
+    const { // TODO: Remove if unused
         ecmaVersion,
         sourceType
     } = parserOptions;
     return {
         globals: configuredGlobals,
         ecmaVersion: normalizeEcmaVersionForLanguageOptions(ecmaVersion),
@@ -724,7 +621,6 @@ function createLanguageOptions({ globals: configuredGlobals, parser, parserOptio
         parserOptions
     };
 }
 /**
  * Combines the provided globals object with the globals from environments
  * @param {Record<string, GlobalConf>} providedGlobals The 'globals' key in a config
@@ -738,14 +634,12 @@ function resolveGlobals(providedGlobals, enabledEnvironments) {
         providedGlobals
     );
 }
 /**
  * Strips Unicode BOM from a given text.
  * @param {string} text A text to strip.
  * @returns {string} The stripped text.
  */
 function stripUnicodeBOM(text) {
     /*
      * Check Unicode BOM.
      * In JavaScript, string data is stored as UTF-16, so BOM is 0xFEFF.
@@ -756,7 +650,6 @@ function stripUnicodeBOM(text) {
     }
     return text;
 }
 /**
  * Get the options for a rule (not including severity), if any
  * @param {Array|number} ruleConfig rule configuration
@@ -767,9 +660,7 @@ function getRuleOptions(ruleConfig) {
         return ruleConfig.slice(1);
     }
     return [];
 }
 /**
  * Analyze scope of the given AST.
  * @param {ASTNode} ast The `Program` node to analyze.
@@ -781,7 +672,6 @@ function analyzeScope(ast, languageOptions, visitorKeys) {
     const parserOptions = languageOptions.parserOptions;
     const ecmaFeatures = parserOptions.ecmaFeatures || {};
     const ecmaVersion = languageOptions.ecmaVersion || DEFAULT_ECMA_VERSION;
     return eslintScope.analyze(ast, {
         ignoreEval: true,
         nodejsScope: ecmaFeatures.globalReturn,
@@ -792,7 +682,6 @@ function analyzeScope(ast, languageOptions, visitorKeys) {
         fallback: Traverser.getKeys
     });
 }
 /**
  * Parses text into an AST. Moved out here because the try-catch prevents
  * optimization of functions, so it's best to keep the try-catch as isolated
@@ -821,7 +710,6 @@ function parse(text, languageOptions, filePath) {
             filePath
         }
     );
     /*
      * Check for parsing errors first. If there's a parsing error, nothing
      * else can happen. However, a parsing error does not throw an error
@@ -833,20 +721,15 @@ function parse(text, languageOptions, filePath) {
         const parseResult = (typeof parser.parseForESLint === "function")
             ? parser.parseForESLint(textToParse, parserOptions)
             : { ast: parser.parse(textToParse, parserOptions) };
         debug("Parsing successful:", filePath);
         const ast = parseResult.ast;
         const parserServices = parseResult.services || {};
         const visitorKeys = parseResult.visitorKeys || evk.KEYS;
         debug("Scope analysis:", filePath);
         const scopeManager = parseResult.scopeManager || analyzeScope(ast, languageOptions, visitorKeys);
         debug("Scope analysis successful:", filePath);
         return {
             success: true,
             /*
              * Save all values that `parseForESLint()` returned.
              * If a `SourceCode` object is given as the first parameter instead of source code text,
@@ -862,12 +745,9 @@ function parse(text, languageOptions, filePath) {
             })
         };
     } catch (ex) {
         // If the message includes a leading line number, strip it:
         const message = `Parsing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
         debug("%s\n%s", message, ex.stack);
         return {
             success: false,
             error: {
@@ -882,7 +762,6 @@ function parse(text, languageOptions, filePath) {
         };
     }
 }
 /**
  * Runs a rule, and gets its listeners
  * @param {Rule} rule A normalized rule with a `create` method
@@ -898,7 +777,6 @@ function createRuleListeners(rule, ruleContext) {
         throw ex;
     }
 }
 // methods that exist on SourceCode object
 const DEPRECATED_SOURCECODE_PASSTHROUGHS = {
     getSource: "getText",
@@ -922,8 +800,6 @@ const DEPRECATED_SOURCECODE_PASSTHROUGHS = {
     getTokensBefore: "getTokensBefore",
     getTokensBetween: "getTokensBetween"
 };
 const BASE_TRAVERSAL_CONTEXT = Object.freeze(
     Object.keys(DEPRECATED_SOURCECODE_PASSTHROUGHS).reduce(
         (contextInfo, methodName) =>
@@ -935,7 +811,6 @@ const BASE_TRAVERSAL_CONTEXT = Object.freeze(
         {}
     )
 );
 /**
  * Runs the given rules on the given SourceCode object
  * @param {SourceCode} sourceCode A SourceCode object for the given text
@@ -954,7 +829,6 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
     const emitter = createEmitter();
     const nodeQueue = [];
     let currentNode = sourceCode.ast;
     Traverser.traverse(sourceCode.ast, {
         enter(node, parent) {
             node.parent = parent;
@@ -965,7 +839,6 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
         },
         visitorKeys: sourceCode.visitorKeys
     });
     /*
      * Create a frozen object with the ruleContext properties and methods that are shared by all rules.
      * All rule contexts will inherit from this object. This avoids the performance penalty of copying all the
@@ -997,24 +870,18 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
             }
         )
     );
     const lintingProblems = [];
     Object.keys(configuredRules).forEach(ruleId => {
         const severity = ConfigOps.getRuleSeverity(configuredRules[ruleId]);
         // not load disabled rules
         if (severity === 0) {
             return;
         }
         const rule = ruleMapper(ruleId);
         if (!rule) {
             lintingProblems.push(createLintingProblem({ ruleId }));
             return;
         }
         const messageIds = rule.meta && rule.meta.messages;
         let reportTranslator = null;
         const ruleContext = Object.freeze(
@@ -1024,7 +891,6 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
                     id: ruleId,
                     options: getRuleOptions(configuredRules[ruleId]),
                     report(...args) {
                         /*
                          * Create a report translator lazily.
                          * In a vast majority of cases, any given rule reports zero errors on a given
@@ -1045,13 +911,11 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
                             });
                         }
                         const problem = reportTranslator(...args);
                         if (problem.fix && !(rule.meta && rule.meta.fixable)) {
                             throw new Error("Fixable rules must set the `meta.fixable` property to \"code\" or \"whitespace\".");
                         }
                         if (problem.suggestions && !(rule.meta && rule.meta.hasSuggestions === true)) {
                             if (rule.meta && rule.meta.docs && typeof rule.meta.docs.suggestion !== "undefined") {
                                 // Encourage migration from the former property name.
                                 throw new Error("Rules with suggestions must set the `meta.hasSuggestions` property to `true`. `meta.docs.suggestion` is ignored by ESLint.");
                             }
@@ -1062,9 +926,7 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
                 }
             )
         );
         const ruleListeners = timing.enabled ? timing.time(ruleId, createRuleListeners)(rule, ruleContext) : createRuleListeners(rule, ruleContext);
         /**
          * Include `ruleId` in error logs
          * @param {Function} ruleListener A rule method that listens for a node.
@@ -1080,32 +942,26 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
                 }
             };
         }
         if (typeof ruleListeners === "undefined" || ruleListeners === null) {
             throw new Error(`The create() function for rule '${ruleId}' did not return an object.`);
         }
         // add all the selectors from the rule as listeners
         Object.keys(ruleListeners).forEach(selector => {
             const ruleListener = timing.enabled
                 ? timing.time(ruleId, ruleListeners[selector])
                 : ruleListeners[selector];
             emitter.on(
                 selector,
                 addRuleErrorHandler(ruleListener)
             );
         });
     });
     // only run code path analyzer if the top level node is "Program", skip otherwise
     const eventGenerator = nodeQueue[0].node.type === "Program"
         ? new CodePathAnalyzer(new NodeEventGenerator(emitter, { visitorKeys: sourceCode.visitorKeys, fallback: Traverser.getKeys }))
         : new NodeEventGenerator(emitter, { visitorKeys: sourceCode.visitorKeys, fallback: Traverser.getKeys });
     nodeQueue.forEach(traversalInfo => {
         currentNode = traversalInfo.node;
         try {
             if (traversalInfo.isEntering) {
                 eventGenerator.enterNode(currentNode);
@@ -1117,10 +973,8 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
             throw err;
         }
     });
     return lintingProblems;
 }
 /**
  * Ensure the source code to be a string.
  * @param {string|SourceCode} textOrSourceCode The text or source code object.
@@ -1130,13 +984,10 @@ function ensureText(textOrSourceCode) {
     if (typeof textOrSourceCode === "object") {
         const { hasBOM, text } = textOrSourceCode;
         const bom = hasBOM ? "\uFEFF" : "";
         return bom + text;
     }
     return String(textOrSourceCode);
 }
 /**
  * Get an environment.
  * @param {LinterInternalSlots} slots The internal slots of Linter.
@@ -1150,7 +1001,6 @@ function getEnv(slots, envId) {
         null
     );
 }
 /**
  * Get a rule.
  * @param {LinterInternalSlots} slots The internal slots of Linter.
@@ -1163,7 +1013,6 @@ function getRule(slots, ruleId) {
         slots.ruleMap.get(ruleId)
     );
 }
 /**
  * Normalize the value of the cwd
  * @param {string | undefined} cwd raw value of the cwd, path to a directory that should be considered as the current working directory, can be undefined.
@@ -1176,18 +1025,15 @@ function normalizeCwd(cwd) {
     if (typeof process === "object") {
         return process.cwd();
     }
     // It's more explicit to assign the undefined
     // eslint-disable-next-line no-undefined -- Consistently returning a value
     return undefined;
 }
 /**
  * The map to store private data.
  * @type {WeakMap<Linter, LinterInternalSlots>}
  */
 const internalSlotsMap = new WeakMap();
 /**
  * Throws an error when the given linter is in flat config mode.
  * @param {Linter} linter The linter to check.
@@ -1196,23 +1042,18 @@ const internalSlotsMap = new WeakMap();
  */
 function assertEslintrcConfig(linter) {
     const { configType } = internalSlotsMap.get(linter);
     if (configType === "flat") {
         throw new Error("This method cannot be used with flat config. Add your entries directly into the config array.");
     }
 }
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
 /**
  * Object that is responsible for verifying JavaScript text
  * @name Linter
  */
 class Linter {
     /**
      * Initialize the Linter.
      * @param {Object} [config] the config object
@@ -1229,10 +1070,8 @@ class Linter {
             parserMap: new Map([["espree", espree]]),
             ruleMap: new Rules()
         });
         this.version = pkg.version;
     }
     /**
      * Getter for package version.
      * @static
@@ -1241,7 +1080,6 @@ class Linter {
     static get version() {
         return pkg.version;
     }
     /**
      * Same as linter.verify, except without support for processors.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
@@ -1254,8 +1092,7 @@ class Linter {
         const slots = internalSlotsMap.get(this);
         const config = providedConfig || {};
         const options = normalizeVerifyOptions(providedOptions, config);
-        let text;
+        let text; // TODO: Remove if unused
         // evaluate arguments
         if (typeof textOrSourceCode === "string") {
             slots.lastSourceCode = null;
@@ -1264,11 +1101,9 @@ class Linter {
             slots.lastSourceCode = textOrSourceCode;
             text = textOrSourceCode.text;
         }
         // Resolve parser.
         let parserName = DEFAULT_PARSER_NAME;
         let parser = espree;
         if (typeof config.parser === "object" && config.parser !== null) {
             parserName = config.parser.filePath;
             parser = config.parser.definition;
@@ -1287,7 +1122,6 @@ class Linter {
             parserName = config.parser;
             parser = slots.parserMap.get(config.parser);
         }
         // search and apply "eslint-env *".
         const envInFile = options.allowInlineConfig && !options.warnInlineConfig
             ? findEslintEnv(text)
@@ -1297,7 +1131,6 @@ class Linter {
             .filter(envName => resolvedEnvConfig[envName])
             .map(envName => getEnv(slots, envName))
             .filter(env => env);
         const parserOptions = resolveParserOptions(parser, config.parserOptions || {}, enabledEnvs);
         const configuredGlobals = resolveGlobals(config.globals || {}, enabledEnvs);
         const settings = config.settings || {};
@@ -1306,21 +1139,17 @@ class Linter {
             parser,
             parserOptions
         });
         if (!slots.lastSourceCode) {
             const parseResult = parse(
                 text,
                 languageOptions,
                 options.filename
             );
             if (!parseResult.success) {
                 return [parseResult.error];
             }
             slots.lastSourceCode = parseResult.sourceCode;
         } else {
             /*
              * If the given source code object as the first argument does not have scopeManager, analyze the scope.
              * This is for backward compatibility (SourceCode is frozen so it cannot rebind).
@@ -1335,22 +1164,18 @@ class Linter {
                 });
             }
         }
         const sourceCode = slots.lastSourceCode;
         const commentDirectives = options.allowInlineConfig
             ? getDirectiveComments(sourceCode, ruleId => getRule(slots, ruleId), options.warnInlineConfig)
             : { configuredRules: {}, enabledGlobals: {}, exportedVariables: {}, problems: [], disableDirectives: [] };
         // augment global scope with declared global variables
         addDeclaredGlobals(
             sourceCode.scopeManager.scopes[0],
             configuredGlobals,
             { exportedVariables: commentDirectives.exportedVariables, enabledGlobals: commentDirectives.enabledGlobals }
         );
         const configuredRules = Object.assign({}, config.rules, commentDirectives.configuredRules);
-        let lintingProblems;
+        let lintingProblems; // TODO: Remove if unused
         try {
             lintingProblems = runRules(
                 sourceCode,
@@ -1370,21 +1195,17 @@ class Linter {
             debug("Filename:", options.filename);
             if (err.currentNode) {
                 const { line } = err.currentNode.loc.start;
                 debug("Line:", line);
                 err.message += `:${line}`;
             }
             debug("Parser Options:", parserOptions);
             debug("Parser Path:", parserName);
             debug("Settings:", settings);
             if (err.ruleId) {
                 err.message += `\nRule: "${err.ruleId}"`;
             }
             throw err;
         }
         return applyDisableDirectives({
             directives: commentDirectives.disableDirectives,
             disableFixes: options.disableFixes,
@@ -1394,7 +1215,6 @@ class Linter {
             reportUnusedDisableDirectives: options.reportUnusedDisableDirectives
         });
     }
     /**
      * Verifies the text against the rules specified by the second argument.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
@@ -1406,16 +1226,12 @@ class Linter {
      */
     verify(textOrSourceCode, config, filenameOrOptions) {
         debug("Verify");
         const { configType, cwd } = internalSlotsMap.get(this);
         const options = typeof filenameOrOptions === "string"
             ? { filename: filenameOrOptions }
             : filenameOrOptions || {};
         if (config) {
             if (configType === "flat") {
                 /*
                  * Because of how Webpack packages up the files, we can't
                  * compare directly to `FlatConfigArray` using `instanceof`
@@ -1424,25 +1240,20 @@ class Linter {
                  * `FlatConfigArray` if it has a `getConfig()` method.
                  */
                 let configArray = config;
                 if (!Array.isArray(config) || typeof config.getConfig !== "function") {
                     configArray = new FlatConfigArray(config, { basePath: cwd });
                     configArray.normalizeSync();
                 }
                 return this._distinguishSuppressedMessages(this._verifyWithFlatConfigArray(textOrSourceCode, configArray, options, true));
             }
             if (typeof config.extractConfig === "function") {
                 return this._distinguishSuppressedMessages(this._verifyWithConfigArray(textOrSourceCode, config, options));
             }
         }
         /*
          * If we get to here, it means `config` is just an object rather
          * than a config array so we can go right into linting.
          */
         /*
          * `Linter` doesn't support `overrides` property in configuration.
          * So we cannot apply multiple processors.
@@ -1452,7 +1263,6 @@ class Linter {
         }
         return this._distinguishSuppressedMessages(this._verifyWithoutProcessors(textOrSourceCode, config, options));
     }
     /**
      * Verify with a processor.
      * @param {string|SourceCode} textOrSourceCode The source code.
@@ -1472,18 +1282,13 @@ class Linter {
             options.filterCodeBlock ||
             (blockFilename => blockFilename.endsWith(".js"));
         const originalExtname = path.extname(filename);
-        let blocks;
+        let blocks; // TODO: Remove if unused
         try {
             blocks = preprocess(text, filenameToExpose);
         } catch (ex) {
             // If the message includes a leading line number, strip it:
             const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
             debug("%s\n%s", message, ex.stack);
             return [
                 {
                     ruleId: null,
@@ -1496,24 +1301,19 @@ class Linter {
                 }
             ];
         }
         const messageLists = blocks.map((block, i) => {
             debug("A code block was found: %o", block.filename || "(unnamed)");
             // Keep the legacy behavior.
             if (typeof block === "string") {
                 return this._verifyWithFlatConfigArrayAndWithoutProcessors(block, config, options);
             }
             const blockText = block.text;
             const blockName = path.join(filename, `${i}_${block.filename}`);
             // Skip this block if filtered.
             if (!filterCodeBlock(blockName, blockText)) {
                 debug("This code block was skipped.");
                 return [];
             }
             // Resolve configuration again if the file content or extension was changed.
             if (configForRecursive && (text !== blockText || path.extname(blockName) !== originalExtname)) {
                 debug("Resolving configuration again because the file content or extension was changed.");
@@ -1523,7 +1323,6 @@ class Linter {
                     { ...options, filename: blockName, physicalFilename }
                 );
             }
             // Does lint.
             return this._verifyWithFlatConfigArrayAndWithoutProcessors(
                 blockText,
@@ -1531,10 +1330,8 @@ class Linter {
                 { ...options, filename: blockName, physicalFilename }
             );
         });
         return postprocess(messageLists, filenameToExpose);
     }
     /**
      * Same as linter.verify, except without support for processors.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
@@ -1547,8 +1344,7 @@ class Linter {
         const slots = internalSlotsMap.get(this);
         const config = providedConfig || {};
         const options = normalizeVerifyOptions(providedOptions, config);
-        let text;
+        let text; // TODO: Remove if unused
         // evaluate arguments
         if (typeof textOrSourceCode === "string") {
             slots.lastSourceCode = null;
@@ -1557,26 +1353,19 @@ class Linter {
             slots.lastSourceCode = textOrSourceCode;
             text = textOrSourceCode.text;
         }
         const languageOptions = config.languageOptions;
         languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions(
             languageOptions.ecmaVersion
         );
         // double check that there is a parser to avoid mysterious error messages
         if (!languageOptions.parser) {
             throw new TypeError(`No parser specified for ${options.filename}`);
         }
         // Espree expects this information to be passed in
         if (isEspree(languageOptions.parser)) {
             const parserOptions = languageOptions.parserOptions;
             if (languageOptions.sourceType) {
                 parserOptions.sourceType = languageOptions.sourceType;
                 if (
                     parserOptions.sourceType === "module" &&
                     parserOptions.ecmaFeatures &&
@@ -1586,23 +1375,18 @@ class Linter {
                 }
             }
         }
         const settings = config.settings || {};
         if (!slots.lastSourceCode) {
             const parseResult = parse(
                 text,
                 languageOptions,
                 options.filename
             );
             if (!parseResult.success) {
                 return [parseResult.error];
             }
             slots.lastSourceCode = parseResult.sourceCode;
         } else {
             /*
              * If the given source code object as the first argument does not have scopeManager, analyze the scope.
              * This is for backward compatibility (SourceCode is frozen so it cannot rebind).
@@ -1617,21 +1401,17 @@ class Linter {
                 });
             }
         }
         const sourceCode = slots.lastSourceCode;
         /*
          * Make adjustments based on the language options. For JavaScript,
          * this is primarily about adding variables into the global scope
          * to account for ecmaVersion and configured globals.
          */
         sourceCode.applyLanguageOptions(languageOptions);
         const mergedInlineConfig = {
             rules: {}
         };
         const inlineConfigProblems = [];
         /*
          * Inline config can be either enabled or disabled. If disabled, it's possible
          * to detect the inline config and emit a warning (though this is not required).
@@ -1639,7 +1419,6 @@ class Linter {
          * need to check if it's a warning or not.
          */
         if (options.allowInlineConfig) {
             // if inline config should warn then add the warnings
             if (options.warnInlineConfig) {
                 sourceCode.getInlineConfigNodes().forEach(node => {
@@ -1649,11 +1428,9 @@ class Linter {
                         loc: node.loc,
                         severity: 1
                     }));
                 });
             } else {
                 const inlineConfigResult = sourceCode.applyInlineConfig();
                 inlineConfigProblems.push(
                     ...inlineConfigResult.problems
                         .map(createLintingProblem)
@@ -1662,28 +1439,20 @@ class Linter {
                             return problem;
                         })
                 );
                 // next we need to verify information about the specified rules
                 const ruleValidator = new RuleValidator();
                 for (const { config: inlineConfig, node } of inlineConfigResult.configs) {
                     Object.keys(inlineConfig.rules).forEach(ruleId => {
                         const rule = getRuleFromConfig(ruleId, config);
                         const ruleValue = inlineConfig.rules[ruleId];
                         if (!rule) {
                             inlineConfigProblems.push(createLintingProblem({ ruleId, loc: node.loc }));
                             return;
                         }
                         try {
                             const ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
                             assertIsRuleOptions(ruleId, ruleValue);
                             assertIsRuleSeverity(ruleId, ruleOptions[0]);
                             ruleValidator.validate({
                                 plugins: config.plugins,
                                 rules: {
@@ -1692,17 +1461,14 @@ class Linter {
                             });
                             mergedInlineConfig.rules[ruleId] = ruleValue;
                         } catch (err) {
                             let baseMessage = err.message.slice(
                                 err.message.startsWith("Key \"rules\":")
                                     ? err.message.indexOf(":", 12) + 1
                                     : err.message.indexOf(":") + 1
                             ).trim();
                             if (err.messageTemplate) {
                                 baseMessage += ` You passed "${ruleValue}".`;
                             }
                             inlineConfigProblems.push(createLintingProblem({
                                 ruleId,
                                 message: `Inline configuration for rule "${ruleId}" is invalid:\n\t${baseMessage}\n`,
@@ -1713,19 +1479,15 @@ class Linter {
                 }
             }
         }
         const commentDirectives = options.allowInlineConfig && !options.warnInlineConfig
             ? getDirectiveCommentsForFlatConfig(
                 sourceCode,
                 ruleId => getRuleFromConfig(ruleId, config)
             )
             : { problems: [], disableDirectives: [] };
         const configuredRules = Object.assign({}, config.rules, mergedInlineConfig.rules);
-        let lintingProblems;
+        let lintingProblems; // TODO: Remove if unused
         sourceCode.finalize();
         try {
             lintingProblems = runRules(
                 sourceCode,
@@ -1745,22 +1507,17 @@ class Linter {
             debug("Filename:", options.filename);
             if (err.currentNode) {
                 const { line } = err.currentNode.loc.start;
                 debug("Line:", line);
                 err.message += `:${line}`;
             }
             debug("Parser Options:", languageOptions.parserOptions);
             // debug("Parser Path:", parserName);
             debug("Settings:", settings);
             if (err.ruleId) {
                 err.message += `\nRule: "${err.ruleId}"`;
             }
             throw err;
         }
         return applyDisableDirectives({
             directives: commentDirectives.disableDirectives,
             disableFixes: options.disableFixes,
@@ -1771,7 +1528,6 @@ class Linter {
             reportUnusedDisableDirectives: options.reportUnusedDisableDirectives
         });
     }
     /**
      * Verify a given code with `ConfigArray`.
      * @param {string|SourceCode} textOrSourceCode The source code.
@@ -1781,22 +1537,18 @@ class Linter {
      */
     _verifyWithConfigArray(textOrSourceCode, configArray, options) {
         debug("With ConfigArray: %s", options.filename);
         // Store the config array in order to get plugin envs and rules later.
         internalSlotsMap.get(this).lastConfigArray = configArray;
         // Extract the final config for this file.
         const config = configArray.extractConfig(options.filename);
         const processor =
             config.processor &&
             configArray.pluginProcessors.get(config.processor);
         // Verify.
         if (processor) {
             debug("Apply the processor: %o", config.processor);
             const { preprocess, postprocess, supportsAutofix } = processor;
             const disableFixes = options.disableFixes || !supportsAutofix;
             return this._verifyWithProcessor(
                 textOrSourceCode,
                 config,
@@ -1806,7 +1558,6 @@ class Linter {
         }
         return this._verifyWithoutProcessors(textOrSourceCode, config, options);
     }
     /**
      * Verify a given code with a flat config.
      * @param {string|SourceCode} textOrSourceCode The source code.
@@ -1818,14 +1569,11 @@ class Linter {
      */
     _verifyWithFlatConfigArray(textOrSourceCode, configArray, options, firstCall = false) {
         debug("With flat config: %s", options.filename);
         // we need a filename to match configs against
         const filename = options.filename || "__placeholder__.js";
         // Store the config array in order to get plugin envs and rules later.
         internalSlotsMap.get(this).lastConfigArray = configArray;
         const config = configArray.getConfig(filename);
         if (!config) {
             return [
                 {
@@ -1838,13 +1586,11 @@ class Linter {
                 }
             ];
         }
         // Verify.
         if (config.processor) {
             debug("Apply the processor: %o", config.processor);
             const { preprocess, postprocess, supportsAutofix } = config.processor;
             const disableFixes = options.disableFixes || !supportsAutofix;
             return this._verifyWithFlatConfigArrayAndProcessor(
                 textOrSourceCode,
                 config,
@@ -1852,15 +1598,12 @@ class Linter {
                 configArray
             );
         }
         // check for options-based processing
         if (firstCall && (options.preprocess || options.postprocess)) {
             return this._verifyWithFlatConfigArrayAndProcessor(textOrSourceCode, config, options);
         }
         return this._verifyWithFlatConfigArrayAndWithoutProcessors(textOrSourceCode, config, options);
     }
     /**
      * Verify with a processor.
      * @param {string|SourceCode} textOrSourceCode The source code.
@@ -1880,18 +1623,13 @@ class Linter {
             options.filterCodeBlock ||
             (blockFilename => blockFilename.endsWith(".js"));
         const originalExtname = path.extname(filename);
-        let blocks;
+        let blocks; // TODO: Remove if unused
         try {
             blocks = preprocess(text, filenameToExpose);
         } catch (ex) {
             // If the message includes a leading line number, strip it:
             const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
             debug("%s\n%s", message, ex.stack);
             return [
                 {
                     ruleId: null,
@@ -1904,24 +1642,19 @@ class Linter {
                 }
             ];
         }
         const messageLists = blocks.map((block, i) => {
             debug("A code block was found: %o", block.filename || "(unnamed)");
             // Keep the legacy behavior.
             if (typeof block === "string") {
                 return this._verifyWithoutProcessors(block, config, options);
             }
             const blockText = block.text;
             const blockName = path.join(filename, `${i}_${block.filename}`);
             // Skip this block if filtered.
             if (!filterCodeBlock(blockName, blockText)) {
                 debug("This code block was skipped.");
                 return [];
             }
             // Resolve configuration again if the file content or extension was changed.
             if (configForRecursive && (text !== blockText || path.extname(blockName) !== originalExtname)) {
                 debug("Resolving configuration again because the file content or extension was changed.");
@@ -1931,7 +1664,6 @@ class Linter {
                     { ...options, filename: blockName, physicalFilename }
                 );
             }
             // Does lint.
             return this._verifyWithoutProcessors(
                 blockText,
@@ -1939,10 +1671,8 @@ class Linter {
                 { ...options, filename: blockName, physicalFilename }
             );
         });
         return postprocess(messageLists, filenameToExpose);
     }
     /**
      * Given a list of reported problems, distinguish problems between normal messages and suppressed messages.
      * The normal messages will be returned and the suppressed messages will be stored as lastSuppressedMessages.
@@ -1953,7 +1683,6 @@ class Linter {
         const messages = [];
         const suppressedMessages = [];
         const slots = internalSlotsMap.get(this);
         for (const problem of problems) {
             if (problem.suppressions) {
                 suppressedMessages.push(problem);
@@ -1961,12 +1690,9 @@ class Linter {
                 messages.push(problem);
             }
         }
         slots.lastSuppressedMessages = suppressedMessages;
         return messages;
     }
     /**
      * Gets the SourceCode object representing the parsed source.
      * @returns {SourceCode} The SourceCode object.
@@ -1974,7 +1700,6 @@ class Linter {
     getSourceCode() {
         return internalSlotsMap.get(this).lastSourceCode;
     }
     /**
      * Gets the list of SuppressedLintMessage produced in the last running.
      * @returns {SuppressedLintMessage[]} The list of SuppressedLintMessage
@@ -1982,7 +1707,6 @@ class Linter {
     getSuppressedMessages() {
         return internalSlotsMap.get(this).lastSuppressedMessages;
     }
     /**
      * Defines a new linting rule.
      * @param {string} ruleId A unique rule identifier
@@ -1993,7 +1717,6 @@ class Linter {
         assertEslintrcConfig(this);
         internalSlotsMap.get(this).ruleMap.define(ruleId, ruleModule);
     }
     /**
      * Defines many new linting rules.
      * @param {Record<string, Function | Rule>} rulesToDefine map from unique rule identifier to rule
@@ -2005,7 +1728,6 @@ class Linter {
             this.defineRule(ruleId, rulesToDefine[ruleId]);
         });
     }
     /**
      * Gets an object with all loaded rules.
      * @returns {Map<string, Rule>} All loaded rules
@@ -2013,16 +1735,13 @@ class Linter {
     getRules() {
         assertEslintrcConfig(this);
         const { lastConfigArray, ruleMap } = internalSlotsMap.get(this);
         return new Map(function *() {
             yield* ruleMap;
             if (lastConfigArray) {
                 yield* lastConfigArray.pluginRules;
             }
         }());
     }
     /**
      * Define a new parser module
      * @param {string} parserId Name of the parser
@@ -2033,7 +1752,6 @@ class Linter {
         assertEslintrcConfig(this);
         internalSlotsMap.get(this).parserMap.set(parserId, parserModule);
     }
     /**
      * Performs multiple autofix passes over the text until as many fixes as possible
      * have been applied.
@@ -2051,7 +1769,6 @@ class Linter {
             currentText = text;
         const debugTextDescription = options && options.filename || `${text.slice(0, 10)}...`;
         const shouldFix = options && typeof options.fix !== "undefined" ? options.fix : true;
         /**
          * This loop continues until one of the following is true:
          *
@@ -2063,13 +1780,10 @@ class Linter {
          */
         do {
             passNumber++;
             debug(`Linting code for ${debugTextDescription} (pass ${passNumber})`);
             messages = this.verify(currentText, config, options);
             debug(`Generating fixed text for ${debugTextDescription} (pass ${passNumber})`);
             fixedResult = SourceCodeFixer.applyFixes(currentText, messages, shouldFix);
             /*
              * stop if there are any syntax errors.
              * 'fixedResult.output' is a empty string.
@@ -2077,18 +1791,14 @@ class Linter {
             if (messages.length === 1 && messages[0].fatal) {
                 break;
             }
             // keep track if any fixes were ever applied - important for return value
             fixed = fixed || fixedResult.fixed;
             // update to use the fixed output instead of the original text
             currentText = fixedResult.output;
         } while (
             fixedResult.fixed &&
             passNumber < MAX_AUTOFIX_PASSES
         );
         /*
          * If the last result had fixes, we need to lint again to be sure we have
          * the most up-to-date information.
@@ -2096,18 +1806,14 @@ class Linter {
         if (fixedResult.fixed) {
             fixedResult.messages = this.verify(currentText, config, options);
         }
         // ensure the last result properly reflects if fixes were done
         fixedResult.fixed = fixed;
         fixedResult.output = currentText;
         return fixedResult;
     }
 }
 module.exports = {
     Linter,
     /**
      * Get the internal slots of a given Linter instance for tests.
      * @param {Linter} instance The Linter instance to get.
@@ -2116,4 +1822,4 @@ module.exports = {
     getLinterInternalSlots(instance) {
         return internalSlotsMap.get(instance);
     }
-};
+};