Bump packages to fix linter

node_modules/@eslint/eslintrc/lib/cascading-config-array-factory.js

@@ -17,19 +17,25 @@
  *
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const os = require("os");
-const path = require("path");
-const ConfigValidator = require("./shared/config-validator");
-const { emitDeprecationWarning } = require("./shared/deprecation-warnings");
-const { ConfigArrayFactory } = require("./config-array-factory");
-const { ConfigArray, ConfigDependency, IgnorePattern } = require("./config-array");
-const debug = require("debug")("eslintrc:cascading-config-array-factory");
+import debugOrig from "debug";
+import os from "os";
+import path from "path";
+
+import { ConfigArrayFactory } from "./config-array-factory.js";
+import {
+    ConfigArray,
+    ConfigDependency,
+    IgnorePattern
+} from "./config-array/index.js";
+import ConfigValidator from "./shared/config-validator.js";
+import { emitDeprecationWarning } from "./shared/deprecation-warnings.js";
+
+const debug = debugOrig("eslintrc:cascading-config-array-factory");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -56,7 +62,9 @@ const debug = require("debug")("eslintrc:cascading-config-array-factory");
  * @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.
  */
 
 /**
@@ -77,7 +85,9 @@ const debug = require("debug")("eslintrc:cascading-config-array-factory");
  * @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>} */
@@ -218,7 +228,9 @@ class CascadingConfigArrayFactory {
         loadRules,
         resolver,
         eslintRecommendedPath,
-        eslintAllPath
+        getEslintRecommendedConfig,
+        eslintAllPath,
+        getEslintAllConfig
     } = {}) {
         const configArrayFactory = new ConfigArrayFactory({
             additionalPluginPool,
@@ -227,7 +239,9 @@ class CascadingConfigArrayFactory {
             builtInRules,
             resolver,
             eslintRecommendedPath,
-            eslintAllPath
+            getEslintRecommendedConfig,
+            eslintAllPath,
+            getEslintAllConfig
         });
 
         internalSlotsMap.set(this, {
@@ -236,8 +250,7 @@ class CascadingConfigArrayFactory {
                 configArrayFactory,
                 cwd,
                 rulePaths,
-                loadRules,
-                resolver
+                loadRules
             }),
             baseConfigData,
             cliConfigArray: createCLIConfigArray({
@@ -516,4 +529,4 @@ class CascadingConfigArrayFactory {
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = { CascadingConfigArrayFactory };
+export { CascadingConfigArrayFactory };

node_modules/@eslint/eslintrc/lib/config-array-factory.js

@@ -33,26 +33,31 @@
  *
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const fs = require("fs");
-const path = require("path");
-const importFresh = require("import-fresh");
-const stripComments = require("strip-json-comments");
-const ConfigValidator = require("./shared/config-validator");
-const naming = require("./shared/naming");
-const ModuleResolver = require("./shared/relative-module-resolver");
-const {
+import debugOrig from "debug";
+import fs from "fs";
+import importFresh from "import-fresh";
+import { createRequire } from "module";
+import path from "path";
+import stripComments from "strip-json-comments";
+
+import {
     ConfigArray,
     ConfigDependency,
     IgnorePattern,
     OverrideTester
-} = require("./config-array");
-const debug = require("debug")("eslintrc:config-array-factory");
+} from "./config-array/index.js";
+import ConfigValidator from "./shared/config-validator.js";
+import * as naming from "./shared/naming.js";
+import * as ModuleResolver from "./shared/relative-module-resolver.js";
+
+const require = createRequire(import.meta.url);
+
+const debug = debugOrig("eslintrc:config-array-factory");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -86,7 +91,9 @@ const configFilenames = [
  * @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.
  */
 
 /**
@@ -97,7 +104,9 @@ const configFilenames = [
  * @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.
  */
 
 /**
@@ -120,6 +129,9 @@ const configFilenames = [
 /** @type {WeakMap<ConfigArrayFactory, ConfigArrayFactoryInternalSlots>} */
 const internalSlotsMap = new WeakMap();
 
+/** @type {WeakMap<object, Plugin>} */
+const normalizedPlugins = new WeakMap();
+
 /**
  * Check if a given string is a file path.
  * @param {string} nameOrPath A module name or file path.
@@ -158,7 +170,7 @@ function loadYAMLConfigFile(filePath) {
     try {
 
         // empty YAML file can be null, so always use
-        return yaml.safeLoad(readFile(filePath)) || {};
+        return yaml.load(readFile(filePath)) || {};
     } catch (e) {
         debug(`Error reading YAML file: ${filePath}`);
         e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
@@ -204,7 +216,7 @@ function loadLegacyConfigFile(filePath) {
     const yaml = require("js-yaml");
 
     try {
-        return yaml.safeLoad(stripComments(readFile(filePath))) || /* istanbul ignore next */ {};
+        return yaml.load(stripComments(readFile(filePath))) || /* istanbul ignore next */ {};
     } catch (e) {
         debug("Error reading YAML file: %s\n%o", filePath, e);
         e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
@@ -396,12 +408,25 @@ function createContext(
  * @returns {Plugin} The normalized plugin.
  */
 function normalizePlugin(plugin) {
-    return {
+
+    // first check the cache
+    let normalizedPlugin = normalizedPlugins.get(plugin);
+
+    if (normalizedPlugin) {
+        return normalizedPlugin;
+    }
+
+    normalizedPlugin = {
         configs: plugin.configs || {},
         environments: plugin.environments || {},
         processors: plugin.processors || {},
         rules: plugin.rules || {}
     };
+
+    // save the reference for later
+    normalizedPlugins.set(plugin, normalizedPlugin);
+
+    return normalizedPlugin;
 }
 
 //------------------------------------------------------------------------------
@@ -424,7 +449,9 @@ class ConfigArrayFactory {
         builtInRules,
         resolver = ModuleResolver,
         eslintAllPath,
-        eslintRecommendedPath
+        getEslintAllConfig,
+        eslintRecommendedPath,
+        getEslintRecommendedConfig
     } = {}) {
         internalSlotsMap.set(this, {
             additionalPluginPool,
@@ -435,7 +462,9 @@ class ConfigArrayFactory {
             builtInRules,
             resolver,
             eslintAllPath,
-            eslintRecommendedPath
+            getEslintAllConfig,
+            eslintRecommendedPath,
+            getEslintRecommendedConfig
         });
     }
 
@@ -793,20 +822,41 @@ class ConfigArrayFactory {
      * @private
      */
     _loadExtendedBuiltInConfig(extendName, ctx) {
-        const { eslintAllPath, eslintRecommendedPath } = internalSlotsMap.get(this);
+        const {
+            eslintAllPath,
+            getEslintAllConfig,
+            eslintRecommendedPath,
+            getEslintRecommendedConfig
+        } = internalSlotsMap.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,
-                filePath: eslintRecommendedPath,
-                name: `${ctx.name} » ${extendName}`
+                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,
-                filePath: eslintAllPath,
-                name: `${ctx.name} » ${extendName}`
+                name,
+                filePath: eslintAllPath
             });
         }
 
@@ -922,11 +972,11 @@ class ConfigArrayFactory {
     _loadParser(nameOrPath, ctx) {
         debug("Loading parser %j from %s", nameOrPath, ctx.filePath);
 
-        const { cwd } = internalSlotsMap.get(this);
+        const { cwd, resolver } = internalSlotsMap.get(this);
         const relativeTo = ctx.filePath || path.join(cwd, "__placeholder__.js");
 
         try {
-            const filePath = ModuleResolver.resolve(nameOrPath, relativeTo);
+            const filePath = resolver.resolve(nameOrPath, relativeTo);
 
             writeDebugLogForLoading(nameOrPath, relativeTo, filePath);
 
@@ -973,7 +1023,7 @@ class ConfigArrayFactory {
     _loadPlugin(name, ctx) {
         debug("Loading plugin %j from %s", name, ctx.filePath);
 
-        const { additionalPluginPool } = internalSlotsMap.get(this);
+        const { additionalPluginPool, resolver } = internalSlotsMap.get(this);
         const request = naming.normalizePackageName(name, "eslint-plugin");
         const id = naming.getShorthandName(request, "eslint-plugin");
         const relativeTo = path.join(ctx.pluginBasePath, "__placeholder__.js");
@@ -1014,7 +1064,7 @@ class ConfigArrayFactory {
         let error;
 
         try {
-            filePath = ModuleResolver.resolve(request, relativeTo);
+            filePath = resolver.resolve(request, relativeTo);
         } catch (resolveError) {
             error = resolveError;
             /* istanbul ignore else */
@@ -1096,4 +1146,4 @@ class ConfigArrayFactory {
     }
 }
 
-module.exports = { ConfigArrayFactory, createContext };
+export { ConfigArrayFactory, createContext };

node_modules/@eslint/eslintrc/lib/config-array/config-array.js

@@ -24,14 +24,13 @@
  *
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const { ExtractedConfig } = require("./extracted-config");
-const { IgnorePattern } = require("./ignore-pattern");
+import { ExtractedConfig } from "./extracted-config.js";
+import { IgnorePattern } from "./ignore-pattern.js";
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -504,21 +503,21 @@ class ConfigArray extends Array {
     }
 }
 
-const exportObject = {
+/**
+ * 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.get(instance);
+
+    return Array.from(cache.values());
+}
+
+
+export {
     ConfigArray,
-
-    /**
-     * 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
-     */
-    getUsedExtractedConfigs(instance) {
-        const { cache } = internalSlotsMap.get(instance);
-
-        return Array.from(cache.values());
-    }
+    getUsedExtractedConfigs
 };
-
-module.exports = exportObject;

node_modules/@eslint/eslintrc/lib/config-array/config-dependency.js

@@ -14,9 +14,8 @@
  *
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
-const util = require("util");
+import util from "util";
 
 /**
  * The class is to store parsers or plugins.
@@ -113,4 +112,4 @@ class ConfigDependency {
 /** @typedef {ConfigDependency<import("../../shared/types").Parser>} DependentParser */
 /** @typedef {ConfigDependency<import("../../shared/types").Plugin>} DependentPlugin */
 
-module.exports = { ConfigDependency };
+export { ConfigDependency };

node_modules/@eslint/eslintrc/lib/config-array/extracted-config.js

@@ -14,9 +14,8 @@
  *
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
-const { IgnorePattern } = require("./ignore-pattern");
+import { IgnorePattern } from "./ignore-pattern.js";
 
 // For VSCode intellisense
 /** @typedef {import("../../shared/types").ConfigData} ConfigData */
@@ -143,4 +142,4 @@ class ExtractedConfig {
     }
 }
 
-module.exports = { ExtractedConfig };
+export { ExtractedConfig };

node_modules/@eslint/eslintrc/lib/config-array/ignore-pattern.js

@@ -27,16 +27,17 @@
  *
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert");
-const path = require("path");
-const ignore = require("ignore");
-const debug = require("debug")("eslintrc:ignore-pattern");
+import assert from "assert";
+import path from "path";
+import ignore from "ignore";
+import debugOrig from "debug";
+
+const debug = debugOrig("eslintrc:ignore-pattern");
 
 /** @typedef {ReturnType<import("ignore").default>} Ignore */
 
@@ -155,8 +156,8 @@ class IgnorePattern {
         const patterns = [].concat(
             ...ignorePatterns.map(p => p.getPatternsRelativeTo(basePath))
         );
-        const ig = ignore().add([...DotPatterns, ...patterns]);
-        const dotIg = ignore().add(patterns);
+        const ig = ignore({ allowRelativePaths: true }).add([...DotPatterns, ...patterns]);
+        const dotIg = ignore({ allowRelativePaths: true }).add(patterns);
 
         debug("  processed: %o", { basePath, patterns });
 
@@ -234,4 +235,4 @@ class IgnorePattern {
     }
 }
 
-module.exports = { IgnorePattern };
+export { IgnorePattern };

node_modules/@eslint/eslintrc/lib/config-array/index.js

@@ -2,15 +2,14 @@
  * @fileoverview `ConfigArray` class.
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
-const { ConfigArray, getUsedExtractedConfigs } = require("./config-array");
-const { ConfigDependency } = require("./config-dependency");
-const { ExtractedConfig } = require("./extracted-config");
-const { IgnorePattern } = require("./ignore-pattern");
-const { OverrideTester } = require("./override-tester");
+import { ConfigArray, getUsedExtractedConfigs } from "./config-array.js";
+import { ConfigDependency } from "./config-dependency.js";
+import { ExtractedConfig } from "./extracted-config.js";
+import { IgnorePattern } from "./ignore-pattern.js";
+import { OverrideTester } from "./override-tester.js";
 
-module.exports = {
+export {
     ConfigArray,
     ConfigDependency,
     ExtractedConfig,

node_modules/@eslint/eslintrc/lib/config-array/override-tester.js

@@ -16,12 +16,14 @@
  *
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
-const assert = require("assert");
-const path = require("path");
-const util = require("util");
-const { Minimatch } = require("minimatch");
+import assert from "assert";
+import path from "path";
+import util from "util";
+import minimatch from "minimatch";
+
+const { Minimatch } = minimatch;
+
 const minimatchOpts = { dot: true, matchBase: true };
 
 /**
@@ -220,4 +222,4 @@ class OverrideTester {
     }
 }
 
-module.exports = { OverrideTester };
+export { OverrideTester };

node_modules/@eslint/eslintrc/lib/flat-compat.js

@@ -3,16 +3,15 @@
  * @author Nicholas C. Zakas
  */
 
-"use strict";
-
 //-----------------------------------------------------------------------------
 // Requirements
 //-----------------------------------------------------------------------------
 
-const path = require("path");
-const environments = require("../conf/environments");
-const createDebug = require("debug");
-const { ConfigArrayFactory } = require("./config-array-factory");
+import createDebug from "debug";
+import path from "path";
+
+import environments from "../conf/environments.js";
+import { ConfigArrayFactory } from "./config-array-factory.js";
 
 //-----------------------------------------------------------------------------
 // Helpers
@@ -223,8 +222,8 @@ class FlatCompat {
         this[cafactory] = new ConfigArrayFactory({
             cwd: baseDirectory,
             resolvePluginsRelativeTo,
-            eslintAllPath: path.resolve(__dirname, "../conf/eslint-all.js"),
-            eslintRecommendedPath: path.resolve(__dirname, "../conf/eslint-recommended.js")
+            getEslintAllConfig: () => ({ settings: { "eslint:all": true } }),
+            getEslintRecommendedConfig: () => ({ settings: { "eslint:recommended": true } })
         });
     }
 
@@ -274,7 +273,7 @@ class FlatCompat {
     /**
      * 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.
+     * @returns {Object[]} An array of flag-config objects representing the environments.
      */
     env(envConfig) {
         return this.config({
@@ -285,7 +284,7 @@ class FlatCompat {
     /**
      * 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.
+     * @returns {Object[]} An array of flag-config objects representing the config.
      */
     extends(...configsToExtend) {
         return this.config({
@@ -296,7 +295,7 @@ class FlatCompat {
     /**
      * 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.
+     * @returns {Object[]} An array of flag-config objects representing the plugins.
      */
     plugins(...plugins) {
         return this.config({
@@ -305,4 +304,4 @@ class FlatCompat {
     }
 }
 
-exports.FlatCompat = FlatCompat;
+export { FlatCompat };

node_modules/@eslint/eslintrc/lib/index-universal.js

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Package exports for @eslint/eslintrc
+ * @author Nicholas C. Zakas
+ */
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+import * as ConfigOps from "./shared/config-ops.js";
+import ConfigValidator from "./shared/config-validator.js";
+import * as naming from "./shared/naming.js";
+import environments from "../conf/environments.js";
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+const Legacy = {
+    environments,
+
+    // shared
+    ConfigOps,
+    ConfigValidator,
+    naming
+};
+
+export {
+    Legacy
+};

node_modules/@eslint/eslintrc/lib/index.js

@@ -2,52 +2,54 @@
  * @fileoverview Package exports for @eslint/eslintrc
  * @author Nicholas C. Zakas
  */
-"use strict";
-
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const {
+import {
     ConfigArrayFactory,
-    createContext: createConfigArrayFactoryContext
-} = require("./config-array-factory");
+    createContext as createConfigArrayFactoryContext
+} from "./config-array-factory.js";
 
-const { CascadingConfigArrayFactory } = require("./cascading-config-array-factory");
-const ModuleResolver = require("./shared/relative-module-resolver");
-const { ConfigArray, getUsedExtractedConfigs } = require("./config-array");
-const { ConfigDependency } = require("./config-array/config-dependency");
-const { ExtractedConfig } = require("./config-array/extracted-config");
-const { IgnorePattern } = require("./config-array/ignore-pattern");
-const { OverrideTester } = require("./config-array/override-tester");
-const ConfigOps = require("./shared/config-ops");
-const ConfigValidator = require("./shared/config-validator");
-const naming = require("./shared/naming");
-const { FlatCompat } = require("./flat-compat");
+import { CascadingConfigArrayFactory } from "./cascading-config-array-factory.js";
+import * as ModuleResolver from "./shared/relative-module-resolver.js";
+import { ConfigArray, getUsedExtractedConfigs } from "./config-array/index.js";
+import { ConfigDependency } from "./config-array/config-dependency.js";
+import { ExtractedConfig } from "./config-array/extracted-config.js";
+import { IgnorePattern } from "./config-array/ignore-pattern.js";
+import { OverrideTester } from "./config-array/override-tester.js";
+import * as ConfigOps from "./shared/config-ops.js";
+import ConfigValidator from "./shared/config-validator.js";
+import * as naming from "./shared/naming.js";
+import { FlatCompat } from "./flat-compat.js";
+import environments from "../conf/environments.js";
 
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
 
-module.exports = {
+const Legacy = {
+    ConfigArray,
+    createConfigArrayFactoryContext,
+    CascadingConfigArrayFactory,
+    ConfigArrayFactory,
+    ConfigDependency,
+    ExtractedConfig,
+    IgnorePattern,
+    OverrideTester,
+    getUsedExtractedConfigs,
+    environments,
 
-    Legacy: {
-        ConfigArray,
-        createConfigArrayFactoryContext,
-        CascadingConfigArrayFactory,
-        ConfigArrayFactory,
-        ConfigDependency,
-        ExtractedConfig,
-        IgnorePattern,
-        OverrideTester,
-        getUsedExtractedConfigs,
+    // shared
+    ConfigOps,
+    ConfigValidator,
+    ModuleResolver,
+    naming
+};
 
-        // shared
-        ConfigOps,
-        ConfigValidator,
-        ModuleResolver,
-        naming
-    },
+export {
+
+    Legacy,
 
     FlatCompat
 

node_modules/@eslint/eslintrc/lib/shared/ajv.js

@@ -2,20 +2,177 @@
  * @fileoverview The instance of Ajv validator.
  * @author Evgeny Poberezkin
  */
-"use strict";
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const Ajv = require("ajv"),
-    metaSchema = require("ajv/lib/refs/json-schema-draft-04.json");
+import Ajv from "ajv";
+
+//-----------------------------------------------------------------------------
+// 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
 //------------------------------------------------------------------------------
 
-module.exports = (additionalOptions = {}) => {
+export default (additionalOptions = {}) => {
     const ajv = new Ajv({
         meta: false,
         useDefaults: true,

node_modules/@eslint/eslintrc/lib/shared/config-ops.js

@@ -3,7 +3,6 @@
  * so no Node-specific code can be here.
  * @author Nicholas C. Zakas
  */
-"use strict";
 
 //------------------------------------------------------------------------------
 // Private
@@ -20,111 +19,117 @@ const RULE_SEVERITY_STRINGS = ["off", "warn", "error"],
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = {
+/**
+ * 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;
 
-    /**
-     * 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.
-     */
-    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}
-     */
-    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.
-     */
-    isErrorSeverity(ruleConfig) {
-        return module.exports.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.
-     */
-    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.
-     */
-    isEverySeverityValid(config) {
-        return Object.keys(config).every(ruleId => this.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
-     */
-    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')`);
-        }
+    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')`);
+    }
+}
+
+export {
+    getRuleSeverity,
+    normalizeToStrings,
+    isErrorSeverity,
+    isValidSeverity,
+    isEverySeverityValid,
+    normalizeConfigGlobal
 };

node_modules/@eslint/eslintrc/lib/shared/config-validator.js

@@ -3,22 +3,21 @@
  * @author Brandon Mills
  */
 
-"use strict";
-
 /* eslint class-methods-use-this: "off" */
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const
-    util = require("util"),
-    configSchema = require("../../conf/config-schema"),
-    BuiltInEnvironments = require("../../conf/environments"),
-    ConfigOps = require("./config-ops"),
-    { emitDeprecationWarning } = require("./deprecation-warnings");
+import util from "util";
+import * as ConfigOps from "./config-ops.js";
+import { emitDeprecationWarning } from "./deprecation-warnings.js";
+import ajvOrig from "./ajv.js";
+import configSchema from "../../conf/config-schema.js";
+import BuiltInEnvironments from "../../conf/environments.js";
+
+const ajv = ajvOrig();
 
-const ajv = require("./ajv")();
 const ruleValidators = new WeakMap();
 const noop = Function.prototype;
 
@@ -38,7 +37,7 @@ const validated = new WeakSet();
 // Exports
 //-----------------------------------------------------------------------------
 
-module.exports = class ConfigValidator {
+export default class ConfigValidator {
     constructor({ builtInRules = new Map() } = {}) {
         this.builtInRules = builtInRules;
     }
@@ -323,4 +322,4 @@ module.exports = class ConfigValidator {
         }
     }
 
-};
+}

node_modules/@eslint/eslintrc/lib/shared/deprecation-warnings.js

@@ -2,13 +2,12 @@
  * @fileoverview Provide the function that emits deprecation warnings.
  * @author Toru Nagashima <http://github.com/mysticatea>
  */
-"use strict";
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const path = require("path");
+import path from "path";
 
 //------------------------------------------------------------------------------
 // Private
@@ -59,6 +58,6 @@ function emitDeprecationWarning(source, errorCode) {
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = {
+export {
     emitDeprecationWarning
 };

node_modules/@eslint/eslintrc/lib/shared/naming.js

@@ -1,7 +1,6 @@
 /**
  * @fileoverview Common helpers for naming of plugins, formatters and configs
  */
-"use strict";
 
 const NAMESPACE_REGEX = /^@.*\//iu;
 
@@ -90,7 +89,7 @@ function getNamespaceFromTerm(term) {
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = {
+export {
     normalizePackageName,
     getShorthandName,
     getNamespaceFromTerm

node_modules/@eslint/eslintrc/lib/shared/relative-module-resolver.js

@@ -3,42 +3,40 @@
  * @author Teddy Katz
  */
 
-"use strict";
-
-const Module = require("module");
+import Module from "module";
 
 /*
  * `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.
  */
-// eslint-disable-next-line node/no-unsupported-features/node-builtins, node/no-deprecated-api
-const createRequire = Module.createRequire || Module.createRequireFromPath;
+const createRequire = Module.createRequire;
 
-module.exports = {
+/**
+ * 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) {
 
-    /**
-     * 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`
-     */
-    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;
+        // 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;
     }
+}
+
+export {
+    resolve
 };

node_modules/@eslint/eslintrc/lib/shared/types.js

@@ -2,10 +2,9 @@
  * @fileoverview Define common types for input completion.
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
-"use strict";
 
 /** @type {any} */
-module.exports = {};
+export default {};
 
 /** @typedef {boolean | "off" | "readable" | "readonly" | "writable" | "writeable"} GlobalConf */
 /** @typedef {0 | 1 | 2 | "off" | "warn" | "error"} SeverityConf */