'use strict';

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

var util = require('node:util');
var path = require('node: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 = new Set([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.has(severity);
}

/**
 * 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 -- part of the API
  ajv._opts.defaultMeta = metaSchema.id;

  return ajv;
};

/**
 * @fileoverview Applies default rule options
 * @author JoshuaKGoldberg
 */

/**
 * Check if the variable contains an object strictly rejecting arrays
 * @param {unknown} value an object
 * @returns {boolean} Whether value is an object
 */
function isObjectNotArray(value) {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

/**
 * Deeply merges second on top of first, creating a new {} object if needed.
 * @param {T} first Base, default value.
 * @param {U} second User-specified value.
 * @returns {T | U | (T & U)} Merged equivalent of second on top of first.
 */
function deepMergeObjects(first, second) {
  if (second === void 0) {
    return first;
  }

  if (!isObjectNotArray(first) || !isObjectNotArray(second)) {
    return second;
  }

  const result = { ...first, ...second };

  for (const key of Object.keys(second)) {
    if (Object.prototype.propertyIsEnumerable.call(first, key)) {
      result[key] = deepMergeObjects(first[key], second[key]);
    }
  }

  return result;
}

/**
 * Deeply merges second on top of first, creating a new [] array if needed.
 * @param {T[] | undefined} first Base, default values.
 * @param {U[] | undefined} second User-specified values.
 * @returns {(T | U | (T & U))[]} Merged equivalent of second on top of first.
 */
function deepMergeArrays(first, second) {
  if (!first || !second) {
    return second || first || [];
  }

  return [
    ...first.map((value, i) => deepMergeObjects(value, second[i])),
    ...second.slice(first.length),
  ];
}

/**
 * @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.hasOwn(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,
      },
    },
    es2023: {
      globals: {
        ...newGlobals2015,
        ...newGlobals2017,
        ...newGlobals2020,
        ...newGlobals2021,
      },
      parserOptions: {
        ecmaVersion: 14,
      },
    },
    es2024: {
      globals: {
        ...newGlobals2015,
        ...newGlobals2017,
        ...newGlobals2020,
        ...newGlobals2021,
      },
      parserOptions: {
        ecmaVersion: 15,
      },
    },

    // 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();

// JSON schema that disallows passing any options
const noOptionsSchema = Object.freeze({
  type: 'array',
  minItems: 0,
  maxItems: 0,
});

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

/**
 * Validator for configuration objects.
 */
class ConfigValidator {
  constructor({ builtInRules = new Map() } = {}) {
    this.builtInRules = builtInRules;
  }

  /**
   * Gets a complete options schema for a rule.
   * @param {Rule} rule A rule object
   * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`.
   * @returns {Object|null} JSON Schema for the rule's options.
   *      `null` if rule wasn't passed or its `meta.schema` is `false`.
   */
  getRuleOptionsSchema(rule) {
    if (!rule) {
      return null;
    }

    if (!rule.meta) {
      return { ...noOptionsSchema }; // default if `meta.schema` is not specified
    }

    const schema = rule.meta.schema;

    if (typeof schema === 'undefined') {
      return { ...noOptionsSchema }; // default if `meta.schema` is not specified
    }

    // `schema:false` is an allowed explicit opt-out of options validation for the rule
    if (schema === false) {
      return null;
    }

    if (typeof schema !== 'object' || schema === null) {
      throw new TypeError("Rule's `meta.schema` must be an array or object");
    }

    // ESLint-specific array form needs to be converted into a valid JSON Schema definition
    if (Array.isArray(schema)) {
      if (schema.length) {
        return {
          type: 'array',
          items: schema,
          minItems: 0,
          maxItems: schema.length,
        };
      }

      // `schema:[]` is an explicit way to specify that the rule does not accept any options
      return { ...noOptionsSchema };
    }

    // `schema:<object>` is assumed to be a valid JSON Schema definition
    return schema;
  }

  /**
   * 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
   * @throws {Error} If the severity is invalid.
   */
  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}
   * @throws {Error} If the options are invalid.
   */
  validateRuleSchema(rule, localOptions) {
    if (!ruleValidators.has(rule)) {
      try {
        const schema = this.getRuleOptionsSchema(rule);

        if (schema) {
          ruleValidators.set(rule, ajv.compile(schema));
        }
      } catch (err) {
        const errorWithCode = new Error(err.message, { cause: err });

        errorWithCode.code = 'ESLINT_INVALID_RULE_OPTIONS_SCHEMA';

        throw errorWithCode;
      }
    }

    const validateRule = ruleValidators.get(rule);

    if (validateRule) {
      const mergedOptions = deepMergeArrays(
        rule.meta?.defaultOptions,
        localOptions
      );

      validateRule(mergedOptions);

      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}
   * @throws {Error} If the options are invalid.
   */
  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) {
      let enhancedMessage =
        err.code === 'ESLINT_INVALID_RULE_OPTIONS_SCHEMA' ?
          `Error while processing options validation schema of rule '${ruleId}': ${err.message}`
        : `Configuration for rule "${ruleId}" is invalid:\n${err.message}`;

      if (typeof source === 'string') {
        enhancedMessage = `${source}:\n\t${enhancedMessage}`;
      }

      const enhancedError = new Error(enhancedMessage, { cause: err });

      if (err.code) {
        enhancedError.code = err.code;
      }

      throw enhancedError;
    }
  }

  /**
   * 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 {(envId:string) => Object} [getAdditionalEnv] A map from strings to loaded environments.
   * @returns {void}
   * @throws {Error} If the environment is invalid.
   */
  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 {(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 {(id:string) => Processor} getProcessor The getter of defined processors.
   * @returns {void}
   * @throws {Error} If the processor is invalid.
   */
  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}
   * @throws {Error} If the config is invalid.
   */
  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.hasOwn(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 {(ruleId:string) => Object} [getAdditionalRule] A map from strings to loaded rules.
   * @param {(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