Ajout de promotion et de commande

2026-04-25 15:28:39 +02:00
parent eddb103755
commit faa3d7718c
8428 changed files with 1126442 additions and 6 deletions
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -0,0 +1,145 @@
+export { ObjectSchema } from "@eslint/object-schema";
+export type PropertyDefinition = $eslintobjectschema.PropertyDefinition;
+export type ObjectDefinition = $eslintobjectschema.ObjectDefinition;
+export type ConfigObject = $typests.ConfigObject;
+export type IMinimatchStatic = minimatch.IMinimatchStatic;
+export type IMinimatch = minimatch.IMinimatch;
+export type ObjectSchemaInstance = ObjectSchema;
+/**
+ * Represents an array of config objects and provides method for working with
+ * those config objects.
+ */
+export class ConfigArray extends Array<any> {
+    /**
+     * Creates a new instance of ConfigArray.
+     * @param {Iterable|Function|Object} configs An iterable yielding config
+     *      objects, or a config function, or a config object.
+     * @param {Object} options The options for the ConfigArray.
+     * @param {string} [options.basePath="/"] The absolute path of the config file directory.
+     * 		Defaults to `"/"`.
+     * @param {boolean} [options.normalized=false] Flag indicating if the
+     *      configs have already been normalized.
+     * @param {Object} [options.schema] The additional schema
+     *      definitions to use for the ConfigArray schema.
+     * @param {Array<string>} [options.extraConfigTypes] List of config types supported.
+     * @throws {TypeError} When the `basePath` is not a non-empty string,
+     */
+    constructor(configs: Iterable<any> | Function | any, { basePath, normalized, schema: customSchema, extraConfigTypes, }?: {
+        basePath?: string;
+        normalized?: boolean;
+        schema?: any;
+        extraConfigTypes?: Array<string>;
+    });
+    /**
+     * The path of the config file that this array was loaded from.
+     * This is used to calculate filename matches.
+     * @property basePath
+     * @type {string}
+     */
+    basePath: string;
+    /**
+     * The supported config types.
+     * @type {Array<string>}
+     */
+    extraConfigTypes: Array<string>;
+    /**
+     * Returns the `files` globs from every config object in the array.
+     * This can be used to determine which files will be matched by a
+     * config array or to use as a glob pattern when no patterns are provided
+     * for a command line interface.
+     * @returns {Array<string|Function>} An array of matchers.
+     */
+    get files(): Array<string | Function>;
+    /**
+     * Returns ignore matchers that should always be ignored regardless of
+     * the matching `files` fields in any configs. This is necessary to mimic
+     * the behavior of things like .gitignore and .eslintignore, allowing a
+     * globbing operation to be faster.
+     * @returns {Object[]} An array of config objects representing global ignores.
+     */
+    get ignores(): any[];
+    /**
+     * Indicates if the config array has been normalized.
+     * @returns {boolean} True if the config array is normalized, false if not.
+     */
+    isNormalized(): boolean;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {Promise<ConfigArray>} The current ConfigArray instance.
+     */
+    normalize(context?: any): Promise<ConfigArray>;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {ConfigArray} The current ConfigArray instance.
+     */
+    normalizeSync(context?: any): ConfigArray;
+    /**
+     * Returns the config object for a given file path and a status that can be used to determine why a file has no config.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {{ config?: Object, status: "ignored"|"external"|"unconfigured"|"matched" }}
+     * An object with an optional property `config` and property `status`.
+     * `config` is the config object for the specified file as returned by {@linkcode ConfigArray.getConfig},
+     * `status` a is one of the constants returned by {@linkcode ConfigArray.getConfigStatus}.
+     */
+    getConfigWithStatus(filePath: string): {
+        config?: any;
+        status: "ignored" | "external" | "unconfigured" | "matched";
+    };
+    /**
+     * Returns the config object for a given file path.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {Object|undefined} The config object for this file or `undefined`.
+     */
+    getConfig(filePath: string): any | undefined;
+    /**
+     * Determines whether a file has a config or why it doesn't.
+     * @param {string} filePath The path of the file to check.
+     * @returns {"ignored"|"external"|"unconfigured"|"matched"} One of the following values:
+     * * `"ignored"`: the file is ignored
+     * * `"external"`: the file is outside the base path
+     * * `"unconfigured"`: the file is not matched by any config
+     * * `"matched"`: the file has a matching config
+     */
+    getConfigStatus(filePath: string): "ignored" | "external" | "unconfigured" | "matched";
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     * @deprecated Use `isFileIgnored` instead.
+     */
+    isIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     */
+    isFileIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given directory is ignored based on the configs.
+     * This checks only default `ignores` that don't have `files` in the
+     * same config. A pattern such as `/foo` be considered to ignore the directory
+     * while a pattern such as `/foo/**` is not considered to ignore the
+     * directory because it is matching files.
+     * @param {string} directoryPath The path of a directory to check.
+     * @returns {boolean} True if the directory is ignored, false if not. Will
+     * 		return true for any directory that is not inside of `basePath`.
+     * @throws {Error} When the `ConfigArray` is not normalized.
+     */
+    isDirectoryIgnored(directoryPath: string): boolean;
+    #private;
+}
+export namespace ConfigArraySymbol {
+    let isNormalized: symbol;
+    let configCache: symbol;
+    let schema: symbol;
+    let finalizeConfig: symbol;
+    let preprocessConfig: symbol;
+}
+import type * as $eslintobjectschema from "@eslint/object-schema";
+import type * as $typests from "./types.cts";
+import minimatch from 'minimatch';
+import { ObjectSchema } from '@eslint/object-schema';
@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Types for the config-array package.
+ * @author Nicholas C. Zakas
+ */
+
+export interface ConfigObject {
+	/**
+	 * The base path for files and ignores.
+	 */
+	basePath?: string;
+
+	/**
+	 * The files to include.
+	 */
+	files?: string[];
+
+	/**
+	 * The files to exclude.
+	 */
+	ignores?: string[];
+
+	/**
+	 * The name of the config object.
+	 */
+	name?: string;
+
+	// may also have any number of other properties
+	[key: string]: unknown;
+}
@@ -0,0 +1,145 @@
+export { ObjectSchema } from "@eslint/object-schema";
+export type PropertyDefinition = $eslintobjectschema.PropertyDefinition;
+export type ObjectDefinition = $eslintobjectschema.ObjectDefinition;
+export type ConfigObject = $typests.ConfigObject;
+export type IMinimatchStatic = minimatch.IMinimatchStatic;
+export type IMinimatch = minimatch.IMinimatch;
+export type ObjectSchemaInstance = ObjectSchema;
+/**
+ * Represents an array of config objects and provides method for working with
+ * those config objects.
+ */
+export class ConfigArray extends Array<any> {
+    /**
+     * Creates a new instance of ConfigArray.
+     * @param {Iterable|Function|Object} configs An iterable yielding config
+     *      objects, or a config function, or a config object.
+     * @param {Object} options The options for the ConfigArray.
+     * @param {string} [options.basePath="/"] The absolute path of the config file directory.
+     * 		Defaults to `"/"`.
+     * @param {boolean} [options.normalized=false] Flag indicating if the
+     *      configs have already been normalized.
+     * @param {Object} [options.schema] The additional schema
+     *      definitions to use for the ConfigArray schema.
+     * @param {Array<string>} [options.extraConfigTypes] List of config types supported.
+     * @throws {TypeError} When the `basePath` is not a non-empty string,
+     */
+    constructor(configs: Iterable<any> | Function | any, { basePath, normalized, schema: customSchema, extraConfigTypes, }?: {
+        basePath?: string;
+        normalized?: boolean;
+        schema?: any;
+        extraConfigTypes?: Array<string>;
+    });
+    /**
+     * The path of the config file that this array was loaded from.
+     * This is used to calculate filename matches.
+     * @property basePath
+     * @type {string}
+     */
+    basePath: string;
+    /**
+     * The supported config types.
+     * @type {Array<string>}
+     */
+    extraConfigTypes: Array<string>;
+    /**
+     * Returns the `files` globs from every config object in the array.
+     * This can be used to determine which files will be matched by a
+     * config array or to use as a glob pattern when no patterns are provided
+     * for a command line interface.
+     * @returns {Array<string|Function>} An array of matchers.
+     */
+    get files(): Array<string | Function>;
+    /**
+     * Returns ignore matchers that should always be ignored regardless of
+     * the matching `files` fields in any configs. This is necessary to mimic
+     * the behavior of things like .gitignore and .eslintignore, allowing a
+     * globbing operation to be faster.
+     * @returns {Object[]} An array of config objects representing global ignores.
+     */
+    get ignores(): any[];
+    /**
+     * Indicates if the config array has been normalized.
+     * @returns {boolean} True if the config array is normalized, false if not.
+     */
+    isNormalized(): boolean;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {Promise<ConfigArray>} The current ConfigArray instance.
+     */
+    normalize(context?: any): Promise<ConfigArray>;
+    /**
+     * Normalizes a config array by flattening embedded arrays and executing
+     * config functions.
+     * @param {Object} [context] The context object for config functions.
+     * @returns {ConfigArray} The current ConfigArray instance.
+     */
+    normalizeSync(context?: any): ConfigArray;
+    /**
+     * Returns the config object for a given file path and a status that can be used to determine why a file has no config.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {{ config?: Object, status: "ignored"|"external"|"unconfigured"|"matched" }}
+     * An object with an optional property `config` and property `status`.
+     * `config` is the config object for the specified file as returned by {@linkcode ConfigArray.getConfig},
+     * `status` a is one of the constants returned by {@linkcode ConfigArray.getConfigStatus}.
+     */
+    getConfigWithStatus(filePath: string): {
+        config?: any;
+        status: "ignored" | "external" | "unconfigured" | "matched";
+    };
+    /**
+     * Returns the config object for a given file path.
+     * @param {string} filePath The path of a file to get a config for.
+     * @returns {Object|undefined} The config object for this file or `undefined`.
+     */
+    getConfig(filePath: string): any | undefined;
+    /**
+     * Determines whether a file has a config or why it doesn't.
+     * @param {string} filePath The path of the file to check.
+     * @returns {"ignored"|"external"|"unconfigured"|"matched"} One of the following values:
+     * * `"ignored"`: the file is ignored
+     * * `"external"`: the file is outside the base path
+     * * `"unconfigured"`: the file is not matched by any config
+     * * `"matched"`: the file has a matching config
+     */
+    getConfigStatus(filePath: string): "ignored" | "external" | "unconfigured" | "matched";
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     * @deprecated Use `isFileIgnored` instead.
+     */
+    isIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given filepath is ignored based on the configs.
+     * @param {string} filePath The path of a file to check.
+     * @returns {boolean} True if the path is ignored, false if not.
+     */
+    isFileIgnored(filePath: string): boolean;
+    /**
+     * Determines if the given directory is ignored based on the configs.
+     * This checks only default `ignores` that don't have `files` in the
+     * same config. A pattern such as `/foo` be considered to ignore the directory
+     * while a pattern such as `/foo/**` is not considered to ignore the
+     * directory because it is matching files.
+     * @param {string} directoryPath The path of a directory to check.
+     * @returns {boolean} True if the directory is ignored, false if not. Will
+     * 		return true for any directory that is not inside of `basePath`.
+     * @throws {Error} When the `ConfigArray` is not normalized.
+     */
+    isDirectoryIgnored(directoryPath: string): boolean;
+    #private;
+}
+export namespace ConfigArraySymbol {
+    let isNormalized: symbol;
+    let configCache: symbol;
+    let schema: symbol;
+    let finalizeConfig: symbol;
+    let preprocessConfig: symbol;
+}
+import type * as $eslintobjectschema from "@eslint/object-schema";
+import type * as $typests from "./types.ts";
+import minimatch from 'minimatch';
+import { ObjectSchema } from '@eslint/object-schema';
@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Types for the config-array package.
+ * @author Nicholas C. Zakas
+ */
+export interface ConfigObject {
+    /**
+     * The base path for files and ignores.
+     */
+    basePath?: string;
+    /**
+     * The files to include.
+     */
+    files?: string[];
+    /**
+     * The files to exclude.
+     */
+    ignores?: string[];
+    /**
+     * The name of the config object.
+     */
+    name?: string;
+    [key: string]: unknown;
+}
@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Types for the config-array package.
+ * @author Nicholas C. Zakas
+ */
+
+export interface ConfigObject {
+	/**
+	 * The base path for files and ignores.
+	 */
+	basePath?: string;
+
+	/**
+	 * The files to include.
+	 */
+	files?: string[];
+
+	/**
+	 * The files to exclude.
+	 */
+	ignores?: string[];
+
+	/**
+	 * The name of the config object.
+	 */
+	name?: string;
+
+	// may also have any number of other properties
+	[key: string]: unknown;
+}
@@ -0,0 +1,64 @@
+{
+  "name": "@eslint/config-array",
+  "version": "0.21.2",
+  "description": "General purpose glob-based configuration matching.",
+  "author": "Nicholas C. Zakas",
+  "type": "module",
+  "main": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "import": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eslint/rewrite.git",
+    "directory": "packages/config-array"
+  },
+  "bugs": {
+    "url": "https://github.com/eslint/rewrite/issues"
+  },
+  "homepage": "https://github.com/eslint/rewrite/tree/main/packages/config-array#readme",
+  "scripts": {
+    "build:dedupe-types": "node ../../tools/dedupe-types.js dist/cjs/index.cjs dist/esm/index.js",
+    "build:cts": "node ../../tools/build-cts.js dist/esm/index.d.ts dist/cjs/index.d.cts",
+    "build:std__path": "rollup -c rollup.std__path-config.js && node fix-std__path-imports",
+    "build": "rollup -c && npm run build:dedupe-types && tsc -p tsconfig.esm.json && npm run build:cts && npm run build:std__path",
+    "pretest": "npm run build",
+    "test": "mocha \"tests/**/*.test.js\"",
+    "test:coverage": "c8 npm test",
+    "test:jsr": "npx jsr@latest publish --dry-run",
+    "test:types": "tsc -p tests/types/tsconfig.json"
+  },
+  "keywords": [
+    "configuration",
+    "configarray",
+    "config file"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@eslint/object-schema": "^2.1.7",
+    "debug": "^4.3.1",
+    "minimatch": "^3.1.5"
+  },
+  "devDependencies": {
+    "@jsr/std__path": "^1.0.4",
+    "@types/minimatch": "^3.0.5",
+    "rollup-plugin-copy": "^3.5.0"
+  },
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  }
+}
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -0,0 +1,26 @@
+export type Config = $eslintcore.ConfigObject;
+export type LegacyConfig = $eslintcore.LegacyConfigObject;
+export type Plugin = $eslintcore.Plugin;
+export type RuleConfig = $eslintcore.RuleConfig;
+export type ExtendsElement = $typests.ExtendsElement;
+export type SimpleExtendsElement = $typests.SimpleExtendsElement;
+export type ConfigWithExtends = $typests.ConfigWithExtends;
+export type InfiniteConfigArray = $typests.InfiniteArray<Config>;
+export type ConfigWithExtendsArray = $typests.ConfigWithExtendsArray;
+/**
+ * Helper function to define a config array.
+ * @param {ConfigWithExtendsArray} args The arguments to the function.
+ * @returns {Config[]} The config array.
+ * @throws {TypeError} If no arguments are provided or if an argument is not an object.
+ */
+export function defineConfig(...args: ConfigWithExtendsArray): Config[];
+/**
+ * Creates a global ignores config with the given patterns.
+ * @param {string[]} ignorePatterns The ignore patterns.
+ * @param {string} [name] The name of the global ignores config.
+ * @returns {Config} The global ignores config.
+ * @throws {TypeError} If ignorePatterns is not an array or if it is empty.
+ */
+export function globalIgnores(ignorePatterns: string[], name?: string): Config;
+import type * as $eslintcore from "@eslint/core";
+import type * as $typests from "./types.cts";
@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Types for this package.
+ */
+
+import type { ConfigObject } from "@eslint/core";
+
+/**
+ * Infinite array type.
+ */
+export type InfiniteArray<T> = T | InfiniteArray<T>[];
+
+/**
+ * The type of array element in the `extends` property after flattening.
+ */
+export type SimpleExtendsElement = string | ConfigObject;
+
+/**
+ * The type of array element in the `extends` property before flattening.
+ */
+export type ExtendsElement = SimpleExtendsElement | InfiniteArray<ConfigObject>;
+
+/**
+ * Config with extends. Valid only inside of `defineConfig()`.
+ */
+export interface ConfigWithExtends extends ConfigObject {
+	extends?: ExtendsElement[];
+}
+
+export type ConfigWithExtendsArray = InfiniteArray<ConfigWithExtends>[];
@@ -0,0 +1,26 @@
+export type Config = $eslintcore.ConfigObject;
+export type LegacyConfig = $eslintcore.LegacyConfigObject;
+export type Plugin = $eslintcore.Plugin;
+export type RuleConfig = $eslintcore.RuleConfig;
+export type ExtendsElement = $typests.ExtendsElement;
+export type SimpleExtendsElement = $typests.SimpleExtendsElement;
+export type ConfigWithExtends = $typests.ConfigWithExtends;
+export type InfiniteConfigArray = $typests.InfiniteArray<Config>;
+export type ConfigWithExtendsArray = $typests.ConfigWithExtendsArray;
+/**
+ * Helper function to define a config array.
+ * @param {ConfigWithExtendsArray} args The arguments to the function.
+ * @returns {Config[]} The config array.
+ * @throws {TypeError} If no arguments are provided or if an argument is not an object.
+ */
+export function defineConfig(...args: ConfigWithExtendsArray): Config[];
+/**
+ * Creates a global ignores config with the given patterns.
+ * @param {string[]} ignorePatterns The ignore patterns.
+ * @param {string} [name] The name of the global ignores config.
+ * @returns {Config} The global ignores config.
+ * @throws {TypeError} If ignorePatterns is not an array or if it is empty.
+ */
+export function globalIgnores(ignorePatterns: string[], name?: string): Config;
+import type * as $eslintcore from "@eslint/core";
+import type * as $typests from "./types.ts";
@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Types for this package.
+ */
+import type { ConfigObject } from "@eslint/core";
+/**
+ * Infinite array type.
+ */
+export type InfiniteArray<T> = T | InfiniteArray<T>[];
+/**
+ * The type of array element in the `extends` property after flattening.
+ */
+export type SimpleExtendsElement = string | ConfigObject;
+/**
+ * The type of array element in the `extends` property before flattening.
+ */
+export type ExtendsElement = SimpleExtendsElement | InfiniteArray<ConfigObject>;
+/**
+ * Config with extends. Valid only inside of `defineConfig()`.
+ */
+export interface ConfigWithExtends extends ConfigObject {
+    extends?: ExtendsElement[];
+}
+export type ConfigWithExtendsArray = InfiniteArray<ConfigWithExtends>[];
@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Types for this package.
+ */
+
+import type { ConfigObject } from "@eslint/core";
+
+/**
+ * Infinite array type.
+ */
+export type InfiniteArray<T> = T | InfiniteArray<T>[];
+
+/**
+ * The type of array element in the `extends` property after flattening.
+ */
+export type SimpleExtendsElement = string | ConfigObject;
+
+/**
+ * The type of array element in the `extends` property before flattening.
+ */
+export type ExtendsElement = SimpleExtendsElement | InfiniteArray<ConfigObject>;
+
+/**
+ * Config with extends. Valid only inside of `defineConfig()`.
+ */
+export interface ConfigWithExtends extends ConfigObject {
+	extends?: ExtendsElement[];
+}
+
+export type ConfigWithExtendsArray = InfiniteArray<ConfigWithExtends>[];
@@ -0,0 +1,60 @@
+{
+  "name": "@eslint/config-helpers",
+  "version": "0.4.2",
+  "description": "Helper utilities for creating ESLint configuration",
+  "type": "module",
+  "main": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "import": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "build:dedupe-types": "node ../../tools/dedupe-types.js dist/cjs/index.cjs dist/esm/index.js",
+    "build:cts": "node ../../tools/build-cts.js dist/esm/index.d.ts dist/cjs/index.d.cts",
+    "build": "rollup -c && npm run build:dedupe-types && tsc -p tsconfig.esm.json && npm run build:cts",
+    "test": "mocha \"tests/**/*.test.js\"",
+    "test:coverage": "c8 npm test",
+    "test:jsr": "npx jsr@latest publish --dry-run",
+    "test:pnpm": "cd tests/pnpm && pnpm install && pnpm exec tsc",
+    "test:types": "tsc -p tests/types/tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eslint/rewrite.git",
+    "directory": "packages/config-helpers"
+  },
+  "keywords": [
+    "eslint"
+  ],
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/eslint/rewrite/issues"
+  },
+  "homepage": "https://github.com/eslint/rewrite/tree/main/packages/config-helpers#readme",
+  "dependencies": {
+    "@eslint/core": "^0.17.0"
+  },
+  "devDependencies": {
+    "eslint": "^9.27.0",
+    "rollup-plugin-copy": "^3.5.0"
+  },
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  }
+}
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -0,0 +1,49 @@
+{
+  "name": "@eslint/core",
+  "version": "0.17.0",
+  "description": "Runtime-agnostic core of ESLint",
+  "type": "module",
+  "types": "./dist/esm/types.d.ts",
+  "exports": {
+    "types": {
+      "import": "./dist/esm/types.d.ts",
+      "require": "./dist/cjs/types.d.cts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:cts": "node -e \"fs.cpSync('dist/esm/types.d.ts', 'dist/cjs/types.d.cts')\"",
+    "build": "tsc && npm run build:cts",
+    "test:jsr": "npx jsr@latest publish --dry-run",
+    "test:types": "tsc -p tests/types/tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eslint/rewrite.git",
+    "directory": "packages/core"
+  },
+  "keywords": [
+    "eslint",
+    "core"
+  ],
+  "author": "Nicholas C. Zakas",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/eslint/rewrite/issues"
+  },
+  "homepage": "https://github.com/eslint/rewrite/tree/main/packages/core#readme",
+  "dependencies": {
+    "@types/json-schema": "^7.0.15"
+  },
+  "devDependencies": {
+    "json-schema": "^0.4.0"
+  },
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  }
+}
@@ -0,0 +1,19 @@
+Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
@@ -0,0 +1,79 @@
+/**
+ * @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"
+};
+
+export default configSchema;
@@ -0,0 +1,215 @@
+/**
+ * @fileoverview Defines environment settings and globals.
+ * @author Elan Shanker
+ */
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+import globals from "globals";
+
+//------------------------------------------------------------------------------
+// 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.es2015, globals.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>} */
+export default new Map(Object.entries({
+
+    // Language
+    builtin: {
+        globals: globals.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.browser
+    },
+    node: {
+        globals: globals.node,
+        parserOptions: {
+            ecmaFeatures: {
+                globalReturn: true
+            }
+        }
+    },
+    "shared-node-browser": {
+        globals: globals["shared-node-browser"]
+    },
+    worker: {
+        globals: globals.worker
+    },
+    serviceworker: {
+        globals: globals.serviceworker
+    },
+
+    // Frameworks
+    commonjs: {
+        globals: globals.commonjs,
+        parserOptions: {
+            ecmaFeatures: {
+                globalReturn: true
+            }
+        }
+    },
+    amd: {
+        globals: globals.amd
+    },
+    mocha: {
+        globals: globals.mocha
+    },
+    jasmine: {
+        globals: globals.jasmine
+    },
+    jest: {
+        globals: globals.jest
+    },
+    phantomjs: {
+        globals: globals.phantomjs
+    },
+    jquery: {
+        globals: globals.jquery
+    },
+    qunit: {
+        globals: globals.qunit
+    },
+    prototypejs: {
+        globals: globals.prototypejs
+    },
+    shelljs: {
+        globals: globals.shelljs
+    },
+    meteor: {
+        globals: globals.meteor
+    },
+    mongo: {
+        globals: globals.mongo
+    },
+    protractor: {
+        globals: globals.protractor
+    },
+    applescript: {
+        globals: globals.applescript
+    },
+    nashorn: {
+        globals: globals.nashorn
+    },
+    atomtest: {
+        globals: globals.atomtest
+    },
+    embertest: {
+        globals: globals.embertest
+    },
+    webextensions: {
+        globals: globals.webextensions
+    },
+    greasemonkey: {
+        globals: globals.greasemonkey
+    }
+}));
@@ -0,0 +1,76 @@
+/**
+ * @fileoverview This file contains the core types for ESLint. It was initially extracted
+ * from the `@types/eslint__eslintrc` package.
+ */
+
+/*
+ * MIT License
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE
+ */
+
+import type { Linter } from "eslint";
+
+/**
+ * A compatibility class for working with configs.
+ */
+export class FlatCompat {
+    constructor({
+        baseDirectory,
+        resolvePluginsRelativeTo,
+        recommendedConfig,
+        allConfig,
+    }?: {
+        /**
+         * default: process.cwd()
+         */
+        baseDirectory?: string;
+        resolvePluginsRelativeTo?: string;
+        recommendedConfig?: Linter.LegacyConfig;
+        allConfig?: Linter.LegacyConfig;
+    });
+
+    /**
+     * Translates an ESLintRC-style config into a flag-config-style config.
+     * @param eslintrcConfig The ESLintRC-style config object.
+     * @returns A flag-config-style config object.
+     */
+    config(eslintrcConfig: Linter.LegacyConfig): Linter.Config[];
+
+    /**
+     * Translates the `env` section of an ESLintRC-style config.
+     * @param envConfig The `env` section of an ESLintRC config.
+     * @returns An array of flag-config objects representing the environments.
+     */
+    env(envConfig: { [name: string]: boolean }): Linter.Config[];
+
+    /**
+     * Translates the `extends` section of an ESLintRC-style config.
+     * @param configsToExtend The names of the configs to load.
+     * @returns An array of flag-config objects representing the config.
+     */
+    extends(...configsToExtend: string[]): Linter.Config[];
+
+    /**
+     * Translates the `plugins` section of an ESLintRC-style config.
+     * @param plugins The names of the plugins to load.
+     * @returns An array of flag-config objects representing the plugins.
+     */
+    plugins(...plugins: string[]): Linter.Config[];
+}
@@ -0,0 +1,124 @@
+/**
+ * @fileoverview `ConfigDependency` class.
+ *
+ * `ConfigDependency` class expresses a loaded parser or plugin.
+ *
+ * If the parser or plugin was loaded successfully, it has `definition` property
+ * and `filePath` property. Otherwise, it has `error` property.
+ *
+ * When `JSON.stringify()` converted a `ConfigDependency` object to a JSON, it
+ * omits `definition` property.
+ *
+ * `ConfigArrayFactory` creates `ConfigDependency` objects when it loads parsers
+ * or plugins.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+import util from "node:util";
+
+/**
+ * The class is to store parsers or plugins.
+ * This class hides the loaded object from `JSON.stringify()` and `console.log`.
+ * @template T
+ */
+class ConfigDependency {
+
+    /**
+     * Initialize this instance.
+     * @param {Object} data The dependency data.
+     * @param {T} [data.definition] The dependency if the loading succeeded.
+     * @param {T} [data.original] The original, non-normalized dependency if the loading succeeded.
+     * @param {Error} [data.error] The error object if the loading failed.
+     * @param {string} [data.filePath] The actual path to the dependency if the loading succeeded.
+     * @param {string} data.id The ID of this dependency.
+     * @param {string} data.importerName The name of the config file which loads this dependency.
+     * @param {string} data.importerPath The path to the config file which loads this dependency.
+     */
+    constructor({
+        definition = null,
+        original = null,
+        error = null,
+        filePath = null,
+        id,
+        importerName,
+        importerPath
+    }) {
+
+        /**
+         * The loaded dependency if the loading succeeded.
+         * @type {T|null}
+         */
+        this.definition = definition;
+
+        /**
+         * The original dependency as loaded directly from disk if the loading succeeded.
+         * @type {T|null}
+         */
+        this.original = original;
+
+        /**
+         * The error object if the loading failed.
+         * @type {Error|null}
+         */
+        this.error = error;
+
+        /**
+         * The loaded dependency if the loading succeeded.
+         * @type {string|null}
+         */
+        this.filePath = filePath;
+
+        /**
+         * The ID of this dependency.
+         * @type {string}
+         */
+        this.id = id;
+
+        /**
+         * The name of the config file which loads this dependency.
+         * @type {string}
+         */
+        this.importerName = importerName;
+
+        /**
+         * The path to the config file which loads this dependency.
+         * @type {string}
+         */
+        this.importerPath = importerPath;
+    }
+
+    /**
+     * Converts this instance to a JSON compatible object.
+     * @returns {Object} a JSON compatible object.
+     */
+    toJSON() {
+        const obj = this[util.inspect.custom]();
+
+        // Display `error.message` (`Error#message` is unenumerable).
+        if (obj.error instanceof Error) {
+            obj.error = { ...obj.error, message: obj.error.message };
+        }
+
+        return obj;
+    }
+
+    /**
+     * Custom inspect method for Node.js `console.log()`.
+     * @returns {Object} an object to display by `console.log()`.
+     */
+    [util.inspect.custom]() {
+        const {
+            definition: _ignore1, // eslint-disable-line no-unused-vars -- needed to make `obj` correct
+            original: _ignore2, // eslint-disable-line no-unused-vars -- needed to make `obj` correct
+            ...obj
+        } = this;
+
+        return obj;
+    }
+}
+
+/** @typedef {ConfigDependency<import("../../shared/types").Parser>} DependentParser */
+/** @typedef {ConfigDependency<import("../../shared/types").Plugin>} DependentPlugin */
+
+export { ConfigDependency };
@@ -0,0 +1,145 @@
+/**
+ * @fileoverview `ExtractedConfig` class.
+ *
+ * `ExtractedConfig` class expresses a final configuration for a specific file.
+ *
+ * It provides one method.
+ *
+ * - `toCompatibleObjectAsConfigFileContent()`
+ *      Convert this configuration to the compatible object as the content of
+ *      config files. It converts the loaded parser and plugins to strings.
+ *      `CLIEngine#getConfigForFile(filePath)` method uses this method.
+ *
+ * `ConfigArray#extractConfig(filePath)` creates a `ExtractedConfig` instance.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+import { IgnorePattern } from "./ignore-pattern.js";
+
+// For VSCode intellisense
+/** @typedef {import("../../shared/types").ConfigData} ConfigData */
+/** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
+/** @typedef {import("../../shared/types").SeverityConf} SeverityConf */
+/** @typedef {import("./config-dependency").DependentParser} DependentParser */
+/** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
+
+/**
+ * Check if `xs` starts with `ys`.
+ * @template T
+ * @param {T[]} xs The array to check.
+ * @param {T[]} ys The array that may be the first part of `xs`.
+ * @returns {boolean} `true` if `xs` starts with `ys`.
+ */
+function startsWith(xs, ys) {
+    return xs.length >= ys.length && ys.every((y, i) => y === xs[i]);
+}
+
+/**
+ * The class for extracted config data.
+ */
+class ExtractedConfig {
+    constructor() {
+
+        /**
+         * The config name what `noInlineConfig` setting came from.
+         * @type {string}
+         */
+        this.configNameOfNoInlineConfig = "";
+
+        /**
+         * Environments.
+         * @type {Record<string, boolean>}
+         */
+        this.env = {};
+
+        /**
+         * Global variables.
+         * @type {Record<string, GlobalConf>}
+         */
+        this.globals = {};
+
+        /**
+         * The glob patterns that ignore to lint.
+         * @type {(((filePath:string, dot?:boolean) => boolean) & { basePath:string; patterns:string[] }) | undefined}
+         */
+        this.ignores = void 0;
+
+        /**
+         * The flag that disables directive comments.
+         * @type {boolean|undefined}
+         */
+        this.noInlineConfig = void 0;
+
+        /**
+         * Parser definition.
+         * @type {DependentParser|null}
+         */
+        this.parser = null;
+
+        /**
+         * Options for the parser.
+         * @type {Object}
+         */
+        this.parserOptions = {};
+
+        /**
+         * Plugin definitions.
+         * @type {Record<string, DependentPlugin>}
+         */
+        this.plugins = {};
+
+        /**
+         * Processor ID.
+         * @type {string|null}
+         */
+        this.processor = null;
+
+        /**
+         * The flag that reports unused `eslint-disable` directive comments.
+         * @type {boolean|undefined}
+         */
+        this.reportUnusedDisableDirectives = void 0;
+
+        /**
+         * Rule settings.
+         * @type {Record<string, [SeverityConf, ...any[]]>}
+         */
+        this.rules = {};
+
+        /**
+         * Shared settings.
+         * @type {Object}
+         */
+        this.settings = {};
+    }
+
+    /**
+     * Convert this config to the compatible object as a config file content.
+     * @returns {ConfigData} The converted object.
+     */
+    toCompatibleObjectAsConfigFileContent() {
+        const {
+            /* eslint-disable no-unused-vars -- needed to make `config` correct */
+            configNameOfNoInlineConfig: _ignore1,
+            processor: _ignore2,
+            /* eslint-enable no-unused-vars -- needed to make `config` correct */
+            ignores,
+            ...config
+        } = this;
+
+        config.parser = config.parser && config.parser.filePath;
+        config.plugins = Object.keys(config.plugins).filter(Boolean).reverse();
+        config.ignorePatterns = ignores ? ignores.patterns : [];
+
+        // Strip the default patterns from `ignorePatterns`.
+        if (startsWith(config.ignorePatterns, IgnorePattern.DefaultPatterns)) {
+            config.ignorePatterns =
+                config.ignorePatterns.slice(IgnorePattern.DefaultPatterns.length);
+        }
+
+        return config;
+    }
+}
+
+export { ExtractedConfig };
@@ -0,0 +1,239 @@
+/**
+ * @fileoverview `IgnorePattern` class.
+ *
+ * `IgnorePattern` class has the set of glob patterns and the base path.
+ *
+ * It provides two static methods.
+ *
+ * - `IgnorePattern.createDefaultIgnore(cwd)`
+ *      Create the default predicate function.
+ * - `IgnorePattern.createIgnore(ignorePatterns)`
+ *      Create the predicate function from multiple `IgnorePattern` objects.
+ *
+ * It provides two properties and a method.
+ *
+ * - `patterns`
+ *      The glob patterns that ignore to lint.
+ * - `basePath`
+ *      The base path of the glob patterns. If absolute paths existed in the
+ *      glob patterns, those are handled as relative paths to the base path.
+ * - `getPatternsRelativeTo(basePath)`
+ *      Get `patterns` as modified for a given base path. It modifies the
+ *      absolute paths in the patterns as prepending the difference of two base
+ *      paths.
+ *
+ * `ConfigArrayFactory` creates `IgnorePattern` objects when it processes
+ * `ignorePatterns` properties.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+import assert from "node:assert";
+import path from "node:path";
+import ignore from "ignore";
+import debugOrig from "debug";
+
+const debug = debugOrig("eslintrc:ignore-pattern");
+
+/** @typedef {ReturnType<import("ignore").default>} Ignore */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Get the path to the common ancestor directory of given paths.
+ * @param {string[]} sourcePaths The paths to calculate the common ancestor.
+ * @returns {string} The path to the common ancestor directory.
+ */
+function getCommonAncestorPath(sourcePaths) {
+    let result = sourcePaths[0];
+
+    for (let i = 1; i < sourcePaths.length; ++i) {
+        const a = result;
+        const b = sourcePaths[i];
+
+        // Set the shorter one (it's the common ancestor if one includes the other).
+        result = a.length < b.length ? a : b;
+
+        // Set the common ancestor.
+        for (let j = 0, lastSepPos = 0; j < a.length && j < b.length; ++j) {
+            if (a[j] !== b[j]) {
+                result = a.slice(0, lastSepPos);
+                break;
+            }
+            if (a[j] === path.sep) {
+                lastSepPos = j;
+            }
+        }
+    }
+
+    let resolvedResult = result || path.sep;
+
+    // if Windows common ancestor is root of drive must have trailing slash to be absolute.
+    if (resolvedResult && resolvedResult.endsWith(":") && process.platform === "win32") {
+        resolvedResult += path.sep;
+    }
+    return resolvedResult;
+}
+
+/**
+ * Make relative path.
+ * @param {string} from The source path to get relative path.
+ * @param {string} to The destination path to get relative path.
+ * @returns {string} The relative path.
+ */
+function relative(from, to) {
+    const relPath = path.relative(from, to);
+
+    if (path.sep === "/") {
+        return relPath;
+    }
+    return relPath.split(path.sep).join("/");
+}
+
+/**
+ * Get the trailing slash if existed.
+ * @param {string} filePath The path to check.
+ * @returns {string} The trailing slash if existed.
+ */
+function dirSuffix(filePath) {
+    const isDir = (
+        filePath.endsWith(path.sep) ||
+        (process.platform === "win32" && filePath.endsWith("/"))
+    );
+
+    return isDir ? "/" : "";
+}
+
+const DefaultPatterns = Object.freeze(["/**/node_modules/*"]);
+const DotPatterns = Object.freeze([".*", "!.eslintrc.*", "!../"]);
+
+//------------------------------------------------------------------------------
+// Public
+//------------------------------------------------------------------------------
+
+/**
+ * Represents a set of glob patterns to ignore against a base path.
+ */
+class IgnorePattern {
+
+    /**
+     * The default patterns.
+     * @type {string[]}
+     */
+    static get DefaultPatterns() {
+        return DefaultPatterns;
+    }
+
+    /**
+     * Create the default predicate function.
+     * @param {string} cwd The current working directory.
+     * @returns {((filePath:string, dot:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createDefaultIgnore(cwd) {
+        return this.createIgnore([new IgnorePattern(DefaultPatterns, cwd)]);
+    }
+
+    /**
+     * Create the predicate function from multiple `IgnorePattern` objects.
+     * @param {IgnorePattern[]} ignorePatterns The list of ignore patterns.
+     * @returns {((filePath:string, dot?:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createIgnore(ignorePatterns) {
+        debug("Create with: %o", ignorePatterns);
+
+        const basePath = getCommonAncestorPath(ignorePatterns.map(p => p.basePath));
+        const patterns = ignorePatterns.flatMap(p => p.getPatternsRelativeTo(basePath));
+        const ig = ignore({ allowRelativePaths: true }).add([...DotPatterns, ...patterns]);
+        const dotIg = ignore({ allowRelativePaths: true }).add(patterns);
+
+        debug("  processed: %o", { basePath, patterns });
+
+        return Object.assign(
+            (filePath, dot = false) => {
+                assert(path.isAbsolute(filePath), "'filePath' should be an absolute path.");
+                const relPathRaw = relative(basePath, filePath);
+                const relPath = relPathRaw && (relPathRaw + dirSuffix(filePath));
+                const adoptedIg = dot ? dotIg : ig;
+                const result = relPath !== "" && adoptedIg.ignores(relPath);
+
+                debug("Check", { filePath, dot, relativePath: relPath, result });
+                return result;
+            },
+            { basePath, patterns }
+        );
+    }
+
+    /**
+     * Initialize a new `IgnorePattern` instance.
+     * @param {string[]} patterns The glob patterns that ignore to lint.
+     * @param {string} basePath The base path of `patterns`.
+     */
+    constructor(patterns, basePath) {
+        assert(path.isAbsolute(basePath), "'basePath' should be an absolute path.");
+
+        /**
+         * The glob patterns that ignore to lint.
+         * @type {string[]}
+         */
+        this.patterns = patterns;
+
+        /**
+         * The base path of `patterns`.
+         * @type {string}
+         */
+        this.basePath = basePath;
+
+        /**
+         * If `true` then patterns which don't start with `/` will match the paths to the outside of `basePath`. Defaults to `false`.
+         *
+         * It's set `true` for `.eslintignore`, `package.json`, and `--ignore-path` for backward compatibility.
+         * It's `false` as-is for `ignorePatterns` property in config files.
+         * @type {boolean}
+         */
+        this.loose = false;
+    }
+
+    /**
+     * Get `patterns` as modified for a given base path. It modifies the
+     * absolute paths in the patterns as prepending the difference of two base
+     * paths.
+     * @param {string} newBasePath The base path.
+     * @returns {string[]} Modifired patterns.
+     */
+    getPatternsRelativeTo(newBasePath) {
+        assert(path.isAbsolute(newBasePath), "'newBasePath' should be an absolute path.");
+        const { basePath, loose, patterns } = this;
+
+        if (newBasePath === basePath) {
+            return patterns;
+        }
+        const prefix = `/${relative(newBasePath, basePath)}`;
+
+        return patterns.map(pattern => {
+            const negative = pattern.startsWith("!");
+            const head = negative ? "!" : "";
+            const body = negative ? pattern.slice(1) : pattern;
+
+            if (body.startsWith("/") || body.startsWith("../")) {
+                return `${head}${prefix}${body}`;
+            }
+            return loose ? pattern : `${head}${prefix}/**/${body}`;
+        });
+    }
+}
+
+export { IgnorePattern };
@@ -0,0 +1,19 @@
+/**
+ * @fileoverview `ConfigArray` class.
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+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";
+
+export {
+    ConfigArray,
+    ConfigDependency,
+    ExtractedConfig,
+    IgnorePattern,
+    OverrideTester,
+    getUsedExtractedConfigs
+};
@@ -0,0 +1,227 @@
+/**
+ * @fileoverview `OverrideTester` class.
+ *
+ * `OverrideTester` class handles `files` property and `excludedFiles` property
+ * of `overrides` config.
+ *
+ * It provides one method.
+ *
+ * - `test(filePath)`
+ *      Test if a file path matches the pair of `files` property and
+ *      `excludedFiles` property. The `filePath` argument must be an absolute
+ *      path.
+ *
+ * `ConfigArrayFactory` creates `OverrideTester` objects when it processes
+ * `overrides` properties.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+import assert from "node:assert";
+import path from "node:path";
+import util from "node:util";
+import minimatch from "minimatch";
+
+const { Minimatch } = minimatch;
+
+const minimatchOpts = { dot: true, matchBase: true };
+
+/**
+ * @typedef {Object} Pattern
+ * @property {InstanceType<Minimatch>[] | null} includes The positive matchers.
+ * @property {InstanceType<Minimatch>[] | null} excludes The negative matchers.
+ */
+
+/**
+ * Normalize a given pattern to an array.
+ * @param {string|string[]|undefined} patterns A glob pattern or an array of glob patterns.
+ * @returns {string[]|null} Normalized patterns.
+ * @private
+ */
+function normalizePatterns(patterns) {
+    if (Array.isArray(patterns)) {
+        return patterns.filter(Boolean);
+    }
+    if (typeof patterns === "string" && patterns) {
+        return [patterns];
+    }
+    return [];
+}
+
+/**
+ * Create the matchers of given patterns.
+ * @param {string[]} patterns The patterns.
+ * @returns {InstanceType<Minimatch>[] | null} The matchers.
+ */
+function toMatcher(patterns) {
+    if (patterns.length === 0) {
+        return null;
+    }
+    return patterns.map(pattern => {
+        if (/^\.[/\\]/u.test(pattern)) {
+            return new Minimatch(
+                pattern.slice(2),
+
+                // `./*.js` should not match with `subdir/foo.js`
+                { ...minimatchOpts, matchBase: false }
+            );
+        }
+        return new Minimatch(pattern, minimatchOpts);
+    });
+}
+
+/**
+ * Convert a given matcher to string.
+ * @param {Pattern} matchers The matchers.
+ * @returns {string} The string expression of the matcher.
+ */
+function patternToJson({ includes, excludes }) {
+    return {
+        includes: includes && includes.map(m => m.pattern),
+        excludes: excludes && excludes.map(m => m.pattern)
+    };
+}
+
+/**
+ * The class to test given paths are matched by the patterns.
+ */
+class OverrideTester {
+
+    /**
+     * Create a tester with given criteria.
+     * If there are no criteria, returns `null`.
+     * @param {string|string[]} files The glob patterns for included files.
+     * @param {string|string[]} excludedFiles The glob patterns for excluded files.
+     * @param {string} basePath The path to the base directory to test paths.
+     * @returns {OverrideTester|null} The created instance or `null`.
+     * @throws {Error} When invalid patterns are given.
+     */
+    static create(files, excludedFiles, basePath) {
+        const includePatterns = normalizePatterns(files);
+        const excludePatterns = normalizePatterns(excludedFiles);
+        let endsWithWildcard = false;
+
+        if (includePatterns.length === 0) {
+            return null;
+        }
+
+        // Rejects absolute paths or relative paths to parents.
+        for (const pattern of includePatterns) {
+            if (path.isAbsolute(pattern) || pattern.includes("..")) {
+                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
+            }
+            if (pattern.endsWith("*")) {
+                endsWithWildcard = true;
+            }
+        }
+        for (const pattern of excludePatterns) {
+            if (path.isAbsolute(pattern) || pattern.includes("..")) {
+                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
+            }
+        }
+
+        const includes = toMatcher(includePatterns);
+        const excludes = toMatcher(excludePatterns);
+
+        return new OverrideTester(
+            [{ includes, excludes }],
+            basePath,
+            endsWithWildcard
+        );
+    }
+
+    /**
+     * Combine two testers by logical and.
+     * If either of the testers was `null`, returns the other tester.
+     * The `basePath` property of the two must be the same value.
+     * @param {OverrideTester|null} a A tester.
+     * @param {OverrideTester|null} b Another tester.
+     * @returns {OverrideTester|null} Combined tester.
+     */
+    static and(a, b) {
+        if (!b) {
+            return a && new OverrideTester(
+                a.patterns,
+                a.basePath,
+                a.endsWithWildcard
+            );
+        }
+        if (!a) {
+            return new OverrideTester(
+                b.patterns,
+                b.basePath,
+                b.endsWithWildcard
+            );
+        }
+
+        assert.strictEqual(a.basePath, b.basePath);
+        return new OverrideTester(
+            a.patterns.concat(b.patterns),
+            a.basePath,
+            a.endsWithWildcard || b.endsWithWildcard
+        );
+    }
+
+    /**
+     * Initialize this instance.
+     * @param {Pattern[]} patterns The matchers.
+     * @param {string} basePath The base path.
+     * @param {boolean} endsWithWildcard If `true` then a pattern ends with `*`.
+     */
+    constructor(patterns, basePath, endsWithWildcard = false) {
+
+        /** @type {Pattern[]} */
+        this.patterns = patterns;
+
+        /** @type {string} */
+        this.basePath = basePath;
+
+        /** @type {boolean} */
+        this.endsWithWildcard = endsWithWildcard;
+    }
+
+    /**
+     * Test if a given path is matched or not.
+     * @param {string} filePath The absolute path to the target file.
+     * @returns {boolean} `true` if the path was matched.
+     * @throws {Error} When invalid `filePath` is given.
+     */
+    test(filePath) {
+        if (typeof filePath !== "string" || !path.isAbsolute(filePath)) {
+            throw new Error(`'filePath' should be an absolute path, but got ${filePath}.`);
+        }
+        const relativePath = path.relative(this.basePath, filePath);
+
+        return this.patterns.every(({ includes, excludes }) => (
+            (!includes || includes.some(m => m.match(relativePath))) &&
+            (!excludes || !excludes.some(m => m.match(relativePath)))
+        ));
+    }
+
+    /**
+     * Converts this instance to a JSON compatible object.
+     * @returns {Object} a JSON compatible object.
+     */
+    toJSON() {
+        if (this.patterns.length === 1) {
+            return {
+                ...patternToJson(this.patterns[0]),
+                basePath: this.basePath
+            };
+        }
+        return {
+            AND: this.patterns.map(patternToJson),
+            basePath: this.basePath
+        };
+    }
+
+    /**
+     * Custom inspect method for Node.js `console.log()`.
+     * @returns {Object} an object to display by `console.log()`.
+     */
+    [util.inspect.custom]() {
+        return this.toJSON();
+    }
+}
+
+export { OverrideTester };
@@ -0,0 +1,329 @@
+/**
+ * @fileoverview Compatibility class for flat config.
+ * @author Nicholas C. Zakas
+ */
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+import createDebug from "debug";
+import path from "node:path";
+
+import environments from "../conf/environments.js";
+import { ConfigArrayFactory } from "./config-array-factory.js";
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+/** @typedef {import("../../shared/types").Environment} Environment */
+/** @typedef {import("../../shared/types").Processor} Processor */
+
+const debug = createDebug("eslintrc:flat-compat");
+const cafactory = Symbol("cafactory");
+
+/**
+ * Translates an ESLintRC-style config object into a flag-config-style config
+ * object.
+ * @param {Object} eslintrcConfig An ESLintRC-style config object.
+ * @param {Object} options Options to help translate the config.
+ * @param {string} options.resolveConfigRelativeTo To the directory to resolve
+ *      configs from.
+ * @param {string} options.resolvePluginsRelativeTo The directory to resolve
+ *      plugins from.
+ * @param {ReadOnlyMap<string,Environment>} options.pluginEnvironments A map of plugin environment
+ *      names to objects.
+ * @param {ReadOnlyMap<string,Processor>} options.pluginProcessors A map of plugin processor
+ *      names to objects.
+ * @returns {Object} A flag-config-style config object.
+ * @throws {Error} If a plugin or environment cannot be resolved.
+ */
+function translateESLintRC(eslintrcConfig, {
+    resolveConfigRelativeTo,
+    resolvePluginsRelativeTo,
+    pluginEnvironments,
+    pluginProcessors
+}) {
+
+    const flatConfig = {};
+    const configs = [];
+    const languageOptions = {};
+    const linterOptions = {};
+    const keysToCopy = ["settings", "rules", "processor"];
+    const languageOptionsKeysToCopy = ["globals", "parser", "parserOptions"];
+    const linterOptionsKeysToCopy = ["noInlineConfig", "reportUnusedDisableDirectives"];
+
+    // copy over simple translations
+    for (const key of keysToCopy) {
+        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
+            flatConfig[key] = eslintrcConfig[key];
+        }
+    }
+
+    // copy over languageOptions
+    for (const key of languageOptionsKeysToCopy) {
+        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
+
+            // create the languageOptions key in the flat config
+            flatConfig.languageOptions = languageOptions;
+
+            if (key === "parser") {
+                debug(`Resolving parser '${languageOptions[key]}' relative to ${resolveConfigRelativeTo}`);
+
+                if (eslintrcConfig[key].error) {
+                    throw eslintrcConfig[key].error;
+                }
+
+                languageOptions[key] = eslintrcConfig[key].definition;
+                continue;
+            }
+
+            // clone any object values that are in the eslintrc config
+            if (eslintrcConfig[key] && typeof eslintrcConfig[key] === "object") {
+                languageOptions[key] = {
+                    ...eslintrcConfig[key]
+                };
+            } else {
+                languageOptions[key] = eslintrcConfig[key];
+            }
+        }
+    }
+
+    // copy over linterOptions
+    for (const key of linterOptionsKeysToCopy) {
+        if (key in eslintrcConfig && typeof eslintrcConfig[key] !== "undefined") {
+            flatConfig.linterOptions = linterOptions;
+            linterOptions[key] = eslintrcConfig[key];
+        }
+    }
+
+    // move ecmaVersion a level up
+    if (languageOptions.parserOptions) {
+
+        if ("ecmaVersion" in languageOptions.parserOptions) {
+            languageOptions.ecmaVersion = languageOptions.parserOptions.ecmaVersion;
+            delete languageOptions.parserOptions.ecmaVersion;
+        }
+
+        if ("sourceType" in languageOptions.parserOptions) {
+            languageOptions.sourceType = languageOptions.parserOptions.sourceType;
+            delete languageOptions.parserOptions.sourceType;
+        }
+
+        // check to see if we even need parserOptions anymore and remove it if not
+        if (Object.keys(languageOptions.parserOptions).length === 0) {
+            delete languageOptions.parserOptions;
+        }
+    }
+
+    // overrides
+    if (eslintrcConfig.criteria) {
+        flatConfig.files = [absoluteFilePath => eslintrcConfig.criteria.test(absoluteFilePath)];
+    }
+
+    // translate plugins
+    if (eslintrcConfig.plugins && typeof eslintrcConfig.plugins === "object") {
+        debug(`Translating plugins: ${eslintrcConfig.plugins}`);
+
+        flatConfig.plugins = {};
+
+        for (const pluginName of Object.keys(eslintrcConfig.plugins)) {
+
+            debug(`Translating plugin: ${pluginName}`);
+            debug(`Resolving plugin '${pluginName} relative to ${resolvePluginsRelativeTo}`);
+
+            const { original: plugin, error } = eslintrcConfig.plugins[pluginName];
+
+            if (error) {
+                throw error;
+            }
+
+            flatConfig.plugins[pluginName] = plugin;
+
+            // create a config for any processors
+            if (plugin.processors) {
+                for (const processorName of Object.keys(plugin.processors)) {
+                    if (processorName.startsWith(".")) {
+                        debug(`Assigning processor: ${pluginName}/${processorName}`);
+
+                        configs.unshift({
+                            files: [`**/*${processorName}`],
+                            processor: pluginProcessors.get(`${pluginName}/${processorName}`)
+                        });
+                    }
+
+                }
+            }
+        }
+    }
+
+    // translate env - must come after plugins
+    if (eslintrcConfig.env && typeof eslintrcConfig.env === "object") {
+        for (const envName of Object.keys(eslintrcConfig.env)) {
+
+            // only add environments that are true
+            if (eslintrcConfig.env[envName]) {
+                debug(`Translating environment: ${envName}`);
+
+                if (environments.has(envName)) {
+
+                    // built-in environments should be defined first
+                    configs.unshift(...translateESLintRC({
+                        criteria: eslintrcConfig.criteria,
+                        ...environments.get(envName)
+                    }, {
+                        resolveConfigRelativeTo,
+                        resolvePluginsRelativeTo
+                    }));
+                } else if (pluginEnvironments.has(envName)) {
+
+                    // if the environment comes from a plugin, it should come after the plugin config
+                    configs.push(...translateESLintRC({
+                        criteria: eslintrcConfig.criteria,
+                        ...pluginEnvironments.get(envName)
+                    }, {
+                        resolveConfigRelativeTo,
+                        resolvePluginsRelativeTo
+                    }));
+                }
+            }
+        }
+    }
+
+    // only add if there are actually keys in the config
+    if (Object.keys(flatConfig).length > 0) {
+        configs.push(flatConfig);
+    }
+
+    return configs;
+}
+
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * A compatibility class for working with configs.
+ */
+class FlatCompat {
+
+    constructor({
+        baseDirectory = process.cwd(),
+        resolvePluginsRelativeTo = baseDirectory,
+        recommendedConfig,
+        allConfig
+    } = {}) {
+        this.baseDirectory = baseDirectory;
+        this.resolvePluginsRelativeTo = resolvePluginsRelativeTo;
+        this[cafactory] = new ConfigArrayFactory({
+            cwd: baseDirectory,
+            resolvePluginsRelativeTo,
+            getEslintAllConfig() {
+
+                if (!allConfig) {
+                    throw new TypeError("Missing parameter 'allConfig' in FlatCompat constructor.");
+                }
+
+                // remove name property if it exists
+                const config = { ...allConfig };
+
+                delete config.name;
+
+                return config;
+            },
+            getEslintRecommendedConfig() {
+
+                if (!recommendedConfig) {
+                    throw new TypeError("Missing parameter 'recommendedConfig' in FlatCompat constructor.");
+                }
+
+                // remove name property if it exists
+                const config = { ...recommendedConfig };
+
+                delete config.name;
+
+                return config;
+            }
+        });
+    }
+
+    /**
+     * Translates an ESLintRC-style config into a flag-config-style config.
+     * @param {Object} eslintrcConfig The ESLintRC-style config object.
+     * @returns {Object} A flag-config-style config object.
+     */
+    config(eslintrcConfig) {
+        const eslintrcArray = this[cafactory].create(eslintrcConfig, {
+            basePath: this.baseDirectory
+        });
+
+        const flatArray = [];
+        let hasIgnorePatterns = false;
+
+        eslintrcArray.forEach(configData => {
+            if (configData.type === "config") {
+                hasIgnorePatterns = hasIgnorePatterns || configData.ignorePattern;
+                flatArray.push(...translateESLintRC(configData, {
+                    resolveConfigRelativeTo: path.join(this.baseDirectory, "__placeholder.js"),
+                    resolvePluginsRelativeTo: path.join(this.resolvePluginsRelativeTo, "__placeholder.js"),
+                    pluginEnvironments: eslintrcArray.pluginEnvironments,
+                    pluginProcessors: eslintrcArray.pluginProcessors
+                }));
+            }
+        });
+
+        // combine ignorePatterns to emulate ESLintRC behavior better
+        if (hasIgnorePatterns) {
+            flatArray.unshift({
+                ignores: [filePath => {
+
+                    // Compute the final config for this file.
+                    // This filters config array elements by `files`/`excludedFiles` then merges the elements.
+                    const finalConfig = eslintrcArray.extractConfig(filePath);
+
+                    // Test the `ignorePattern` properties of the final config.
+                    return Boolean(finalConfig.ignores) && finalConfig.ignores(filePath);
+                }]
+            });
+        }
+
+        return flatArray;
+    }
+
+    /**
+     * Translates the `env` section of an ESLintRC-style config.
+     * @param {Object} envConfig The `env` section of an ESLintRC config.
+     * @returns {Object[]} An array of flag-config objects representing the environments.
+     */
+    env(envConfig) {
+        return this.config({
+            env: envConfig
+        });
+    }
+
+    /**
+     * Translates the `extends` section of an ESLintRC-style config.
+     * @param {...string} configsToExtend The names of the configs to load.
+     * @returns {Object[]} An array of flag-config objects representing the config.
+     */
+    extends(...configsToExtend) {
+        return this.config({
+            extends: configsToExtend
+        });
+    }
+
+    /**
+     * Translates the `plugins` section of an ESLintRC-style config.
+     * @param {...string} plugins The names of the plugins to load.
+     * @returns {Object[]} An array of flag-config objects representing the plugins.
+     */
+    plugins(...plugins) {
+        return this.config({
+            plugins
+        });
+    }
+}
+
+export { FlatCompat };
@@ -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
+};
@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Package exports for @eslint/eslintrc
+ * @author Nicholas C. Zakas
+ */
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+import {
+    ConfigArrayFactory,
+    createContext as createConfigArrayFactoryContext,
+    loadConfigFile
+} from "./config-array-factory.js";
+
+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
+//-----------------------------------------------------------------------------
+
+const Legacy = {
+    ConfigArray,
+    createConfigArrayFactoryContext,
+    CascadingConfigArrayFactory,
+    ConfigArrayFactory,
+    ConfigDependency,
+    ExtractedConfig,
+    IgnorePattern,
+    OverrideTester,
+    getUsedExtractedConfigs,
+    environments,
+    loadConfigFile,
+
+    // shared
+    ConfigOps,
+    ConfigValidator,
+    ModuleResolver,
+    naming
+};
+
+export {
+
+    Legacy,
+
+    FlatCompat
+
+};
@@ -0,0 +1,191 @@
+/**
+ * @fileoverview The instance of Ajv validator.
+ * @author Evgeny Poberezkin
+ */
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+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
+//------------------------------------------------------------------------------
+
+export default (additionalOptions = {}) => {
+    const ajv = new Ajv({
+        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;
+};
--- a/Show More
+++ b/Show More