astro-eslint-parser 0.0.18 → 0.1.0

package/README.md

@@ -19,8 +19,6 @@ 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
 
 <!--
@@ -28,7 +26,7 @@ At least it works fine with a [fork of the `astro.build` repository](https://git
 
 #### [@ota-meshi/eslint-plugin-astro](https://ota-meshi.github.io/eslint-plugin-astro/)
 
-ESLint plugin for Astro.  
+ESLint plugin for Astro component.  
 It provides many unique check rules by using the template AST.
 -->
 

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 { 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: 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

@@ -42,7 +42,7 @@ function getEspree() {
             try {
                 espreeCache = 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>;

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 {};