decidim 0.26.4 → 0.26.5

data/packages/webpacker/node_modules/@eslint/eslintrc/dist/eslintrc.cjs

@@ -1,4295 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var debugOrig = require('debug');
-var fs = require('fs');
-var importFresh = require('import-fresh');
-var Module = require('module');
-var path = require('path');
-var stripComments = require('strip-json-comments');
-var assert = require('assert');
-var ignore = require('ignore');
-var util = require('util');
-var minimatch = require('minimatch');
-var Ajv = require('ajv');
-var globals = require('globals');
-var os = require('os');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var debugOrig__default = /*#__PURE__*/_interopDefaultLegacy(debugOrig);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var importFresh__default = /*#__PURE__*/_interopDefaultLegacy(importFresh);
-var Module__default = /*#__PURE__*/_interopDefaultLegacy(Module);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var stripComments__default = /*#__PURE__*/_interopDefaultLegacy(stripComments);
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-var ignore__default = /*#__PURE__*/_interopDefaultLegacy(ignore);
-var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
-var minimatch__default = /*#__PURE__*/_interopDefaultLegacy(minimatch);
-var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
-var globals__default = /*#__PURE__*/_interopDefaultLegacy(globals);
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-
-/**
- * @fileoverview `IgnorePattern` class.
- *
- * `IgnorePattern` class has the set of glob patterns and the base path.
- *
- * It provides two static methods.
- *
- * - `IgnorePattern.createDefaultIgnore(cwd)`
- *      Create the default predicate function.
- * - `IgnorePattern.createIgnore(ignorePatterns)`
- *      Create the predicate function from multiple `IgnorePattern` objects.
- *
- * It provides two properties and a method.
- *
- * - `patterns`
- *      The glob patterns that ignore to lint.
- * - `basePath`
- *      The base path of the glob patterns. If absolute paths existed in the
- *      glob patterns, those are handled as relative paths to the base path.
- * - `getPatternsRelativeTo(basePath)`
- *      Get `patterns` as modified for a given base path. It modifies the
- *      absolute paths in the patterns as prepending the difference of two base
- *      paths.
- *
- * `ConfigArrayFactory` creates `IgnorePattern` objects when it processes
- * `ignorePatterns` properties.
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-const debug$3 = debugOrig__default["default"]("eslintrc:ignore-pattern");
-
-/** @typedef {ReturnType<import("ignore").default>} Ignore */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Get the path to the common ancestor directory of given paths.
- * @param {string[]} sourcePaths The paths to calculate the common ancestor.
- * @returns {string} The path to the common ancestor directory.
- */
-function getCommonAncestorPath(sourcePaths) {
-    let result = sourcePaths[0];
-
-    for (let i = 1; i < sourcePaths.length; ++i) {
-        const a = result;
-        const b = sourcePaths[i];
-
-        // Set the shorter one (it's the common ancestor if one includes the other).
-        result = a.length < b.length ? a : b;
-
-        // Set the common ancestor.
-        for (let j = 0, lastSepPos = 0; j < a.length && j < b.length; ++j) {
-            if (a[j] !== b[j]) {
-                result = a.slice(0, lastSepPos);
-                break;
-            }
-            if (a[j] === path__default["default"].sep) {
-                lastSepPos = j;
-            }
-        }
-    }
-
-    let resolvedResult = result || path__default["default"].sep;
-
-    // if Windows common ancestor is root of drive must have trailing slash to be absolute.
-    if (resolvedResult && resolvedResult.endsWith(":") && process.platform === "win32") {
-        resolvedResult += path__default["default"].sep;
-    }
-    return resolvedResult;
-}
-
-/**
- * Make relative path.
- * @param {string} from The source path to get relative path.
- * @param {string} to The destination path to get relative path.
- * @returns {string} The relative path.
- */
-function relative(from, to) {
-    const relPath = path__default["default"].relative(from, to);
-
-    if (path__default["default"].sep === "/") {
-        return relPath;
-    }
-    return relPath.split(path__default["default"].sep).join("/");
-}
-
-/**
- * Get the trailing slash if existed.
- * @param {string} filePath The path to check.
- * @returns {string} The trailing slash if existed.
- */
-function dirSuffix(filePath) {
-    const isDir = (
-        filePath.endsWith(path__default["default"].sep) ||
-        (process.platform === "win32" && filePath.endsWith("/"))
-    );
-
-    return isDir ? "/" : "";
-}
-
-const DefaultPatterns = Object.freeze(["/**/node_modules/*"]);
-const DotPatterns = Object.freeze([".*", "!.eslintrc.*", "!../"]);
-
-//------------------------------------------------------------------------------
-// Public
-//------------------------------------------------------------------------------
-
-class IgnorePattern {
-
-    /**
-     * The default patterns.
-     * @type {string[]}
-     */
-    static get DefaultPatterns() {
-        return DefaultPatterns;
-    }
-
-    /**
-     * Create the default predicate function.
-     * @param {string} cwd The current working directory.
-     * @returns {((filePath:string, dot:boolean) => boolean) & {basePath:string; patterns:string[]}}
-     * The preficate function.
-     * The first argument is an absolute path that is checked.
-     * The second argument is the flag to not ignore dotfiles.
-     * If the predicate function returned `true`, it means the path should be ignored.
-     */
-    static createDefaultIgnore(cwd) {
-        return this.createIgnore([new IgnorePattern(DefaultPatterns, cwd)]);
-    }
-
-    /**
-     * Create the predicate function from multiple `IgnorePattern` objects.
-     * @param {IgnorePattern[]} ignorePatterns The list of ignore patterns.
-     * @returns {((filePath:string, dot?:boolean) => boolean) & {basePath:string; patterns:string[]}}
-     * The preficate function.
-     * The first argument is an absolute path that is checked.
-     * The second argument is the flag to not ignore dotfiles.
-     * If the predicate function returned `true`, it means the path should be ignored.
-     */
-    static createIgnore(ignorePatterns) {
-        debug$3("Create with: %o", ignorePatterns);
-
-        const basePath = getCommonAncestorPath(ignorePatterns.map(p => p.basePath));
-        const patterns = [].concat(
-            ...ignorePatterns.map(p => p.getPatternsRelativeTo(basePath))
-        );
-        const ig = ignore__default["default"]().add([...DotPatterns, ...patterns]);
-        const dotIg = ignore__default["default"]().add(patterns);
-
-        debug$3("  processed: %o", { basePath, patterns });
-
-        return Object.assign(
-            (filePath, dot = false) => {
-                assert__default["default"](path__default["default"].isAbsolute(filePath), "'filePath' should be an absolute path.");
-                const relPathRaw = relative(basePath, filePath);
-                const relPath = relPathRaw && (relPathRaw + dirSuffix(filePath));
-                const adoptedIg = dot ? dotIg : ig;
-                const result = relPath !== "" && adoptedIg.ignores(relPath);
-
-                debug$3("Check", { filePath, dot, relativePath: relPath, result });
-                return result;
-            },
-            { basePath, patterns }
-        );
-    }
-
-    /**
-     * Initialize a new `IgnorePattern` instance.
-     * @param {string[]} patterns The glob patterns that ignore to lint.
-     * @param {string} basePath The base path of `patterns`.
-     */
-    constructor(patterns, basePath) {
-        assert__default["default"](path__default["default"].isAbsolute(basePath), "'basePath' should be an absolute path.");
-
-        /**
-         * The glob patterns that ignore to lint.
-         * @type {string[]}
-         */
-        this.patterns = patterns;
-
-        /**
-         * The base path of `patterns`.
-         * @type {string}
-         */
-        this.basePath = basePath;
-
-        /**
-         * If `true` then patterns which don't start with `/` will match the paths to the outside of `basePath`. Defaults to `false`.
-         *
-         * It's set `true` for `.eslintignore`, `package.json`, and `--ignore-path` for backward compatibility.
-         * It's `false` as-is for `ignorePatterns` property in config files.
-         * @type {boolean}
-         */
-        this.loose = false;
-    }
-
-    /**
-     * Get `patterns` as modified for a given base path. It modifies the
-     * absolute paths in the patterns as prepending the difference of two base
-     * paths.
-     * @param {string} newBasePath The base path.
-     * @returns {string[]} Modifired patterns.
-     */
-    getPatternsRelativeTo(newBasePath) {
-        assert__default["default"](path__default["default"].isAbsolute(newBasePath), "'newBasePath' should be an absolute path.");
-        const { basePath, loose, patterns } = this;
-
-        if (newBasePath === basePath) {
-            return patterns;
-        }
-        const prefix = `/${relative(newBasePath, basePath)}`;
-
-        return patterns.map(pattern => {
-            const negative = pattern.startsWith("!");
-            const head = negative ? "!" : "";
-            const body = negative ? pattern.slice(1) : pattern;
-
-            if (body.startsWith("/") || body.startsWith("../")) {
-                return `${head}${prefix}${body}`;
-            }
-            return loose ? pattern : `${head}${prefix}/**/${body}`;
-        });
-    }
-}
-
-/**
- * @fileoverview `ExtractedConfig` class.
- *
- * `ExtractedConfig` class expresses a final configuration for a specific file.
- *
- * It provides one method.
- *
- * - `toCompatibleObjectAsConfigFileContent()`
- *      Convert this configuration to the compatible object as the content of
- *      config files. It converts the loaded parser and plugins to strings.
- *      `CLIEngine#getConfigForFile(filePath)` method uses this method.
- *
- * `ConfigArray#extractConfig(filePath)` creates a `ExtractedConfig` instance.
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-// For VSCode intellisense
-/** @typedef {import("../../shared/types").ConfigData} ConfigData */
-/** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
-/** @typedef {import("../../shared/types").SeverityConf} SeverityConf */
-/** @typedef {import("./config-dependency").DependentParser} DependentParser */
-/** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
-
-/**
- * Check if `xs` starts with `ys`.
- * @template T
- * @param {T[]} xs The array to check.
- * @param {T[]} ys The array that may be the first part of `xs`.
- * @returns {boolean} `true` if `xs` starts with `ys`.
- */
-function startsWith(xs, ys) {
-    return xs.length >= ys.length && ys.every((y, i) => y === xs[i]);
-}
-
-/**
- * The class for extracted config data.
- */
-class ExtractedConfig {
-    constructor() {
-
-        /**
-         * The config name what `noInlineConfig` setting came from.
-         * @type {string}
-         */
-        this.configNameOfNoInlineConfig = "";
-
-        /**
-         * Environments.
-         * @type {Record<string, boolean>}
-         */
-        this.env = {};
-
-        /**
-         * Global variables.
-         * @type {Record<string, GlobalConf>}
-         */
-        this.globals = {};
-
-        /**
-         * The glob patterns that ignore to lint.
-         * @type {(((filePath:string, dot?:boolean) => boolean) & { basePath:string; patterns:string[] }) | undefined}
-         */
-        this.ignores = void 0;
-
-        /**
-         * The flag that disables directive comments.
-         * @type {boolean|undefined}
-         */
-        this.noInlineConfig = void 0;
-
-        /**
-         * Parser definition.
-         * @type {DependentParser|null}
-         */
-        this.parser = null;
-
-        /**
-         * Options for the parser.
-         * @type {Object}
-         */
-        this.parserOptions = {};
-
-        /**
-         * Plugin definitions.
-         * @type {Record<string, DependentPlugin>}
-         */
-        this.plugins = {};
-
-        /**
-         * Processor ID.
-         * @type {string|null}
-         */
-        this.processor = null;
-
-        /**
-         * The flag that reports unused `eslint-disable` directive comments.
-         * @type {boolean|undefined}
-         */
-        this.reportUnusedDisableDirectives = void 0;
-
-        /**
-         * Rule settings.
-         * @type {Record<string, [SeverityConf, ...any[]]>}
-         */
-        this.rules = {};
-
-        /**
-         * Shared settings.
-         * @type {Object}
-         */
-        this.settings = {};
-    }
-
-    /**
-     * Convert this config to the compatible object as a config file content.
-     * @returns {ConfigData} The converted object.
-     */
-    toCompatibleObjectAsConfigFileContent() {
-        const {
-            /* eslint-disable no-unused-vars */
-            configNameOfNoInlineConfig: _ignore1,
-            processor: _ignore2,
-            /* eslint-enable no-unused-vars */
-            ignores,
-            ...config
-        } = this;
-
-        config.parser = config.parser && config.parser.filePath;
-        config.plugins = Object.keys(config.plugins).filter(Boolean).reverse();
-        config.ignorePatterns = ignores ? ignores.patterns : [];
-
-        // Strip the default patterns from `ignorePatterns`.
-        if (startsWith(config.ignorePatterns, IgnorePattern.DefaultPatterns)) {
-            config.ignorePatterns =
-                config.ignorePatterns.slice(IgnorePattern.DefaultPatterns.length);
-        }
-
-        return config;
-    }
-}
-
-/**
- * @fileoverview `ConfigArray` class.
- *
- * `ConfigArray` class expresses the full of a configuration. It has the entry
- * config file, base config files that were extended, loaded parsers, and loaded
- * plugins.
- *
- * `ConfigArray` class provides three properties and two methods.
- *
- * - `pluginEnvironments`
- * - `pluginProcessors`
- * - `pluginRules`
- *      The `Map` objects that contain the members of all plugins that this
- *      config array contains. Those map objects don't have mutation methods.
- *      Those keys are the member ID such as `pluginId/memberName`.
- * - `isRoot()`
- *      If `true` then this configuration has `root:true` property.
- * - `extractConfig(filePath)`
- *      Extract the final configuration for a given file. This means merging
- *      every config array element which that `criteria` property matched. The
- *      `filePath` argument must be an absolute path.
- *
- * `ConfigArrayFactory` provides the loading logic of config files.
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-// Define types for VSCode IntelliSense.
-/** @typedef {import("../../shared/types").Environment} Environment */
-/** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
-/** @typedef {import("../../shared/types").RuleConf} RuleConf */
-/** @typedef {import("../../shared/types").Rule} Rule */
-/** @typedef {import("../../shared/types").Plugin} Plugin */
-/** @typedef {import("../../shared/types").Processor} Processor */
-/** @typedef {import("./config-dependency").DependentParser} DependentParser */
-/** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
-/** @typedef {import("./override-tester")["OverrideTester"]} OverrideTester */
-
-/**
- * @typedef {Object} ConfigArrayElement
- * @property {string} name The name of this config element.
- * @property {string} filePath The path to the source file of this config element.
- * @property {InstanceType<OverrideTester>|null} criteria The tester for the `files` and `excludedFiles` of this config element.
- * @property {Record<string, boolean>|undefined} env The environment settings.
- * @property {Record<string, GlobalConf>|undefined} globals The global variable settings.
- * @property {IgnorePattern|undefined} ignorePattern The ignore patterns.
- * @property {boolean|undefined} noInlineConfig The flag that disables directive comments.
- * @property {DependentParser|undefined} parser The parser loader.
- * @property {Object|undefined} parserOptions The parser options.
- * @property {Record<string, DependentPlugin>|undefined} plugins The plugin loaders.
- * @property {string|undefined} processor The processor name to refer plugin's processor.
- * @property {boolean|undefined} reportUnusedDisableDirectives The flag to report unused `eslint-disable` comments.
- * @property {boolean|undefined} root The flag to express root.
- * @property {Record<string, RuleConf>|undefined} rules The rule settings
- * @property {Object|undefined} settings The shared settings.
- * @property {"config" | "ignore" | "implicit-processor"} type The element type.
- */
-
-/**
- * @typedef {Object} ConfigArrayInternalSlots
- * @property {Map<string, ExtractedConfig>} cache The cache to extract configs.
- * @property {ReadonlyMap<string, Environment>|null} envMap The map from environment ID to environment definition.
- * @property {ReadonlyMap<string, Processor>|null} processorMap The map from processor ID to environment definition.
- * @property {ReadonlyMap<string, Rule>|null} ruleMap The map from rule ID to rule definition.
- */
-
-/** @type {WeakMap<ConfigArray, ConfigArrayInternalSlots>} */
-const internalSlotsMap$2 = new class extends WeakMap {
-    get(key) {
-        let value = super.get(key);
-
-        if (!value) {
-            value = {
-                cache: new Map(),
-                envMap: null,
-                processorMap: null,
-                ruleMap: null
-            };
-            super.set(key, value);
-        }
-
-        return value;
-    }
-}();
-
-/**
- * Get the indices which are matched to a given file.
- * @param {ConfigArrayElement[]} elements The elements.
- * @param {string} filePath The path to a target file.
- * @returns {number[]} The indices.
- */
-function getMatchedIndices(elements, filePath) {
-    const indices = [];
-
-    for (let i = elements.length - 1; i >= 0; --i) {
-        const element = elements[i];
-
-        if (!element.criteria || (filePath && element.criteria.test(filePath))) {
-            indices.push(i);
-        }
-    }
-
-    return indices;
-}
-
-/**
- * Check if a value is a non-null object.
- * @param {any} x The value to check.
- * @returns {boolean} `true` if the value is a non-null object.
- */
-function isNonNullObject(x) {
-    return typeof x === "object" && x !== null;
-}
-
-/**
- * Merge two objects.
- *
- * Assign every property values of `y` to `x` if `x` doesn't have the property.
- * If `x`'s property value is an object, it does recursive.
- * @param {Object} target The destination to merge
- * @param {Object|undefined} source The source to merge.
- * @returns {void}
- */
-function mergeWithoutOverwrite(target, source) {
-    if (!isNonNullObject(source)) {
-        return;
-    }
-
-    for (const key of Object.keys(source)) {
-        if (key === "__proto__") {
-            continue;
-        }
-
-        if (isNonNullObject(target[key])) {
-            mergeWithoutOverwrite(target[key], source[key]);
-        } else if (target[key] === void 0) {
-            if (isNonNullObject(source[key])) {
-                target[key] = Array.isArray(source[key]) ? [] : {};
-                mergeWithoutOverwrite(target[key], source[key]);
-            } else if (source[key] !== void 0) {
-                target[key] = source[key];
-            }
-        }
-    }
-}
-
-/**
- * The error for plugin conflicts.
- */
-class PluginConflictError extends Error {
-
-    /**
-     * Initialize this error object.
-     * @param {string} pluginId The plugin ID.
-     * @param {{filePath:string, importerName:string}[]} plugins The resolved plugins.
-     */
-    constructor(pluginId, plugins) {
-        super(`Plugin "${pluginId}" was conflicted between ${plugins.map(p => `"${p.importerName}"`).join(" and ")}.`);
-        this.messageTemplate = "plugin-conflict";
-        this.messageData = { pluginId, plugins };
-    }
-}
-
-/**
- * Merge plugins.
- * `target`'s definition is prior to `source`'s.
- * @param {Record<string, DependentPlugin>} target The destination to merge
- * @param {Record<string, DependentPlugin>|undefined} source The source to merge.
- * @returns {void}
- */
-function mergePlugins(target, source) {
-    if (!isNonNullObject(source)) {
-        return;
-    }
-
-    for (const key of Object.keys(source)) {
-        if (key === "__proto__") {
-            continue;
-        }
-        const targetValue = target[key];
-        const sourceValue = source[key];
-
-        // Adopt the plugin which was found at first.
-        if (targetValue === void 0) {
-            if (sourceValue.error) {
-                throw sourceValue.error;
-            }
-            target[key] = sourceValue;
-        } else if (sourceValue.filePath !== targetValue.filePath) {
-            throw new PluginConflictError(key, [
-                {
-                    filePath: targetValue.filePath,
-                    importerName: targetValue.importerName
-                },
-                {
-                    filePath: sourceValue.filePath,
-                    importerName: sourceValue.importerName
-                }
-            ]);
-        }
-    }
-}
-
-/**
- * Merge rule configs.
- * `target`'s definition is prior to `source`'s.
- * @param {Record<string, Array>} target The destination to merge
- * @param {Record<string, RuleConf>|undefined} source The source to merge.
- * @returns {void}
- */
-function mergeRuleConfigs(target, source) {
-    if (!isNonNullObject(source)) {
-        return;
-    }
-
-    for (const key of Object.keys(source)) {
-        if (key === "__proto__") {
-            continue;
-        }
-        const targetDef = target[key];
-        const sourceDef = source[key];
-
-        // Adopt the rule config which was found at first.
-        if (targetDef === void 0) {
-            if (Array.isArray(sourceDef)) {
-                target[key] = [...sourceDef];
-            } else {
-                target[key] = [sourceDef];
-            }
-
-        /*
-         * If the first found rule config is severity only and the current rule
-         * config has options, merge the severity and the options.
-         */
-        } else if (
-            targetDef.length === 1 &&
-            Array.isArray(sourceDef) &&
-            sourceDef.length >= 2
-        ) {
-            targetDef.push(...sourceDef.slice(1));
-        }
-    }
-}
-
-/**
- * Create the extracted config.
- * @param {ConfigArray} instance The config elements.
- * @param {number[]} indices The indices to use.
- * @returns {ExtractedConfig} The extracted config.
- */
-function createConfig(instance, indices) {
-    const config = new ExtractedConfig();
-    const ignorePatterns = [];
-
-    // Merge elements.
-    for (const index of indices) {
-        const element = instance[index];
-
-        // Adopt the parser which was found at first.
-        if (!config.parser && element.parser) {
-            if (element.parser.error) {
-                throw element.parser.error;
-            }
-            config.parser = element.parser;
-        }
-
-        // Adopt the processor which was found at first.
-        if (!config.processor && element.processor) {
-            config.processor = element.processor;
-        }
-
-        // Adopt the noInlineConfig which was found at first.
-        if (config.noInlineConfig === void 0 && element.noInlineConfig !== void 0) {
-            config.noInlineConfig = element.noInlineConfig;
-            config.configNameOfNoInlineConfig = element.name;
-        }
-
-        // Adopt the reportUnusedDisableDirectives which was found at first.
-        if (config.reportUnusedDisableDirectives === void 0 && element.reportUnusedDisableDirectives !== void 0) {
-            config.reportUnusedDisableDirectives = element.reportUnusedDisableDirectives;
-        }
-
-        // Collect ignorePatterns
-        if (element.ignorePattern) {
-            ignorePatterns.push(element.ignorePattern);
-        }
-
-        // Merge others.
-        mergeWithoutOverwrite(config.env, element.env);
-        mergeWithoutOverwrite(config.globals, element.globals);
-        mergeWithoutOverwrite(config.parserOptions, element.parserOptions);
-        mergeWithoutOverwrite(config.settings, element.settings);
-        mergePlugins(config.plugins, element.plugins);
-        mergeRuleConfigs(config.rules, element.rules);
-    }
-
-    // Create the predicate function for ignore patterns.
-    if (ignorePatterns.length > 0) {
-        config.ignores = IgnorePattern.createIgnore(ignorePatterns.reverse());
-    }
-
-    return config;
-}
-
-/**
- * Collect definitions.
- * @template T, U
- * @param {string} pluginId The plugin ID for prefix.
- * @param {Record<string,T>} defs The definitions to collect.
- * @param {Map<string, U>} map The map to output.
- * @param {function(T): U} [normalize] The normalize function for each value.
- * @returns {void}
- */
-function collect(pluginId, defs, map, normalize) {
-    if (defs) {
-        const prefix = pluginId && `${pluginId}/`;
-
-        for (const [key, value] of Object.entries(defs)) {
-            map.set(
-                `${prefix}${key}`,
-                normalize ? normalize(value) : value
-            );
-        }
-    }
-}
-
-/**
- * Normalize a rule definition.
- * @param {Function|Rule} rule The rule definition to normalize.
- * @returns {Rule} The normalized rule definition.
- */
-function normalizePluginRule(rule) {
-    return typeof rule === "function" ? { create: rule } : rule;
-}
-
-/**
- * Delete the mutation methods from a given map.
- * @param {Map<any, any>} map The map object to delete.
- * @returns {void}
- */
-function deleteMutationMethods(map) {
-    Object.defineProperties(map, {
-        clear: { configurable: true, value: void 0 },
-        delete: { configurable: true, value: void 0 },
-        set: { configurable: true, value: void 0 }
-    });
-}
-
-/**
- * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.
- * @param {ConfigArrayElement[]} elements The config elements.
- * @param {ConfigArrayInternalSlots} slots The internal slots.
- * @returns {void}
- */
-function initPluginMemberMaps(elements, slots) {
-    const processed = new Set();
-
-    slots.envMap = new Map();
-    slots.processorMap = new Map();
-    slots.ruleMap = new Map();
-
-    for (const element of elements) {
-        if (!element.plugins) {
-            continue;
-        }
-
-        for (const [pluginId, value] of Object.entries(element.plugins)) {
-            const plugin = value.definition;
-
-            if (!plugin || processed.has(pluginId)) {
-                continue;
-            }
-            processed.add(pluginId);
-
-            collect(pluginId, plugin.environments, slots.envMap);
-            collect(pluginId, plugin.processors, slots.processorMap);
-            collect(pluginId, plugin.rules, slots.ruleMap, normalizePluginRule);
-        }
-    }
-
-    deleteMutationMethods(slots.envMap);
-    deleteMutationMethods(slots.processorMap);
-    deleteMutationMethods(slots.ruleMap);
-}
-
-/**
- * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.
- * @param {ConfigArray} instance The config elements.
- * @returns {ConfigArrayInternalSlots} The extracted config.
- */
-function ensurePluginMemberMaps(instance) {
-    const slots = internalSlotsMap$2.get(instance);
-
-    if (!slots.ruleMap) {
-        initPluginMemberMaps(instance, slots);
-    }
-
-    return slots;
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * The Config Array.
- *
- * `ConfigArray` instance contains all settings, parsers, and plugins.
- * You need to call `ConfigArray#extractConfig(filePath)` method in order to
- * extract, merge and get only the config data which is related to an arbitrary
- * file.
- * @extends {Array<ConfigArrayElement>}
- */
-class ConfigArray extends Array {
-
-    /**
-     * Get the plugin environments.
-     * The returned map cannot be mutated.
-     * @type {ReadonlyMap<string, Environment>} The plugin environments.
-     */
-    get pluginEnvironments() {
-        return ensurePluginMemberMaps(this).envMap;
-    }
-
-    /**
-     * Get the plugin processors.
-     * The returned map cannot be mutated.
-     * @type {ReadonlyMap<string, Processor>} The plugin processors.
-     */
-    get pluginProcessors() {
-        return ensurePluginMemberMaps(this).processorMap;
-    }
-
-    /**
-     * Get the plugin rules.
-     * The returned map cannot be mutated.
-     * @returns {ReadonlyMap<string, Rule>} The plugin rules.
-     */
-    get pluginRules() {
-        return ensurePluginMemberMaps(this).ruleMap;
-    }
-
-    /**
-     * Check if this config has `root` flag.
-     * @returns {boolean} `true` if this config array is root.
-     */
-    isRoot() {
-        for (let i = this.length - 1; i >= 0; --i) {
-            const root = this[i].root;
-
-            if (typeof root === "boolean") {
-                return root;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Extract the config data which is related to a given file.
-     * @param {string} filePath The absolute path to the target file.
-     * @returns {ExtractedConfig} The extracted config data.
-     */
-    extractConfig(filePath) {
-        const { cache } = internalSlotsMap$2.get(this);
-        const indices = getMatchedIndices(this, filePath);
-        const cacheKey = indices.join(",");
-
-        if (!cache.has(cacheKey)) {
-            cache.set(cacheKey, createConfig(this, indices));
-        }
-
-        return cache.get(cacheKey);
-    }
-
-    /**
-     * Check if a given path is an additional lint target.
-     * @param {string} filePath The absolute path to the target file.
-     * @returns {boolean} `true` if the file is an additional lint target.
-     */
-    isAdditionalTargetPath(filePath) {
-        for (const { criteria, type } of this) {
-            if (
-                type === "config" &&
-                criteria &&
-                !criteria.endsWithWildcard &&
-                criteria.test(filePath)
-            ) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-
-/**
- * Get the used extracted configs.
- * CLIEngine will use this method to collect used deprecated rules.
- * @param {ConfigArray} instance The config array object to get.
- * @returns {ExtractedConfig[]} The used extracted configs.
- * @private
- */
-function getUsedExtractedConfigs(instance) {
-    const { cache } = internalSlotsMap$2.get(instance);
-
-    return Array.from(cache.values());
-}
-
-/**
- * @fileoverview `ConfigDependency` class.
- *
- * `ConfigDependency` class expresses a loaded parser or plugin.
- *
- * If the parser or plugin was loaded successfully, it has `definition` property
- * and `filePath` property. Otherwise, it has `error` property.
- *
- * When `JSON.stringify()` converted a `ConfigDependency` object to a JSON, it
- * omits `definition` property.
- *
- * `ConfigArrayFactory` creates `ConfigDependency` objects when it loads parsers
- * or plugins.
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-/**
- * The class is to store parsers or plugins.
- * This class hides the loaded object from `JSON.stringify()` and `console.log`.
- * @template T
- */
-class ConfigDependency {
-
-    /**
-     * Initialize this instance.
-     * @param {Object} data The dependency data.
-     * @param {T} [data.definition] The dependency if the loading succeeded.
-     * @param {Error} [data.error] The error object if the loading failed.
-     * @param {string} [data.filePath] The actual path to the dependency if the loading succeeded.
-     * @param {string} data.id The ID of this dependency.
-     * @param {string} data.importerName The name of the config file which loads this dependency.
-     * @param {string} data.importerPath The path to the config file which loads this dependency.
-     */
-    constructor({
-        definition = null,
-        error = null,
-        filePath = null,
-        id,
-        importerName,
-        importerPath
-    }) {
-
-        /**
-         * The loaded dependency if the loading succeeded.
-         * @type {T|null}
-         */
-        this.definition = definition;
-
-        /**
-         * The error object if the loading failed.
-         * @type {Error|null}
-         */
-        this.error = error;
-
-        /**
-         * The loaded dependency if the loading succeeded.
-         * @type {string|null}
-         */
-        this.filePath = filePath;
-
-        /**
-         * The ID of this dependency.
-         * @type {string}
-         */
-        this.id = id;
-
-        /**
-         * The name of the config file which loads this dependency.
-         * @type {string}
-         */
-        this.importerName = importerName;
-
-        /**
-         * The path to the config file which loads this dependency.
-         * @type {string}
-         */
-        this.importerPath = importerPath;
-    }
-
-    // eslint-disable-next-line jsdoc/require-description
-    /**
-     * @returns {Object} a JSON compatible object.
-     */
-    toJSON() {
-        const obj = this[util__default["default"].inspect.custom]();
-
-        // Display `error.message` (`Error#message` is unenumerable).
-        if (obj.error instanceof Error) {
-            obj.error = { ...obj.error, message: obj.error.message };
-        }
-
-        return obj;
-    }
-
-    // eslint-disable-next-line jsdoc/require-description
-    /**
-     * @returns {Object} an object to display by `console.log()`.
-     */
-    [util__default["default"].inspect.custom]() {
-        const {
-            definition: _ignore, // eslint-disable-line no-unused-vars
-            ...obj
-        } = this;
-
-        return obj;
-    }
-}
-
-/**
- * @fileoverview `OverrideTester` class.
- *
- * `OverrideTester` class handles `files` property and `excludedFiles` property
- * of `overrides` config.
- *
- * It provides one method.
- *
- * - `test(filePath)`
- *      Test if a file path matches the pair of `files` property and
- *      `excludedFiles` property. The `filePath` argument must be an absolute
- *      path.
- *
- * `ConfigArrayFactory` creates `OverrideTester` objects when it processes
- * `overrides` properties.
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-const { Minimatch } = minimatch__default["default"];
-
-const minimatchOpts = { dot: true, matchBase: true };
-
-/**
- * @typedef {Object} Pattern
- * @property {InstanceType<Minimatch>[] | null} includes The positive matchers.
- * @property {InstanceType<Minimatch>[] | null} excludes The negative matchers.
- */
-
-/**
- * Normalize a given pattern to an array.
- * @param {string|string[]|undefined} patterns A glob pattern or an array of glob patterns.
- * @returns {string[]|null} Normalized patterns.
- * @private
- */
-function normalizePatterns(patterns) {
-    if (Array.isArray(patterns)) {
-        return patterns.filter(Boolean);
-    }
-    if (typeof patterns === "string" && patterns) {
-        return [patterns];
-    }
-    return [];
-}
-
-/**
- * Create the matchers of given patterns.
- * @param {string[]} patterns The patterns.
- * @returns {InstanceType<Minimatch>[] | null} The matchers.
- */
-function toMatcher(patterns) {
-    if (patterns.length === 0) {
-        return null;
-    }
-    return patterns.map(pattern => {
-        if (/^\.[/\\]/u.test(pattern)) {
-            return new Minimatch(
-                pattern.slice(2),
-
-                // `./*.js` should not match with `subdir/foo.js`
-                { ...minimatchOpts, matchBase: false }
-            );
-        }
-        return new Minimatch(pattern, minimatchOpts);
-    });
-}
-
-/**
- * Convert a given matcher to string.
- * @param {Pattern} matchers The matchers.
- * @returns {string} The string expression of the matcher.
- */
-function patternToJson({ includes, excludes }) {
-    return {
-        includes: includes && includes.map(m => m.pattern),
-        excludes: excludes && excludes.map(m => m.pattern)
-    };
-}
-
-/**
- * The class to test given paths are matched by the patterns.
- */
-class OverrideTester {
-
-    /**
-     * Create a tester with given criteria.
-     * If there are no criteria, returns `null`.
-     * @param {string|string[]} files The glob patterns for included files.
-     * @param {string|string[]} excludedFiles The glob patterns for excluded files.
-     * @param {string} basePath The path to the base directory to test paths.
-     * @returns {OverrideTester|null} The created instance or `null`.
-     */
-    static create(files, excludedFiles, basePath) {
-        const includePatterns = normalizePatterns(files);
-        const excludePatterns = normalizePatterns(excludedFiles);
-        let endsWithWildcard = false;
-
-        if (includePatterns.length === 0) {
-            return null;
-        }
-
-        // Rejects absolute paths or relative paths to parents.
-        for (const pattern of includePatterns) {
-            if (path__default["default"].isAbsolute(pattern) || pattern.includes("..")) {
-                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
-            }
-            if (pattern.endsWith("*")) {
-                endsWithWildcard = true;
-            }
-        }
-        for (const pattern of excludePatterns) {
-            if (path__default["default"].isAbsolute(pattern) || pattern.includes("..")) {
-                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
-            }
-        }
-
-        const includes = toMatcher(includePatterns);
-        const excludes = toMatcher(excludePatterns);
-
-        return new OverrideTester(
-            [{ includes, excludes }],
-            basePath,
-            endsWithWildcard
-        );
-    }
-
-    /**
-     * Combine two testers by logical and.
-     * If either of the testers was `null`, returns the other tester.
-     * The `basePath` property of the two must be the same value.
-     * @param {OverrideTester|null} a A tester.
-     * @param {OverrideTester|null} b Another tester.
-     * @returns {OverrideTester|null} Combined tester.
-     */
-    static and(a, b) {
-        if (!b) {
-            return a && new OverrideTester(
-                a.patterns,
-                a.basePath,
-                a.endsWithWildcard
-            );
-        }
-        if (!a) {
-            return new OverrideTester(
-                b.patterns,
-                b.basePath,
-                b.endsWithWildcard
-            );
-        }
-
-        assert__default["default"].strictEqual(a.basePath, b.basePath);
-        return new OverrideTester(
-            a.patterns.concat(b.patterns),
-            a.basePath,
-            a.endsWithWildcard || b.endsWithWildcard
-        );
-    }
-
-    /**
-     * Initialize this instance.
-     * @param {Pattern[]} patterns The matchers.
-     * @param {string} basePath The base path.
-     * @param {boolean} endsWithWildcard If `true` then a pattern ends with `*`.
-     */
-    constructor(patterns, basePath, endsWithWildcard = false) {
-
-        /** @type {Pattern[]} */
-        this.patterns = patterns;
-
-        /** @type {string} */
-        this.basePath = basePath;
-
-        /** @type {boolean} */
-        this.endsWithWildcard = endsWithWildcard;
-    }
-
-    /**
-     * Test if a given path is matched or not.
-     * @param {string} filePath The absolute path to the target file.
-     * @returns {boolean} `true` if the path was matched.
-     */
-    test(filePath) {
-        if (typeof filePath !== "string" || !path__default["default"].isAbsolute(filePath)) {
-            throw new Error(`'filePath' should be an absolute path, but got ${filePath}.`);
-        }
-        const relativePath = path__default["default"].relative(this.basePath, filePath);
-
-        return this.patterns.every(({ includes, excludes }) => (
-            (!includes || includes.some(m => m.match(relativePath))) &&
-            (!excludes || !excludes.some(m => m.match(relativePath)))
-        ));
-    }
-
-    // eslint-disable-next-line jsdoc/require-description
-    /**
-     * @returns {Object} a JSON compatible object.
-     */
-    toJSON() {
-        if (this.patterns.length === 1) {
-            return {
-                ...patternToJson(this.patterns[0]),
-                basePath: this.basePath
-            };
-        }
-        return {
-            AND: this.patterns.map(patternToJson),
-            basePath: this.basePath
-        };
-    }
-
-    // eslint-disable-next-line jsdoc/require-description
-    /**
-     * @returns {Object} an object to display by `console.log()`.
-     */
-    [util__default["default"].inspect.custom]() {
-        return this.toJSON();
-    }
-}
-
-/**
- * @fileoverview `ConfigArray` class.
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-/**
- * @fileoverview Config file operations. This file must be usable in the browser,
- * so no Node-specific code can be here.
- * @author Nicholas C. Zakas
- */
-
-//------------------------------------------------------------------------------
-// Private
-//------------------------------------------------------------------------------
-
-const RULE_SEVERITY_STRINGS = ["off", "warn", "error"],
-    RULE_SEVERITY = RULE_SEVERITY_STRINGS.reduce((map, value, index) => {
-        map[value] = index;
-        return map;
-    }, {}),
-    VALID_SEVERITIES = [0, 1, 2, "off", "warn", "error"];
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Normalizes the severity value of a rule's configuration to a number
- * @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally
- * received from the user. A valid config value is either 0, 1, 2, the string "off" (treated the same as 0),
- * the string "warn" (treated the same as 1), the string "error" (treated the same as 2), or an array
- * whose first element is one of the above values. Strings are matched case-insensitively.
- * @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0.
- */
-function getRuleSeverity(ruleConfig) {
-    const severityValue = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
-
-    if (severityValue === 0 || severityValue === 1 || severityValue === 2) {
-        return severityValue;
-    }
-
-    if (typeof severityValue === "string") {
-        return RULE_SEVERITY[severityValue.toLowerCase()] || 0;
-    }
-
-    return 0;
-}
-
-/**
- * Converts old-style severity settings (0, 1, 2) into new-style
- * severity settings (off, warn, error) for all rules. Assumption is that severity
- * values have already been validated as correct.
- * @param {Object} config The config object to normalize.
- * @returns {void}
- */
-function normalizeToStrings(config) {
-
-    if (config.rules) {
-        Object.keys(config.rules).forEach(ruleId => {
-            const ruleConfig = config.rules[ruleId];
-
-            if (typeof ruleConfig === "number") {
-                config.rules[ruleId] = RULE_SEVERITY_STRINGS[ruleConfig] || RULE_SEVERITY_STRINGS[0];
-            } else if (Array.isArray(ruleConfig) && typeof ruleConfig[0] === "number") {
-                ruleConfig[0] = RULE_SEVERITY_STRINGS[ruleConfig[0]] || RULE_SEVERITY_STRINGS[0];
-            }
-        });
-    }
-}
-
-/**
- * Determines if the severity for the given rule configuration represents an error.
- * @param {int|string|Array} ruleConfig The configuration for an individual rule.
- * @returns {boolean} True if the rule represents an error, false if not.
- */
-function isErrorSeverity(ruleConfig) {
-    return getRuleSeverity(ruleConfig) === 2;
-}
-
-/**
- * Checks whether a given config has valid severity or not.
- * @param {number|string|Array} ruleConfig The configuration for an individual rule.
- * @returns {boolean} `true` if the configuration has valid severity.
- */
-function isValidSeverity(ruleConfig) {
-    let severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
-
-    if (typeof severity === "string") {
-        severity = severity.toLowerCase();
-    }
-    return VALID_SEVERITIES.indexOf(severity) !== -1;
-}
-
-/**
- * Checks whether every rule of a given config has valid severity or not.
- * @param {Object} config The configuration for rules.
- * @returns {boolean} `true` if the configuration has valid severity.
- */
-function isEverySeverityValid(config) {
-    return Object.keys(config).every(ruleId => isValidSeverity(config[ruleId]));
-}
-
-/**
- * Normalizes a value for a global in a config
- * @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in
- * a global directive comment
- * @returns {("readable"|"writeable"|"off")} The value normalized as a string
- * @throws Error if global value is invalid
- */
-function normalizeConfigGlobal(configuredValue) {
-    switch (configuredValue) {
-        case "off":
-            return "off";
-
-        case true:
-        case "true":
-        case "writeable":
-        case "writable":
-            return "writable";
-
-        case null:
-        case false:
-        case "false":
-        case "readable":
-        case "readonly":
-            return "readonly";
-
-        default:
-            throw new Error(`'${configuredValue}' is not a valid configuration for a global (use 'readonly', 'writable', or 'off')`);
-    }
-}
-
-var ConfigOps = {
-    __proto__: null,
-    getRuleSeverity: getRuleSeverity,
-    normalizeToStrings: normalizeToStrings,
-    isErrorSeverity: isErrorSeverity,
-    isValidSeverity: isValidSeverity,
-    isEverySeverityValid: isEverySeverityValid,
-    normalizeConfigGlobal: normalizeConfigGlobal
-};
-
-/**
- * @fileoverview Provide the function that emits deprecation warnings.
- * @author Toru Nagashima <http://github.com/mysticatea>
- */
-
-//------------------------------------------------------------------------------
-// Private
-//------------------------------------------------------------------------------
-
-// Defitions for deprecation warnings.
-const deprecationWarningMessages = {
-    ESLINT_LEGACY_ECMAFEATURES:
-        "The 'ecmaFeatures' config file property is deprecated and has no effect.",
-    ESLINT_PERSONAL_CONFIG_LOAD:
-        "'~/.eslintrc.*' config files have been deprecated. " +
-        "Please use a config file per project or the '--config' option.",
-    ESLINT_PERSONAL_CONFIG_SUPPRESS:
-        "'~/.eslintrc.*' config files have been deprecated. " +
-        "Please remove it or add 'root:true' to the config files in your " +
-        "projects in order to avoid loading '~/.eslintrc.*' accidentally."
-};
-
-const sourceFileErrorCache = new Set();
-
-/**
- * Emits a deprecation warning containing a given filepath. A new deprecation warning is emitted
- * for each unique file path, but repeated invocations with the same file path have no effect.
- * No warnings are emitted if the `--no-deprecation` or `--no-warnings` Node runtime flags are active.
- * @param {string} source The name of the configuration source to report the warning for.
- * @param {string} errorCode The warning message to show.
- * @returns {void}
- */
-function emitDeprecationWarning(source, errorCode) {
-    const cacheKey = JSON.stringify({ source, errorCode });
-
-    if (sourceFileErrorCache.has(cacheKey)) {
-        return;
-    }
-    sourceFileErrorCache.add(cacheKey);
-
-    const rel = path__default["default"].relative(process.cwd(), source);
-    const message = deprecationWarningMessages[errorCode];
-
-    process.emitWarning(
-        `${message} (found in "${rel}")`,
-        "DeprecationWarning",
-        errorCode
-    );
-}
-
-/**
- * @fileoverview The instance of Ajv validator.
- * @author Evgeny Poberezkin
- */
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-/*
- * Copied from ajv/lib/refs/json-schema-draft-04.json
- * The MIT License (MIT)
- * Copyright (c) 2015-2017 Evgeny Poberezkin
- */
-const metaSchema = {
-    id: "http://json-schema.org/draft-04/schema#",
-    $schema: "http://json-schema.org/draft-04/schema#",
-    description: "Core schema meta-schema",
-    definitions: {
-        schemaArray: {
-            type: "array",
-            minItems: 1,
-            items: { $ref: "#" }
-        },
-        positiveInteger: {
-            type: "integer",
-            minimum: 0
-        },
-        positiveIntegerDefault0: {
-            allOf: [{ $ref: "#/definitions/positiveInteger" }, { default: 0 }]
-        },
-        simpleTypes: {
-            enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
-        },
-        stringArray: {
-            type: "array",
-            items: { type: "string" },
-            minItems: 1,
-            uniqueItems: true
-        }
-    },
-    type: "object",
-    properties: {
-        id: {
-            type: "string"
-        },
-        $schema: {
-            type: "string"
-        },
-        title: {
-            type: "string"
-        },
-        description: {
-            type: "string"
-        },
-        default: { },
-        multipleOf: {
-            type: "number",
-            minimum: 0,
-            exclusiveMinimum: true
-        },
-        maximum: {
-            type: "number"
-        },
-        exclusiveMaximum: {
-            type: "boolean",
-            default: false
-        },
-        minimum: {
-            type: "number"
-        },
-        exclusiveMinimum: {
-            type: "boolean",
-            default: false
-        },
-        maxLength: { $ref: "#/definitions/positiveInteger" },
-        minLength: { $ref: "#/definitions/positiveIntegerDefault0" },
-        pattern: {
-            type: "string",
-            format: "regex"
-        },
-        additionalItems: {
-            anyOf: [
-                { type: "boolean" },
-                { $ref: "#" }
-            ],
-            default: { }
-        },
-        items: {
-            anyOf: [
-                { $ref: "#" },
-                { $ref: "#/definitions/schemaArray" }
-            ],
-            default: { }
-        },
-        maxItems: { $ref: "#/definitions/positiveInteger" },
-        minItems: { $ref: "#/definitions/positiveIntegerDefault0" },
-        uniqueItems: {
-            type: "boolean",
-            default: false
-        },
-        maxProperties: { $ref: "#/definitions/positiveInteger" },
-        minProperties: { $ref: "#/definitions/positiveIntegerDefault0" },
-        required: { $ref: "#/definitions/stringArray" },
-        additionalProperties: {
-            anyOf: [
-                { type: "boolean" },
-                { $ref: "#" }
-            ],
-            default: { }
-        },
-        definitions: {
-            type: "object",
-            additionalProperties: { $ref: "#" },
-            default: { }
-        },
-        properties: {
-            type: "object",
-            additionalProperties: { $ref: "#" },
-            default: { }
-        },
-        patternProperties: {
-            type: "object",
-            additionalProperties: { $ref: "#" },
-            default: { }
-        },
-        dependencies: {
-            type: "object",
-            additionalProperties: {
-                anyOf: [
-                    { $ref: "#" },
-                    { $ref: "#/definitions/stringArray" }
-                ]
-            }
-        },
-        enum: {
-            type: "array",
-            minItems: 1,
-            uniqueItems: true
-        },
-        type: {
-            anyOf: [
-                { $ref: "#/definitions/simpleTypes" },
-                {
-                    type: "array",
-                    items: { $ref: "#/definitions/simpleTypes" },
-                    minItems: 1,
-                    uniqueItems: true
-                }
-            ]
-        },
-        format: { type: "string" },
-        allOf: { $ref: "#/definitions/schemaArray" },
-        anyOf: { $ref: "#/definitions/schemaArray" },
-        oneOf: { $ref: "#/definitions/schemaArray" },
-        not: { $ref: "#" }
-    },
-    dependencies: {
-        exclusiveMaximum: ["maximum"],
-        exclusiveMinimum: ["minimum"]
-    },
-    default: { }
-};
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-var ajvOrig = (additionalOptions = {}) => {
-    const ajv = new Ajv__default["default"]({
-        meta: false,
-        useDefaults: true,
-        validateSchema: false,
-        missingRefs: "ignore",
-        verbose: true,
-        schemaId: "auto",
-        ...additionalOptions
-    });
-
-    ajv.addMetaSchema(metaSchema);
-    // eslint-disable-next-line no-underscore-dangle
-    ajv._opts.defaultMeta = metaSchema.id;
-
-    return ajv;
-};
-
-/**
- * @fileoverview Defines a schema for configs.
- * @author Sylvan Mably
- */
-
-const baseConfigProperties = {
-    $schema: { type: "string" },
-    env: { type: "object" },
-    extends: { $ref: "#/definitions/stringOrStrings" },
-    globals: { type: "object" },
-    overrides: {
-        type: "array",
-        items: { $ref: "#/definitions/overrideConfig" },
-        additionalItems: false
-    },
-    parser: { type: ["string", "null"] },
-    parserOptions: { type: "object" },
-    plugins: { type: "array" },
-    processor: { type: "string" },
-    rules: { type: "object" },
-    settings: { type: "object" },
-    noInlineConfig: { type: "boolean" },
-    reportUnusedDisableDirectives: { type: "boolean" },
-
-    ecmaFeatures: { type: "object" } // deprecated; logs a warning when used
-};
-
-const configSchema = {
-    definitions: {
-        stringOrStrings: {
-            oneOf: [
-                { type: "string" },
-                {
-                    type: "array",
-                    items: { type: "string" },
-                    additionalItems: false
-                }
-            ]
-        },
-        stringOrStringsRequired: {
-            oneOf: [
-                { type: "string" },
-                {
-                    type: "array",
-                    items: { type: "string" },
-                    additionalItems: false,
-                    minItems: 1
-                }
-            ]
-        },
-
-        // Config at top-level.
-        objectConfig: {
-            type: "object",
-            properties: {
-                root: { type: "boolean" },
-                ignorePatterns: { $ref: "#/definitions/stringOrStrings" },
-                ...baseConfigProperties
-            },
-            additionalProperties: false
-        },
-
-        // Config in `overrides`.
-        overrideConfig: {
-            type: "object",
-            properties: {
-                excludedFiles: { $ref: "#/definitions/stringOrStrings" },
-                files: { $ref: "#/definitions/stringOrStringsRequired" },
-                ...baseConfigProperties
-            },
-            required: ["files"],
-            additionalProperties: false
-        }
-    },
-
-    $ref: "#/definitions/objectConfig"
-};
-
-/**
- * @fileoverview Defines environment settings and globals.
- * @author Elan Shanker
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Get the object that has difference.
- * @param {Record<string,boolean>} current The newer object.
- * @param {Record<string,boolean>} prev The older object.
- * @returns {Record<string,boolean>} The difference object.
- */
-function getDiff(current, prev) {
-    const retv = {};
-
-    for (const [key, value] of Object.entries(current)) {
-        if (!Object.hasOwnProperty.call(prev, key)) {
-            retv[key] = value;
-        }
-    }
-
-    return retv;
-}
-
-const newGlobals2015 = getDiff(globals__default["default"].es2015, globals__default["default"].es5); // 19 variables such as Promise, Map, ...
-const newGlobals2017 = {
-    Atomics: false,
-    SharedArrayBuffer: false
-};
-const newGlobals2020 = {
-    BigInt: false,
-    BigInt64Array: false,
-    BigUint64Array: false,
-    globalThis: false
-};
-
-const newGlobals2021 = {
-    AggregateError: false,
-    FinalizationRegistry: false,
-    WeakRef: false
-};
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/** @type {Map<string, import("../lib/shared/types").Environment>} */
-var environments = new Map(Object.entries({
-
-    // Language
-    builtin: {
-        globals: globals__default["default"].es5
-    },
-    es6: {
-        globals: newGlobals2015,
-        parserOptions: {
-            ecmaVersion: 6
-        }
-    },
-    es2015: {
-        globals: newGlobals2015,
-        parserOptions: {
-            ecmaVersion: 6
-        }
-    },
-    es2016: {
-        globals: newGlobals2015,
-        parserOptions: {
-            ecmaVersion: 7
-        }
-    },
-    es2017: {
-        globals: { ...newGlobals2015, ...newGlobals2017 },
-        parserOptions: {
-            ecmaVersion: 8
-        }
-    },
-    es2018: {
-        globals: { ...newGlobals2015, ...newGlobals2017 },
-        parserOptions: {
-            ecmaVersion: 9
-        }
-    },
-    es2019: {
-        globals: { ...newGlobals2015, ...newGlobals2017 },
-        parserOptions: {
-            ecmaVersion: 10
-        }
-    },
-    es2020: {
-        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020 },
-        parserOptions: {
-            ecmaVersion: 11
-        }
-    },
-    es2021: {
-        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
-        parserOptions: {
-            ecmaVersion: 12
-        }
-    },
-    es2022: {
-        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
-        parserOptions: {
-            ecmaVersion: 13
-        }
-    },
-
-    // Platforms
-    browser: {
-        globals: globals__default["default"].browser
-    },
-    node: {
-        globals: globals__default["default"].node,
-        parserOptions: {
-            ecmaFeatures: {
-                globalReturn: true
-            }
-        }
-    },
-    "shared-node-browser": {
-        globals: globals__default["default"]["shared-node-browser"]
-    },
-    worker: {
-        globals: globals__default["default"].worker
-    },
-    serviceworker: {
-        globals: globals__default["default"].serviceworker
-    },
-
-    // Frameworks
-    commonjs: {
-        globals: globals__default["default"].commonjs,
-        parserOptions: {
-            ecmaFeatures: {
-                globalReturn: true
-            }
-        }
-    },
-    amd: {
-        globals: globals__default["default"].amd
-    },
-    mocha: {
-        globals: globals__default["default"].mocha
-    },
-    jasmine: {
-        globals: globals__default["default"].jasmine
-    },
-    jest: {
-        globals: globals__default["default"].jest
-    },
-    phantomjs: {
-        globals: globals__default["default"].phantomjs
-    },
-    jquery: {
-        globals: globals__default["default"].jquery
-    },
-    qunit: {
-        globals: globals__default["default"].qunit
-    },
-    prototypejs: {
-        globals: globals__default["default"].prototypejs
-    },
-    shelljs: {
-        globals: globals__default["default"].shelljs
-    },
-    meteor: {
-        globals: globals__default["default"].meteor
-    },
-    mongo: {
-        globals: globals__default["default"].mongo
-    },
-    protractor: {
-        globals: globals__default["default"].protractor
-    },
-    applescript: {
-        globals: globals__default["default"].applescript
-    },
-    nashorn: {
-        globals: globals__default["default"].nashorn
-    },
-    atomtest: {
-        globals: globals__default["default"].atomtest
-    },
-    embertest: {
-        globals: globals__default["default"].embertest
-    },
-    webextensions: {
-        globals: globals__default["default"].webextensions
-    },
-    greasemonkey: {
-        globals: globals__default["default"].greasemonkey
-    }
-}));
-
-/**
- * @fileoverview Validates configs.
- * @author Brandon Mills
- */
-
-const ajv = ajvOrig();
-
-const ruleValidators = new WeakMap();
-const noop = Function.prototype;
-
-//------------------------------------------------------------------------------
-// Private
-//------------------------------------------------------------------------------
-let validateSchema;
-const severityMap = {
-    error: 2,
-    warn: 1,
-    off: 0
-};
-
-const validated = new WeakSet();
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-class ConfigValidator {
-    constructor({ builtInRules = new Map() } = {}) {
-        this.builtInRules = builtInRules;
-    }
-
-    /**
-     * Gets a complete options schema for a rule.
-     * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
-     * @returns {Object} JSON Schema for the rule's options.
-     */
-    getRuleOptionsSchema(rule) {
-        if (!rule) {
-            return null;
-        }
-
-        const schema = rule.schema || rule.meta && rule.meta.schema;
-
-        // Given a tuple of schemas, insert warning level at the beginning
-        if (Array.isArray(schema)) {
-            if (schema.length) {
-                return {
-                    type: "array",
-                    items: schema,
-                    minItems: 0,
-                    maxItems: schema.length
-                };
-            }
-            return {
-                type: "array",
-                minItems: 0,
-                maxItems: 0
-            };
-
-        }
-
-        // Given a full schema, leave it alone
-        return schema || null;
-    }
-
-    /**
-     * Validates a rule's severity and returns the severity value. Throws an error if the severity is invalid.
-     * @param {options} options The given options for the rule.
-     * @returns {number|string} The rule's severity value
-     */
-    validateRuleSeverity(options) {
-        const severity = Array.isArray(options) ? options[0] : options;
-        const normSeverity = typeof severity === "string" ? severityMap[severity.toLowerCase()] : severity;
-
-        if (normSeverity === 0 || normSeverity === 1 || normSeverity === 2) {
-            return normSeverity;
-        }
-
-        throw new Error(`\tSeverity should be one of the following: 0 = off, 1 = warn, 2 = error (you passed '${util__default["default"].inspect(severity).replace(/'/gu, "\"").replace(/\n/gu, "")}').\n`);
-
-    }
-
-    /**
-     * Validates the non-severity options passed to a rule, based on its schema.
-     * @param {{create: Function}} rule The rule to validate
-     * @param {Array} localOptions The options for the rule, excluding severity
-     * @returns {void}
-     */
-    validateRuleSchema(rule, localOptions) {
-        if (!ruleValidators.has(rule)) {
-            const schema = this.getRuleOptionsSchema(rule);
-
-            if (schema) {
-                ruleValidators.set(rule, ajv.compile(schema));
-            }
-        }
-
-        const validateRule = ruleValidators.get(rule);
-
-        if (validateRule) {
-            validateRule(localOptions);
-            if (validateRule.errors) {
-                throw new Error(validateRule.errors.map(
-                    error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
-                ).join(""));
-            }
-        }
-    }
-
-    /**
-     * Validates a rule's options against its schema.
-     * @param {{create: Function}|null} rule The rule that the config is being validated for
-     * @param {string} ruleId The rule's unique name.
-     * @param {Array|number} options The given options for the rule.
-     * @param {string|null} source The name of the configuration source to report in any errors. If null or undefined,
-     * no source is prepended to the message.
-     * @returns {void}
-     */
-    validateRuleOptions(rule, ruleId, options, source = null) {
-        try {
-            const severity = this.validateRuleSeverity(options);
-
-            if (severity !== 0) {
-                this.validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);
-            }
-        } catch (err) {
-            const enhancedMessage = `Configuration for rule "${ruleId}" is invalid:\n${err.message}`;
-
-            if (typeof source === "string") {
-                throw new Error(`${source}:\n\t${enhancedMessage}`);
-            } else {
-                throw new Error(enhancedMessage);
-            }
-        }
-    }
-
-    /**
-     * Validates an environment object
-     * @param {Object} environment The environment config object to validate.
-     * @param {string} source The name of the configuration source to report in any errors.
-     * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded environments.
-     * @returns {void}
-     */
-    validateEnvironment(
-        environment,
-        source,
-        getAdditionalEnv = noop
-    ) {
-
-        // not having an environment is ok
-        if (!environment) {
-            return;
-        }
-
-        Object.keys(environment).forEach(id => {
-            const env = getAdditionalEnv(id) || environments.get(id) || null;
-
-            if (!env) {
-                const message = `${source}:\n\tEnvironment key "${id}" is unknown\n`;
-
-                throw new Error(message);
-            }
-        });
-    }
-
-    /**
-     * Validates a rules config object
-     * @param {Object} rulesConfig The rules config object to validate.
-     * @param {string} source The name of the configuration source to report in any errors.
-     * @param {function(ruleId:string): Object} getAdditionalRule A map from strings to loaded rules
-     * @returns {void}
-     */
-    validateRules(
-        rulesConfig,
-        source,
-        getAdditionalRule = noop
-    ) {
-        if (!rulesConfig) {
-            return;
-        }
-
-        Object.keys(rulesConfig).forEach(id => {
-            const rule = getAdditionalRule(id) || this.builtInRules.get(id) || null;
-
-            this.validateRuleOptions(rule, id, rulesConfig[id], source);
-        });
-    }
-
-    /**
-     * Validates a `globals` section of a config file
-     * @param {Object} globalsConfig The `globals` section
-     * @param {string|null} source The name of the configuration source to report in the event of an error.
-     * @returns {void}
-     */
-    validateGlobals(globalsConfig, source = null) {
-        if (!globalsConfig) {
-            return;
-        }
-
-        Object.entries(globalsConfig)
-            .forEach(([configuredGlobal, configuredValue]) => {
-                try {
-                    normalizeConfigGlobal(configuredValue);
-                } catch (err) {
-                    throw new Error(`ESLint configuration of global '${configuredGlobal}' in ${source} is invalid:\n${err.message}`);
-                }
-            });
-    }
-
-    /**
-     * Validate `processor` configuration.
-     * @param {string|undefined} processorName The processor name.
-     * @param {string} source The name of config file.
-     * @param {function(id:string): Processor} getProcessor The getter of defined processors.
-     * @returns {void}
-     */
-    validateProcessor(processorName, source, getProcessor) {
-        if (processorName && !getProcessor(processorName)) {
-            throw new Error(`ESLint configuration of processor in '${source}' is invalid: '${processorName}' was not found.`);
-        }
-    }
-
-    /**
-     * Formats an array of schema validation errors.
-     * @param {Array} errors An array of error messages to format.
-     * @returns {string} Formatted error message
-     */
-    formatErrors(errors) {
-        return errors.map(error => {
-            if (error.keyword === "additionalProperties") {
-                const formattedPropertyPath = error.dataPath.length ? `${error.dataPath.slice(1)}.${error.params.additionalProperty}` : error.params.additionalProperty;
-
-                return `Unexpected top-level property "${formattedPropertyPath}"`;
-            }
-            if (error.keyword === "type") {
-                const formattedField = error.dataPath.slice(1);
-                const formattedExpectedType = Array.isArray(error.schema) ? error.schema.join("/") : error.schema;
-                const formattedValue = JSON.stringify(error.data);
-
-                return `Property "${formattedField}" is the wrong type (expected ${formattedExpectedType} but got \`${formattedValue}\`)`;
-            }
-
-            const field = error.dataPath[0] === "." ? error.dataPath.slice(1) : error.dataPath;
-
-            return `"${field}" ${error.message}. Value: ${JSON.stringify(error.data)}`;
-        }).map(message => `\t- ${message}.\n`).join("");
-    }
-
-    /**
-     * Validates the top level properties of the config object.
-     * @param {Object} config The config object to validate.
-     * @param {string} source The name of the configuration source to report in any errors.
-     * @returns {void}
-     */
-    validateConfigSchema(config, source = null) {
-        validateSchema = validateSchema || ajv.compile(configSchema);
-
-        if (!validateSchema(config)) {
-            throw new Error(`ESLint configuration in ${source} is invalid:\n${this.formatErrors(validateSchema.errors)}`);
-        }
-
-        if (Object.hasOwnProperty.call(config, "ecmaFeatures")) {
-            emitDeprecationWarning(source, "ESLINT_LEGACY_ECMAFEATURES");
-        }
-    }
-
-    /**
-     * Validates an entire config object.
-     * @param {Object} config The config object to validate.
-     * @param {string} source The name of the configuration source to report in any errors.
-     * @param {function(ruleId:string): Object} [getAdditionalRule] A map from strings to loaded rules.
-     * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded envs.
-     * @returns {void}
-     */
-    validate(config, source, getAdditionalRule, getAdditionalEnv) {
-        this.validateConfigSchema(config, source);
-        this.validateRules(config.rules, source, getAdditionalRule);
-        this.validateEnvironment(config.env, source, getAdditionalEnv);
-        this.validateGlobals(config.globals, source);
-
-        for (const override of config.overrides || []) {
-            this.validateRules(override.rules, source, getAdditionalRule);
-            this.validateEnvironment(override.env, source, getAdditionalEnv);
-            this.validateGlobals(config.globals, source);
-        }
-    }
-
-    /**
-     * Validate config array object.
-     * @param {ConfigArray} configArray The config array to validate.
-     * @returns {void}
-     */
-    validateConfigArray(configArray) {
-        const getPluginEnv = Map.prototype.get.bind(configArray.pluginEnvironments);
-        const getPluginProcessor = Map.prototype.get.bind(configArray.pluginProcessors);
-        const getPluginRule = Map.prototype.get.bind(configArray.pluginRules);
-
-        // Validate.
-        for (const element of configArray) {
-            if (validated.has(element)) {
-                continue;
-            }
-            validated.add(element);
-
-            this.validateEnvironment(element.env, element.name, getPluginEnv);
-            this.validateGlobals(element.globals, element.name);
-            this.validateProcessor(element.processor, element.name, getPluginProcessor);
-            this.validateRules(element.rules, element.name, getPluginRule);
-        }
-    }
-
-}
-
-/**
- * @fileoverview Common helpers for naming of plugins, formatters and configs
- */
-
-const NAMESPACE_REGEX = /^@.*\//iu;
-
-/**
- * Brings package name to correct format based on prefix
- * @param {string} name The name of the package.
- * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter"
- * @returns {string} Normalized name of the package
- * @private
- */
-function normalizePackageName(name, prefix) {
-    let normalizedName = name;
-
-    /**
-     * On Windows, name can come in with Windows slashes instead of Unix slashes.
-     * Normalize to Unix first to avoid errors later on.
-     * https://github.com/eslint/eslint/issues/5644
-     */
-    if (normalizedName.includes("\\")) {
-        normalizedName = normalizedName.replace(/\\/gu, "/");
-    }
-
-    if (normalizedName.charAt(0) === "@") {
-
-        /**
-         * it's a scoped package
-         * package name is the prefix, or just a username
-         */
-        const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`, "u"),
-            scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u");
-
-        if (scopedPackageShortcutRegex.test(normalizedName)) {
-            normalizedName = normalizedName.replace(scopedPackageShortcutRegex, `$1/${prefix}`);
-        } else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) {
-
-            /**
-             * for scoped packages, insert the prefix after the first / unless
-             * the path is already @scope/eslint or @scope/eslint-xxx-yyy
-             */
-            normalizedName = normalizedName.replace(/^@([^/]+)\/(.*)$/u, `@$1/${prefix}-$2`);
-        }
-    } else if (!normalizedName.startsWith(`${prefix}-`)) {
-        normalizedName = `${prefix}-${normalizedName}`;
-    }
-
-    return normalizedName;
-}
-
-/**
- * Removes the prefix from a fullname.
- * @param {string} fullname The term which may have the prefix.
- * @param {string} prefix The prefix to remove.
- * @returns {string} The term without prefix.
- */
-function getShorthandName(fullname, prefix) {
-    if (fullname[0] === "@") {
-        let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(fullname);
-
-        if (matchResult) {
-            return matchResult[1];
-        }
-
-        matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(fullname);
-        if (matchResult) {
-            return `${matchResult[1]}/${matchResult[2]}`;
-        }
-    } else if (fullname.startsWith(`${prefix}-`)) {
-        return fullname.slice(prefix.length + 1);
-    }
-
-    return fullname;
-}
-
-/**
- * Gets the scope (namespace) of a term.
- * @param {string} term The term which may have the namespace.
- * @returns {string} The namespace of the term if it has one.
- */
-function getNamespaceFromTerm(term) {
-    const match = term.match(NAMESPACE_REGEX);
-
-    return match ? match[0] : "";
-}
-
-var naming = {
-    __proto__: null,
-    normalizePackageName: normalizePackageName,
-    getShorthandName: getShorthandName,
-    getNamespaceFromTerm: getNamespaceFromTerm
-};
-
-/**
- * Utility for resolving a module relative to another module
- * @author Teddy Katz
- */
-
-/*
- * `Module.createRequire` is added in v12.2.0. It supports URL as well.
- * We only support the case where the argument is a filepath, not a URL.
- */
-const createRequire = Module__default["default"].createRequire;
-
-/**
- * Resolves a Node module relative to another module
- * @param {string} moduleName The name of a Node module, or a path to a Node module.
- * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be
- * a file rather than a directory, but the file need not actually exist.
- * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath`
- */
-function resolve(moduleName, relativeToPath) {
-    try {
-        return createRequire(relativeToPath).resolve(moduleName);
-    } catch (error) {
-
-        // This `if` block is for older Node.js than 12.0.0. We can remove this block in the future.
-        if (
-            typeof error === "object" &&
-            error !== null &&
-            error.code === "MODULE_NOT_FOUND" &&
-            !error.requireStack &&
-            error.message.includes(moduleName)
-        ) {
-            error.message += `\nRequire stack:\n- ${relativeToPath}`;
-        }
-        throw error;
-    }
-}
-
-var ModuleResolver = {
-    __proto__: null,
-    resolve: resolve
-};
-
-/**
- * @fileoverview The factory of `ConfigArray` objects.
- *
- * This class provides methods to create `ConfigArray` instance.
- *
- * - `create(configData, options)`
- *     Create a `ConfigArray` instance from a config data. This is to handle CLI
- *     options except `--config`.
- * - `loadFile(filePath, options)`
- *     Create a `ConfigArray` instance from a config file. This is to handle
- *     `--config` option. If the file was not found, throws the following error:
- *      - If the filename was `*.js`, a `MODULE_NOT_FOUND` error.
- *      - If the filename was `package.json`, an IO error or an
- *        `ESLINT_CONFIG_FIELD_NOT_FOUND` error.
- *      - Otherwise, an IO error such as `ENOENT`.
- * - `loadInDirectory(directoryPath, options)`
- *     Create a `ConfigArray` instance from a config file which is on a given
- *     directory. This tries to load `.eslintrc.*` or `package.json`. If not
- *     found, returns an empty `ConfigArray`.
- * - `loadESLintIgnore(filePath)`
- *     Create a `ConfigArray` instance from a config file that is `.eslintignore`
- *     format. This is to handle `--ignore-path` option.
- * - `loadDefaultESLintIgnore()`
- *     Create a `ConfigArray` instance from `.eslintignore` or `package.json` in
- *     the current working directory.
- *
- * `ConfigArrayFactory` class has the responsibility that loads configuration
- * files, including loading `extends`, `parser`, and `plugins`. The created
- * `ConfigArray` instance has the loaded `extends`, `parser`, and `plugins`.
- *
- * But this class doesn't handle cascading. `CascadingConfigArrayFactory` class
- * handles cascading and hierarchy.
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-const require$1 = Module.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('eslintrc.cjs', document.baseURI).href)));
-
-const debug$2 = debugOrig__default["default"]("eslintrc:config-array-factory");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const configFilenames = [
-    ".eslintrc.js",
-    ".eslintrc.cjs",
-    ".eslintrc.yaml",
-    ".eslintrc.yml",
-    ".eslintrc.json",
-    ".eslintrc",
-    "package.json"
-];
-
-// Define types for VSCode IntelliSense.
-/** @typedef {import("./shared/types").ConfigData} ConfigData */
-/** @typedef {import("./shared/types").OverrideConfigData} OverrideConfigData */
-/** @typedef {import("./shared/types").Parser} Parser */
-/** @typedef {import("./shared/types").Plugin} Plugin */
-/** @typedef {import("./shared/types").Rule} Rule */
-/** @typedef {import("./config-array/config-dependency").DependentParser} DependentParser */
-/** @typedef {import("./config-array/config-dependency").DependentPlugin} DependentPlugin */
-/** @typedef {ConfigArray[0]} ConfigArrayElement */
-
-/**
- * @typedef {Object} ConfigArrayFactoryOptions
- * @property {Map<string,Plugin>} [additionalPluginPool] The map for additional plugins.
- * @property {string} [cwd] The path to the current working directory.
- * @property {string} [resolvePluginsRelativeTo] A path to the directory that plugins should be resolved from. Defaults to `cwd`.
- * @property {Map<string,Rule>} builtInRules The rules that are built in to ESLint.
- * @property {Object} [resolver=ModuleResolver] The module resolver object.
- * @property {string} eslintAllPath The path to the definitions for eslint:all.
- * @property {Function} getEslintAllConfig Returns the config data for eslint:all.
- * @property {string} eslintRecommendedPath The path to the definitions for eslint:recommended.
- * @property {Function} getEslintRecommendedConfig Returns the config data for eslint:recommended.
- */
-
-/**
- * @typedef {Object} ConfigArrayFactoryInternalSlots
- * @property {Map<string,Plugin>} additionalPluginPool The map for additional plugins.
- * @property {string} cwd The path to the current working directory.
- * @property {string | undefined} resolvePluginsRelativeTo An absolute path the the directory that plugins should be resolved from.
- * @property {Map<string,Rule>} builtInRules The rules that are built in to ESLint.
- * @property {Object} [resolver=ModuleResolver] The module resolver object.
- * @property {string} eslintAllPath The path to the definitions for eslint:all.
- * @property {Function} getEslintAllConfig Returns the config data for eslint:all.
- * @property {string} eslintRecommendedPath The path to the definitions for eslint:recommended.
- * @property {Function} getEslintRecommendedConfig Returns the config data for eslint:recommended.
- */
-
-/**
- * @typedef {Object} ConfigArrayFactoryLoadingContext
- * @property {string} filePath The path to the current configuration.
- * @property {string} matchBasePath The base path to resolve relative paths in `overrides[].files`, `overrides[].excludedFiles`, and `ignorePatterns`.
- * @property {string} name The name of the current configuration.
- * @property {string} pluginBasePath The base path to resolve plugins.
- * @property {"config" | "ignore" | "implicit-processor"} type The type of the current configuration. This is `"config"` in normal. This is `"ignore"` if it came from `.eslintignore`. This is `"implicit-processor"` if it came from legacy file-extension processors.
- */
-
-/**
- * @typedef {Object} ConfigArrayFactoryLoadingContext
- * @property {string} filePath The path to the current configuration.
- * @property {string} matchBasePath The base path to resolve relative paths in `overrides[].files`, `overrides[].excludedFiles`, and `ignorePatterns`.
- * @property {string} name The name of the current configuration.
- * @property {"config" | "ignore" | "implicit-processor"} type The type of the current configuration. This is `"config"` in normal. This is `"ignore"` if it came from `.eslintignore`. This is `"implicit-processor"` if it came from legacy file-extension processors.
- */
-
-/** @type {WeakMap<ConfigArrayFactory, ConfigArrayFactoryInternalSlots>} */
-const internalSlotsMap$1 = new WeakMap();
-
-/**
- * Check if a given string is a file path.
- * @param {string} nameOrPath A module name or file path.
- * @returns {boolean} `true` if the `nameOrPath` is a file path.
- */
-function isFilePath(nameOrPath) {
-    return (
-        /^\.{1,2}[/\\]/u.test(nameOrPath) ||
-        path__default["default"].isAbsolute(nameOrPath)
-    );
-}
-
-/**
- * Convenience wrapper for synchronously reading file contents.
- * @param {string} filePath The filename to read.
- * @returns {string} The file contents, with the BOM removed.
- * @private
- */
-function readFile(filePath) {
-    return fs__default["default"].readFileSync(filePath, "utf8").replace(/^\ufeff/u, "");
-}
-
-/**
- * Loads a YAML configuration from a file.
- * @param {string} filePath The filename to load.
- * @returns {ConfigData} The configuration object from the file.
- * @throws {Error} If the file cannot be read.
- * @private
- */
-function loadYAMLConfigFile(filePath) {
-    debug$2(`Loading YAML config file: ${filePath}`);
-
-    // lazy load YAML to improve performance when not used
-    const yaml = require$1("js-yaml");
-
-    try {
-
-        // empty YAML file can be null, so always use
-        return yaml.load(readFile(filePath)) || {};
-    } catch (e) {
-        debug$2(`Error reading YAML file: ${filePath}`);
-        e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
-        throw e;
-    }
-}
-
-/**
- * Loads a JSON configuration from a file.
- * @param {string} filePath The filename to load.
- * @returns {ConfigData} The configuration object from the file.
- * @throws {Error} If the file cannot be read.
- * @private
- */
-function loadJSONConfigFile(filePath) {
-    debug$2(`Loading JSON config file: ${filePath}`);
-
-    try {
-        return JSON.parse(stripComments__default["default"](readFile(filePath)));
-    } catch (e) {
-        debug$2(`Error reading JSON file: ${filePath}`);
-        e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
-        e.messageTemplate = "failed-to-read-json";
-        e.messageData = {
-            path: filePath,
-            message: e.message
-        };
-        throw e;
-    }
-}
-
-/**
- * Loads a legacy (.eslintrc) configuration from a file.
- * @param {string} filePath The filename to load.
- * @returns {ConfigData} The configuration object from the file.
- * @throws {Error} If the file cannot be read.
- * @private
- */
-function loadLegacyConfigFile(filePath) {
-    debug$2(`Loading legacy config file: ${filePath}`);
-
-    // lazy load YAML to improve performance when not used
-    const yaml = require$1("js-yaml");
-
-    try {
-        return yaml.load(stripComments__default["default"](readFile(filePath))) || /* istanbul ignore next */ {};
-    } catch (e) {
-        debug$2("Error reading YAML file: %s\n%o", filePath, e);
-        e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
-        throw e;
-    }
-}
-
-/**
- * Loads a JavaScript configuration from a file.
- * @param {string} filePath The filename to load.
- * @returns {ConfigData} The configuration object from the file.
- * @throws {Error} If the file cannot be read.
- * @private
- */
-function loadJSConfigFile(filePath) {
-    debug$2(`Loading JS config file: ${filePath}`);
-    try {
-        return importFresh__default["default"](filePath);
-    } catch (e) {
-        debug$2(`Error reading JavaScript file: ${filePath}`);
-        e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
-        throw e;
-    }
-}
-
-/**
- * Loads a configuration from a package.json file.
- * @param {string} filePath The filename to load.
- * @returns {ConfigData} The configuration object from the file.
- * @throws {Error} If the file cannot be read.
- * @private
- */
-function loadPackageJSONConfigFile(filePath) {
-    debug$2(`Loading package.json config file: ${filePath}`);
-    try {
-        const packageData = loadJSONConfigFile(filePath);
-
-        if (!Object.hasOwnProperty.call(packageData, "eslintConfig")) {
-            throw Object.assign(
-                new Error("package.json file doesn't have 'eslintConfig' field."),
-                { code: "ESLINT_CONFIG_FIELD_NOT_FOUND" }
-            );
-        }
-
-        return packageData.eslintConfig;
-    } catch (e) {
-        debug$2(`Error reading package.json file: ${filePath}`);
-        e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
-        throw e;
-    }
-}
-
-/**
- * Loads a `.eslintignore` from a file.
- * @param {string} filePath The filename to load.
- * @returns {string[]} The ignore patterns from the file.
- * @private
- */
-function loadESLintIgnoreFile(filePath) {
-    debug$2(`Loading .eslintignore file: ${filePath}`);
-
-    try {
-        return readFile(filePath)
-            .split(/\r?\n/gu)
-            .filter(line => line.trim() !== "" && !line.startsWith("#"));
-    } catch (e) {
-        debug$2(`Error reading .eslintignore file: ${filePath}`);
-        e.message = `Cannot read .eslintignore file: ${filePath}\nError: ${e.message}`;
-        throw e;
-    }
-}
-
-/**
- * Creates an error to notify about a missing config to extend from.
- * @param {string} configName The name of the missing config.
- * @param {string} importerName The name of the config that imported the missing config
- * @param {string} messageTemplate The text template to source error strings from.
- * @returns {Error} The error object to throw
- * @private
- */
-function configInvalidError(configName, importerName, messageTemplate) {
-    return Object.assign(
-        new Error(`Failed to load config "${configName}" to extend from.`),
-        {
-            messageTemplate,
-            messageData: { configName, importerName }
-        }
-    );
-}
-
-/**
- * Loads a configuration file regardless of the source. Inspects the file path
- * to determine the correctly way to load the config file.
- * @param {string} filePath The path to the configuration.
- * @returns {ConfigData|null} The configuration information.
- * @private
- */
-function loadConfigFile(filePath) {
-    switch (path__default["default"].extname(filePath)) {
-        case ".js":
-        case ".cjs":
-            return loadJSConfigFile(filePath);
-
-        case ".json":
-            if (path__default["default"].basename(filePath) === "package.json") {
-                return loadPackageJSONConfigFile(filePath);
-            }
-            return loadJSONConfigFile(filePath);
-
-        case ".yaml":
-        case ".yml":
-            return loadYAMLConfigFile(filePath);
-
-        default:
-            return loadLegacyConfigFile(filePath);
-    }
-}
-
-/**
- * Write debug log.
- * @param {string} request The requested module name.
- * @param {string} relativeTo The file path to resolve the request relative to.
- * @param {string} filePath The resolved file path.
- * @returns {void}
- */
-function writeDebugLogForLoading(request, relativeTo, filePath) {
-    /* istanbul ignore next */
-    if (debug$2.enabled) {
-        let nameAndVersion = null;
-
-        try {
-            const packageJsonPath = resolve(
-                `${request}/package.json`,
-                relativeTo
-            );
-            const { version = "unknown" } = require$1(packageJsonPath);
-
-            nameAndVersion = `${request}@${version}`;
-        } catch (error) {
-            debug$2("package.json was not found:", error.message);
-            nameAndVersion = request;
-        }
-
-        debug$2("Loaded: %s (%s)", nameAndVersion, filePath);
-    }
-}
-
-/**
- * Create a new context with default values.
- * @param {ConfigArrayFactoryInternalSlots} slots The internal slots.
- * @param {"config" | "ignore" | "implicit-processor" | undefined} providedType The type of the current configuration. Default is `"config"`.
- * @param {string | undefined} providedName The name of the current configuration. Default is the relative path from `cwd` to `filePath`.
- * @param {string | undefined} providedFilePath The path to the current configuration. Default is empty string.
- * @param {string | undefined} providedMatchBasePath The type of the current configuration. Default is the directory of `filePath` or `cwd`.
- * @returns {ConfigArrayFactoryLoadingContext} The created context.
- */
-function createContext(
-    { cwd, resolvePluginsRelativeTo },
-    providedType,
-    providedName,
-    providedFilePath,
-    providedMatchBasePath
-) {
-    const filePath = providedFilePath
-        ? path__default["default"].resolve(cwd, providedFilePath)
-        : "";
-    const matchBasePath =
-        (providedMatchBasePath && path__default["default"].resolve(cwd, providedMatchBasePath)) ||
-        (filePath && path__default["default"].dirname(filePath)) ||
-        cwd;
-    const name =
-        providedName ||
-        (filePath && path__default["default"].relative(cwd, filePath)) ||
-        "";
-    const pluginBasePath =
-        resolvePluginsRelativeTo ||
-        (filePath && path__default["default"].dirname(filePath)) ||
-        cwd;
-    const type = providedType || "config";
-
-    return { filePath, matchBasePath, name, pluginBasePath, type };
-}
-
-/**
- * Normalize a given plugin.
- * - Ensure the object to have four properties: configs, environments, processors, and rules.
- * - Ensure the object to not have other properties.
- * @param {Plugin} plugin The plugin to normalize.
- * @returns {Plugin} The normalized plugin.
- */
-function normalizePlugin(plugin) {
-    return {
-        configs: plugin.configs || {},
-        environments: plugin.environments || {},
-        processors: plugin.processors || {},
-        rules: plugin.rules || {}
-    };
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * The factory of `ConfigArray` objects.
- */
-class ConfigArrayFactory {
-
-    /**
-     * Initialize this instance.
-     * @param {ConfigArrayFactoryOptions} [options] The map for additional plugins.
-     */
-    constructor({
-        additionalPluginPool = new Map(),
-        cwd = process.cwd(),
-        resolvePluginsRelativeTo,
-        builtInRules,
-        resolver = ModuleResolver,
-        eslintAllPath,
-        getEslintAllConfig,
-        eslintRecommendedPath,
-        getEslintRecommendedConfig
-    } = {}) {
-        internalSlotsMap$1.set(this, {
-            additionalPluginPool,
-            cwd,
-            resolvePluginsRelativeTo:
-                resolvePluginsRelativeTo &&
-                path__default["default"].resolve(cwd, resolvePluginsRelativeTo),
-            builtInRules,
-            resolver,
-            eslintAllPath,
-            getEslintAllConfig,
-            eslintRecommendedPath,
-            getEslintRecommendedConfig
-        });
-    }
-
-    /**
-     * Create `ConfigArray` instance from a config data.
-     * @param {ConfigData|null} configData The config data to create.
-     * @param {Object} [options] The options.
-     * @param {string} [options.basePath] The base path to resolve relative paths in `overrides[].files`, `overrides[].excludedFiles`, and `ignorePatterns`.
-     * @param {string} [options.filePath] The path to this config data.
-     * @param {string} [options.name] The config name.
-     * @returns {ConfigArray} Loaded config.
-     */
-    create(configData, { basePath, filePath, name } = {}) {
-        if (!configData) {
-            return new ConfigArray();
-        }
-
-        const slots = internalSlotsMap$1.get(this);
-        const ctx = createContext(slots, "config", name, filePath, basePath);
-        const elements = this._normalizeConfigData(configData, ctx);
-
-        return new ConfigArray(...elements);
-    }
-
-    /**
-     * Load a config file.
-     * @param {string} filePath The path to a config file.
-     * @param {Object} [options] The options.
-     * @param {string} [options.basePath] The base path to resolve relative paths in `overrides[].files`, `overrides[].excludedFiles`, and `ignorePatterns`.
-     * @param {string} [options.name] The config name.
-     * @returns {ConfigArray} Loaded config.
-     */
-    loadFile(filePath, { basePath, name } = {}) {
-        const slots = internalSlotsMap$1.get(this);
-        const ctx = createContext(slots, "config", name, filePath, basePath);
-
-        return new ConfigArray(...this._loadConfigData(ctx));
-    }
-
-    /**
-     * Load the config file on a given directory if exists.
-     * @param {string} directoryPath The path to a directory.
-     * @param {Object} [options] The options.
-     * @param {string} [options.basePath] The base path to resolve relative paths in `overrides[].files`, `overrides[].excludedFiles`, and `ignorePatterns`.
-     * @param {string} [options.name] The config name.
-     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
-     */
-    loadInDirectory(directoryPath, { basePath, name } = {}) {
-        const slots = internalSlotsMap$1.get(this);
-
-        for (const filename of configFilenames) {
-            const ctx = createContext(
-                slots,
-                "config",
-                name,
-                path__default["default"].join(directoryPath, filename),
-                basePath
-            );
-
-            if (fs__default["default"].existsSync(ctx.filePath) && fs__default["default"].statSync(ctx.filePath).isFile()) {
-                let configData;
-
-                try {
-                    configData = loadConfigFile(ctx.filePath);
-                } catch (error) {
-                    if (!error || error.code !== "ESLINT_CONFIG_FIELD_NOT_FOUND") {
-                        throw error;
-                    }
-                }
-
-                if (configData) {
-                    debug$2(`Config file found: ${ctx.filePath}`);
-                    return new ConfigArray(
-                        ...this._normalizeConfigData(configData, ctx)
-                    );
-                }
-            }
-        }
-
-        debug$2(`Config file not found on ${directoryPath}`);
-        return new ConfigArray();
-    }
-
-    /**
-     * Check if a config file on a given directory exists or not.
-     * @param {string} directoryPath The path to a directory.
-     * @returns {string | null} The path to the found config file. If not found then null.
-     */
-    static getPathToConfigFileInDirectory(directoryPath) {
-        for (const filename of configFilenames) {
-            const filePath = path__default["default"].join(directoryPath, filename);
-
-            if (fs__default["default"].existsSync(filePath)) {
-                if (filename === "package.json") {
-                    try {
-                        loadPackageJSONConfigFile(filePath);
-                        return filePath;
-                    } catch { /* ignore */ }
-                } else {
-                    return filePath;
-                }
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Load `.eslintignore` file.
-     * @param {string} filePath The path to a `.eslintignore` file to load.
-     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
-     */
-    loadESLintIgnore(filePath) {
-        const slots = internalSlotsMap$1.get(this);
-        const ctx = createContext(
-            slots,
-            "ignore",
-            void 0,
-            filePath,
-            slots.cwd
-        );
-        const ignorePatterns = loadESLintIgnoreFile(ctx.filePath);
-
-        return new ConfigArray(
-            ...this._normalizeESLintIgnoreData(ignorePatterns, ctx)
-        );
-    }
-
-    /**
-     * Load `.eslintignore` file in the current working directory.
-     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
-     */
-    loadDefaultESLintIgnore() {
-        const slots = internalSlotsMap$1.get(this);
-        const eslintIgnorePath = path__default["default"].resolve(slots.cwd, ".eslintignore");
-        const packageJsonPath = path__default["default"].resolve(slots.cwd, "package.json");
-
-        if (fs__default["default"].existsSync(eslintIgnorePath)) {
-            return this.loadESLintIgnore(eslintIgnorePath);
-        }
-        if (fs__default["default"].existsSync(packageJsonPath)) {
-            const data = loadJSONConfigFile(packageJsonPath);
-
-            if (Object.hasOwnProperty.call(data, "eslintIgnore")) {
-                if (!Array.isArray(data.eslintIgnore)) {
-                    throw new Error("Package.json eslintIgnore property requires an array of paths");
-                }
-                const ctx = createContext(
-                    slots,
-                    "ignore",
-                    "eslintIgnore in package.json",
-                    packageJsonPath,
-                    slots.cwd
-                );
-
-                return new ConfigArray(
-                    ...this._normalizeESLintIgnoreData(data.eslintIgnore, ctx)
-                );
-            }
-        }
-
-        return new ConfigArray();
-    }
-
-    /**
-     * Load a given config file.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} Loaded config.
-     * @private
-     */
-    _loadConfigData(ctx) {
-        return this._normalizeConfigData(loadConfigFile(ctx.filePath), ctx);
-    }
-
-    /**
-     * Normalize a given `.eslintignore` data to config array elements.
-     * @param {string[]} ignorePatterns The patterns to ignore files.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    *_normalizeESLintIgnoreData(ignorePatterns, ctx) {
-        const elements = this._normalizeObjectConfigData(
-            { ignorePatterns },
-            ctx
-        );
-
-        // Set `ignorePattern.loose` flag for backward compatibility.
-        for (const element of elements) {
-            if (element.ignorePattern) {
-                element.ignorePattern.loose = true;
-            }
-            yield element;
-        }
-    }
-
-    /**
-     * Normalize a given config to an array.
-     * @param {ConfigData} configData The config data to normalize.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    _normalizeConfigData(configData, ctx) {
-        const validator = new ConfigValidator();
-
-        validator.validateConfigSchema(configData, ctx.name || ctx.filePath);
-        return this._normalizeObjectConfigData(configData, ctx);
-    }
-
-    /**
-     * Normalize a given config to an array.
-     * @param {ConfigData|OverrideConfigData} configData The config data to normalize.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    *_normalizeObjectConfigData(configData, ctx) {
-        const { files, excludedFiles, ...configBody } = configData;
-        const criteria = OverrideTester.create(
-            files,
-            excludedFiles,
-            ctx.matchBasePath
-        );
-        const elements = this._normalizeObjectConfigDataBody(configBody, ctx);
-
-        // Apply the criteria to every element.
-        for (const element of elements) {
-
-            /*
-             * Merge the criteria.
-             * This is for the `overrides` entries that came from the
-             * configurations of `overrides[].extends`.
-             */
-            element.criteria = OverrideTester.and(criteria, element.criteria);
-
-            /*
-             * Remove `root` property to ignore `root` settings which came from
-             * `extends` in `overrides`.
-             */
-            if (element.criteria) {
-                element.root = void 0;
-            }
-
-            yield element;
-        }
-    }
-
-    /**
-     * Normalize a given config to an array.
-     * @param {ConfigData} configData The config data to normalize.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    *_normalizeObjectConfigDataBody(
-        {
-            env,
-            extends: extend,
-            globals,
-            ignorePatterns,
-            noInlineConfig,
-            parser: parserName,
-            parserOptions,
-            plugins: pluginList,
-            processor,
-            reportUnusedDisableDirectives,
-            root,
-            rules,
-            settings,
-            overrides: overrideList = []
-        },
-        ctx
-    ) {
-        const extendList = Array.isArray(extend) ? extend : [extend];
-        const ignorePattern = ignorePatterns && new IgnorePattern(
-            Array.isArray(ignorePatterns) ? ignorePatterns : [ignorePatterns],
-            ctx.matchBasePath
-        );
-
-        // Flatten `extends`.
-        for (const extendName of extendList.filter(Boolean)) {
-            yield* this._loadExtends(extendName, ctx);
-        }
-
-        // Load parser & plugins.
-        const parser = parserName && this._loadParser(parserName, ctx);
-        const plugins = pluginList && this._loadPlugins(pluginList, ctx);
-
-        // Yield pseudo config data for file extension processors.
-        if (plugins) {
-            yield* this._takeFileExtensionProcessors(plugins, ctx);
-        }
-
-        // Yield the config data except `extends` and `overrides`.
-        yield {
-
-            // Debug information.
-            type: ctx.type,
-            name: ctx.name,
-            filePath: ctx.filePath,
-
-            // Config data.
-            criteria: null,
-            env,
-            globals,
-            ignorePattern,
-            noInlineConfig,
-            parser,
-            parserOptions,
-            plugins,
-            processor,
-            reportUnusedDisableDirectives,
-            root,
-            rules,
-            settings
-        };
-
-        // Flatten `overries`.
-        for (let i = 0; i < overrideList.length; ++i) {
-            yield* this._normalizeObjectConfigData(
-                overrideList[i],
-                { ...ctx, name: `${ctx.name}#overrides[${i}]` }
-            );
-        }
-    }
-
-    /**
-     * Load configs of an element in `extends`.
-     * @param {string} extendName The name of a base config.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    _loadExtends(extendName, ctx) {
-        debug$2("Loading {extends:%j} relative to %s", extendName, ctx.filePath);
-        try {
-            if (extendName.startsWith("eslint:")) {
-                return this._loadExtendedBuiltInConfig(extendName, ctx);
-            }
-            if (extendName.startsWith("plugin:")) {
-                return this._loadExtendedPluginConfig(extendName, ctx);
-            }
-            return this._loadExtendedShareableConfig(extendName, ctx);
-        } catch (error) {
-            error.message += `\nReferenced from: ${ctx.filePath || ctx.name}`;
-            throw error;
-        }
-    }
-
-    /**
-     * Load configs of an element in `extends`.
-     * @param {string} extendName The name of a base config.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    _loadExtendedBuiltInConfig(extendName, ctx) {
-        const {
-            eslintAllPath,
-            getEslintAllConfig,
-            eslintRecommendedPath,
-            getEslintRecommendedConfig
-        } = internalSlotsMap$1.get(this);
-
-        if (extendName === "eslint:recommended") {
-            const name = `${ctx.name} » ${extendName}`;
-
-            if (getEslintRecommendedConfig) {
-                if (typeof getEslintRecommendedConfig !== "function") {
-                    throw new Error(`getEslintRecommendedConfig must be a function instead of '${getEslintRecommendedConfig}'`);
-                }
-                return this._normalizeConfigData(getEslintRecommendedConfig(), { ...ctx, name, filePath: "" });
-            }
-            return this._loadConfigData({
-                ...ctx,
-                name,
-                filePath: eslintRecommendedPath
-            });
-        }
-        if (extendName === "eslint:all") {
-            const name = `${ctx.name} » ${extendName}`;
-
-            if (getEslintAllConfig) {
-                if (typeof getEslintAllConfig !== "function") {
-                    throw new Error(`getEslintAllConfig must be a function instead of '${getEslintAllConfig}'`);
-                }
-                return this._normalizeConfigData(getEslintAllConfig(), { ...ctx, name, filePath: "" });
-            }
-            return this._loadConfigData({
-                ...ctx,
-                name,
-                filePath: eslintAllPath
-            });
-        }
-
-        throw configInvalidError(extendName, ctx.name, "extend-config-missing");
-    }
-
-    /**
-     * Load configs of an element in `extends`.
-     * @param {string} extendName The name of a base config.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    _loadExtendedPluginConfig(extendName, ctx) {
-        const slashIndex = extendName.lastIndexOf("/");
-
-        if (slashIndex === -1) {
-            throw configInvalidError(extendName, ctx.filePath, "plugin-invalid");
-        }
-
-        const pluginName = extendName.slice("plugin:".length, slashIndex);
-        const configName = extendName.slice(slashIndex + 1);
-
-        if (isFilePath(pluginName)) {
-            throw new Error("'extends' cannot use a file path for plugins.");
-        }
-
-        const plugin = this._loadPlugin(pluginName, ctx);
-        const configData =
-            plugin.definition &&
-            plugin.definition.configs[configName];
-
-        if (configData) {
-            return this._normalizeConfigData(configData, {
-                ...ctx,
-                filePath: plugin.filePath || ctx.filePath,
-                name: `${ctx.name} » plugin:${plugin.id}/${configName}`
-            });
-        }
-
-        throw plugin.error || configInvalidError(extendName, ctx.filePath, "extend-config-missing");
-    }
-
-    /**
-     * Load configs of an element in `extends`.
-     * @param {string} extendName The name of a base config.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
-     * @private
-     */
-    _loadExtendedShareableConfig(extendName, ctx) {
-        const { cwd, resolver } = internalSlotsMap$1.get(this);
-        const relativeTo = ctx.filePath || path__default["default"].join(cwd, "__placeholder__.js");
-        let request;
-
-        if (isFilePath(extendName)) {
-            request = extendName;
-        } else if (extendName.startsWith(".")) {
-            request = `./${extendName}`; // For backward compatibility. A ton of tests depended on this behavior.
-        } else {
-            request = normalizePackageName(
-                extendName,
-                "eslint-config"
-            );
-        }
-
-        let filePath;
-
-        try {
-            filePath = resolver.resolve(request, relativeTo);
-        } catch (error) {
-            /* istanbul ignore else */
-            if (error && error.code === "MODULE_NOT_FOUND") {
-                throw configInvalidError(extendName, ctx.filePath, "extend-config-missing");
-            }
-            throw error;
-        }
-
-        writeDebugLogForLoading(request, relativeTo, filePath);
-        return this._loadConfigData({
-            ...ctx,
-            filePath,
-            name: `${ctx.name} » ${request}`
-        });
-    }
-
-    /**
-     * Load given plugins.
-     * @param {string[]} names The plugin names to load.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {Record<string,DependentPlugin>} The loaded parser.
-     * @private
-     */
-    _loadPlugins(names, ctx) {
-        return names.reduce((map, name) => {
-            if (isFilePath(name)) {
-                throw new Error("Plugins array cannot includes file paths.");
-            }
-            const plugin = this._loadPlugin(name, ctx);
-
-            map[plugin.id] = plugin;
-
-            return map;
-        }, {});
-    }
-
-    /**
-     * Load a given parser.
-     * @param {string} nameOrPath The package name or the path to a parser file.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {DependentParser} The loaded parser.
-     */
-    _loadParser(nameOrPath, ctx) {
-        debug$2("Loading parser %j from %s", nameOrPath, ctx.filePath);
-
-        const { cwd, resolver } = internalSlotsMap$1.get(this);
-        const relativeTo = ctx.filePath || path__default["default"].join(cwd, "__placeholder__.js");
-
-        try {
-            const filePath = resolver.resolve(nameOrPath, relativeTo);
-
-            writeDebugLogForLoading(nameOrPath, relativeTo, filePath);
-
-            return new ConfigDependency({
-                definition: require$1(filePath),
-                filePath,
-                id: nameOrPath,
-                importerName: ctx.name,
-                importerPath: ctx.filePath
-            });
-        } catch (error) {
-
-            // If the parser name is "espree", load the espree of ESLint.
-            if (nameOrPath === "espree") {
-                debug$2("Fallback espree.");
-                return new ConfigDependency({
-                    definition: require$1("espree"),
-                    filePath: require$1.resolve("espree"),
-                    id: nameOrPath,
-                    importerName: ctx.name,
-                    importerPath: ctx.filePath
-                });
-            }
-
-            debug$2("Failed to load parser '%s' declared in '%s'.", nameOrPath, ctx.name);
-            error.message = `Failed to load parser '${nameOrPath}' declared in '${ctx.name}': ${error.message}`;
-
-            return new ConfigDependency({
-                error,
-                id: nameOrPath,
-                importerName: ctx.name,
-                importerPath: ctx.filePath
-            });
-        }
-    }
-
-    /**
-     * Load a given plugin.
-     * @param {string} name The plugin name to load.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {DependentPlugin} The loaded plugin.
-     * @private
-     */
-    _loadPlugin(name, ctx) {
-        debug$2("Loading plugin %j from %s", name, ctx.filePath);
-
-        const { additionalPluginPool, resolver } = internalSlotsMap$1.get(this);
-        const request = normalizePackageName(name, "eslint-plugin");
-        const id = getShorthandName(request, "eslint-plugin");
-        const relativeTo = path__default["default"].join(ctx.pluginBasePath, "__placeholder__.js");
-
-        if (name.match(/\s+/u)) {
-            const error = Object.assign(
-                new Error(`Whitespace found in plugin name '${name}'`),
-                {
-                    messageTemplate: "whitespace-found",
-                    messageData: { pluginName: request }
-                }
-            );
-
-            return new ConfigDependency({
-                error,
-                id,
-                importerName: ctx.name,
-                importerPath: ctx.filePath
-            });
-        }
-
-        // Check for additional pool.
-        const plugin =
-            additionalPluginPool.get(request) ||
-            additionalPluginPool.get(id);
-
-        if (plugin) {
-            return new ConfigDependency({
-                definition: normalizePlugin(plugin),
-                filePath: "", // It's unknown where the plugin came from.
-                id,
-                importerName: ctx.name,
-                importerPath: ctx.filePath
-            });
-        }
-
-        let filePath;
-        let error;
-
-        try {
-            filePath = resolver.resolve(request, relativeTo);
-        } catch (resolveError) {
-            error = resolveError;
-            /* istanbul ignore else */
-            if (error && error.code === "MODULE_NOT_FOUND") {
-                error.messageTemplate = "plugin-missing";
-                error.messageData = {
-                    pluginName: request,
-                    resolvePluginsRelativeTo: ctx.pluginBasePath,
-                    importerName: ctx.name
-                };
-            }
-        }
-
-        if (filePath) {
-            try {
-                writeDebugLogForLoading(request, relativeTo, filePath);
-
-                const startTime = Date.now();
-                const pluginDefinition = require$1(filePath);
-
-                debug$2(`Plugin ${filePath} loaded in: ${Date.now() - startTime}ms`);
-
-                return new ConfigDependency({
-                    definition: normalizePlugin(pluginDefinition),
-                    filePath,
-                    id,
-                    importerName: ctx.name,
-                    importerPath: ctx.filePath
-                });
-            } catch (loadError) {
-                error = loadError;
-            }
-        }
-
-        debug$2("Failed to load plugin '%s' declared in '%s'.", name, ctx.name);
-        error.message = `Failed to load plugin '${name}' declared in '${ctx.name}': ${error.message}`;
-        return new ConfigDependency({
-            error,
-            id,
-            importerName: ctx.name,
-            importerPath: ctx.filePath
-        });
-    }
-
-    /**
-     * Take file expression processors as config array elements.
-     * @param {Record<string,DependentPlugin>} plugins The plugin definitions.
-     * @param {ConfigArrayFactoryLoadingContext} ctx The loading context.
-     * @returns {IterableIterator<ConfigArrayElement>} The config array elements of file expression processors.
-     * @private
-     */
-    *_takeFileExtensionProcessors(plugins, ctx) {
-        for (const pluginId of Object.keys(plugins)) {
-            const processors =
-                plugins[pluginId] &&
-                plugins[pluginId].definition &&
-                plugins[pluginId].definition.processors;
-
-            if (!processors) {
-                continue;
-            }
-
-            for (const processorId of Object.keys(processors)) {
-                if (processorId.startsWith(".")) {
-                    yield* this._normalizeObjectConfigData(
-                        {
-                            files: [`*${processorId}`],
-                            processor: `${pluginId}/${processorId}`
-                        },
-                        {
-                            ...ctx,
-                            type: "implicit-processor",
-                            name: `${ctx.name}#processors["${pluginId}/${processorId}"]`
-                        }
-                    );
-                }
-            }
-        }
-    }
-}
-
-/**
- * @fileoverview `CascadingConfigArrayFactory` class.
- *
- * `CascadingConfigArrayFactory` class has a responsibility:
- *
- * 1. Handles cascading of config files.
- *
- * It provides two methods:
- *
- * - `getConfigArrayForFile(filePath)`
- *     Get the corresponded configuration of a given file. This method doesn't
- *     throw even if the given file didn't exist.
- * - `clearCache()`
- *     Clear the internal cache. You have to call this method when
- *     `additionalPluginPool` was updated if `baseConfig` or `cliConfig` depends
- *     on the additional plugins. (`CLIEngine#addPlugin()` method calls this.)
- *
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-
-const debug$1 = debugOrig__default["default"]("eslintrc:cascading-config-array-factory");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-// Define types for VSCode IntelliSense.
-/** @typedef {import("./shared/types").ConfigData} ConfigData */
-/** @typedef {import("./shared/types").Parser} Parser */
-/** @typedef {import("./shared/types").Plugin} Plugin */
-/** @typedef {import("./shared/types").Rule} Rule */
-/** @typedef {ReturnType<ConfigArrayFactory["create"]>} ConfigArray */
-
-/**
- * @typedef {Object} CascadingConfigArrayFactoryOptions
- * @property {Map<string,Plugin>} [additionalPluginPool] The map for additional plugins.
- * @property {ConfigData} [baseConfig] The config by `baseConfig` option.
- * @property {ConfigData} [cliConfig] The config by CLI options (`--env`, `--global`, `--ignore-pattern`, `--parser`, `--parser-options`, `--plugin`, and `--rule`). CLI options overwrite the setting in config files.
- * @property {string} [cwd] The base directory to start lookup.
- * @property {string} [ignorePath] The path to the alternative file of `.eslintignore`.
- * @property {string[]} [rulePaths] The value of `--rulesdir` option.
- * @property {string} [specificConfigPath] The value of `--config` option.
- * @property {boolean} [useEslintrc] if `false` then it doesn't load config files.
- * @property {Function} loadRules The function to use to load rules.
- * @property {Map<string,Rule>} builtInRules The rules that are built in to ESLint.
- * @property {Object} [resolver=ModuleResolver] The module resolver object.
- * @property {string} eslintAllPath The path to the definitions for eslint:all.
- * @property {Function} getEslintAllConfig Returns the config data for eslint:all.
- * @property {string} eslintRecommendedPath The path to the definitions for eslint:recommended.
- * @property {Function} getEslintRecommendedConfig Returns the config data for eslint:recommended.
- */
-
-/**
- * @typedef {Object} CascadingConfigArrayFactoryInternalSlots
- * @property {ConfigArray} baseConfigArray The config array of `baseConfig` option.
- * @property {ConfigData} baseConfigData The config data of `baseConfig` option. This is used to reset `baseConfigArray`.
- * @property {ConfigArray} cliConfigArray The config array of CLI options.
- * @property {ConfigData} cliConfigData The config data of CLI options. This is used to reset `cliConfigArray`.
- * @property {ConfigArrayFactory} configArrayFactory The factory for config arrays.
- * @property {Map<string, ConfigArray>} configCache The cache from directory paths to config arrays.
- * @property {string} cwd The base directory to start lookup.
- * @property {WeakMap<ConfigArray, ConfigArray>} finalizeCache The cache from config arrays to finalized config arrays.
- * @property {string} [ignorePath] The path to the alternative file of `.eslintignore`.
- * @property {string[]|null} rulePaths The value of `--rulesdir` option. This is used to reset `baseConfigArray`.
- * @property {string|null} specificConfigPath The value of `--config` option. This is used to reset `cliConfigArray`.
- * @property {boolean} useEslintrc if `false` then it doesn't load config files.
- * @property {Function} loadRules The function to use to load rules.
- * @property {Map<string,Rule>} builtInRules The rules that are built in to ESLint.
- * @property {Object} [resolver=ModuleResolver] The module resolver object.
- * @property {string} eslintAllPath The path to the definitions for eslint:all.
- * @property {Function} getEslintAllConfig Returns the config data for eslint:all.
- * @property {string} eslintRecommendedPath The path to the definitions for eslint:recommended.
- * @property {Function} getEslintRecommendedConfig Returns the config data for eslint:recommended.
- */
-
-/** @type {WeakMap<CascadingConfigArrayFactory, CascadingConfigArrayFactoryInternalSlots>} */
-const internalSlotsMap = new WeakMap();
-
-/**
- * Create the config array from `baseConfig` and `rulePaths`.
- * @param {CascadingConfigArrayFactoryInternalSlots} slots The slots.
- * @returns {ConfigArray} The config array of the base configs.
- */
-function createBaseConfigArray({
-    configArrayFactory,
-    baseConfigData,
-    rulePaths,
-    cwd,
-    loadRules
-}) {
-    const baseConfigArray = configArrayFactory.create(
-        baseConfigData,
-        { name: "BaseConfig" }
-    );
-
-    /*
-     * Create the config array element for the default ignore patterns.
-     * This element has `ignorePattern` property that ignores the default
-     * patterns in the current working directory.
-     */
-    baseConfigArray.unshift(configArrayFactory.create(
-        { ignorePatterns: IgnorePattern.DefaultPatterns },
-        { name: "DefaultIgnorePattern" }
-    )[0]);
-
-    /*
-     * Load rules `--rulesdir` option as a pseudo plugin.
-     * Use a pseudo plugin to define rules of `--rulesdir`, so we can validate
-     * the rule's options with only information in the config array.
-     */
-    if (rulePaths && rulePaths.length > 0) {
-        baseConfigArray.push({
-            type: "config",
-            name: "--rulesdir",
-            filePath: "",
-            plugins: {
-                "": new ConfigDependency({
-                    definition: {
-                        rules: rulePaths.reduce(
-                            (map, rulesPath) => Object.assign(
-                                map,
-                                loadRules(rulesPath, cwd)
-                            ),
-                            {}
-                        )
-                    },
-                    filePath: "",
-                    id: "",
-                    importerName: "--rulesdir",
-                    importerPath: ""
-                })
-            }
-        });
-    }
-
-    return baseConfigArray;
-}
-
-/**
- * Create the config array from CLI options.
- * @param {CascadingConfigArrayFactoryInternalSlots} slots The slots.
- * @returns {ConfigArray} The config array of the base configs.
- */
-function createCLIConfigArray({
-    cliConfigData,
-    configArrayFactory,
-    cwd,
-    ignorePath,
-    specificConfigPath
-}) {
-    const cliConfigArray = configArrayFactory.create(
-        cliConfigData,
-        { name: "CLIOptions" }
-    );
-
-    cliConfigArray.unshift(
-        ...(ignorePath
-            ? configArrayFactory.loadESLintIgnore(ignorePath)
-            : configArrayFactory.loadDefaultESLintIgnore())
-    );
-
-    if (specificConfigPath) {
-        cliConfigArray.unshift(
-            ...configArrayFactory.loadFile(
-                specificConfigPath,
-                { name: "--config", basePath: cwd }
-            )
-        );
-    }
-
-    return cliConfigArray;
-}
-
-/**
- * The error type when there are files matched by a glob, but all of them have been ignored.
- */
-class ConfigurationNotFoundError extends Error {
-
-    // eslint-disable-next-line jsdoc/require-description
-    /**
-     * @param {string} directoryPath The directory path.
-     */
-    constructor(directoryPath) {
-        super(`No ESLint configuration found in ${directoryPath}.`);
-        this.messageTemplate = "no-config-found";
-        this.messageData = { directoryPath };
-    }
-}
-
-/**
- * This class provides the functionality that enumerates every file which is
- * matched by given glob patterns and that configuration.
- */
-class CascadingConfigArrayFactory {
-
-    /**
-     * Initialize this enumerator.
-     * @param {CascadingConfigArrayFactoryOptions} options The options.
-     */
-    constructor({
-        additionalPluginPool = new Map(),
-        baseConfig: baseConfigData = null,
-        cliConfig: cliConfigData = null,
-        cwd = process.cwd(),
-        ignorePath,
-        resolvePluginsRelativeTo,
-        rulePaths = [],
-        specificConfigPath = null,
-        useEslintrc = true,
-        builtInRules = new Map(),
-        loadRules,
-        resolver,
-        eslintRecommendedPath,
-        getEslintRecommendedConfig,
-        eslintAllPath,
-        getEslintAllConfig
-    } = {}) {
-        const configArrayFactory = new ConfigArrayFactory({
-            additionalPluginPool,
-            cwd,
-            resolvePluginsRelativeTo,
-            builtInRules,
-            resolver,
-            eslintRecommendedPath,
-            getEslintRecommendedConfig,
-            eslintAllPath,
-            getEslintAllConfig
-        });
-
-        internalSlotsMap.set(this, {
-            baseConfigArray: createBaseConfigArray({
-                baseConfigData,
-                configArrayFactory,
-                cwd,
-                rulePaths,
-                loadRules,
-                resolver
-            }),
-            baseConfigData,
-            cliConfigArray: createCLIConfigArray({
-                cliConfigData,
-                configArrayFactory,
-                cwd,
-                ignorePath,
-                specificConfigPath
-            }),
-            cliConfigData,
-            configArrayFactory,
-            configCache: new Map(),
-            cwd,
-            finalizeCache: new WeakMap(),
-            ignorePath,
-            rulePaths,
-            specificConfigPath,
-            useEslintrc,
-            builtInRules,
-            loadRules
-        });
-    }
-
-    /**
-     * The path to the current working directory.
-     * This is used by tests.
-     * @type {string}
-     */
-    get cwd() {
-        const { cwd } = internalSlotsMap.get(this);
-
-        return cwd;
-    }
-
-    /**
-     * Get the config array of a given file.
-     * If `filePath` was not given, it returns the config which contains only
-     * `baseConfigData` and `cliConfigData`.
-     * @param {string} [filePath] The file path to a file.
-     * @param {Object} [options] The options.
-     * @param {boolean} [options.ignoreNotFoundError] If `true` then it doesn't throw `ConfigurationNotFoundError`.
-     * @returns {ConfigArray} The config array of the file.
-     */
-    getConfigArrayForFile(filePath, { ignoreNotFoundError = false } = {}) {
-        const {
-            baseConfigArray,
-            cliConfigArray,
-            cwd
-        } = internalSlotsMap.get(this);
-
-        if (!filePath) {
-            return new ConfigArray(...baseConfigArray, ...cliConfigArray);
-        }
-
-        const directoryPath = path__default["default"].dirname(path__default["default"].resolve(cwd, filePath));
-
-        debug$1(`Load config files for ${directoryPath}.`);
-
-        return this._finalizeConfigArray(
-            this._loadConfigInAncestors(directoryPath),
-            directoryPath,
-            ignoreNotFoundError
-        );
-    }
-
-    /**
-     * Set the config data to override all configs.
-     * Require to call `clearCache()` method after this method is called.
-     * @param {ConfigData} configData The config data to override all configs.
-     * @returns {void}
-     */
-    setOverrideConfig(configData) {
-        const slots = internalSlotsMap.get(this);
-
-        slots.cliConfigData = configData;
-    }
-
-    /**
-     * Clear config cache.
-     * @returns {void}
-     */
-    clearCache() {
-        const slots = internalSlotsMap.get(this);
-
-        slots.baseConfigArray = createBaseConfigArray(slots);
-        slots.cliConfigArray = createCLIConfigArray(slots);
-        slots.configCache.clear();
-    }
-
-    /**
-     * Load and normalize config files from the ancestor directories.
-     * @param {string} directoryPath The path to a leaf directory.
-     * @param {boolean} configsExistInSubdirs `true` if configurations exist in subdirectories.
-     * @returns {ConfigArray} The loaded config.
-     * @private
-     */
-    _loadConfigInAncestors(directoryPath, configsExistInSubdirs = false) {
-        const {
-            baseConfigArray,
-            configArrayFactory,
-            configCache,
-            cwd,
-            useEslintrc
-        } = internalSlotsMap.get(this);
-
-        if (!useEslintrc) {
-            return baseConfigArray;
-        }
-
-        let configArray = configCache.get(directoryPath);
-
-        // Hit cache.
-        if (configArray) {
-            debug$1(`Cache hit: ${directoryPath}.`);
-            return configArray;
-        }
-        debug$1(`No cache found: ${directoryPath}.`);
-
-        const homePath = os__default["default"].homedir();
-
-        // Consider this is root.
-        if (directoryPath === homePath && cwd !== homePath) {
-            debug$1("Stop traversing because of considered root.");
-            if (configsExistInSubdirs) {
-                const filePath = ConfigArrayFactory.getPathToConfigFileInDirectory(directoryPath);
-
-                if (filePath) {
-                    emitDeprecationWarning(
-                        filePath,
-                        "ESLINT_PERSONAL_CONFIG_SUPPRESS"
-                    );
-                }
-            }
-            return this._cacheConfig(directoryPath, baseConfigArray);
-        }
-
-        // Load the config on this directory.
-        try {
-            configArray = configArrayFactory.loadInDirectory(directoryPath);
-        } catch (error) {
-            /* istanbul ignore next */
-            if (error.code === "EACCES") {
-                debug$1("Stop traversing because of 'EACCES' error.");
-                return this._cacheConfig(directoryPath, baseConfigArray);
-            }
-            throw error;
-        }
-
-        if (configArray.length > 0 && configArray.isRoot()) {
-            debug$1("Stop traversing because of 'root:true'.");
-            configArray.unshift(...baseConfigArray);
-            return this._cacheConfig(directoryPath, configArray);
-        }
-
-        // Load from the ancestors and merge it.
-        const parentPath = path__default["default"].dirname(directoryPath);
-        const parentConfigArray = parentPath && parentPath !== directoryPath
-            ? this._loadConfigInAncestors(
-                parentPath,
-                configsExistInSubdirs || configArray.length > 0
-            )
-            : baseConfigArray;
-
-        if (configArray.length > 0) {
-            configArray.unshift(...parentConfigArray);
-        } else {
-            configArray = parentConfigArray;
-        }
-
-        // Cache and return.
-        return this._cacheConfig(directoryPath, configArray);
-    }
-
-    /**
-     * Freeze and cache a given config.
-     * @param {string} directoryPath The path to a directory as a cache key.
-     * @param {ConfigArray} configArray The config array as a cache value.
-     * @returns {ConfigArray} The `configArray` (frozen).
-     */
-    _cacheConfig(directoryPath, configArray) {
-        const { configCache } = internalSlotsMap.get(this);
-
-        Object.freeze(configArray);
-        configCache.set(directoryPath, configArray);
-
-        return configArray;
-    }
-
-    /**
-     * Finalize a given config array.
-     * Concatenate `--config` and other CLI options.
-     * @param {ConfigArray} configArray The parent config array.
-     * @param {string} directoryPath The path to the leaf directory to find config files.
-     * @param {boolean} ignoreNotFoundError If `true` then it doesn't throw `ConfigurationNotFoundError`.
-     * @returns {ConfigArray} The loaded config.
-     * @private
-     */
-    _finalizeConfigArray(configArray, directoryPath, ignoreNotFoundError) {
-        const {
-            cliConfigArray,
-            configArrayFactory,
-            finalizeCache,
-            useEslintrc,
-            builtInRules
-        } = internalSlotsMap.get(this);
-
-        let finalConfigArray = finalizeCache.get(configArray);
-
-        if (!finalConfigArray) {
-            finalConfigArray = configArray;
-
-            // Load the personal config if there are no regular config files.
-            if (
-                useEslintrc &&
-                configArray.every(c => !c.filePath) &&
-                cliConfigArray.every(c => !c.filePath) // `--config` option can be a file.
-            ) {
-                const homePath = os__default["default"].homedir();
-
-                debug$1("Loading the config file of the home directory:", homePath);
-
-                const personalConfigArray = configArrayFactory.loadInDirectory(
-                    homePath,
-                    { name: "PersonalConfig" }
-                );
-
-                if (
-                    personalConfigArray.length > 0 &&
-                    !directoryPath.startsWith(homePath)
-                ) {
-                    const lastElement =
-                        personalConfigArray[personalConfigArray.length - 1];
-
-                    emitDeprecationWarning(
-                        lastElement.filePath,
-                        "ESLINT_PERSONAL_CONFIG_LOAD"
-                    );
-                }
-
-                finalConfigArray = finalConfigArray.concat(personalConfigArray);
-            }
-
-            // Apply CLI options.
-            if (cliConfigArray.length > 0) {
-                finalConfigArray = finalConfigArray.concat(cliConfigArray);
-            }
-
-            // Validate rule settings and environments.
-            const validator = new ConfigValidator({
-                builtInRules
-            });
-
-            validator.validateConfigArray(finalConfigArray);
-
-            // Cache it.
-            Object.freeze(finalConfigArray);
-            finalizeCache.set(configArray, finalConfigArray);
-
-            debug$1(
-                "Configuration was determined: %o on %s",
-                finalConfigArray,
-                directoryPath
-            );
-        }
-
-        // At least one element (the default ignore patterns) exists.
-        if (!ignoreNotFoundError && useEslintrc && finalConfigArray.length <= 1) {
-            throw new ConfigurationNotFoundError(directoryPath);
-        }
-
-        return finalConfigArray;
-    }
-}
-
-/**
- * @fileoverview Compatibility class for flat config.
- * @author Nicholas C. Zakas
- */
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-/** @typedef {import("../../shared/types").Environment} Environment */
-/** @typedef {import("../../shared/types").Processor} Processor */
-
-const debug = debugOrig__default["default"]("eslintrc:flat-compat");
-const cafactory = Symbol("cafactory");
-
-/**
- * Translates an ESLintRC-style config object into a flag-config-style config
- * object.
- * @param {Object} eslintrcConfig An ESLintRC-style config object.
- * @param {Object} options Options to help translate the config.
- * @param {string} options.resolveConfigRelativeTo To the directory to resolve
- *      configs from.
- * @param {string} options.resolvePluginsRelativeTo The directory to resolve
- *      plugins from.
- * @param {ReadOnlyMap<string,Environment>} options.pluginEnvironments A map of plugin environment
- *      names to objects.
- * @param {ReadOnlyMap<string,Processor>} options.pluginProcessors A map of plugin processor
- *      names to objects.
- * @returns {Object} A flag-config-style config object.
- */
-function translateESLintRC(eslintrcConfig, {
-    resolveConfigRelativeTo,
-    resolvePluginsRelativeTo,
-    pluginEnvironments,
-    pluginProcessors
-}) {
-
-    const flatConfig = {};
-    const configs = [];
-    const languageOptions = {};
-    const linterOptions = {};
-    const keysToCopy = ["settings", "rules", "processor"];
-    const languageOptionsKeysToCopy = ["globals", "parser", "parserOptions"];
-    const linterOptionsKeysToCopy = ["noInlineConfig", "reportUnusedDisableDirectives"];
-
-    // check for special settings for eslint:all and eslint:recommended:
-    if (eslintrcConfig.settings) {
-        if (eslintrcConfig.settings["eslint:all"] === true) {
-            return ["eslint:all"];
-        }
-
-        if (eslintrcConfig.settings["eslint:recommended"] === true) {
-            return ["eslint:recommended"];
-        }
-    }
-
-    // copy over simple translations
-    for (const key of keysToCopy) {
-        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
-            flatConfig[key] = eslintrcConfig[key];
-        }
-    }
-
-    // copy over languageOptions
-    for (const key of languageOptionsKeysToCopy) {
-        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
-
-            // create the languageOptions key in the flat config
-            flatConfig.languageOptions = languageOptions;
-
-            if (key === "parser") {
-                debug(`Resolving parser '${languageOptions[key]}' relative to ${resolveConfigRelativeTo}`);
-
-                if (eslintrcConfig[key].error) {
-                    throw eslintrcConfig[key].error;
-                }
-
-                languageOptions[key] = eslintrcConfig[key].definition;
-                continue;
-            }
-
-            // clone any object values that are in the eslintrc config
-            if (eslintrcConfig[key] && typeof eslintrcConfig[key] === "object") {
-                languageOptions[key] = {
-                    ...eslintrcConfig[key]
-                };
-            } else {
-                languageOptions[key] = eslintrcConfig[key];
-            }
-        }
-    }
-
-    // copy over linterOptions
-    for (const key of linterOptionsKeysToCopy) {
-        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
-            flatConfig.linterOptions = linterOptions;
-            linterOptions[key] = eslintrcConfig[key];
-        }
-    }
-
-    // move ecmaVersion a level up
-    if (languageOptions.parserOptions) {
-
-        if ("ecmaVersion" in languageOptions.parserOptions) {
-            languageOptions.ecmaVersion = languageOptions.parserOptions.ecmaVersion;
-            delete languageOptions.parserOptions.ecmaVersion;
-        }
-
-        if ("sourceType" in languageOptions.parserOptions) {
-            languageOptions.sourceType = languageOptions.parserOptions.sourceType;
-            delete languageOptions.parserOptions.sourceType;
-        }
-
-        // check to see if we even need parserOptions anymore and remove it if not
-        if (Object.keys(languageOptions.parserOptions).length === 0) {
-            delete languageOptions.parserOptions;
-        }
-    }
-
-    // overrides
-    if (eslintrcConfig.criteria) {
-        flatConfig.files = [absoluteFilePath => eslintrcConfig.criteria.test(absoluteFilePath)];
-    }
-
-    // translate plugins
-    if (eslintrcConfig.plugins && typeof eslintrcConfig.plugins === "object") {
-        debug(`Translating plugins: ${eslintrcConfig.plugins}`);
-
-        flatConfig.plugins = {};
-
-        for (const pluginName of Object.keys(eslintrcConfig.plugins)) {
-
-            debug(`Translating plugin: ${pluginName}`);
-            debug(`Resolving plugin '${pluginName} relative to ${resolvePluginsRelativeTo}`);
-
-            const { definition: plugin, error } = eslintrcConfig.plugins[pluginName];
-
-            if (error) {
-                throw error;
-            }
-
-            flatConfig.plugins[pluginName] = plugin;
-
-            // create a config for any processors
-            if (plugin.processors) {
-                for (const processorName of Object.keys(plugin.processors)) {
-                    if (processorName.startsWith(".")) {
-                        debug(`Assigning processor: ${pluginName}/${processorName}`);
-
-                        configs.unshift({
-                            files: [`**/*${processorName}`],
-                            processor: pluginProcessors.get(`${pluginName}/${processorName}`)
-                        });
-                    }
-
-                }
-            }
-        }
-    }
-
-    // translate env - must come after plugins
-    if (eslintrcConfig.env && typeof eslintrcConfig.env === "object") {
-        for (const envName of Object.keys(eslintrcConfig.env)) {
-
-            // only add environments that are true
-            if (eslintrcConfig.env[envName]) {
-                debug(`Translating environment: ${envName}`);
-
-                if (environments.has(envName)) {
-
-                    // built-in environments should be defined first
-                    configs.unshift(...translateESLintRC(environments.get(envName), {
-                        resolveConfigRelativeTo,
-                        resolvePluginsRelativeTo
-                    }));
-                } else if (pluginEnvironments.has(envName)) {
-
-                    // if the environment comes from a plugin, it should come after the plugin config
-                    configs.push(...translateESLintRC(pluginEnvironments.get(envName), {
-                        resolveConfigRelativeTo,
-                        resolvePluginsRelativeTo
-                    }));
-                }
-            }
-        }
-    }
-
-    // only add if there are actually keys in the config
-    if (Object.keys(flatConfig).length > 0) {
-        configs.push(flatConfig);
-    }
-
-    return configs;
-}
-
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-/**
- * A compatibility class for working with configs.
- */
-class FlatCompat {
-
-    constructor({
-        baseDirectory = process.cwd(),
-        resolvePluginsRelativeTo = baseDirectory
-    } = {}) {
-        this.baseDirectory = baseDirectory;
-        this.resolvePluginsRelativeTo = resolvePluginsRelativeTo;
-        this[cafactory] = new ConfigArrayFactory({
-            cwd: baseDirectory,
-            resolvePluginsRelativeTo,
-            getEslintAllConfig: () => ({ settings: { "eslint:all": true } }),
-            getEslintRecommendedConfig: () => ({ settings: { "eslint:recommended": true } })
-        });
-    }
-
-    /**
-     * Translates an ESLintRC-style config into a flag-config-style config.
-     * @param {Object} eslintrcConfig The ESLintRC-style config object.
-     * @returns {Object} A flag-config-style config object.
-     */
-    config(eslintrcConfig) {
-        const eslintrcArray = this[cafactory].create(eslintrcConfig, {
-            basePath: this.baseDirectory
-        });
-
-        const flatArray = [];
-        let hasIgnorePatterns = false;
-
-        eslintrcArray.forEach(configData => {
-            if (configData.type === "config") {
-                hasIgnorePatterns = hasIgnorePatterns || configData.ignorePattern;
-                flatArray.push(...translateESLintRC(configData, {
-                    resolveConfigRelativeTo: path__default["default"].join(this.baseDirectory, "__placeholder.js"),
-                    resolvePluginsRelativeTo: path__default["default"].join(this.resolvePluginsRelativeTo, "__placeholder.js"),
-                    pluginEnvironments: eslintrcArray.pluginEnvironments,
-                    pluginProcessors: eslintrcArray.pluginProcessors
-                }));
-            }
-        });
-
-        // combine ignorePatterns to emulate ESLintRC behavior better
-        if (hasIgnorePatterns) {
-            flatArray.unshift({
-                ignores: [filePath => {
-
-                    // Compute the final config for this file.
-                    // This filters config array elements by `files`/`excludedFiles` then merges the elements.
-                    const finalConfig = eslintrcArray.extractConfig(filePath);
-
-                    // Test the `ignorePattern` properties of the final config.
-                    return Boolean(finalConfig.ignores) && finalConfig.ignores(filePath);
-                }]
-            });
-        }
-
-        return flatArray;
-    }
-
-    /**
-     * Translates the `env` section of an ESLintRC-style config.
-     * @param {Object} envConfig The `env` section of an ESLintRC config.
-     * @returns {Object} A flag-config object representing the environments.
-     */
-    env(envConfig) {
-        return this.config({
-            env: envConfig
-        });
-    }
-
-    /**
-     * Translates the `extends` section of an ESLintRC-style config.
-     * @param {...string} configsToExtend The names of the configs to load.
-     * @returns {Object} A flag-config object representing the config.
-     */
-    extends(...configsToExtend) {
-        return this.config({
-            extends: configsToExtend
-        });
-    }
-
-    /**
-     * Translates the `plugins` section of an ESLintRC-style config.
-     * @param {...string} plugins The names of the plugins to load.
-     * @returns {Object} A flag-config object representing the plugins.
-     */
-    plugins(...plugins) {
-        return this.config({
-            plugins
-        });
-    }
-}
-
-/**
- * @fileoverview Package exports for @eslint/eslintrc
- * @author Nicholas C. Zakas
- */
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-const Legacy = {
-    ConfigArray,
-    createConfigArrayFactoryContext: createContext,
-    CascadingConfigArrayFactory,
-    ConfigArrayFactory,
-    ConfigDependency,
-    ExtractedConfig,
-    IgnorePattern,
-    OverrideTester,
-    getUsedExtractedConfigs,
-    environments,
-
-    // shared
-    ConfigOps,
-    ConfigValidator,
-    ModuleResolver,
-    naming
-};
-
-exports.FlatCompat = FlatCompat;
-exports.Legacy = Legacy;
-//# sourceMappingURL=eslintrc.cjs.map