eslint 9.21.0 → 9.23.0

package/lib/cli-engine/cli-engine.js

@@ -20,16 +20,15 @@ const path = require("node:path");
 const defaultOptions = require("../../conf/default-cli-options");
 const pkg = require("../../package.json");
 
-
 const {
-    Legacy: {
-        ConfigOps,
-        naming,
-        CascadingConfigArrayFactory,
-        IgnorePattern,
-        getUsedExtractedConfigs,
-        ModuleResolver
-    }
+	Legacy: {
+		ConfigOps,
+		naming,
+		CascadingConfigArrayFactory,
+		IgnorePattern,
+		getUsedExtractedConfigs,
+		ModuleResolver,
+	},
 } = require("@eslint/eslintrc");
 
 const { FileEnumerator } = require("./file-enumerator");
@@ -42,15 +41,15 @@ const LintResultCache = require("./lint-result-cache");
 
 const debug = require("debug")("eslint:cli-engine");
 const removedFormatters = new Set([
-    "checkstyle",
-    "codeframe",
-    "compact",
-    "jslint-xml",
-    "junit",
-    "table",
-    "tap",
-    "unix",
-    "visualstudio"
+	"checkstyle",
+	"codeframe",
+	"compact",
+	"jslint-xml",
+	"junit",
+	"table",
+	"tap",
+	"unix",
+	"visualstudio",
 ]);
 const validFixTypes = new Set(["directive", "problem", "suggestion", "layout"]);
 
@@ -155,11 +154,11 @@ const internalSlotsMap = new WeakMap();
  * @throws {Error} If an invalid fix type is found.
  */
 function validateFixTypes(fixTypes) {
-    for (const fixType of fixTypes) {
-        if (!validFixTypes.has(fixType)) {
-            throw new Error(`Invalid fix type "${fixType}" found.`);
-        }
-    }
+	for (const fixType of fixTypes) {
+		if (!validFixTypes.has(fixType)) {
+			throw new Error(`Invalid fix type "${fixType}" found.`);
+		}
+	}
 }
 
 /**
@@ -169,33 +168,33 @@ function validateFixTypes(fixTypes) {
  * @private
  */
 function calculateStatsPerFile(messages) {
-    const stat = {
-        errorCount: 0,
-        fatalErrorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-    };
-
-    for (let i = 0; i < messages.length; i++) {
-        const message = messages[i];
-
-        if (message.fatal || message.severity === 2) {
-            stat.errorCount++;
-            if (message.fatal) {
-                stat.fatalErrorCount++;
-            }
-            if (message.fix) {
-                stat.fixableErrorCount++;
-            }
-        } else {
-            stat.warningCount++;
-            if (message.fix) {
-                stat.fixableWarningCount++;
-            }
-        }
-    }
-    return stat;
+	const stat = {
+		errorCount: 0,
+		fatalErrorCount: 0,
+		warningCount: 0,
+		fixableErrorCount: 0,
+		fixableWarningCount: 0,
+	};
+
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+
+		if (message.fatal || message.severity === 2) {
+			stat.errorCount++;
+			if (message.fatal) {
+				stat.fatalErrorCount++;
+			}
+			if (message.fix) {
+				stat.fixableErrorCount++;
+			}
+		} else {
+			stat.warningCount++;
+			if (message.fix) {
+				stat.fixableWarningCount++;
+			}
+		}
+	}
+	return stat;
 }
 
 /**
@@ -205,25 +204,25 @@ function calculateStatsPerFile(messages) {
  * @private
  */
 function calculateStatsPerRun(results) {
-    const stat = {
-        errorCount: 0,
-        fatalErrorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-    };
-
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-
-        stat.errorCount += result.errorCount;
-        stat.fatalErrorCount += result.fatalErrorCount;
-        stat.warningCount += result.warningCount;
-        stat.fixableErrorCount += result.fixableErrorCount;
-        stat.fixableWarningCount += result.fixableWarningCount;
-    }
-
-    return stat;
+	const stat = {
+		errorCount: 0,
+		fatalErrorCount: 0,
+		warningCount: 0,
+		fixableErrorCount: 0,
+		fixableWarningCount: 0,
+	};
+
+	for (let i = 0; i < results.length; i++) {
+		const result = results[i];
+
+		stat.errorCount += result.errorCount;
+		stat.fatalErrorCount += result.fatalErrorCount;
+		stat.warningCount += result.warningCount;
+		stat.fixableErrorCount += result.fixableErrorCount;
+		stat.fixableWarningCount += result.fixableWarningCount;
+	}
+
+	return stat;
 }
 
 /**
@@ -242,65 +241,62 @@ function calculateStatsPerRun(results) {
  * @private
  */
 function verifyText({
-    text,
-    cwd,
-    filePath: providedFilePath,
-    config,
-    fix,
-    allowInlineConfig,
-    reportUnusedDisableDirectives,
-    fileEnumerator,
-    linter
+	text,
+	cwd,
+	filePath: providedFilePath,
+	config,
+	fix,
+	allowInlineConfig,
+	reportUnusedDisableDirectives,
+	fileEnumerator,
+	linter,
 }) {
-    const filePath = providedFilePath || "<text>";
-
-    debug(`Lint ${filePath}`);
-
-    /*
-     * Verify.
-     * `config.extractConfig(filePath)` requires an absolute path, but `linter`
-     * doesn't know CWD, so it gives `linter` an absolute path always.
-     */
-    const filePathToVerify = filePath === "<text>" ? path.join(cwd, filePath) : filePath;
-    const { fixed, messages, output } = linter.verifyAndFix(
-        text,
-        config,
-        {
-            allowInlineConfig,
-            filename: filePathToVerify,
-            fix,
-            reportUnusedDisableDirectives,
-
-            /**
-             * Check if the linter should adopt a given code block or not.
-             * @param {string} blockFilename The virtual filename of a code block.
-             * @returns {boolean} `true` if the linter should adopt the code block.
-             */
-            filterCodeBlock(blockFilename) {
-                return fileEnumerator.isTargetPath(blockFilename);
-            }
-        }
-    );
-
-    // Tweak and return.
-    const result = {
-        filePath,
-        messages,
-        suppressedMessages: linter.getSuppressedMessages(),
-        ...calculateStatsPerFile(messages)
-    };
-
-    if (fixed) {
-        result.output = output;
-    }
-    if (
-        result.errorCount + result.warningCount > 0 &&
-        typeof result.output === "undefined"
-    ) {
-        result.source = text;
-    }
-
-    return result;
+	const filePath = providedFilePath || "<text>";
+
+	debug(`Lint ${filePath}`);
+
+	/*
+	 * Verify.
+	 * `config.extractConfig(filePath)` requires an absolute path, but `linter`
+	 * doesn't know CWD, so it gives `linter` an absolute path always.
+	 */
+	const filePathToVerify =
+		filePath === "<text>" ? path.join(cwd, filePath) : filePath;
+	const { fixed, messages, output } = linter.verifyAndFix(text, config, {
+		allowInlineConfig,
+		filename: filePathToVerify,
+		fix,
+		reportUnusedDisableDirectives,
+
+		/**
+		 * Check if the linter should adopt a given code block or not.
+		 * @param {string} blockFilename The virtual filename of a code block.
+		 * @returns {boolean} `true` if the linter should adopt the code block.
+		 */
+		filterCodeBlock(blockFilename) {
+			return fileEnumerator.isTargetPath(blockFilename);
+		},
+	});
+
+	// Tweak and return.
+	const result = {
+		filePath,
+		messages,
+		suppressedMessages: linter.getSuppressedMessages(),
+		...calculateStatsPerFile(messages),
+	};
+
+	if (fixed) {
+		result.output = output;
+	}
+	if (
+		result.errorCount + result.warningCount > 0 &&
+		typeof result.output === "undefined"
+	) {
+		result.source = text;
+	}
+
+	return result;
 }
 
 /**
@@ -311,37 +307,42 @@ function verifyText({
  * @private
  */
 function createIgnoreResult(filePath, baseDir) {
-    let message;
-    const isHidden = filePath.split(path.sep)
-        .find(segment => /^\./u.test(segment));
-    const isInNodeModules = baseDir && path.relative(baseDir, filePath).startsWith("node_modules");
-
-    if (isHidden) {
-        message = "File ignored by default.  Use a negated ignore pattern (like \"--ignore-pattern '!<relative/path/to/filename>'\") to override.";
-    } else if (isInNodeModules) {
-        message = "File ignored by default. Use \"--ignore-pattern '!node_modules/*'\" to override.";
-    } else {
-        message = "File ignored because of a matching ignore pattern. Use \"--no-ignore\" to override.";
-    }
-
-    return {
-        filePath: path.resolve(filePath),
-        messages: [
-            {
-                ruleId: null,
-                fatal: false,
-                severity: 1,
-                message,
-                nodeType: null
-            }
-        ],
-        suppressedMessages: [],
-        errorCount: 0,
-        fatalErrorCount: 0,
-        warningCount: 1,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-    };
+	let message;
+	const isHidden = filePath
+		.split(path.sep)
+		.find(segment => /^\./u.test(segment));
+	const isInNodeModules =
+		baseDir && path.relative(baseDir, filePath).startsWith("node_modules");
+
+	if (isHidden) {
+		message =
+			"File ignored by default.  Use a negated ignore pattern (like \"--ignore-pattern '!<relative/path/to/filename>'\") to override.";
+	} else if (isInNodeModules) {
+		message =
+			"File ignored by default. Use \"--ignore-pattern '!node_modules/*'\" to override.";
+	} else {
+		message =
+			'File ignored because of a matching ignore pattern. Use "--no-ignore" to override.';
+	}
+
+	return {
+		filePath: path.resolve(filePath),
+		messages: [
+			{
+				ruleId: null,
+				fatal: false,
+				severity: 1,
+				message,
+				nodeType: null,
+			},
+		],
+		suppressedMessages: [],
+		errorCount: 0,
+		fatalErrorCount: 0,
+		warningCount: 1,
+		fixableErrorCount: 0,
+		fixableWarningCount: 0,
+	};
 }
 
 /**
@@ -351,14 +352,14 @@ function createIgnoreResult(filePath, baseDir) {
  * @returns {Rule|null} The rule or null.
  */
 function getRule(ruleId, configArrays) {
-    for (const configArray of configArrays) {
-        const rule = configArray.pluginRules.get(ruleId);
-
-        if (rule) {
-            return rule;
-        }
-    }
-    return builtInRules.get(ruleId) || null;
+	for (const configArray of configArrays) {
+		const rule = configArray.pluginRules.get(ruleId);
+
+		if (rule) {
+			return rule;
+		}
+	}
+	return builtInRules.get(ruleId) || null;
 }
 
 /**
@@ -369,13 +370,13 @@ function getRule(ruleId, configArrays) {
  * @returns {boolean} Whether the message should be fixed.
  */
 function shouldMessageBeFixed(message, lastConfigArrays, fixTypes) {
-    if (!message.ruleId) {
-        return fixTypes.has("directive");
-    }
+	if (!message.ruleId) {
+		return fixTypes.has("directive");
+	}
 
-    const rule = message.ruleId && getRule(message.ruleId, lastConfigArrays);
+	const rule = message.ruleId && getRule(message.ruleId, lastConfigArrays);
 
-    return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type));
+	return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type));
 }
 
 /**
@@ -383,41 +384,40 @@ function shouldMessageBeFixed(message, lastConfigArrays, fixTypes) {
  * @param {ConfigArray[]} usedConfigArrays The config arrays which were used.
  * @returns {IterableIterator<DeprecatedRuleInfo>} Used deprecated rules.
  */
-function *iterateRuleDeprecationWarnings(usedConfigArrays) {
-    const processedRuleIds = new Set();
-
-    // Flatten used configs.
-    /** @type {ExtractedConfig[]} */
-    const configs = usedConfigArrays.flatMap(getUsedExtractedConfigs);
-
-    // Traverse rule configs.
-    for (const config of configs) {
-        for (const [ruleId, ruleConfig] of Object.entries(config.rules)) {
-
-            // Skip if it was processed.
-            if (processedRuleIds.has(ruleId)) {
-                continue;
-            }
-            processedRuleIds.add(ruleId);
-
-            // Skip if it's not used.
-            if (!ConfigOps.getRuleSeverity(ruleConfig)) {
-                continue;
-            }
-            const rule = getRule(ruleId, usedConfigArrays);
-
-            // Skip if it's not deprecated.
-            if (!(rule && rule.meta && rule.meta.deprecated)) {
-                continue;
-            }
-
-            // This rule was used and deprecated.
-            yield {
-                ruleId,
-                replacedBy: rule.meta.replacedBy || []
-            };
-        }
-    }
+function* iterateRuleDeprecationWarnings(usedConfigArrays) {
+	const processedRuleIds = new Set();
+
+	// Flatten used configs.
+	/** @type {ExtractedConfig[]} */
+	const configs = usedConfigArrays.flatMap(getUsedExtractedConfigs);
+
+	// Traverse rule configs.
+	for (const config of configs) {
+		for (const [ruleId, ruleConfig] of Object.entries(config.rules)) {
+			// Skip if it was processed.
+			if (processedRuleIds.has(ruleId)) {
+				continue;
+			}
+			processedRuleIds.add(ruleId);
+
+			// Skip if it's not used.
+			if (!ConfigOps.getRuleSeverity(ruleConfig)) {
+				continue;
+			}
+			const rule = getRule(ruleId, usedConfigArrays);
+
+			// Skip if it's not deprecated.
+			if (!(rule && rule.meta && rule.meta.deprecated)) {
+				continue;
+			}
+
+			// This rule was used and deprecated.
+			yield {
+				ruleId,
+				replacedBy: rule.meta.replacedBy || [],
+			};
+		}
+	}
 }
 
 /**
@@ -427,10 +427,9 @@ function *iterateRuleDeprecationWarnings(usedConfigArrays) {
  * @private
  */
 function isErrorMessage(message) {
-    return message.severity === 2;
+	return message.severity === 2;
 }
 
-
 /**
  * return the cacheFile to be used by eslint, based on whether the provided parameter is
  * a directory or looks like a directory (ends in `path.sep`), in which case the file
@@ -442,65 +441,62 @@ function isErrorMessage(message) {
  * @returns {string} the resolved path to the cache file
  */
 function getCacheFile(cacheFile, cwd) {
-
-    /*
-     * make sure the path separators are normalized for the environment/os
-     * keeping the trailing path separator if present
-     */
-    const normalizedCacheFile = path.normalize(cacheFile);
-
-    const resolvedCacheFile = path.resolve(cwd, normalizedCacheFile);
-    const looksLikeADirectory = normalizedCacheFile.slice(-1) === path.sep;
-
-    /**
-     * return the name for the cache file in case the provided parameter is a directory
-     * @returns {string} the resolved path to the cacheFile
-     */
-    function getCacheFileForDirectory() {
-        return path.join(resolvedCacheFile, `.cache_${hash(cwd)}`);
-    }
-
-    let fileStats;
-
-    try {
-        fileStats = fs.lstatSync(resolvedCacheFile);
-    } catch {
-        fileStats = null;
-    }
-
-
-    /*
-     * in case the file exists we need to verify if the provided path
-     * is a directory or a file. If it is a directory we want to create a file
-     * inside that directory
-     */
-    if (fileStats) {
-
-        /*
-         * is a directory or is a file, but the original file the user provided
-         * looks like a directory but `path.resolve` removed the `last path.sep`
-         * so we need to still treat this like a directory
-         */
-        if (fileStats.isDirectory() || looksLikeADirectory) {
-            return getCacheFileForDirectory();
-        }
-
-        // is file so just use that file
-        return resolvedCacheFile;
-    }
-
-    /*
-     * here we known the file or directory doesn't exist,
-     * so we will try to infer if its a directory if it looks like a directory
-     * for the current operating system.
-     */
-
-    // if the last character passed is a path separator we assume is a directory
-    if (looksLikeADirectory) {
-        return getCacheFileForDirectory();
-    }
-
-    return resolvedCacheFile;
+	/*
+	 * make sure the path separators are normalized for the environment/os
+	 * keeping the trailing path separator if present
+	 */
+	const normalizedCacheFile = path.normalize(cacheFile);
+
+	const resolvedCacheFile = path.resolve(cwd, normalizedCacheFile);
+	const looksLikeADirectory = normalizedCacheFile.slice(-1) === path.sep;
+
+	/**
+	 * return the name for the cache file in case the provided parameter is a directory
+	 * @returns {string} the resolved path to the cacheFile
+	 */
+	function getCacheFileForDirectory() {
+		return path.join(resolvedCacheFile, `.cache_${hash(cwd)}`);
+	}
+
+	let fileStats;
+
+	try {
+		fileStats = fs.lstatSync(resolvedCacheFile);
+	} catch {
+		fileStats = null;
+	}
+
+	/*
+	 * in case the file exists we need to verify if the provided path
+	 * is a directory or a file. If it is a directory we want to create a file
+	 * inside that directory
+	 */
+	if (fileStats) {
+		/*
+		 * is a directory or is a file, but the original file the user provided
+		 * looks like a directory but `path.resolve` removed the `last path.sep`
+		 * so we need to still treat this like a directory
+		 */
+		if (fileStats.isDirectory() || looksLikeADirectory) {
+			return getCacheFileForDirectory();
+		}
+
+		// is file so just use that file
+		return resolvedCacheFile;
+	}
+
+	/*
+	 * here we known the file or directory doesn't exist,
+	 * so we will try to infer if its a directory if it looks like a directory
+	 * for the current operating system.
+	 */
+
+	// if the last character passed is a path separator we assume is a directory
+	if (looksLikeADirectory) {
+		return getCacheFileForDirectory();
+	}
+
+	return resolvedCacheFile;
 }
 
 /**
@@ -512,23 +508,21 @@ function getCacheFile(cacheFile, cwd) {
  * @returns {Record<string,boolean>} The boolean map.
  */
 function toBooleanMap(keys, defaultValue, displayName) {
-    if (keys && !Array.isArray(keys)) {
-        throw new Error(`${displayName} must be an array.`);
-    }
-    if (keys && keys.length > 0) {
-        return keys.reduce((map, def) => {
-            const [key, value] = def.split(":");
-
-            if (key !== "__proto__") {
-                map[key] = value === void 0
-                    ? defaultValue
-                    : value === "true";
-            }
-
-            return map;
-        }, {});
-    }
-    return void 0;
+	if (keys && !Array.isArray(keys)) {
+		throw new Error(`${displayName} must be an array.`);
+	}
+	if (keys && keys.length > 0) {
+		return keys.reduce((map, def) => {
+			const [key, value] = def.split(":");
+
+			if (key !== "__proto__") {
+				map[key] = value === void 0 ? defaultValue : value === "true";
+			}
+
+			return map;
+		}, {});
+	}
+	return void 0;
 }
 
 /**
@@ -537,36 +531,30 @@ function toBooleanMap(keys, defaultValue, displayName) {
  * @returns {ConfigData|null} The created config data.
  */
 function createConfigDataFromOptions(options) {
-    const {
-        ignorePattern,
-        parser,
-        parserOptions,
-        plugins,
-        rules
-    } = options;
-    const env = toBooleanMap(options.envs, true, "envs");
-    const globals = toBooleanMap(options.globals, false, "globals");
-
-    if (
-        env === void 0 &&
-        globals === void 0 &&
-        (ignorePattern === void 0 || ignorePattern.length === 0) &&
-        parser === void 0 &&
-        parserOptions === void 0 &&
-        plugins === void 0 &&
-        rules === void 0
-    ) {
-        return null;
-    }
-    return {
-        env,
-        globals,
-        ignorePatterns: ignorePattern,
-        parser,
-        parserOptions,
-        plugins,
-        rules
-    };
+	const { ignorePattern, parser, parserOptions, plugins, rules } = options;
+	const env = toBooleanMap(options.envs, true, "envs");
+	const globals = toBooleanMap(options.globals, false, "globals");
+
+	if (
+		env === void 0 &&
+		globals === void 0 &&
+		(ignorePattern === void 0 || ignorePattern.length === 0) &&
+		parser === void 0 &&
+		parserOptions === void 0 &&
+		plugins === void 0 &&
+		rules === void 0
+	) {
+		return null;
+	}
+	return {
+		env,
+		globals,
+		ignorePatterns: ignorePattern,
+		parser,
+		parserOptions,
+		plugins,
+		rules,
+	};
 }
 
 /**
@@ -576,14 +564,14 @@ function createConfigDataFromOptions(options) {
  * @returns {boolean} `true` if a directory exists
  */
 function directoryExists(resolvedPath) {
-    try {
-        return fs.statSync(resolvedPath).isDirectory();
-    } catch (error) {
-        if (error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
-            return false;
-        }
-        throw error;
-    }
+	try {
+		return fs.statSync(resolvedPath).isDirectory();
+	} catch (error) {
+		if (error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+			return false;
+		}
+		throw error;
+	}
 }
 
 //------------------------------------------------------------------------------
@@ -594,496 +582,528 @@ function directoryExists(resolvedPath) {
  * Core CLI.
  */
 class CLIEngine {
-
-    /**
-     * Creates a new instance of the core CLI engine.
-     * @param {CLIEngineOptions} providedOptions The options for this instance.
-     * @param {Object} [additionalData] Additional settings that are not CLIEngineOptions.
-     * @param {Record<string,Plugin>|null} [additionalData.preloadedPlugins] Preloaded plugins.
-     */
-    constructor(providedOptions, { preloadedPlugins } = {}) {
-        const options = Object.assign(
-            Object.create(null),
-            defaultOptions,
-            { cwd: process.cwd() },
-            providedOptions
-        );
-
-        if (options.fix === void 0) {
-            options.fix = false;
-        }
-
-        const additionalPluginPool = new Map();
-
-        if (preloadedPlugins) {
-            for (const [id, plugin] of Object.entries(preloadedPlugins)) {
-                additionalPluginPool.set(id, plugin);
-            }
-        }
-
-        const cacheFilePath = getCacheFile(
-            options.cacheLocation || options.cacheFile,
-            options.cwd
-        );
-        const configArrayFactory = new CascadingConfigArrayFactory({
-            additionalPluginPool,
-            baseConfig: options.baseConfig || null,
-            cliConfig: createConfigDataFromOptions(options),
-            cwd: options.cwd,
-            ignorePath: options.ignorePath,
-            resolvePluginsRelativeTo: options.resolvePluginsRelativeTo,
-            rulePaths: options.rulePaths,
-            specificConfigPath: options.configFile,
-            useEslintrc: options.useEslintrc,
-            builtInRules,
-            loadRules,
-            getEslintRecommendedConfig: () => require("@eslint/js").configs.recommended,
-            getEslintAllConfig: () => require("@eslint/js").configs.all
-        });
-        const fileEnumerator = new FileEnumerator({
-            configArrayFactory,
-            cwd: options.cwd,
-            extensions: options.extensions,
-            globInputPaths: options.globInputPaths,
-            errorOnUnmatchedPattern: options.errorOnUnmatchedPattern,
-            ignore: options.ignore
-        });
-        const lintResultCache =
-            options.cache ? new LintResultCache(cacheFilePath, options.cacheStrategy) : null;
-        const linter = new Linter({ cwd: options.cwd, configType: "eslintrc" });
-
-        /** @type {ConfigArray[]} */
-        const lastConfigArrays = [configArrayFactory.getConfigArrayForFile()];
-
-        // Store private data.
-        internalSlotsMap.set(this, {
-            additionalPluginPool,
-            cacheFilePath,
-            configArrayFactory,
-            defaultIgnores: IgnorePattern.createDefaultIgnore(options.cwd),
-            fileEnumerator,
-            lastConfigArrays,
-            lintResultCache,
-            linter,
-            options
-        });
-
-        // setup special filter for fixes
-        if (options.fix && options.fixTypes && options.fixTypes.length > 0) {
-            debug(`Using fix types ${options.fixTypes}`);
-
-            // throw an error if any invalid fix types are found
-            validateFixTypes(options.fixTypes);
-
-            // convert to Set for faster lookup
-            const fixTypes = new Set(options.fixTypes);
-
-            // save original value of options.fix in case it's a function
-            const originalFix = (typeof options.fix === "function")
-                ? options.fix : () => true;
-
-            options.fix = message => shouldMessageBeFixed(message, lastConfigArrays, fixTypes) && originalFix(message);
-        }
-    }
-
-    getRules() {
-        const { lastConfigArrays } = internalSlotsMap.get(this);
-
-        return new Map(function *() {
-            yield* builtInRules;
-
-            for (const configArray of lastConfigArrays) {
-                yield* configArray.pluginRules;
-            }
-        }());
-    }
-
-    /**
-     * Returns results that only contains errors.
-     * @param {LintResult[]} results The results to filter.
-     * @returns {LintResult[]} The filtered results.
-     */
-    static getErrorResults(results) {
-        const filtered = [];
-
-        results.forEach(result => {
-            const filteredMessages = result.messages.filter(isErrorMessage);
-            const filteredSuppressedMessages = result.suppressedMessages.filter(isErrorMessage);
-
-            if (filteredMessages.length > 0) {
-                filtered.push({
-                    ...result,
-                    messages: filteredMessages,
-                    suppressedMessages: filteredSuppressedMessages,
-                    errorCount: filteredMessages.length,
-                    warningCount: 0,
-                    fixableErrorCount: result.fixableErrorCount,
-                    fixableWarningCount: 0
-                });
-            }
-        });
-
-        return filtered;
-    }
-
-    /**
-     * Outputs fixes from the given results to files.
-     * @param {LintReport} report The report object created by CLIEngine.
-     * @returns {void}
-     */
-    static outputFixes(report) {
-        report.results.filter(result => Object.hasOwn(result, "output")).forEach(result => {
-            fs.writeFileSync(result.filePath, result.output);
-        });
-    }
-
-    /**
-     * Resolves the patterns passed into executeOnFiles() into glob-based patterns
-     * for easier handling.
-     * @param {string[]} patterns The file patterns passed on the command line.
-     * @returns {string[]} The equivalent glob patterns.
-     */
-    resolveFileGlobPatterns(patterns) {
-        const { options } = internalSlotsMap.get(this);
-
-        if (options.globInputPaths === false) {
-            return patterns.filter(Boolean);
-        }
-
-        const extensions = (options.extensions || [".js"]).map(ext => ext.replace(/^\./u, ""));
-        const dirSuffix = `/**/*.{${extensions.join(",")}}`;
-
-        return patterns.filter(Boolean).map(pathname => {
-            const resolvedPath = path.resolve(options.cwd, pathname);
-            const newPath = directoryExists(resolvedPath)
-                ? pathname.replace(/[/\\]$/u, "") + dirSuffix
-                : pathname;
-
-            return path.normalize(newPath).replace(/\\/gu, "/");
-        });
-    }
-
-    /**
-     * Executes the current configuration on an array of file and directory names.
-     * @param {string[]} patterns An array of file and directory names.
-     * @throws {Error} As may be thrown by `fs.unlinkSync`.
-     * @returns {LintReport} The results for all files that were linted.
-     */
-    executeOnFiles(patterns) {
-        const {
-            cacheFilePath,
-            fileEnumerator,
-            lastConfigArrays,
-            lintResultCache,
-            linter,
-            options: {
-                allowInlineConfig,
-                cache,
-                cwd,
-                fix,
-                reportUnusedDisableDirectives
-            }
-        } = internalSlotsMap.get(this);
-        const results = [];
-        const startTime = Date.now();
-
-        // Clear the last used config arrays.
-        lastConfigArrays.length = 0;
-
-        // Delete cache file; should this do here?
-        if (!cache) {
-            try {
-                fs.unlinkSync(cacheFilePath);
-            } catch (error) {
-                const errorCode = error && error.code;
-
-                // Ignore errors when no such file exists or file system is read only (and cache file does not exist)
-                if (errorCode !== "ENOENT" && !(errorCode === "EROFS" && !fs.existsSync(cacheFilePath))) {
-                    throw error;
-                }
-            }
-        }
-
-        // Iterate source code files.
-        for (const { config, filePath, ignored } of fileEnumerator.iterateFiles(patterns)) {
-            if (ignored) {
-                results.push(createIgnoreResult(filePath, cwd));
-                continue;
-            }
-
-            /*
-             * Store used configs for:
-             * - this method uses to collect used deprecated rules.
-             * - `getRules()` method uses to collect all loaded rules.
-             * - `--fix-type` option uses to get the loaded rule's meta data.
-             */
-            if (!lastConfigArrays.includes(config)) {
-                lastConfigArrays.push(config);
-            }
-
-            // Skip if there is cached result.
-            if (lintResultCache) {
-                const cachedResult =
-                    lintResultCache.getCachedLintResults(filePath, config);
-
-                if (cachedResult) {
-                    const hadMessages =
-                        cachedResult.messages &&
-                        cachedResult.messages.length > 0;
-
-                    if (hadMessages && fix) {
-                        debug(`Reprocessing cached file to allow autofix: ${filePath}`);
-                    } else {
-                        debug(`Skipping file since it hasn't changed: ${filePath}`);
-                        results.push(cachedResult);
-                        continue;
-                    }
-                }
-            }
-
-            // Do lint.
-            const result = verifyText({
-                text: fs.readFileSync(filePath, "utf8"),
-                filePath,
-                config,
-                cwd,
-                fix,
-                allowInlineConfig,
-                reportUnusedDisableDirectives,
-                fileEnumerator,
-                linter
-            });
-
-            results.push(result);
-
-            /*
-             * Store the lint result in the LintResultCache.
-             * NOTE: The LintResultCache will remove the file source and any
-             * other properties that are difficult to serialize, and will
-             * hydrate those properties back in on future lint runs.
-             */
-            if (lintResultCache) {
-                lintResultCache.setCachedLintResults(filePath, config, result);
-            }
-        }
-
-        // Persist the cache to disk.
-        if (lintResultCache) {
-            lintResultCache.reconcile();
-        }
-
-        debug(`Linting complete in: ${Date.now() - startTime}ms`);
-        let usedDeprecatedRules;
-
-        return {
-            results,
-            ...calculateStatsPerRun(results),
-
-            // Initialize it lazily because CLI and `ESLint` API don't use it.
-            get usedDeprecatedRules() {
-                if (!usedDeprecatedRules) {
-                    usedDeprecatedRules = Array.from(
-                        iterateRuleDeprecationWarnings(lastConfigArrays)
-                    );
-                }
-                return usedDeprecatedRules;
-            }
-        };
-    }
-
-    /**
-     * Executes the current configuration on text.
-     * @param {string} text A string of JavaScript code to lint.
-     * @param {string} [filename] An optional string representing the texts filename.
-     * @param {boolean} [warnIgnored] Always warn when a file is ignored
-     * @returns {LintReport} The results for the linting.
-     */
-    executeOnText(text, filename, warnIgnored) {
-        const {
-            configArrayFactory,
-            fileEnumerator,
-            lastConfigArrays,
-            linter,
-            options: {
-                allowInlineConfig,
-                cwd,
-                fix,
-                reportUnusedDisableDirectives
-            }
-        } = internalSlotsMap.get(this);
-        const results = [];
-        const startTime = Date.now();
-        const resolvedFilename = filename && path.resolve(cwd, filename);
-
-
-        // Clear the last used config arrays.
-        lastConfigArrays.length = 0;
-        if (resolvedFilename && this.isPathIgnored(resolvedFilename)) {
-            if (warnIgnored) {
-                results.push(createIgnoreResult(resolvedFilename, cwd));
-            }
-        } else {
-            const config = configArrayFactory.getConfigArrayForFile(
-                resolvedFilename || "__placeholder__.js"
-            );
-
-            /*
-             * Store used configs for:
-             * - this method uses to collect used deprecated rules.
-             * - `getRules()` method uses to collect all loaded rules.
-             * - `--fix-type` option uses to get the loaded rule's meta data.
-             */
-            lastConfigArrays.push(config);
-
-            // Do lint.
-            results.push(verifyText({
-                text,
-                filePath: resolvedFilename,
-                config,
-                cwd,
-                fix,
-                allowInlineConfig,
-                reportUnusedDisableDirectives,
-                fileEnumerator,
-                linter
-            }));
-        }
-
-        debug(`Linting complete in: ${Date.now() - startTime}ms`);
-        let usedDeprecatedRules;
-
-        return {
-            results,
-            ...calculateStatsPerRun(results),
-
-            // Initialize it lazily because CLI and `ESLint` API don't use it.
-            get usedDeprecatedRules() {
-                if (!usedDeprecatedRules) {
-                    usedDeprecatedRules = Array.from(
-                        iterateRuleDeprecationWarnings(lastConfigArrays)
-                    );
-                }
-                return usedDeprecatedRules;
-            }
-        };
-    }
-
-    /**
-     * Returns a configuration object for the given file based on the CLI options.
-     * This is the same logic used by the ESLint CLI executable to determine
-     * configuration for each file it processes.
-     * @param {string} filePath The path of the file to retrieve a config object for.
-     * @throws {Error} If filepath a directory path.
-     * @returns {ConfigData} A configuration object for the file.
-     */
-    getConfigForFile(filePath) {
-        const { configArrayFactory, options } = internalSlotsMap.get(this);
-        const absolutePath = path.resolve(options.cwd, filePath);
-
-        if (directoryExists(absolutePath)) {
-            throw Object.assign(
-                new Error("'filePath' should not be a directory path."),
-                { messageTemplate: "print-config-with-directory-path" }
-            );
-        }
-
-        return configArrayFactory
-            .getConfigArrayForFile(absolutePath)
-            .extractConfig(absolutePath)
-            .toCompatibleObjectAsConfigFileContent();
-    }
-
-    /**
-     * Checks if a given path is ignored by ESLint.
-     * @param {string} filePath The path of the file to check.
-     * @returns {boolean} Whether or not the given path is ignored.
-     */
-    isPathIgnored(filePath) {
-        const {
-            configArrayFactory,
-            defaultIgnores,
-            options: { cwd, ignore }
-        } = internalSlotsMap.get(this);
-        const absolutePath = path.resolve(cwd, filePath);
-
-        if (ignore) {
-            const config = configArrayFactory
-                .getConfigArrayForFile(absolutePath)
-                .extractConfig(absolutePath);
-            const ignores = config.ignores || defaultIgnores;
-
-            return ignores(absolutePath);
-        }
-
-        return defaultIgnores(absolutePath);
-    }
-
-    /**
-     * Returns the formatter representing the given format or null if the `format` is not a string.
-     * @param {string} [format] The name of the format to load or the path to a
-     *      custom formatter.
-     * @throws {any} As may be thrown by requiring of formatter
-     * @returns {(FormatterFunction|null)} The formatter function or null if the `format` is not a string.
-     */
-    getFormatter(format) {
-
-        // default is stylish
-        const resolvedFormatName = format || "stylish";
-
-        // only strings are valid formatters
-        if (typeof resolvedFormatName === "string") {
-
-            // replace \ with / for Windows compatibility
-            const normalizedFormatName = resolvedFormatName.replace(/\\/gu, "/");
-
-            const slots = internalSlotsMap.get(this);
-            const cwd = slots ? slots.options.cwd : process.cwd();
-            const namespace = naming.getNamespaceFromTerm(normalizedFormatName);
-
-            let formatterPath;
-
-            // if there's a slash, then it's a file (TODO: this check seems dubious for scoped npm packages)
-            if (!namespace && normalizedFormatName.includes("/")) {
-                formatterPath = path.resolve(cwd, normalizedFormatName);
-            } else {
-                try {
-                    const npmFormat = naming.normalizePackageName(normalizedFormatName, "eslint-formatter");
-
-                    formatterPath = ModuleResolver.resolve(npmFormat, path.join(cwd, "__placeholder__.js"));
-                } catch {
-                    formatterPath = path.resolve(__dirname, "formatters", normalizedFormatName);
-                }
-            }
-
-            try {
-                return require(formatterPath);
-            } catch (ex) {
-                if (removedFormatters.has(format)) {
-                    ex.message = `The ${format} formatter is no longer part of core ESLint. Install it manually with \`npm install -D eslint-formatter-${format}\``;
-                } else {
-                    ex.message = `There was a problem loading formatter: ${formatterPath}\nError: ${ex.message}`;
-                }
-                throw ex;
-            }
-
-        } else {
-            return null;
-        }
-    }
+	/**
+	 * Creates a new instance of the core CLI engine.
+	 * @param {CLIEngineOptions} providedOptions The options for this instance.
+	 * @param {Object} [additionalData] Additional settings that are not CLIEngineOptions.
+	 * @param {Record<string,Plugin>|null} [additionalData.preloadedPlugins] Preloaded plugins.
+	 */
+	constructor(providedOptions, { preloadedPlugins } = {}) {
+		const options = Object.assign(
+			Object.create(null),
+			defaultOptions,
+			{ cwd: process.cwd() },
+			providedOptions,
+		);
+
+		if (options.fix === void 0) {
+			options.fix = false;
+		}
+
+		const additionalPluginPool = new Map();
+
+		if (preloadedPlugins) {
+			for (const [id, plugin] of Object.entries(preloadedPlugins)) {
+				additionalPluginPool.set(id, plugin);
+			}
+		}
+
+		const cacheFilePath = getCacheFile(
+			options.cacheLocation || options.cacheFile,
+			options.cwd,
+		);
+		const configArrayFactory = new CascadingConfigArrayFactory({
+			additionalPluginPool,
+			baseConfig: options.baseConfig || null,
+			cliConfig: createConfigDataFromOptions(options),
+			cwd: options.cwd,
+			ignorePath: options.ignorePath,
+			resolvePluginsRelativeTo: options.resolvePluginsRelativeTo,
+			rulePaths: options.rulePaths,
+			specificConfigPath: options.configFile,
+			useEslintrc: options.useEslintrc,
+			builtInRules,
+			loadRules,
+			getEslintRecommendedConfig: () =>
+				require("@eslint/js").configs.recommended,
+			getEslintAllConfig: () => require("@eslint/js").configs.all,
+		});
+		const fileEnumerator = new FileEnumerator({
+			configArrayFactory,
+			cwd: options.cwd,
+			extensions: options.extensions,
+			globInputPaths: options.globInputPaths,
+			errorOnUnmatchedPattern: options.errorOnUnmatchedPattern,
+			ignore: options.ignore,
+		});
+		const lintResultCache = options.cache
+			? new LintResultCache(cacheFilePath, options.cacheStrategy)
+			: null;
+		const linter = new Linter({ cwd: options.cwd, configType: "eslintrc" });
+
+		/** @type {ConfigArray[]} */
+		const lastConfigArrays = [configArrayFactory.getConfigArrayForFile()];
+
+		// Store private data.
+		internalSlotsMap.set(this, {
+			additionalPluginPool,
+			cacheFilePath,
+			configArrayFactory,
+			defaultIgnores: IgnorePattern.createDefaultIgnore(options.cwd),
+			fileEnumerator,
+			lastConfigArrays,
+			lintResultCache,
+			linter,
+			options,
+		});
+
+		// setup special filter for fixes
+		if (options.fix && options.fixTypes && options.fixTypes.length > 0) {
+			debug(`Using fix types ${options.fixTypes}`);
+
+			// throw an error if any invalid fix types are found
+			validateFixTypes(options.fixTypes);
+
+			// convert to Set for faster lookup
+			const fixTypes = new Set(options.fixTypes);
+
+			// save original value of options.fix in case it's a function
+			const originalFix =
+				typeof options.fix === "function" ? options.fix : () => true;
+
+			options.fix = message =>
+				shouldMessageBeFixed(message, lastConfigArrays, fixTypes) &&
+				originalFix(message);
+		}
+	}
+
+	getRules() {
+		const { lastConfigArrays } = internalSlotsMap.get(this);
+
+		return new Map(
+			(function* () {
+				yield* builtInRules;
+
+				for (const configArray of lastConfigArrays) {
+					yield* configArray.pluginRules;
+				}
+			})(),
+		);
+	}
+
+	/**
+	 * Returns results that only contains errors.
+	 * @param {LintResult[]} results The results to filter.
+	 * @returns {LintResult[]} The filtered results.
+	 */
+	static getErrorResults(results) {
+		const filtered = [];
+
+		results.forEach(result => {
+			const filteredMessages = result.messages.filter(isErrorMessage);
+			const filteredSuppressedMessages =
+				result.suppressedMessages.filter(isErrorMessage);
+
+			if (filteredMessages.length > 0) {
+				filtered.push({
+					...result,
+					messages: filteredMessages,
+					suppressedMessages: filteredSuppressedMessages,
+					errorCount: filteredMessages.length,
+					warningCount: 0,
+					fixableErrorCount: result.fixableErrorCount,
+					fixableWarningCount: 0,
+				});
+			}
+		});
+
+		return filtered;
+	}
+
+	/**
+	 * Outputs fixes from the given results to files.
+	 * @param {LintReport} report The report object created by CLIEngine.
+	 * @returns {void}
+	 */
+	static outputFixes(report) {
+		report.results
+			.filter(result => Object.hasOwn(result, "output"))
+			.forEach(result => {
+				fs.writeFileSync(result.filePath, result.output);
+			});
+	}
+
+	/**
+	 * Resolves the patterns passed into executeOnFiles() into glob-based patterns
+	 * for easier handling.
+	 * @param {string[]} patterns The file patterns passed on the command line.
+	 * @returns {string[]} The equivalent glob patterns.
+	 */
+	resolveFileGlobPatterns(patterns) {
+		const { options } = internalSlotsMap.get(this);
+
+		if (options.globInputPaths === false) {
+			return patterns.filter(Boolean);
+		}
+
+		const extensions = (options.extensions || [".js"]).map(ext =>
+			ext.replace(/^\./u, ""),
+		);
+		const dirSuffix = `/**/*.{${extensions.join(",")}}`;
+
+		return patterns.filter(Boolean).map(pathname => {
+			const resolvedPath = path.resolve(options.cwd, pathname);
+			const newPath = directoryExists(resolvedPath)
+				? pathname.replace(/[/\\]$/u, "") + dirSuffix
+				: pathname;
+
+			return path.normalize(newPath).replace(/\\/gu, "/");
+		});
+	}
+
+	/**
+	 * Executes the current configuration on an array of file and directory names.
+	 * @param {string[]} patterns An array of file and directory names.
+	 * @throws {Error} As may be thrown by `fs.unlinkSync`.
+	 * @returns {LintReport} The results for all files that were linted.
+	 */
+	executeOnFiles(patterns) {
+		const {
+			cacheFilePath,
+			fileEnumerator,
+			lastConfigArrays,
+			lintResultCache,
+			linter,
+			options: {
+				allowInlineConfig,
+				cache,
+				cwd,
+				fix,
+				reportUnusedDisableDirectives,
+			},
+		} = internalSlotsMap.get(this);
+		const results = [];
+		const startTime = Date.now();
+
+		// Clear the last used config arrays.
+		lastConfigArrays.length = 0;
+
+		// Delete cache file; should this do here?
+		if (!cache) {
+			try {
+				fs.unlinkSync(cacheFilePath);
+			} catch (error) {
+				const errorCode = error && error.code;
+
+				// Ignore errors when no such file exists or file system is read only (and cache file does not exist)
+				if (
+					errorCode !== "ENOENT" &&
+					!(errorCode === "EROFS" && !fs.existsSync(cacheFilePath))
+				) {
+					throw error;
+				}
+			}
+		}
+
+		// Iterate source code files.
+		for (const { config, filePath, ignored } of fileEnumerator.iterateFiles(
+			patterns,
+		)) {
+			if (ignored) {
+				results.push(createIgnoreResult(filePath, cwd));
+				continue;
+			}
+
+			/*
+			 * Store used configs for:
+			 * - this method uses to collect used deprecated rules.
+			 * - `getRules()` method uses to collect all loaded rules.
+			 * - `--fix-type` option uses to get the loaded rule's meta data.
+			 */
+			if (!lastConfigArrays.includes(config)) {
+				lastConfigArrays.push(config);
+			}
+
+			// Skip if there is cached result.
+			if (lintResultCache) {
+				const cachedResult = lintResultCache.getCachedLintResults(
+					filePath,
+					config,
+				);
+
+				if (cachedResult) {
+					const hadMessages =
+						cachedResult.messages &&
+						cachedResult.messages.length > 0;
+
+					if (hadMessages && fix) {
+						debug(
+							`Reprocessing cached file to allow autofix: ${filePath}`,
+						);
+					} else {
+						debug(
+							`Skipping file since it hasn't changed: ${filePath}`,
+						);
+						results.push(cachedResult);
+						continue;
+					}
+				}
+			}
+
+			// Do lint.
+			const result = verifyText({
+				text: fs.readFileSync(filePath, "utf8"),
+				filePath,
+				config,
+				cwd,
+				fix,
+				allowInlineConfig,
+				reportUnusedDisableDirectives,
+				fileEnumerator,
+				linter,
+			});
+
+			results.push(result);
+
+			/*
+			 * Store the lint result in the LintResultCache.
+			 * NOTE: The LintResultCache will remove the file source and any
+			 * other properties that are difficult to serialize, and will
+			 * hydrate those properties back in on future lint runs.
+			 */
+			if (lintResultCache) {
+				lintResultCache.setCachedLintResults(filePath, config, result);
+			}
+		}
+
+		// Persist the cache to disk.
+		if (lintResultCache) {
+			lintResultCache.reconcile();
+		}
+
+		debug(`Linting complete in: ${Date.now() - startTime}ms`);
+		let usedDeprecatedRules;
+
+		return {
+			results,
+			...calculateStatsPerRun(results),
+
+			// Initialize it lazily because CLI and `ESLint` API don't use it.
+			get usedDeprecatedRules() {
+				if (!usedDeprecatedRules) {
+					usedDeprecatedRules = Array.from(
+						iterateRuleDeprecationWarnings(lastConfigArrays),
+					);
+				}
+				return usedDeprecatedRules;
+			},
+		};
+	}
+
+	/**
+	 * Executes the current configuration on text.
+	 * @param {string} text A string of JavaScript code to lint.
+	 * @param {string} [filename] An optional string representing the texts filename.
+	 * @param {boolean} [warnIgnored] Always warn when a file is ignored
+	 * @returns {LintReport} The results for the linting.
+	 */
+	executeOnText(text, filename, warnIgnored) {
+		const {
+			configArrayFactory,
+			fileEnumerator,
+			lastConfigArrays,
+			linter,
+			options: {
+				allowInlineConfig,
+				cwd,
+				fix,
+				reportUnusedDisableDirectives,
+			},
+		} = internalSlotsMap.get(this);
+		const results = [];
+		const startTime = Date.now();
+		const resolvedFilename = filename && path.resolve(cwd, filename);
+
+		// Clear the last used config arrays.
+		lastConfigArrays.length = 0;
+		if (resolvedFilename && this.isPathIgnored(resolvedFilename)) {
+			if (warnIgnored) {
+				results.push(createIgnoreResult(resolvedFilename, cwd));
+			}
+		} else {
+			const config = configArrayFactory.getConfigArrayForFile(
+				resolvedFilename || "__placeholder__.js",
+			);
+
+			/*
+			 * Store used configs for:
+			 * - this method uses to collect used deprecated rules.
+			 * - `getRules()` method uses to collect all loaded rules.
+			 * - `--fix-type` option uses to get the loaded rule's meta data.
+			 */
+			lastConfigArrays.push(config);
+
+			// Do lint.
+			results.push(
+				verifyText({
+					text,
+					filePath: resolvedFilename,
+					config,
+					cwd,
+					fix,
+					allowInlineConfig,
+					reportUnusedDisableDirectives,
+					fileEnumerator,
+					linter,
+				}),
+			);
+		}
+
+		debug(`Linting complete in: ${Date.now() - startTime}ms`);
+		let usedDeprecatedRules;
+
+		return {
+			results,
+			...calculateStatsPerRun(results),
+
+			// Initialize it lazily because CLI and `ESLint` API don't use it.
+			get usedDeprecatedRules() {
+				if (!usedDeprecatedRules) {
+					usedDeprecatedRules = Array.from(
+						iterateRuleDeprecationWarnings(lastConfigArrays),
+					);
+				}
+				return usedDeprecatedRules;
+			},
+		};
+	}
+
+	/**
+	 * Returns a configuration object for the given file based on the CLI options.
+	 * This is the same logic used by the ESLint CLI executable to determine
+	 * configuration for each file it processes.
+	 * @param {string} filePath The path of the file to retrieve a config object for.
+	 * @throws {Error} If filepath a directory path.
+	 * @returns {ConfigData} A configuration object for the file.
+	 */
+	getConfigForFile(filePath) {
+		const { configArrayFactory, options } = internalSlotsMap.get(this);
+		const absolutePath = path.resolve(options.cwd, filePath);
+
+		if (directoryExists(absolutePath)) {
+			throw Object.assign(
+				new Error("'filePath' should not be a directory path."),
+				{ messageTemplate: "print-config-with-directory-path" },
+			);
+		}
+
+		return configArrayFactory
+			.getConfigArrayForFile(absolutePath)
+			.extractConfig(absolutePath)
+			.toCompatibleObjectAsConfigFileContent();
+	}
+
+	/**
+	 * Checks if a given path is ignored by ESLint.
+	 * @param {string} filePath The path of the file to check.
+	 * @returns {boolean} Whether or not the given path is ignored.
+	 */
+	isPathIgnored(filePath) {
+		const {
+			configArrayFactory,
+			defaultIgnores,
+			options: { cwd, ignore },
+		} = internalSlotsMap.get(this);
+		const absolutePath = path.resolve(cwd, filePath);
+
+		if (ignore) {
+			const config = configArrayFactory
+				.getConfigArrayForFile(absolutePath)
+				.extractConfig(absolutePath);
+			const ignores = config.ignores || defaultIgnores;
+
+			return ignores(absolutePath);
+		}
+
+		return defaultIgnores(absolutePath);
+	}
+
+	/**
+	 * Returns the formatter representing the given format or null if the `format` is not a string.
+	 * @param {string} [format] The name of the format to load or the path to a
+	 *      custom formatter.
+	 * @throws {any} As may be thrown by requiring of formatter
+	 * @returns {(FormatterFunction|null)} The formatter function or null if the `format` is not a string.
+	 */
+	getFormatter(format) {
+		// default is stylish
+		const resolvedFormatName = format || "stylish";
+
+		// only strings are valid formatters
+		if (typeof resolvedFormatName === "string") {
+			// replace \ with / for Windows compatibility
+			const normalizedFormatName = resolvedFormatName.replace(
+				/\\/gu,
+				"/",
+			);
+
+			const slots = internalSlotsMap.get(this);
+			const cwd = slots ? slots.options.cwd : process.cwd();
+			const namespace = naming.getNamespaceFromTerm(normalizedFormatName);
+
+			let formatterPath;
+
+			// if there's a slash, then it's a file (TODO: this check seems dubious for scoped npm packages)
+			if (!namespace && normalizedFormatName.includes("/")) {
+				formatterPath = path.resolve(cwd, normalizedFormatName);
+			} else {
+				try {
+					const npmFormat = naming.normalizePackageName(
+						normalizedFormatName,
+						"eslint-formatter",
+					);
+
+					formatterPath = ModuleResolver.resolve(
+						npmFormat,
+						path.join(cwd, "__placeholder__.js"),
+					);
+				} catch {
+					formatterPath = path.resolve(
+						__dirname,
+						"formatters",
+						normalizedFormatName,
+					);
+				}
+			}
+
+			try {
+				return require(formatterPath);
+			} catch (ex) {
+				if (removedFormatters.has(format)) {
+					ex.message = `The ${format} formatter is no longer part of core ESLint. Install it manually with \`npm install -D eslint-formatter-${format}\``;
+				} else {
+					ex.message = `There was a problem loading formatter: ${formatterPath}\nError: ${ex.message}`;
+				}
+				throw ex;
+			}
+		} else {
+			return null;
+		}
+	}
 }
 
 CLIEngine.version = pkg.version;
 CLIEngine.getFormatter = CLIEngine.prototype.getFormatter;
 
 module.exports = {
-    CLIEngine,
-
-    /**
-     * Get the internal slots of a given CLIEngine instance for tests.
-     * @param {CLIEngine} instance The CLIEngine instance to get.
-     * @returns {CLIEngineInternalSlots} The internal slots.
-     */
-    getCLIEngineInternalSlots(instance) {
-        return internalSlotsMap.get(instance);
-    }
+	CLIEngine,
+
+	/**
+	 * Get the internal slots of a given CLIEngine instance for tests.
+	 * @param {CLIEngine} instance The CLIEngine instance to get.
+	 * @returns {CLIEngineInternalSlots} The internal slots.
+	 */
+	getCLIEngineInternalSlots(instance) {
+		return internalSlotsMap.get(instance);
+	},
 };