astro-eslint-parser 0.0.17 → 0.2.0

package/README.md

@@ -19,18 +19,21 @@ 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.  
+
+[eslint-plugin-astro]: https://ota-meshi.github.io/eslint-plugin-astro/
 
 ## 💿 Installation
 
@@ -62,7 +65,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
 
@@ -145,7 +148,7 @@ Example **.vscode/settings.json**:
 }
 ```
 
-## :two_hearts: Compatibility With Existing ESLint Rules
+## :handshake: Compatibility With Existing ESLint Rules
 
 Most of the rules in the ESLint core work for the script part, but some rules are incompatible.  
 This parser will generate a JSX compatible AST for most of the HTML part of the Astro component. Therefore, some rules of [eslint-plugin-react] may work.
@@ -154,7 +157,15 @@ 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
 
-## :hammer: Usage for Custom Rules / Plugins
+## :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
 
 - 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.

package/lib/ast/astro.d.ts

@@ -0,0 +1,49 @@
+import type { JSXAttribute, JSXElement, JSXExpression, JSXExpressionContainer, JSXFragment, JSXText } from "./jsx";
+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 AstroParentNode = JSXElement | JSXFragment | AstroFragment;
+/** Node of Astro program root */
+export interface AstroProgram extends Omit<ES.Program, "type" | "body"> {
+    type: "Program";
+    body: (ES.Program["body"][number] | AstroFragment)[];
+    sourceType: "script" | "module";
+    comments: ES.Comment[];
+    tokens: ES.Token[];
+    parent?: undefined;
+}
+/** Node of Astro fragment */
+export interface AstroFragment extends BaseNode {
+    type: "AstroFragment";
+    children: AstroChild[];
+    parent?: AstroParentNode;
+}
+/** Node of Astro html comment */
+export interface AstroHTMLComment extends BaseNode {
+    type: "AstroHTMLComment";
+    value: string;
+    parent?: AstroParentNode;
+}
+/** Node of Astro doctype */
+export interface AstroDoctype extends BaseNode {
+    type: "AstroDoctype";
+    parent?: AstroFragment;
+}
+/** Node of Astro shorthand attribute */
+export interface AstroShorthandAttribute extends Omit<JSXAttribute, "type"> {
+    type: "AstroShorthandAttribute";
+    value: JSXExpressionContainer;
+}
+/** Node of Astro template-literal attribute */
+export interface AstroTemplateLiteralAttribute extends Omit<JSXAttribute, "type"> {
+    type: "AstroTemplateLiteralAttribute";
+    value: JSXExpressionContainer & {
+        expression: ES.TemplateLiteral;
+    };
+}
+/** Node of Astro raw text */
+export interface AstroRawText extends Omit<JSXText, "type"> {
+    type: "AstroRawText";
+    parent?: JSXElement;
+}

package/lib/ast/base.d.ts

@@ -0,0 +1,6 @@
+import type { TSESTree } from "@typescript-eslint/types";
+export interface BaseNode {
+    loc: TSESTree.SourceLocation;
+    range: TSESTree.Range;
+    type: string;
+}

package/lib/ast/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/ast/index.d.ts

@@ -0,0 +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/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./astro"), exports);
+__exportStar(require("./jsx"), exports);

package/lib/ast/jsx.d.ts

@@ -0,0 +1,91 @@
+import type { TSESTree as ES } from "@typescript-eslint/types";
+import type { AstroFragment, AstroHTMLComment, 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 JSXParentNode = JSXElement | JSXFragment | AstroFragment;
+export interface JSXElement extends BaseNode {
+    type: "JSXElement";
+    openingElement: JSXOpeningElement;
+    closingElement: JSXClosingElement | null;
+    children: JSXChild[];
+    parent?: JSXParentNode;
+}
+export interface JSXFragment extends BaseNode {
+    type: "JSXFragment";
+    openingFragment: JSXOpeningFragment;
+    closingFragment: JSXClosingFragment;
+    children: JSXChild[];
+    parent?: JSXParentNode;
+}
+export interface JSXOpeningElement extends BaseNode {
+    type: "JSXOpeningElement";
+    typeParameters?: ES.TSTypeParameterInstantiation;
+    selfClosing: boolean;
+    name: JSXTagNameExpression;
+    attributes: (JSXAttribute | JSXSpreadAttribute | AstroShorthandAttribute | AstroTemplateLiteralAttribute)[];
+    parent?: JSXElement;
+}
+export interface JSXClosingElement extends BaseNode {
+    type: "JSXClosingElement";
+    name: JSXTagNameExpression;
+    parent?: JSXElement;
+}
+export interface JSXClosingFragment extends BaseNode {
+    type: "JSXClosingFragment";
+    parent?: JSXFragment;
+}
+export interface JSXOpeningFragment extends BaseNode {
+    type: "JSXOpeningFragment";
+    parent?: JSXFragment;
+}
+export interface JSXAttribute extends BaseNode {
+    type: "JSXAttribute";
+    name: JSXIdentifier | JSXNamespacedName;
+    value: JSXExpression | ES.Literal | null;
+    parent?: JSXOpeningElement;
+}
+export interface JSXSpreadAttribute extends BaseNode {
+    type: "JSXSpreadAttribute";
+    argument: ES.Expression;
+    parent?: JSXOpeningElement;
+}
+export declare type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+export interface JSXIdentifier extends BaseNode {
+    type: "JSXIdentifier";
+    name: string;
+    parent?: JSXAttribute | AstroShorthandAttribute | AstroTemplateLiteralAttribute | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXClosingElement;
+}
+export interface JSXMemberExpression extends BaseNode {
+    type: "JSXMemberExpression";
+    object: JSXTagNameExpression;
+    property: JSXIdentifier;
+    parent?: JSXMemberExpression | JSXOpeningElement | JSXClosingElement;
+}
+export interface JSXNamespacedName extends BaseNode {
+    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: "JSXExpressionContainer";
+    expression: ES.Expression | JSXEmptyExpression;
+    parent?: JSXAttribute | AstroShorthandAttribute | AstroTemplateLiteralAttribute | JSXParentNode;
+}
+export interface JSXSpreadChild extends BaseNode {
+    type: "JSXSpreadChild";
+    expression: ES.Expression;
+    parent?: JSXAttribute | JSXParentNode;
+}
+export interface JSXEmptyExpression extends BaseNode {
+    type: "JSXEmptyExpression";
+    parent?: JSXExpressionContainer;
+}
+export interface JSXText extends BaseNode {
+    type: "JSXText";
+    value: string;
+    raw: string;
+    parent?: JSXParentNode;
+}

package/lib/ast/jsx.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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")`.