astro-eslint-parser 0.0.18 → 0.2.1

package/lib/context/script.js

@@ -50,7 +50,6 @@ class ScriptContext {
      * Restore AST nodes
      */
     restore(result) {
-        var _a, _b;
         // remap locations
         const traversed = new Map();
         (0, traverse_1.traverseNodes)(result.ast, {
@@ -102,8 +101,8 @@ class ScriptContext {
         // Adjust program node location
         const firstOffset = Math.min(...[
             result.ast.body[0],
-            (_a = result.ast.tokens) === null || _a === void 0 ? void 0 : _a[0],
-            (_b = result.ast.comments) === null || _b === void 0 ? void 0 : _b[0],
+            result.ast.tokens?.[0],
+            result.ast.comments?.[0],
         ]
             .filter(Boolean)
             .map((t) => t.range[0]));

package/lib/index.d.ts

@@ -1,8 +1,9 @@
 import { parseForESLint } from "./parser";
+import { parseTemplate, ParseTemplateResult } from "./astro-tools";
 import * as AST from "./ast";
 import { traverseNodes } from "./traverse";
 import { ParseError } from "./errors";
 export { AST, ParseError };
 export { parseForESLint };
 export declare const VisitorKeys: import("eslint").SourceCode.VisitorKeys;
-export { traverseNodes };
+export { traverseNodes, parseTemplate, ParseTemplateResult };

package/lib/index.js

@@ -23,9 +23,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseNodes = exports.VisitorKeys = exports.parseForESLint = exports.ParseError = exports.AST = void 0;
+exports.parseTemplate = exports.traverseNodes = exports.VisitorKeys = exports.parseForESLint = exports.ParseError = exports.AST = void 0;
 const parser_1 = require("./parser");
 Object.defineProperty(exports, "parseForESLint", { enumerable: true, get: function () { return parser_1.parseForESLint; } });
+const astro_tools_1 = require("./astro-tools");
+Object.defineProperty(exports, "parseTemplate", { enumerable: true, get: function () { return astro_tools_1.parseTemplate; } });
 const AST = __importStar(require("./ast"));
 exports.AST = AST;
 const traverse_1 = require("./traverse");

package/lib/parser/astro-parser/astrojs-compiler-service.d.ts

@@ -1,7 +1,5 @@
-import type { ParseOptions } from "@astrojs/compiler";
+import type { ParseOptions, ParseResult } from "@astrojs/compiler";
 /**
  * Parse code by `@astrojs/compiler`
  */
-export declare function parse(code: string, options: ParseOptions): {
-    ast: string;
-};
+export declare function parse(code: string, options: ParseOptions): ParseResult;

package/lib/parser/astro-parser/astrojs-compiler-service.js

@@ -1,21 +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.parse = void 0;
-const fs_1 = __importDefault(require("fs"));
-const wasm_exec_1 = __importDefault(require("./wasm_exec"));
-const go = new wasm_exec_1.default();
-const wasmBuffer = fs_1.default.readFileSync(require.resolve("@astrojs/compiler/astro.wasm"));
-const mod = new WebAssembly.Module(wasmBuffer);
-const instance = new WebAssembly.Instance(mod, go.importObject);
-void go.run(instance);
-const service = globalThis["@astrojs/compiler"];
+const synckit_1 = require("synckit");
+const parseSync = (0, synckit_1.createSyncFn)(require.resolve("./astrojs-compiler-worker"));
 /**
  * Parse code by `@astrojs/compiler`
  */
 function parse(code, options) {
-    return service.parse(code, options);
+    return parseSync(code, options);
 }
 exports.parse = parse;

package/lib/parser/astro-parser/astrojs-compiler-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/parser/astro-parser/astrojs-compiler-worker.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const synckit_1 = require("synckit");
+const dynamicImport = new Function("m", "return import(m)");
+(0, synckit_1.runAsWorker)(async (source) => {
+    const { parse } = await dynamicImport("@astrojs/compiler");
+    // console.time("parse")
+    const result = parse(source);
+    // console.timeEnd("parse")
+    return result;
+});

package/lib/parser/astro-parser/parse.js

@@ -31,7 +31,7 @@ const errors_1 = require("../../errors");
  * Parse code by `@astrojs/compiler`
  */
 function parse(code, ctx) {
-    const ast = parseByService(code, ctx).ast;
+    const ast = service.parse(code, { position: true }).ast;
     if (!ast.children) {
         // If the source code is empty, the children property may not be available.
         ast.children = [];
@@ -44,45 +44,17 @@ function parse(code, ctx) {
     return { ast };
 }
 exports.parse = parse;
-/**
- * Parse code by `@astrojs/compiler`
- */
-function parseByService(code, ctx) {
-    const jsonAst = service.parse(code, { position: true }).ast;
-    ctx.originalAST = jsonAst;
-    try {
-        const ast = JSON.parse(jsonAst);
-        ctx.originalAST = ast;
-        return { ast };
-    }
-    catch (_a) {
-        // FIXME: Workaround for escape bugs
-        // Adjust because may get the wrong escape as JSON.
-        const ast = JSON.parse(jsonAst.replace(/\\./gu, (m) => {
-            try {
-                JSON.parse(`"${m}"`);
-                return m;
-            }
-            catch (_a) {
-                return `\\${m}`;
-            }
-        }));
-        ctx.originalAST = ast;
-        return { ast };
-    }
-}
 /**
  * Adjust <html> element node
  */
 function adjustHTML(ast, htmlElement, ctx) {
-    var _a;
     const htmlEnd = ctx.code.indexOf("</html");
     if (htmlEnd == null) {
         return;
     }
     const children = [...htmlElement.children];
     for (const child of children) {
-        const offset = (_a = child.position) === null || _a === void 0 ? void 0 : _a.start.offset;
+        const offset = child.position?.start.offset;
         if (offset != null) {
             if (htmlEnd <= offset) {
                 htmlElement.children.splice(htmlElement.children.indexOf(child), 1);
@@ -98,14 +70,13 @@ function adjustHTML(ast, htmlElement, ctx) {
  * Adjust <body> element node
  */
 function adjustHTMLBody(ast, htmlElement, htmlEnd, bodyElement, ctx) {
-    var _a;
     const bodyEnd = ctx.code.indexOf("</body");
     if (bodyEnd == null) {
         return;
     }
     const children = [...bodyElement.children];
     for (const child of children) {
-        const offset = (_a = child.position) === null || _a === void 0 ? void 0 : _a.start.offset;
+        const offset = child.position?.start.offset;
         if (offset != null) {
             if (bodyEnd <= offset) {
                 bodyElement.children.splice(bodyElement.children.indexOf(child), 1);
@@ -169,8 +140,6 @@ function fixLocations(node, ctx) {
                 if (start < 0) {
                     start = ctx.code.length;
                 }
-                // FIXME: Workaround for escape bugs
-                node.value = ctx.code.slice(node.position.start.offset, start);
             }
             else {
                 const index = tokenIndexSafe(ctx.code, node.value, start);
@@ -179,25 +148,12 @@ function fixLocations(node, ctx) {
                     start += node.value.length;
                 }
                 else {
-                    // FIXME: Workaround for escape bugs
+                    // FIXME: Some white space may be removed.
                     node.position.start.offset = start;
                     const value = node.value.replace(/\s+/gu, "");
-                    for (let charIndex = 0; charIndex < value.length; charIndex++) {
-                        const char = value[charIndex];
-                        const index = tokenIndexSafe(ctx.code, char, start);
-                        if (index != null) {
-                            start = index + 1;
-                            continue;
-                        }
-                        start = (0, astro_1.skipSpaces)(ctx.code, start);
-                        if (ctx.code.startsWith("\\", start)) {
-                            const codeChar = JSON.parse(`"\\${ctx.code[start + 1]}"`);
-                            start += 2;
-                            if (codeChar === char) {
-                                continue;
-                            }
-                        }
-                        start = tokenIndex(ctx, char, start) + 1;
+                    for (const char of value) {
+                        const index = tokenIndex(ctx, char, start);
+                        start = index + 1;
                     }
                     start = (0, astro_1.skipSpaces)(ctx.code, start);
                     node.value = ctx.code.slice(node.position.start.offset, start);

package/lib/parser/index.d.ts

@@ -1,19 +1,6 @@
-import { Context } from "../context";
 import type { AstroProgram } from "../ast";
-import type { TSESTree } from "@typescript-eslint/types";
 import type { ScopeManager } from "eslint-scope";
 import type { ParseResult } from "@astrojs/compiler";
-/**
- * The parsing result of ESLint custom parsers.
- */
-export interface ESLintExtendedProgram {
-    ast: TSESTree.Program;
-    services?: Record<string, any>;
-    visitorKeys?: {
-        [type: string]: string[];
-    };
-    scopeManager?: ScopeManager;
-}
 /**
  * Parse source code
  */
@@ -28,7 +15,3 @@ export declare function parseForESLint(code: string, options?: any): {
     };
     scopeManager: ScopeManager;
 };
-/**
- * Parse for template
- */
-export declare function parseTemplate(code: string, ctx: Context): ParseResult;

package/lib/parser/index.js

@@ -1,28 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTemplate = exports.parseForESLint = void 0;
+exports.parseForESLint = void 0;
 const visitor_keys_1 = require("../visitor-keys");
-const context_1 = require("../context");
 const types_1 = require("@typescript-eslint/types");
 const script_1 = require("./script");
 const sort_1 = require("./sort");
-const errors_1 = require("../errors");
-const parse_1 = require("./astro-parser/parse");
 const process_template_1 = require("./process-template");
+const template_1 = require("./template");
+const parser_options_1 = require("../context/parser-options");
 /**
  * Parse source code
  */
 function parseForESLint(code, options) {
-    const parserOptions = Object.assign({ ecmaVersion: 2020, sourceType: "module", loc: true, range: true, raw: true, tokens: true, comment: true, eslintVisitorKeys: true, eslintScopeManager: true }, (options || {}));
-    parserOptions.ecmaFeatures = Object.assign(Object.assign({}, (parserOptions.ecmaFeatures || {})), { jsx: true });
-    parserOptions.sourceType = "module";
-    if (parserOptions.ecmaVersion <= 5 || parserOptions.ecmaVersion == null) {
-        parserOptions.ecmaVersion = 2015;
-    }
-    const ctx = new context_1.Context(code, parserOptions);
-    const resultTemplate = parseTemplate(ctx.code, ctx);
+    const { result: resultTemplate, context: ctx } = (0, template_1.parseTemplate)(code);
     const scriptContext = (0, process_template_1.processTemplate)(ctx, resultTemplate);
-    const resultScript = (0, script_1.parseScript)(scriptContext.script, ctx);
+    const parserOptions = new parser_options_1.ParserOptionsContext(options);
+    const resultScript = (0, script_1.parseScript)(scriptContext.script, ctx, parserOptions);
     scriptContext.restore(resultScript);
     (0, sort_1.sort)(resultScript.ast.comments);
     (0, sort_1.sort)(resultScript.ast.tokens);
@@ -34,7 +27,6 @@ function parseForESLint(code, options) {
         },
     });
     resultScript.visitorKeys = Object.assign({}, visitor_keys_1.KEYS, resultScript.visitorKeys);
-    ctx.remapCR(resultScript);
     return resultScript;
 }
 exports.parseForESLint = parseForESLint;
@@ -77,20 +69,3 @@ function extractTokens(ast, ctx) {
         return /^[^\w$]$/iu.test(c);
     }
 }
-/**
- * Parse for template
- */
-function parseTemplate(code, ctx) {
-    try {
-        return (0, parse_1.parse)(code, ctx);
-    }
-    catch (e) {
-        if (typeof e.pos === "number") {
-            const err = new errors_1.ParseError(e.message, e.pos, ctx);
-            err.astroCompilerError = e;
-            throw err;
-        }
-        throw e;
-    }
-}
-exports.parseTemplate = parseTemplate;

package/lib/parser/lru-cache.d.ts

@@ -0,0 +1,7 @@
+export declare class LruCache<K, V> extends Map<K, V> {
+    private readonly capacity;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    private deleteOldestEntry;
+}

package/lib/parser/lru-cache.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LruCache = void 0;
+class LruCache extends Map {
+    constructor(capacity) {
+        super();
+        this.capacity = capacity;
+    }
+    get(key) {
+        if (!this.has(key)) {
+            return undefined;
+        }
+        const value = super.get(key);
+        this.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        this.delete(key);
+        super.set(key, value);
+        if (this.size > this.capacity) {
+            this.deleteOldestEntry();
+        }
+        return this;
+    }
+    deleteOldestEntry() {
+        for (const entry of this) {
+            this.delete(entry[0]);
+            return;
+        }
+    }
+}
+exports.LruCache = LruCache;

package/lib/parser/process-template.js

@@ -134,10 +134,23 @@ function processTemplate(ctx, resultTemplate) {
                                 types_1.AST_NODE_TYPES.JSXAttribute &&
                                 scriptNode.range[0] === start) {
                                 const baseNameNode = scriptNode.name;
-                                const nsn = Object.assign(Object.assign({}, baseNameNode), { type: types_1.AST_NODE_TYPES.JSXNamespacedName, namespace: Object.assign({ type: types_1.AST_NODE_TYPES.JSXIdentifier, name: attr.name.slice(0, colonIndex) }, ctx.getLocations(baseNameNode.range[0], baseNameNode.range[0] +
-                                        colonIndex)), name: Object.assign({ type: types_1.AST_NODE_TYPES.JSXIdentifier, name: attr.name.slice(colonIndex + 1) }, ctx.getLocations(baseNameNode.range[0] +
-                                        colonIndex +
-                                        1, baseNameNode.range[1])) });
+                                const nsn = {
+                                    ...baseNameNode,
+                                    type: types_1.AST_NODE_TYPES.JSXNamespacedName,
+                                    namespace: {
+                                        type: types_1.AST_NODE_TYPES.JSXIdentifier,
+                                        name: attr.name.slice(0, colonIndex),
+                                        ...ctx.getLocations(baseNameNode.range[0], baseNameNode.range[0] +
+                                            colonIndex),
+                                    },
+                                    name: {
+                                        type: types_1.AST_NODE_TYPES.JSXIdentifier,
+                                        name: attr.name.slice(colonIndex + 1),
+                                        ...ctx.getLocations(baseNameNode.range[0] +
+                                            colonIndex +
+                                            1, baseNameNode.range[1]),
+                                    },
+                                };
                                 scriptNode.name = nsn;
                                 nsn.namespace.parent = nsn;
                                 nsn.name.parent = nsn;
@@ -212,7 +225,13 @@ function processTemplate(ctx, resultTemplate) {
                     script.addRestoreNodeProcess((scriptNode) => {
                         if (scriptNode.type === types_1.AST_NODE_TYPES.JSXElement &&
                             scriptNode.range[0] === styleNodeStart) {
-                            const textNode = Object.assign({ type: "AstroRawText", value: text.value, raw: text.value, parent: scriptNode }, ctx.getLocations(start, start + text.value.length));
+                            const textNode = {
+                                type: "AstroRawText",
+                                value: text.value,
+                                raw: text.value,
+                                parent: scriptNode,
+                                ...ctx.getLocations(start, start + text.value.length),
+                            };
                             scriptNode.children = [
                                 textNode,
                             ];

package/lib/parser/script.d.ts

@@ -1,6 +1,7 @@
-import type { ESLintExtendedProgram } from ".";
 import type { Context } from "../context";
+import type { ParserOptionsContext } from "../context/parser-options";
+import type { ESLintExtendedProgram } from "../types";
 /**
  * Parse for script
  */
-export declare function parseScript(code: string, ctx: Context): ESLintExtendedProgram;
+export declare function parseScript(code: string, _ctx: Context, parserOptions: ParserOptionsContext): ESLintExtendedProgram;

package/lib/parser/script.js

@@ -1,29 +1,29 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScript = void 0;
-const resolve_parser_1 = require("./resolve-parser");
-const fs_1 = __importDefault(require("fs"));
 const debug_1 = require("../debug");
+const ts_patch_1 = require("./ts-patch");
 /**
  * Parse for script
  */
-function parseScript(code, ctx) {
-    var _a, _b, _c;
-    const parser = (0, resolve_parser_1.getParser)({}, ctx.parserOptions.parser);
-    let removeFile = null;
+function parseScript(code, _ctx, parserOptions) {
+    const parser = parserOptions.getParser();
+    let patchResult;
     try {
-        const scriptOption = Object.assign({}, ctx.parserOptions);
-        if (ctx.isTypeScript() && scriptOption.filePath) {
-            scriptOption.filePath += ".tsx";
-            if (!fs_1.default.existsSync(scriptOption.filePath)) {
-                fs_1.default.writeFileSync(scriptOption.filePath, "/* temp for astro-eslint-parser */");
-                removeFile = scriptOption.filePath;
-            }
+        const scriptParserOptions = {
+            ...parserOptions.parserOptions,
+        };
+        scriptParserOptions.ecmaFeatures = {
+            ...(scriptParserOptions.ecmaFeatures || {}),
+            jsx: true,
+        };
+        if (parserOptions.isTypeScript() &&
+            scriptParserOptions.filePath &&
+            scriptParserOptions.project) {
+            patchResult = (0, ts_patch_1.tsPatch)(scriptParserOptions);
         }
-        const result = (_b = (_a = parser.parseForESLint) === null || _a === void 0 ? void 0 : _a.call(parser, code, scriptOption)) !== null && _b !== void 0 ? _b : (_c = parser.parse) === null || _c === void 0 ? void 0 : _c.call(parser, code, scriptOption);
+        const result = parser.parseForESLint?.(code, scriptParserOptions) ??
+            parser.parse?.(code, scriptParserOptions);
         if ("ast" in result && result.ast != null) {
             return result;
         }
@@ -36,8 +36,7 @@ ${code}`);
         throw e;
     }
     finally {
-        if (removeFile)
-            fs_1.default.unlinkSync(removeFile);
+        patchResult?.terminate();
     }
 }
 exports.parseScript = parseScript;

package/lib/parser/template.d.ts

@@ -0,0 +1,10 @@
+import type { ParseResult } from "@astrojs/compiler";
+import { Context } from "../context";
+export declare type TemplateResult = {
+    result: ParseResult;
+    context: Context;
+};
+/**
+ * Parse the astro component template.
+ */
+export declare function parseTemplate(code: string): TemplateResult;

package/lib/parser/template.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTemplate = void 0;
+const astro_1 = require("../astro");
+const context_1 = require("../context");
+const errors_1 = require("../errors");
+const parse_1 = require("./astro-parser/parse");
+const lru_cache_1 = require("./lru-cache");
+const lruCache = new lru_cache_1.LruCache(5);
+/**
+ * Parse the astro component template.
+ */
+function parseTemplate(code) {
+    const cache = lruCache.get(code);
+    if (cache) {
+        return cache;
+    }
+    const ctx = new context_1.Context(code);
+    const normalized = ctx.locs.getNormalizedLineFeed();
+    const ctxForAstro = normalized.needRemap
+        ? new context_1.Context(normalized.code)
+        : ctx;
+    try {
+        const result = (0, parse_1.parse)(normalized?.code ?? code, ctxForAstro);
+        if (normalized.needRemap) {
+            remap(result, normalized, code, ctxForAstro);
+            ctx.originalAST = ctxForAstro.originalAST;
+        }
+        const templateResult = {
+            result,
+            context: ctx,
+        };
+        lruCache.set(code, templateResult);
+        return templateResult;
+    }
+    catch (e) {
+        if (typeof e.pos === "number") {
+            const err = new errors_1.ParseError(e.message, normalized?.remapIndex(e.pos), ctx);
+            err.astroCompilerError = e;
+            throw err;
+        }
+        throw e;
+    }
+}
+exports.parseTemplate = parseTemplate;
+/** Remap */
+function remap(result, normalized, originalCode, ctxForAstro) {
+    const remapDataMap = new Map();
+    (0, astro_1.walk)(result.ast, normalized.code, (node) => {
+        const start = normalized.remapIndex(node.position.start.offset);
+        let end, value;
+        if (node.position.end) {
+            end = normalized.remapIndex(node.position.end.offset);
+            if (node.position.start.offset === start &&
+                node.position.end.offset === end) {
+                return;
+            }
+        }
+        if (node.type === "text") {
+            value = originalCode.slice(start, normalized.remapIndex((0, astro_1.getEndOffset)(node, ctxForAstro)));
+        }
+        else if (node.type === "comment") {
+            value = originalCode.slice(start + 4, normalized.remapIndex((0, astro_1.getEndOffset)(node, ctxForAstro)) - 3);
+        }
+        else if (node.type === "attribute") {
+            if (node.kind !== "empty" &&
+                node.kind !== "shorthand" &&
+                node.kind !== "spread") {
+                let valueStart = normalized.remapIndex((0, astro_1.calcAttributeValueStartOffset)(node, ctxForAstro));
+                let valueEnd = normalized.remapIndex((0, astro_1.calcAttributeEndOffset)(node, ctxForAstro));
+                if (node.kind !== "quoted" ||
+                    originalCode[valueStart] === '"' ||
+                    originalCode[valueStart] === "'") {
+                    valueStart++;
+                    valueEnd--;
+                }
+                value = originalCode.slice(valueStart, valueEnd);
+            }
+        }
+        remapDataMap.set(node, {
+            start,
+            end,
+            value,
+        });
+    }, (_node) => {
+        /* noop */
+    });
+    for (const [node, remapData] of remapDataMap) {
+        node.position.start.offset = remapData.start;
+        if (node.position.end) {
+            node.position.end.offset = remapData.end;
+        }
+        if (node.type === "text" ||
+            node.type === "comment" ||
+            (node.type === "attribute" &&
+                node.kind !== "empty" &&
+                node.kind !== "shorthand" &&
+                node.kind !== "spread")) {
+            node.value = remapData.value;
+        }
+    }
+}

package/lib/parser/ts-patch.d.ts

@@ -0,0 +1,8 @@
+import type { ParserOptions } from "@typescript-eslint/types";
+export declare type PatchTerminate = {
+    terminate: () => void;
+};
+/**
+ * Apply a patch to parse .astro files as TSX.
+ */
+export declare function tsPatch(scriptParserOptions: ParserOptions): PatchTerminate | null;

package/lib/parser/ts-patch.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsPatch = void 0;
+const module_1 = require("module");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Apply a patch to parse .astro files as TSX.
+ */
+function tsPatch(scriptParserOptions) {
+    try {
+        // Apply a patch to parse .astro files as TSX.
+        const cwd = process.cwd();
+        const relativeTo = path_1.default.join(cwd, "__placeholder__.js");
+        const ts = (0, module_1.createRequire)(relativeTo)("typescript");
+        const { ensureScriptKind, getScriptKindFromFileName } = ts;
+        if (typeof ensureScriptKind === "function" &&
+            typeof getScriptKindFromFileName === "function") {
+            ts.ensureScriptKind = function (fileName, ...args) {
+                if (fileName.endsWith(".astro")) {
+                    return ts.ScriptKind.TSX;
+                }
+                return ensureScriptKind.call(this, fileName, ...args);
+            };
+            ts.getScriptKindFromFileName = function (fileName, ...args) {
+                if (fileName.endsWith(".astro")) {
+                    return ts.ScriptKind.TSX;
+                }
+                return getScriptKindFromFileName.call(this, fileName, ...args);
+            };
+            return {
+                terminate() {
+                    ts.ensureScriptKind = ensureScriptKind;
+                    ts.getScriptKindFromFileName = getScriptKindFromFileName;
+                },
+            };
+        }
+    }
+    catch {
+        // ignore
+    }
+    // If the patch cannot be applied, create a tsx file and parse it.
+    const tsxFilePath = `${scriptParserOptions.filePath}.tsx`;
+    scriptParserOptions.filePath = tsxFilePath;
+    if (!fs_1.default.existsSync(tsxFilePath)) {
+        fs_1.default.writeFileSync(tsxFilePath, "/* temp for astro-eslint-parser */");
+        return {
+            terminate() {
+                fs_1.default.unlinkSync(tsxFilePath);
+            },
+        };
+    }
+    return null;
+}
+exports.tsPatch = tsPatch;

package/lib/types.d.ts

@@ -0,0 +1,21 @@
+import type { TSESTree } from "@typescript-eslint/types";
+import type { ScopeManager } from "eslint-scope";
+/**
+ * The parsing result of ESLint custom parsers.
+ */
+export interface ESLintExtendedProgram {
+    ast: TSESTree.Program;
+    services?: Record<string, any>;
+    visitorKeys?: {
+        [type: string]: string[];
+    };
+    scopeManager?: ScopeManager;
+}
+/**
+ * The interface of a result of ESLint custom parser.
+ */
+export declare type ESLintCustomParserResult = ESLintExtendedProgram["ast"] | ESLintExtendedProgram;
+export interface ESLintCustomParser {
+    parse(code: string, options: any): ESLintCustomParserResult;
+    parseForESLint?(code: string, options: any): ESLintCustomParserResult;
+}

package/lib/types.js

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