astro-eslint-parser 0.0.18 → 0.2.1

package/README.md

@@ -19,18 +19,19 @@ This parser is in the ***experimental stages*** of development.
 
 At least it works fine with a [fork of the `astro.build` repository](https://github.com/ota-meshi/astro.build/tree/eslint).
 
-⚠ Currently this parser relies heavily on the internal API of [@astrojs/compiler]. It may stop working in a future update of [@astrojs/compiler]. ⚠
-
 [@astrojs/compiler]: https://github.com/withastro/compiler
 
-<!--
+## :checkered_flag: Motivation
+
+This parser allows us to lint the script of `.astro` files.
+
+> Note that this parser alone will not lint the scripts inside the `<script>` tag. Use [eslint-plugin-astro] to lint the script inside the `<script>` tag as well.
+
 ### ESLint Plugins Using astro-eslint-parser
 
-#### [@ota-meshi/eslint-plugin-astro](https://ota-meshi.github.io/eslint-plugin-astro/)
+#### [eslint-plugin-astro]
 
-ESLint plugin for Astro.  
-It provides many unique check rules by using the template AST.
--->
+ESLint plugin for Astro component.  
 
 ## 💿 Installation
 
@@ -62,7 +63,7 @@ npm install --save-dev eslint astro-eslint-parser
     $ eslint src --ext .js,.astro
     ```
 
-The commit diff [here](https://github.com/ota-meshi/astro.build/commit/7f291ac15e6d97cc20a64b8f97dcbd85379759b5) is an example of introducing this parser to the `astro.build` repository.
+The commit diff [here](https://github.com/withastro/astro.build/compare/main...ota-meshi:eslint) is an example of introducing this parser to the `astro.build` repository.
 
 ## 🔧 Options
 
@@ -154,13 +155,21 @@ For example, the [react/jsx-no-target-blank] rule works fine.
 [eslint-plugin-react]: https://github.com/jsx-eslint/eslint-plugin-react/
 [react/jsx-no-target-blank]: https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-target-blank.md
 
+## :ghost: Limitations
+
+If this parser is used with `@typescript-eslint/parser` and `parserOptions.project` is set, it will temporarily create a `.tsx` file to parse the `.astro` file.  
+This parser works by converting the `.astro` file to JSX and letting the JavaScript parser parse it.
+Since `@typescript-eslint/parser` can only parse files with the extension `.tsx` as JSX, it is necessary to temporarily create a `.tsx` file. Temporarily created files will try to be deleted after parses, but if the parsing takes a long time, the files may be visible to you.
+
+See also [`@typescript-eslint/parser` readme](https://github.com/typescript-eslint/typescript-eslint/tree/main/packages/parser#parseroptionsecmafeaturesjsx).
+
 ## :hammer_and_wrench: Usage for Custom Rules / Plugins
 
+<!-- - [AST.md](./docs/AST.md) is AST specification. You can check it on the [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/). -->
+
 - TBA
 - You can check the AST in the [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/). However, AST is subject to major changes in the future.
-
-<!-- - [AST.md](./docs/AST.md) is AST specification. You can check it on the [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/). -->
-<!-- - I have already [implemented some rules] in the [`@ota-meshi/eslint-plugin-astro`]. The source code for these rules will be helpful to you. -->
+- I have already [implemented some rules] in the [eslint-plugin-astro]. The source code for these rules will be helpful to you.
 
 ## :beers: Contributing
 
@@ -180,3 +189,5 @@ See the [LICENSE](LICENSE) file for license rights and limitations (MIT).
 
 [Astro]: https://astro.build/
 [ESLint]: https://eslint.org/
+[eslint-plugin-astro]: https://ota-meshi.github.io/eslint-plugin-astro/
+[implemented some rules]: https://ota-meshi.github.io/eslint-plugin-astro/rules/

package/lib/ast/astro.d.ts

@@ -2,7 +2,7 @@ import type { JSXAttribute, JSXElement, JSXExpression, JSXExpressionContainer, J
 import type { TSESTree as ES } from "@typescript-eslint/types";
 import type { BaseNode } from "./base";
 export declare type AstroNode = AstroProgram | AstroFragment | AstroHTMLComment | AstroDoctype | AstroShorthandAttribute | AstroTemplateLiteralAttribute | AstroRawText;
-export declare type AstroChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment;
+export declare type AstroChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment | AstroRawText;
 export declare type AstroParentNode = JSXElement | JSXFragment | AstroFragment;
 /** Node of Astro program root */
 export interface AstroProgram extends Omit<ES.Program, "type" | "body"> {

package/lib/ast/index.d.ts

@@ -1,2 +1,8 @@
 export * from "./astro";
 export * from "./jsx";
+import type { TSESTree } from "@typescript-eslint/types";
+export declare type Comment = TSESTree.Comment;
+export declare type Token = TSESTree.Token;
+export declare type SourceLocation = TSESTree.SourceLocation;
+export declare type Range = TSESTree.Range;
+export declare type Position = TSESTree.Position;

package/lib/ast/jsx.d.ts

@@ -1,25 +1,25 @@
-import type { TSESTree as ES, AST_NODE_TYPES } from "@typescript-eslint/types";
-import type { AstroFragment, AstroHTMLComment, AstroShorthandAttribute, AstroTemplateLiteralAttribute } from "./astro";
+import type { TSESTree as ES } from "@typescript-eslint/types";
+import type { AstroFragment, AstroHTMLComment, AstroRawText, AstroShorthandAttribute, AstroTemplateLiteralAttribute } from "./astro";
 import type { BaseNode } from "./base";
 export declare type JSXNode = JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText;
-export declare type JSXChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment;
+export declare type JSXChild = JSXElement | JSXFragment | JSXExpression | JSXText | AstroHTMLComment | AstroRawText;
 export declare type JSXParentNode = JSXElement | JSXFragment | AstroFragment;
 export interface JSXElement extends BaseNode {
-    type: AST_NODE_TYPES.JSXElement;
+    type: "JSXElement";
     openingElement: JSXOpeningElement;
     closingElement: JSXClosingElement | null;
     children: JSXChild[];
     parent?: JSXParentNode;
 }
 export interface JSXFragment extends BaseNode {
-    type: AST_NODE_TYPES.JSXFragment;
+    type: "JSXFragment";
     openingFragment: JSXOpeningFragment;
     closingFragment: JSXClosingFragment;
     children: JSXChild[];
     parent?: JSXParentNode;
 }
 export interface JSXOpeningElement extends BaseNode {
-    type: AST_NODE_TYPES.JSXOpeningElement;
+    type: "JSXOpeningElement";
     typeParameters?: ES.TSTypeParameterInstantiation;
     selfClosing: boolean;
     name: JSXTagNameExpression;
@@ -27,64 +27,64 @@ export interface JSXOpeningElement extends BaseNode {
     parent?: JSXElement;
 }
 export interface JSXClosingElement extends BaseNode {
-    type: AST_NODE_TYPES.JSXClosingElement;
+    type: "JSXClosingElement";
     name: JSXTagNameExpression;
     parent?: JSXElement;
 }
 export interface JSXClosingFragment extends BaseNode {
-    type: AST_NODE_TYPES.JSXClosingFragment;
+    type: "JSXClosingFragment";
     parent?: JSXFragment;
 }
 export interface JSXOpeningFragment extends BaseNode {
-    type: AST_NODE_TYPES.JSXOpeningFragment;
+    type: "JSXOpeningFragment";
     parent?: JSXFragment;
 }
 export interface JSXAttribute extends BaseNode {
-    type: AST_NODE_TYPES.JSXAttribute;
+    type: "JSXAttribute";
     name: JSXIdentifier | JSXNamespacedName;
     value: JSXExpression | ES.Literal | null;
     parent?: JSXOpeningElement;
 }
 export interface JSXSpreadAttribute extends BaseNode {
-    type: AST_NODE_TYPES.JSXSpreadAttribute;
+    type: "JSXSpreadAttribute";
     argument: ES.Expression;
     parent?: JSXOpeningElement;
 }
 export declare type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
 export interface JSXIdentifier extends BaseNode {
-    type: AST_NODE_TYPES.JSXIdentifier;
+    type: "JSXIdentifier";
     name: string;
     parent?: JSXAttribute | AstroShorthandAttribute | AstroTemplateLiteralAttribute | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXClosingElement;
 }
 export interface JSXMemberExpression extends BaseNode {
-    type: AST_NODE_TYPES.JSXMemberExpression;
+    type: "JSXMemberExpression";
     object: JSXTagNameExpression;
     property: JSXIdentifier;
     parent?: JSXMemberExpression | JSXOpeningElement | JSXClosingElement;
 }
 export interface JSXNamespacedName extends BaseNode {
-    type: AST_NODE_TYPES.JSXNamespacedName;
+    type: "JSXNamespacedName";
     namespace: JSXIdentifier;
     name: JSXIdentifier;
     parent?: JSXAttribute | AstroShorthandAttribute | AstroTemplateLiteralAttribute | JSXMemberExpression | JSXOpeningElement | JSXClosingElement;
 }
 export declare type JSXExpression = JSXExpressionContainer | JSXSpreadChild;
 export interface JSXExpressionContainer extends BaseNode {
-    type: AST_NODE_TYPES.JSXExpressionContainer;
+    type: "JSXExpressionContainer";
     expression: ES.Expression | JSXEmptyExpression;
     parent?: JSXAttribute | AstroShorthandAttribute | AstroTemplateLiteralAttribute | JSXParentNode;
 }
 export interface JSXSpreadChild extends BaseNode {
-    type: AST_NODE_TYPES.JSXSpreadChild;
+    type: "JSXSpreadChild";
     expression: ES.Expression;
     parent?: JSXAttribute | JSXParentNode;
 }
 export interface JSXEmptyExpression extends BaseNode {
-    type: AST_NODE_TYPES.JSXEmptyExpression;
+    type: "JSXEmptyExpression";
     parent?: JSXExpressionContainer;
 }
 export interface JSXText extends BaseNode {
-    type: AST_NODE_TYPES.JSXText;
+    type: "JSXText";
     value: string;
     raw: string;
     parent?: JSXParentNode;

package/lib/astro/index.js

@@ -116,8 +116,7 @@ exports.calcAttributeValueStartOffset = calcAttributeValueStartOffset;
  * Get end offset of tag
  */
 function getEndOffset(node, ctx) {
-    var _a;
-    if (((_a = node.position.end) === null || _a === void 0 ? void 0 : _a.offset) != null) {
+    if (node.position.end?.offset != null) {
         return node.position.end.offset;
     }
     if (isTag(node))
@@ -323,8 +322,7 @@ exports.skipSpaces = skipSpaces;
  * Get children
  */
 function getSortedChildren(parent, code) {
-    var _a;
-    if (parent.type === "root" && ((_a = parent.children[0]) === null || _a === void 0 ? void 0 : _a.type) === "frontmatter") {
+    if (parent.type === "root" && parent.children[0]?.type === "frontmatter") {
         // The order of comments and frontmatter may be changed.
         const children = [...parent.children];
         if (children.every((n) => n.position)) {

package/lib/astro-tools/index.d.ts

@@ -0,0 +1,21 @@
+import type { ParseResult } from "@astrojs/compiler";
+import type { AttributeNode, Node, ParentNode } from "@astrojs/compiler/types";
+export interface ParseTemplateResult {
+    result: ParseResult;
+    getEndOffset: (node: Node) => number;
+    calcAttributeValueStartOffset: (node: AttributeNode) => number;
+    calcAttributeEndOffset: (node: AttributeNode) => number;
+    walk: (parent: ParentNode, enter: (n: Node | AttributeNode, parents: ParentNode[]) => void, leave?: (n: Node | AttributeNode, parents: ParentNode[]) => void) => void;
+    getLocFromIndex: (index: number) => {
+        line: number;
+        column: number;
+    };
+    getIndexFromLoc: (loc: {
+        line: number;
+        column: number;
+    }) => number;
+}
+/**
+ * Parse the astro component template.
+ */
+export declare function parseTemplate(code: string): ParseTemplateResult;

package/lib/astro-tools/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTemplate = void 0;
+const template_1 = require("../parser/template");
+const astro_1 = require("../astro");
+/**
+ * Parse the astro component template.
+ */
+function parseTemplate(code) {
+    const parsed = (0, template_1.parseTemplate)(code);
+    return {
+        result: parsed.result,
+        getEndOffset: (node) => (0, astro_1.getEndOffset)(node, parsed.context),
+        calcAttributeValueStartOffset: (node) => (0, astro_1.calcAttributeValueStartOffset)(node, parsed.context),
+        calcAttributeEndOffset: (node) => (0, astro_1.calcAttributeEndOffset)(node, parsed.context),
+        walk(parent, enter, leave) {
+            (0, astro_1.walk)(parent, code, enter, leave ||
+                (() => {
+                    /* noop */
+                }));
+        },
+        getLocFromIndex: (index) => parsed.context.getLocFromIndex(index),
+        getIndexFromLoc: (loc) => parsed.context.locs.getIndexFromLoc(loc),
+    };
+}
+exports.parseTemplate = parseTemplate;

package/lib/context/index.d.ts

@@ -1,16 +1,14 @@
 import type { TSESTree } from "@typescript-eslint/types";
-import type { ESLintExtendedProgram } from "../parser";
 declare type RangeAndLoc = {
     range: TSESTree.Range;
     loc: TSESTree.SourceLocation;
 };
 export declare class Context {
     readonly code: string;
-    readonly parserOptions: any;
     readonly locs: LinesAndColumns;
     private readonly locsMap;
     private readonly state;
-    constructor(code: string, parserOptions: any);
+    constructor(code: string);
     getLocFromIndex(index: number): {
         line: number;
         column: number;
@@ -27,15 +25,12 @@ export declare class Context {
      * get text
      */
     getText(range: TSESTree.Range): string;
-    isTypeScript(): boolean;
-    remapCR({ ast, visitorKeys }: ESLintExtendedProgram): void;
     get originalAST(): any;
     set originalAST(originalAST: any);
 }
 export declare class LinesAndColumns {
-    readonly code: string;
-    private readonly crs;
     private readonly lineStartIndices;
+    private readonly normalizedLineFeed;
     constructor(origCode: string);
     getLocFromIndex(index: number): {
         line: number;
@@ -45,6 +40,16 @@ export declare class LinesAndColumns {
         line: number;
         column: number;
     }): number;
-    getCRs(): number[];
+    getNormalizedLineFeed(): NormalizedLineFeed;
+}
+export declare class NormalizedLineFeed {
+    readonly code: string;
+    private readonly offsets;
+    get needRemap(): boolean;
+    /**
+     * Remap index
+     */
+    readonly remapIndex: (index: number) => number;
+    constructor(code: string, offsets: number[]);
 }
 export {};

package/lib/context/index.js

@@ -1,20 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinesAndColumns = exports.Context = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const resolve_parser_1 = require("../parser/resolve-parser");
-const traverse_1 = require("../traverse");
+exports.NormalizedLineFeed = exports.LinesAndColumns = exports.Context = void 0;
 class Context {
-    constructor(code, parserOptions) {
+    constructor(code) {
         this.locsMap = new Map();
         this.state = {};
         this.locs = new LinesAndColumns(code);
-        this.code = this.locs.code;
-        this.parserOptions = parserOptions;
+        this.code = code;
     }
     getLocFromIndex(index) {
         let loc = this.locsMap.get(index);
@@ -43,7 +35,11 @@ class Context {
      * Build token
      */
     buildToken(type, range) {
-        return Object.assign({ type, value: this.getText(range) }, this.getLocations(...range));
+        return {
+            type,
+            value: this.getText(range),
+            ...this.getLocations(...range),
+        };
     }
     /**
      * get text
@@ -51,84 +47,6 @@ class Context {
     getText(range) {
         return this.code.slice(range[0], range[1]);
     }
-    isTypeScript() {
-        var _a, _b;
-        if (this.state.isTypeScript != null) {
-            return this.state.isTypeScript;
-        }
-        const parserName = (0, resolve_parser_1.getParserName)({}, (_a = this.parserOptions) === null || _a === void 0 ? void 0 : _a.parser);
-        if (parserName === "@typescript-eslint/parser") {
-            return (this.state.isTypeScript = true);
-        }
-        if (parserName.includes("@typescript-eslint/parser")) {
-            let targetPath = parserName;
-            while (targetPath) {
-                const pkgPath = path_1.default.join(targetPath, "package.json");
-                if (fs_1.default.existsSync(pkgPath)) {
-                    try {
-                        return (this.state.isTypeScript =
-                            ((_b = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"))) === null || _b === void 0 ? void 0 : _b.name) === "@typescript-eslint/parser");
-                    }
-                    catch (_c) {
-                        return (this.state.isTypeScript = false);
-                    }
-                }
-                const parent = path_1.default.dirname(targetPath);
-                if (targetPath === parent) {
-                    break;
-                }
-                targetPath = parent;
-            }
-        }
-        return (this.state.isTypeScript = false);
-    }
-    remapCR({ ast, visitorKeys }) {
-        const crs = this.locs.getCRs();
-        if (!crs.length) {
-            return;
-        }
-        const cache = {};
-        /**
-         * Remap index
-         */
-        function remapIndex(index) {
-            let result = cache[index];
-            if (result != null) {
-                return result;
-            }
-            result = index;
-            for (const cr of crs) {
-                if (cr < result) {
-                    result++;
-                }
-                else {
-                    break;
-                }
-            }
-            return (cache[index] = result);
-        }
-        /**
-         * Remap range
-         */
-        function remapRange(range) {
-            return [remapIndex(range[0]), remapIndex(range[1])];
-        }
-        (0, traverse_1.traverseNodes)(ast, {
-            visitorKeys,
-            enterNode(node) {
-                node.range = remapRange(node.range);
-            },
-            leaveNode() {
-                // ignore
-            },
-        });
-        for (const token of ast.tokens || []) {
-            token.range = remapRange(token.range);
-        }
-        for (const comment of ast.comments || []) {
-            comment.range = remapRange(comment.range);
-        }
-    }
     get originalAST() {
         return this.state.originalAST;
     }
@@ -142,30 +60,31 @@ class LinesAndColumns {
         const len = origCode.length;
         const lineStartIndices = [0];
         const crs = [];
-        let code = "";
+        let normalizedCode = "";
         for (let index = 0; index < len;) {
             const c = origCode[index++];
             if (c === "\r") {
                 const next = origCode[index++] || "";
                 if (next === "\n") {
-                    code += next;
+                    normalizedCode += next;
                     crs.push(index - 2);
+                    lineStartIndices.push(index);
                 }
                 else {
-                    code += `\n${next}`;
+                    normalizedCode += `\n${next}`;
+                    lineStartIndices.push(index - 1);
                 }
-                lineStartIndices.push(code.length);
             }
             else {
-                code += c;
+                normalizedCode += c;
                 if (c === "\n") {
-                    lineStartIndices.push(code.length);
+                    lineStartIndices.push(index);
                 }
             }
         }
         this.lineStartIndices = lineStartIndices;
-        this.code = code;
-        this.crs = crs;
+        //
+        this.normalizedLineFeed = new NormalizedLineFeed(normalizedCode, crs);
     }
     getLocFromIndex(index) {
         const lineNumber = sortedLastIndex(this.lineStartIndices, index);
@@ -179,11 +98,43 @@ class LinesAndColumns {
         const positionIndex = lineStartIndex + loc.column;
         return positionIndex;
     }
-    getCRs() {
-        return this.crs;
+    getNormalizedLineFeed() {
+        return this.normalizedLineFeed;
     }
 }
 exports.LinesAndColumns = LinesAndColumns;
+class NormalizedLineFeed {
+    constructor(code, offsets) {
+        this.code = code;
+        this.offsets = offsets;
+        if (offsets.length) {
+            const cache = {};
+            this.remapIndex = (index) => {
+                let result = cache[index];
+                if (result != null) {
+                    return result;
+                }
+                result = index;
+                for (const offset of offsets) {
+                    if (offset < result) {
+                        result++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                return (cache[index] = result);
+            };
+        }
+        else {
+            this.remapIndex = (i) => i;
+        }
+    }
+    get needRemap() {
+        return this.offsets.length > 0;
+    }
+}
+exports.NormalizedLineFeed = NormalizedLineFeed;
 /**
  * Uses a binary search to determine the highest index at which value should be inserted into array in order to maintain its sort order.
  */

package/lib/context/parser-options.d.ts

@@ -0,0 +1,8 @@
+import type { ESLintCustomParser } from "../types";
+export declare class ParserOptionsContext {
+    readonly parserOptions: any;
+    private readonly state;
+    constructor(options: any);
+    getParser(): ESLintCustomParser;
+    isTypeScript(): boolean;
+}

package/lib/context/parser-options.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserOptionsContext = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const resolve_parser_1 = require("./resolve-parser");
+class ParserOptionsContext {
+    constructor(options) {
+        this.state = {};
+        const parserOptions = {
+            ecmaVersion: 2020,
+            sourceType: "module",
+            loc: true,
+            range: true,
+            raw: true,
+            tokens: true,
+            comment: true,
+            eslintVisitorKeys: true,
+            eslintScopeManager: true,
+            ...(options || {}),
+        };
+        parserOptions.ecmaFeatures = {
+            ...(parserOptions.ecmaFeatures || {}),
+            jsx: true,
+        };
+        parserOptions.sourceType = "module";
+        if (parserOptions.ecmaVersion <= 5 ||
+            parserOptions.ecmaVersion == null) {
+            parserOptions.ecmaVersion = 2015;
+        }
+        this.parserOptions = parserOptions;
+    }
+    getParser() {
+        return (0, resolve_parser_1.getParser)({}, this.parserOptions.parser);
+    }
+    isTypeScript() {
+        if (this.state.isTypeScript != null) {
+            return this.state.isTypeScript;
+        }
+        const parserName = (0, resolve_parser_1.getParserName)({}, this.parserOptions?.parser);
+        if (parserName === "@typescript-eslint/parser") {
+            return (this.state.isTypeScript = true);
+        }
+        if (parserName.includes("@typescript-eslint/parser")) {
+            let targetPath = parserName;
+            while (targetPath) {
+                const pkgPath = path_1.default.join(targetPath, "package.json");
+                if (fs_1.default.existsSync(pkgPath)) {
+                    try {
+                        return (this.state.isTypeScript =
+                            JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"))
+                                ?.name === "@typescript-eslint/parser");
+                    }
+                    catch {
+                        return (this.state.isTypeScript = false);
+                    }
+                }
+                const parent = path_1.default.dirname(targetPath);
+                if (targetPath === parent) {
+                    break;
+                }
+                targetPath = parent;
+            }
+        }
+        return (this.state.isTypeScript = false);
+    }
+}
+exports.ParserOptionsContext = ParserOptionsContext;

package/lib/{parser → context/resolve-parser}/espree.d.ts

@@ -1,4 +1,4 @@
-import type { ESLintCustomParser } from "./resolve-parser";
+import type { ESLintCustomParser } from "../../types";
 /**
  * Load `espree` from the loaded ESLint.
  * If the loaded ESLint was not found, just returns `require("espree")`.

package/lib/{parser → context/resolve-parser}/espree.js

@@ -4,23 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEspree = void 0;
-const module_1 = __importDefault(require("module"));
+const module_1 = require("module");
 const path_1 = __importDefault(require("path"));
-const createRequire = 
-// Added in v12.2.0
-module_1.default.createRequire ||
-    // Added in v10.12.0, but deprecated in v12.2.0.
-    // @ts-expect-error -- old type
-    module_1.default.createRequireFromPath ||
-    // Polyfill - This is not executed on the tests on node@>=10.
-    /* istanbul ignore next */
-    ((modName) => {
-        const mod = new module_1.default(modName);
-        mod.filename = modName;
-        mod.paths = module_1.default._nodeModulePaths(path_1.default.dirname(modName));
-        mod._compile("module.exports = require;", modName);
-        return mod.exports;
-    });
 let espreeCache = null;
 /** Checks if given path is linter path */
 function isLinterPath(p) {
@@ -40,9 +25,9 @@ function getEspree() {
         const linterPath = Object.keys(require.cache || {}).find(isLinterPath);
         if (linterPath) {
             try {
-                espreeCache = createRequire(linterPath)("espree");
+                espreeCache = (0, module_1.createRequire)(linterPath)("espree");
             }
-            catch (_a) {
+            catch {
                 // ignore
             }
         }

package/lib/context/resolve-parser/index.d.ts

@@ -0,0 +1,5 @@
+import type { ESLintCustomParser } from "../../types";
+/** Get parser name */
+export declare function getParserName(attrs: Record<string, string | undefined>, parser: any): string;
+/** Get parser */
+export declare function getParser(attrs: Record<string, string | undefined>, parser: any): ESLintCustomParser;

package/lib/context/script.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from ".";
-import type { ESLintExtendedProgram } from "../parser";
 import type { TSESTree } from "@typescript-eslint/types";
+import type { ESLintExtendedProgram } from "../types";
 declare class RestoreNodeProcessContext {
     readonly result: ESLintExtendedProgram;
     readonly removeTokens: Set<(token: TSESTree.Token) => boolean>;