'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var util = require('util');

var path = require('path');
var Ajv = require('ajv');
var globals = require('globals');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default'
in e ? e : { 'default': e }; }

var util__default = /*#__PURE__*/_interopDefaultLegacy(util);

var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
var globals__default = /*#__PURE__*/_interopDefaultLegacy(globals);

/**
* @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
};

/**
* @fileoverview Package exports for @eslint/eslintrc
* @author Nicholas C. Zakas
*/

//-----------------------------------------------------------------------------
// Exports
//-----------------------------------------------------------------------------

const Legacy = {
environments,

// shared
ConfigOps,
ConfigValidator,
naming
};

exports.Legacy = Legacy;
//# sourceMappingURL=eslintrc-universal.cjs.map