astro-eslint-parser 0.0.14 → 0.0.17

package/README.md

@@ -1,8 +1,10 @@
 # astro-eslint-parser
 
-[Astro] parser for [ESLint].  
+[Astro] component parser for [ESLint].  
 You can check it on [Online DEMO](https://ota-meshi.github.io/astro-eslint-parser/playground).
 
+[![sponsors](https://img.shields.io/badge/-Sponsor-fafbfc?logo=GitHub%20Sponsors)](https://github.com/sponsors/ota-meshi)
+
 [![NPM license](https://img.shields.io/npm/l/astro-eslint-parser.svg)](https://www.npmjs.com/package/astro-eslint-parser)
 [![NPM version](https://img.shields.io/npm/v/astro-eslint-parser.svg)](https://www.npmjs.com/package/astro-eslint-parser)
 [![NPM downloads](https://img.shields.io/badge/dynamic/json.svg?label=downloads&colorB=green&suffix=/day&query=$.downloads&uri=https://api.npmjs.org//downloads/point/last-day/astro-eslint-parser&maxAge=3600)](http://www.npmtrends.com/astro-eslint-parser)
@@ -15,6 +17,8 @@ You can check it on [Online DEMO](https://ota-meshi.github.io/astro-eslint-parse
 
 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
@@ -37,25 +41,28 @@ npm install --save-dev eslint astro-eslint-parser
 ## 📖 Usage
 
 1. Write `overrides.parser` option into your `.eslintrc.*` file.
-2. Use glob patterns or `--ext .astro` CLI option.
 
-```json
-{
-    "extends": "eslint:recommended",
-    "overrides": [
-        {
-            "files": ["*.astro"],
-            "parser": "astro-eslint-parser"
-        }
-    ]
-}
-```
+    ```json
+    {
+        "extends": "eslint:recommended",
+        "overrides": [
+            {
+                "files": ["*.astro"],
+                "parser": "astro-eslint-parser"
+            }
+        ]
+    }
+    ```
 
-```console
-$ eslint "src/**/*.{js,astro}"
-# or
-$ eslint src --ext .astro
-```
+2. If you have specified the extension in the CLI, add `.astro` as well.
+
+    ```console
+    $ eslint "src/**/*.{js,astro}"
+    # or
+    $ 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.
 
 ## 🔧 Options
 
@@ -138,17 +145,16 @@ Example **.vscode/settings.json**:
 }
 ```
 
-## Compatibility With Existing ESLint Rules
+## :two_hearts: 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.
 For example, the [react/jsx-no-target-blank] rule works fine.  
 
-[semi]: https://eslint.org/docs/rules/semi
 [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
 
-## Usage for Custom Rules / Plugins
+## :hammer: 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.
@@ -162,6 +168,12 @@ Welcome contributing!
 
 Please use GitHub's Issues/PRs.
 
+## :heart: Supporting
+
+If you are willing to see that this package continues to be maintained, please consider sponsoring me.
+
+[![sponsors](https://img.shields.io/badge/-Sponsor-fafbfc?logo=GitHub%20Sponsors)](https://github.com/sponsors/ota-meshi)
+
 ## :lock: License
 
 See the [LICENSE](LICENSE) file for license rights and limitations (MIT).

package/lib/ast.d.ts

@@ -1,30 +1,31 @@
 import type { TSESTree } from "@typescript-eslint/types";
-export declare type AstroNode = AstroProgram | AstroRootFragment | AstroHTMLComment | AstroDoctype | AstroShorthandAttribute | AstroTemplateLiteralAttribute | AstroRawText | AstroFragment;
+export declare type AstroNode = AstroProgram | AstroFragment | AstroHTMLComment | AstroDoctype | AstroShorthandAttribute | AstroTemplateLiteralAttribute | AstroRawText;
+export declare type AstroChild = TSESTree.JSXFragment["children"][number] | AstroHTMLComment;
 /** Node of Astro program root */
 export interface AstroProgram extends Omit<TSESTree.Program, "type" | "body"> {
     type: "Program";
-    body: (TSESTree.Program["body"][number] | AstroRootFragment | AstroHTMLComment)[];
+    body: (TSESTree.Program["body"][number] | AstroFragment)[];
     sourceType: "script" | "module";
     comments: TSESTree.Comment[];
     tokens: TSESTree.Token[];
     parent: undefined;
 }
-/** Node of Astro fragment root */
-export interface AstroRootFragment extends Omit<TSESTree.BaseNode, "type" | "parent"> {
-    type: "AstroRootFragment";
-    children: TSESTree.JSXFragment["children"];
-    parent: AstroProgram;
+/** Node of Astro fragment */
+export interface AstroFragment extends Omit<TSESTree.BaseNode, "type" | "parent"> {
+    type: "AstroFragment";
+    children: AstroChild[];
+    parent: TSESTree.JSXFragment["parent"];
 }
 /** Node of Astro html comment */
 export interface AstroHTMLComment extends Omit<TSESTree.BaseNode, "type" | "parent"> {
     type: "AstroHTMLComment";
     value: string;
-    parent: AstroRootFragment | TSESTree.JSXElement | TSESTree.JSXFragment;
+    parent: AstroFragment | AstroFragment | TSESTree.JSXElement | TSESTree.JSXFragment;
 }
 /** Node of Astro doctype */
 export interface AstroDoctype extends Omit<TSESTree.BaseNode, "type" | "parent"> {
     type: "AstroDoctype";
-    parent: AstroRootFragment;
+    parent: AstroFragment | AstroFragment;
 }
 /** Node of Astro shorthand attribute */
 export interface AstroShorthandAttribute extends Omit<TSESTree.JSXAttribute, "type" | "parent"> {
@@ -43,11 +44,5 @@ export interface AstroTemplateLiteralAttribute extends Omit<TSESTree.JSXAttribut
 /** Node of Astro raw text */
 export interface AstroRawText extends Omit<TSESTree.JSXText, "type" | "parent"> {
     type: "AstroRawText";
-    parent: AstroRootFragment | TSESTree.JSXElement | TSESTree.JSXFragment;
-}
-/** Node of Astro fragment expression */
-export interface AstroFragment extends Omit<TSESTree.BaseNode, "type" | "parent"> {
-    type: "AstroFragment";
-    children: TSESTree.JSXFragment["children"];
-    parent: TSESTree.JSXFragment["parent"];
+    parent: AstroFragment | TSESTree.JSXElement | TSESTree.JSXFragment;
 }

package/lib/astro/index.d.ts

@@ -1,4 +1,4 @@
-import type { AttributeNode, CommentNode, ExpressionNode, Node, ParentNode, TagLikeNode } from "@astrojs/compiler/types";
+import type { AttributeNode, CommentNode, Node, ParentNode, TagLikeNode } from "@astrojs/compiler/types";
 import type { Context } from "../context";
 /**
  * Checks if the given node is TagLikeNode
@@ -15,45 +15,41 @@ export declare function walk(parent: ParentNode, code: string, enter: (n: Node |
 /**
  * Get end offset of start tag
  */
-export declare function getStartTagEndOffset(node: TagLikeNode, ctx: Context): number;
-/**
- * Get end offset of tag
- */
-export declare function getTagEndOffset(node: TagLikeNode, parents: ParentNode[], ctx: Context): number;
-/**
- * Get end offset of Expression
- */
-export declare function getExpressionEndOffset(node: ExpressionNode, parents: ParentNode[], ctx: Context): number;
+export declare function calcStartTagEndOffset(node: TagLikeNode, ctx: Context): number;
 /**
  * Get end offset of attribute
  */
-export declare function getAttributeEndOffset(node: AttributeNode, ctx: Context): number;
+export declare function calcAttributeEndOffset(node: AttributeNode, ctx: Context): number;
 /**
  * Get start offset of attribute value
  */
-export declare function getAttributeValueStartOffset(node: AttributeNode, ctx: Context): number;
+export declare function calcAttributeValueStartOffset(node: AttributeNode, ctx: Context): number;
 /**
- * Get end offset of comment
+ * Get end offset of tag
  */
-export declare function getCommentEndOffset(node: CommentNode, ctx: Context): number;
+export declare function getEndOffset(node: Node, ctx: Context): number;
 /**
  * Get content end offset
  */
-export declare function getContentEndOffset(parent: ParentNode, parents: ParentNode[], ctx: Context): number;
+export declare function calcContentEndOffset(parent: ParentNode, ctx: Context): number;
 /**
  * If the given tag is a self-close tag, get the self-closing tag.
  */
-export declare function getSelfClosingTag(node: TagLikeNode, parents: ParentNode[], ctx: Context): null | {
+export declare function getSelfClosingTag(node: TagLikeNode, ctx: Context): null | {
     offset: number;
     end: "/>" | ">";
 };
 /**
  * If the given tag has a end tag, get the end tag.
  */
-export declare function getEndTag(node: TagLikeNode, parents: ParentNode[], ctx: Context): null | {
+export declare function getEndTag(node: TagLikeNode, ctx: Context): null | {
     offset: number;
     tag: string;
 };
+/**
+ * Get end offset of comment
+ */
+export declare function calcCommentEndOffset(node: CommentNode, ctx: Context): number;
 /**
  * Skip spaces
  */

package/lib/astro/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.skipSpaces = exports.getEndTag = exports.getSelfClosingTag = exports.getContentEndOffset = exports.getCommentEndOffset = exports.getAttributeValueStartOffset = exports.getAttributeEndOffset = exports.getExpressionEndOffset = exports.getTagEndOffset = exports.getStartTagEndOffset = exports.walk = exports.walkElements = exports.isParent = exports.isTag = void 0;
+exports.skipSpaces = exports.calcCommentEndOffset = exports.getEndTag = exports.getSelfClosingTag = exports.calcContentEndOffset = exports.getEndOffset = exports.calcAttributeValueStartOffset = exports.calcAttributeEndOffset = exports.calcStartTagEndOffset = exports.walk = exports.walkElements = exports.isParent = exports.isTag = void 0;
 const errors_1 = require("../errors");
 /**
  * Checks if the given node is TagLikeNode
@@ -49,11 +49,11 @@ exports.walk = walk;
 /**
  * Get end offset of start tag
  */
-function getStartTagEndOffset(node, ctx) {
+function calcStartTagEndOffset(node, ctx) {
     const lastAttr = node.attributes[node.attributes.length - 1];
     let beforeCloseIndex;
     if (lastAttr) {
-        beforeCloseIndex = getAttributeEndOffset(lastAttr, ctx);
+        beforeCloseIndex = calcAttributeEndOffset(lastAttr, ctx);
     }
     else {
         const info = getTokenInfo(ctx, [`<${node.name}`], node.position.start.offset);
@@ -62,63 +62,20 @@ function getStartTagEndOffset(node, ctx) {
     const info = getTokenInfo(ctx, [[">", "/>"]], beforeCloseIndex);
     return info.index + info.match.length;
 }
-exports.getStartTagEndOffset = getStartTagEndOffset;
-/**
- * Get end offset of tag
- */
-function getTagEndOffset(node, parents, ctx) {
-    var _a;
-    if (((_a = node.position.end) === null || _a === void 0 ? void 0 : _a.offset) != null) {
-        return node.position.end.offset;
-    }
-    let beforeIndex;
-    if (node.children.length) {
-        const lastChild = node.children[node.children.length - 1];
-        beforeIndex = getEndOffset(lastChild, [node, ...parents], ctx);
-    }
-    else {
-        beforeIndex = getStartTagEndOffset(node, ctx);
-    }
-    beforeIndex = skipSpaces(ctx.code, beforeIndex);
-    if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
-        beforeIndex = beforeIndex + 2 + node.name.length;
-        const info = getTokenInfo(ctx, [">"], beforeIndex);
-        return info.index + info.match.length;
-    }
-    return beforeIndex;
-}
-exports.getTagEndOffset = getTagEndOffset;
-/**
- * Get end offset of Expression
- */
-function getExpressionEndOffset(node, parents, ctx) {
-    var _a;
-    if (((_a = node.position.end) === null || _a === void 0 ? void 0 : _a.offset) != null) {
-        return node.position.end.offset;
-    }
-    if (node.children.length) {
-        const lastChild = node.children[node.children.length - 1];
-        const beforeIndex = getEndOffset(lastChild, [node, ...parents], ctx);
-        const info = getTokenInfo(ctx, ["}"], beforeIndex);
-        return info.index + info.match.length;
-    }
-    const info = getTokenInfo(ctx, ["{", "}"], node.position.start.offset);
-    return info.index + info.match.length;
-}
-exports.getExpressionEndOffset = getExpressionEndOffset;
+exports.calcStartTagEndOffset = calcStartTagEndOffset;
 /**
  * Get end offset of attribute
  */
-function getAttributeEndOffset(node, ctx) {
+function calcAttributeEndOffset(node, ctx) {
     let info;
     if (node.kind === "empty") {
         info = getTokenInfo(ctx, [node.name], node.position.start.offset);
     }
     else if (node.kind === "quoted") {
-        info = getTokenInfo(ctx, [[`"${node.value}"`, `'${node.value}'`, node.value]], getAttributeValueStartOffset(node, ctx));
+        info = getTokenInfo(ctx, [[`"${node.value}"`, `'${node.value}'`, node.value]], calcAttributeValueStartOffset(node, ctx));
     }
     else if (node.kind === "expression") {
-        info = getTokenInfo(ctx, ["{", node.value, "}"], getAttributeValueStartOffset(node, ctx));
+        info = getTokenInfo(ctx, ["{", node.value, "}"], calcAttributeValueStartOffset(node, ctx));
     }
     else if (node.kind === "shorthand") {
         info = getTokenInfo(ctx, ["{", node.name, "}"], node.position.start.offset);
@@ -127,18 +84,18 @@ function getAttributeEndOffset(node, ctx) {
         info = getTokenInfo(ctx, ["{", "...", node.name, "}"], node.position.start.offset);
     }
     else if (node.kind === "template-literal") {
-        info = getTokenInfo(ctx, [`\`${node.value}\``], getAttributeValueStartOffset(node, ctx));
+        info = getTokenInfo(ctx, [`\`${node.value}\``], calcAttributeValueStartOffset(node, ctx));
     }
     else {
         throw new errors_1.ParseError(`Unknown attr kind: ${node.kind}`, node.position.start.offset, ctx);
     }
     return info.index + info.match.length;
 }
-exports.getAttributeEndOffset = getAttributeEndOffset;
+exports.calcAttributeEndOffset = calcAttributeEndOffset;
 /**
  * Get start offset of attribute value
  */
-function getAttributeValueStartOffset(node, ctx) {
+function calcAttributeValueStartOffset(node, ctx) {
     let info;
     if (node.kind === "quoted") {
         info = getTokenInfo(ctx, [node.name, "=", [`"`, `'`, node.value]], node.position.start.offset);
@@ -154,33 +111,58 @@ function getAttributeValueStartOffset(node, ctx) {
     }
     return info.index;
 }
-exports.getAttributeValueStartOffset = getAttributeValueStartOffset;
+exports.calcAttributeValueStartOffset = calcAttributeValueStartOffset;
 /**
- * Get end offset of comment
+ * Get end offset of tag
  */
-function getCommentEndOffset(node, ctx) {
-    const info = getTokenInfo(ctx, ["<!--", node.value, "-->"], node.position.start.offset);
-    return info.index + info.match.length;
+function getEndOffset(node, ctx) {
+    var _a;
+    if (((_a = node.position.end) === null || _a === void 0 ? void 0 : _a.offset) != null) {
+        return node.position.end.offset;
+    }
+    if (isTag(node))
+        return calcTagEndOffset(node, ctx);
+    if (node.type === "expression")
+        return calcExpressionEndOffset(node, ctx);
+    if (node.type === "comment")
+        return calcCommentEndOffset(node, ctx);
+    if (node.type === "frontmatter") {
+        const start = node.position.start.offset;
+        return ctx.code.indexOf("---", start + 3) + 3;
+    }
+    if (node.type === "doctype") {
+        const start = node.position.start.offset;
+        return ctx.code.indexOf(">", start) + 1;
+    }
+    if (node.type === "text") {
+        const start = node.position.start.offset;
+        return start + node.value.length;
+    }
+    if (node.type === "root") {
+        return ctx.code.length;
+    }
+    throw new Error(`unknown type: ${node.type}`);
 }
-exports.getCommentEndOffset = getCommentEndOffset;
+exports.getEndOffset = getEndOffset;
 /**
  * Get content end offset
  */
-function getContentEndOffset(parent, parents, ctx) {
+function calcContentEndOffset(parent, ctx) {
     const code = ctx.code;
     if (isTag(parent)) {
-        const end = getTagEndOffset(parent, parents, ctx);
+        const end = getEndOffset(parent, ctx);
         if (code[end - 1] !== ">") {
             return end;
         }
-        const index = code.lastIndexOf("</", end);
-        if (index >= 0 && code.slice(index, end).trim() === parent.name) {
+        const index = code.lastIndexOf("</", end - 1);
+        if (index >= 0 &&
+            code.slice(index + 2, end - 1).trim() === parent.name) {
             return index;
         }
         return end;
     }
     else if (parent.type === "expression") {
-        const end = getExpressionEndOffset(parent, parents, ctx);
+        const end = getEndOffset(parent, ctx);
         return code.lastIndexOf("}", end);
     }
     else if (parent.type === "root") {
@@ -188,49 +170,42 @@ function getContentEndOffset(parent, parents, ctx) {
     }
     throw new Error(`unknown type: ${parent.type}`);
 }
-exports.getContentEndOffset = getContentEndOffset;
+exports.calcContentEndOffset = calcContentEndOffset;
 /**
  * If the given tag is a self-close tag, get the self-closing tag.
  */
-function getSelfClosingTag(node, parents, ctx) {
-    const children = node.children.filter((c) => c.type !== "text" || c.value.trim());
-    if (children.length > 0) {
+function getSelfClosingTag(node, ctx) {
+    if (node.children.length > 0) {
         return null;
     }
-    const parent = parents[0];
     const code = ctx.code;
-    let nextElementIndex = code.length;
-    const childIndex = parent.children.indexOf(node);
-    if (childIndex === parent.children.length - 1) {
-        // last
-        nextElementIndex = getContentEndOffset(parent, parents.slice(1), ctx);
-    }
-    else {
-        const next = parent.children[childIndex + 1];
-        nextElementIndex = next.position.start.offset;
+    const startTagEndOffset = calcStartTagEndOffset(node, ctx);
+    if (code.startsWith("/>", startTagEndOffset - 2)) {
+        return {
+            offset: startTagEndOffset,
+            end: "/>",
+        };
     }
-    const endOffset = getStartTagEndOffset(node, ctx);
-    if (code.slice(endOffset, nextElementIndex).trim()) {
-        // has end tag
+    if (code.startsWith(`</${node.name}`, startTagEndOffset)) {
         return null;
     }
     return {
-        offset: endOffset,
-        end: code.slice(endOffset - 2, endOffset) === "/>" ? "/>" : ">",
+        offset: startTagEndOffset,
+        end: ">",
     };
 }
 exports.getSelfClosingTag = getSelfClosingTag;
 /**
  * If the given tag has a end tag, get the end tag.
  */
-function getEndTag(node, parents, ctx) {
+function getEndTag(node, ctx) {
     let beforeIndex;
     if (node.children.length) {
         const lastChild = node.children[node.children.length - 1];
-        beforeIndex = getEndOffset(lastChild, [node, ...parents], ctx);
+        beforeIndex = getEndOffset(lastChild, ctx);
     }
     else {
-        beforeIndex = getStartTagEndOffset(node, ctx);
+        beforeIndex = calcStartTagEndOffset(node, ctx);
     }
     beforeIndex = skipSpaces(ctx.code, beforeIndex);
     if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
@@ -246,36 +221,46 @@ function getEndTag(node, parents, ctx) {
     return null;
 }
 exports.getEndTag = getEndTag;
+/**
+ * Get end offset of comment
+ */
+function calcCommentEndOffset(node, ctx) {
+    const info = getTokenInfo(ctx, ["<!--", node.value, "-->"], node.position.start.offset);
+    return info.index + info.match.length;
+}
+exports.calcCommentEndOffset = calcCommentEndOffset;
 /**
  * Get end offset of tag
  */
-function getEndOffset(node, parents, ctx) {
-    var _a;
-    if (((_a = node.position.end) === null || _a === void 0 ? void 0 : _a.offset) != null) {
-        return node.position.end.offset;
-    }
-    if (isTag(node))
-        return getTagEndOffset(node, parents, ctx);
-    if (node.type === "expression")
-        return getExpressionEndOffset(node, parents, ctx);
-    if (node.type === "comment")
-        return getCommentEndOffset(node, ctx);
-    if (node.type === "frontmatter") {
-        const start = node.position.start.offset;
-        return ctx.code.indexOf("---", start + 3) + 3;
+function calcTagEndOffset(node, ctx) {
+    let beforeIndex;
+    if (node.children.length) {
+        const lastChild = node.children[node.children.length - 1];
+        beforeIndex = getEndOffset(lastChild, ctx);
     }
-    if (node.type === "doctype") {
-        const start = node.position.start.offset;
-        return ctx.code.indexOf(">", start) + 1;
+    else {
+        beforeIndex = calcStartTagEndOffset(node, ctx);
     }
-    if (node.type === "text") {
-        const start = node.position.start.offset;
-        return start + node.value.length;
+    beforeIndex = skipSpaces(ctx.code, beforeIndex);
+    if (ctx.code.startsWith(`</${node.name}`, beforeIndex)) {
+        beforeIndex = beforeIndex + 2 + node.name.length;
+        const info = getTokenInfo(ctx, [">"], beforeIndex);
+        return info.index + info.match.length;
     }
-    if (node.type === "root") {
-        return ctx.code.length;
+    return beforeIndex;
+}
+/**
+ * Get end offset of Expression
+ */
+function calcExpressionEndOffset(node, ctx) {
+    if (node.children.length) {
+        const lastChild = node.children[node.children.length - 1];
+        const beforeIndex = getEndOffset(lastChild, ctx);
+        const info = getTokenInfo(ctx, ["}"], beforeIndex);
+        return info.index + info.match.length;
     }
-    throw new Error(`unknown type: ${node.type}`);
+    const info = getTokenInfo(ctx, ["{", "}"], node.position.start.offset);
+    return info.index + info.match.length;
 }
 /**
  * Get token info

package/lib/context/script.d.ts

@@ -1,6 +1,12 @@
 import type { Context } from ".";
 import type { ESLintExtendedProgram } from "../parser";
 import type { TSESTree } from "@typescript-eslint/types";
+declare class RestoreNodeProcessContext {
+    readonly result: ESLintExtendedProgram;
+    readonly removeTokens: Set<(token: TSESTree.Token) => boolean>;
+    constructor(result: ESLintExtendedProgram);
+    addRemoveToken(test: (token: TSESTree.Token) => boolean): void;
+}
 export declare class ScriptContext {
     private readonly ctx;
     script: string;
@@ -14,7 +20,7 @@ export declare class ScriptContext {
     appendOriginal(index: number): void;
     appendScript(fragment: string): void;
     addToken(type: TSESTree.Token["type"], range: TSESTree.Range): void;
-    addRestoreNodeProcess(process: (node: TSESTree.Node, result: ESLintExtendedProgram, parent: TSESTree.Node) => boolean): void;
+    addRestoreNodeProcess(process: (node: TSESTree.Node, context: RestoreNodeProcessContext, parent: TSESTree.Node) => boolean): void;
     /**
      * Restore AST nodes
      */
@@ -22,3 +28,4 @@ export declare class ScriptContext {
     private remapLocation;
     private getRemapRange;
 }
+export {};

package/lib/context/script.js

@@ -2,7 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScriptContext = void 0;
 const traverse_1 = require("../traverse");
-const errors_1 = require("../errors");
+class RestoreNodeProcessContext {
+    constructor(result) {
+        this.removeTokens = new Set();
+        this.result = result;
+    }
+    addRemoveToken(test) {
+        this.removeTokens.add(test);
+    }
+}
 class ScriptContext {
     constructor(ctx) {
         this.script = "";
@@ -17,6 +25,9 @@ class ScriptContext {
         this.consumedIndex += offset;
     }
     appendOriginal(index) {
+        if (this.consumedIndex >= index) {
+            return;
+        }
         this.offsets.push({
             original: this.consumedIndex,
             script: this.script.length,
@@ -39,18 +50,7 @@ class ScriptContext {
      * Restore AST nodes
      */
     restore(result) {
-        const last = result.ast.body[result.ast.body.length - 1];
-        if (last.type !== "ExpressionStatement") {
-            throw new errors_1.ParseError("Unknown state error: Expected ExpressionStatement", last.range[0], this.ctx);
-        }
-        if (last.expression.type !== "JSXFragment") {
-            throw new errors_1.ParseError("Unknown state error: Expected JSXFragment", last.expression.range[0], this.ctx);
-        }
-        // Process for Astro
-        const rootFragment = (result.ast.body[result.ast.body.length - 1] = last.expression);
-        delete rootFragment.closingFragment;
-        delete rootFragment.openingFragment;
-        rootFragment.type = "AstroRootFragment";
+        var _a, _b;
         // remap locations
         const traversed = new Map();
         (0, traverse_1.traverseNodes)(result.ast, {
@@ -77,17 +77,39 @@ class ScriptContext {
         for (const token of result.ast.comments || []) {
             this.remapLocation(token);
         }
+        const context = new RestoreNodeProcessContext(result);
         let restoreNodeProcesses = this.restoreNodeProcesses;
         for (const [node, parent] of traversed) {
             if (!parent)
                 continue;
-            restoreNodeProcesses = restoreNodeProcesses.filter((proc) => !proc(node, result, parent));
+            restoreNodeProcesses = restoreNodeProcesses.filter((proc) => !proc(node, context, parent));
+        }
+        if (context.removeTokens.size) {
+            const tokens = result.ast.tokens || [];
+            for (let index = tokens.length - 1; index >= 0; index--) {
+                const token = tokens[index];
+                for (const rt of context.removeTokens) {
+                    if (rt(token)) {
+                        tokens.splice(index, 1);
+                        context.removeTokens.delete(rt);
+                        if (!context.removeTokens.size) {
+                            break;
+                        }
+                    }
+                }
+            }
         }
         // Adjust program node location
-        const first = result.ast.body[0];
-        if (first.range[0] < result.ast.range[0]) {
-            result.ast.range[0] = first.range[0];
-            result.ast.loc.start = this.ctx.getLocFromIndex(result.ast.range[0]);
+        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],
+        ]
+            .filter(Boolean)
+            .map((t) => t.range[0]));
+        if (firstOffset < result.ast.range[0]) {
+            result.ast.range[0] = firstOffset;
+            result.ast.loc.start = this.ctx.getLocFromIndex(firstOffset);
         }
     }
     remapLocation(node) {
@@ -116,6 +138,9 @@ class ScriptContext {
         }
     }
     getRemapRange(start, end) {
+        if (!this.offsets.length) {
+            return [start, end];
+        }
         let lastStart = this.offsets[0];
         let lastEnd = this.offsets[0];
         for (const offset of this.offsets) {

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

@@ -32,6 +32,10 @@ const errors_1 = require("../../errors");
  */
 function parse(code, ctx) {
     const ast = parseByService(code, ctx).ast;
+    if (!ast.children) {
+        // If the source code is empty, the children property may not be available.
+        ast.children = [];
+    }
     const htmlElement = ast.children.find((n) => n.type === "element" && n.name === "html");
     if (htmlElement) {
         adjustHTML(ast, htmlElement, ctx);
@@ -140,16 +144,22 @@ function fixLocations(node, ctx) {
             start += 1;
             start += node.name.length;
             if (!node.attributes.length) {
-                start = (0, astro_1.getStartTagEndOffset)(node, ctx);
+                start = (0, astro_1.calcStartTagEndOffset)(node, ctx);
             }
         }
         else if (node.type === "attribute") {
             fixLocationForAttr(node, ctx, start);
-            start = (0, astro_1.getAttributeEndOffset)(node, ctx);
+            start = (0, astro_1.calcAttributeEndOffset)(node, ctx);
+            if (node.position.end) {
+                node.position.end.offset = start;
+            }
         }
         else if (node.type === "comment") {
             node.position.start.offset = tokenIndex(ctx, "<!--", start);
-            start = (0, astro_1.getCommentEndOffset)(node, ctx);
+            start = (0, astro_1.calcCommentEndOffset)(node, ctx);
+            if (node.position.end) {
+                node.position.end.offset = start;
+            }
         }
         else if (node.type === "text") {
             if (parent.type === "element" &&
@@ -193,6 +203,9 @@ function fixLocations(node, ctx) {
                     node.value = ctx.code.slice(node.position.start.offset, start);
                 }
             }
+            if (node.position.end) {
+                node.position.end.offset = start;
+            }
         }
         else if (node.type === "expression") {
             start = node.position.start.offset = tokenIndex(ctx, "{", start);
@@ -217,21 +230,22 @@ function fixLocations(node, ctx) {
         if (node.type === "attribute") {
             const attributes = parent.attributes;
             if (attributes[attributes.length - 1] === node) {
-                start = (0, astro_1.getStartTagEndOffset)(parent, ctx);
+                start = (0, astro_1.calcStartTagEndOffset)(parent, ctx);
             }
-            return;
         }
-        if (node.type === "expression") {
+        else if (node.type === "expression") {
             start = tokenIndex(ctx, "}", start) + 1;
         }
         else if (node.type === "fragment" ||
             node.type === "element" ||
             node.type === "component" ||
             node.type === "custom-element") {
-            const closeTagStart = tokenIndexSafe(ctx.code, `</${node.name}`, start);
-            if (closeTagStart != null) {
-                start = closeTagStart + 2 + node.name.length;
-                start = tokenIndex(ctx, ">", start) + 1;
+            if (!(0, astro_1.getSelfClosingTag)(node, ctx)) {
+                const closeTagStart = tokenIndexSafe(ctx.code, `</${node.name}`, start);
+                if (closeTagStart != null) {
+                    start = closeTagStart + 2 + node.name.length;
+                    start = tokenIndex(ctx, ">", start) + 1;
+                }
             }
         }
         else {

package/lib/parser/process-template.js

@@ -11,30 +11,47 @@ function processTemplate(ctx, resultTemplate) {
     let uniqueIdSeq = 0;
     const usedUniqueIds = new Set();
     const script = new script_1.ScriptContext(ctx);
-    const frontmatter = resultTemplate.ast.children.find((n) => n.type === "frontmatter");
     let fragmentOpened = false;
-    if (!frontmatter) {
+    /** Open astro root fragment */
+    function openRootFragment(startOffset) {
         script.appendScript("<>");
         fragmentOpened = true;
+        script.addRestoreNodeProcess((scriptNode, { result }) => {
+            if (scriptNode.type === types_1.AST_NODE_TYPES.ExpressionStatement &&
+                scriptNode.expression.type === types_1.AST_NODE_TYPES.JSXFragment &&
+                scriptNode.range[0] === startOffset &&
+                result.ast.body.includes(scriptNode)) {
+                const index = result.ast.body.indexOf(scriptNode);
+                const rootFragment = (result.ast.body[index] =
+                    scriptNode.expression);
+                delete rootFragment.closingFragment;
+                delete rootFragment.openingFragment;
+                rootFragment.type = "AstroFragment";
+                return true;
+            }
+            return false;
+        });
     }
     (0, astro_1.walkElements)(resultTemplate.ast, ctx.code, 
     // eslint-disable-next-line complexity -- X(
-    (node, parents) => {
+    (node, [parent]) => {
         if (node.type === "frontmatter") {
             const start = node.position.start.offset;
+            if (fragmentOpened) {
+                script.appendScript("</>;");
+                fragmentOpened = false;
+            }
             script.appendOriginal(start);
             script.skipOriginalOffset(3);
-            const end = node.position.end.offset;
+            const end = (0, astro_1.getEndOffset)(node, ctx);
             script.appendOriginal(end - 3);
-            script.appendScript(";<>");
-            fragmentOpened = true;
+            script.appendScript(";");
             script.skipOriginalOffset(3);
-            script.addRestoreNodeProcess((_scriptNode, result) => {
+            script.addRestoreNodeProcess((_scriptNode, { result }) => {
                 for (let index = 0; index < result.ast.body.length; index++) {
                     const st = result.ast.body[index];
                     if (st.type === types_1.AST_NODE_TYPES.EmptyStatement) {
-                        if (st.range[0] === end - 3 &&
-                            st.range[1] === end) {
+                        if (st.range[0] === end - 3 && st.range[1] <= end) {
                             result.ast.body.splice(index, 1);
                             break;
                         }
@@ -50,7 +67,6 @@ function processTemplate(ctx, resultTemplate) {
         }
         else if ((0, astro_1.isTag)(node)) {
             // Process for multiple tag
-            const parent = parents[0];
             if (parent.type === "expression") {
                 const index = parent.children.indexOf(node);
                 const before = parent.children[index - 1];
@@ -82,6 +98,11 @@ function processTemplate(ctx, resultTemplate) {
                     }
                 }
             }
+            const start = node.position.start.offset;
+            script.appendOriginal(start);
+            if (!fragmentOpened) {
+                openRootFragment(start);
+            }
             // Process for attributes
             for (const attr of node.attributes) {
                 if ((node.type === "component" ||
@@ -108,7 +129,7 @@ function processTemplate(ctx, resultTemplate) {
                             start + colonIndex + 1,
                             start + attr.name.length,
                         ]);
-                        script.addRestoreNodeProcess((scriptNode, result) => {
+                        script.addRestoreNodeProcess((scriptNode, context) => {
                             if (scriptNode.type ===
                                 types_1.AST_NODE_TYPES.JSXAttribute &&
                                 scriptNode.range[0] === start) {
@@ -120,17 +141,10 @@ function processTemplate(ctx, resultTemplate) {
                                 scriptNode.name = nsn;
                                 nsn.namespace.parent = nsn;
                                 nsn.name.parent = nsn;
-                                const tokens = result.ast.tokens || [];
-                                for (let index = 0; index < tokens.length; index++) {
-                                    const token = tokens[index];
-                                    if (token.range[0] ===
-                                        baseNameNode.range[0] &&
-                                        token.range[1] ===
-                                            baseNameNode.range[1]) {
-                                        tokens.splice(index, 1);
-                                        break;
-                                    }
-                                }
+                                context.addRemoveToken((token) => token.range[0] ===
+                                    baseNameNode.range[0] &&
+                                    token.range[1] ===
+                                        baseNameNode.range[1]);
                                 return true;
                             }
                             return false;
@@ -163,8 +177,8 @@ function processTemplate(ctx, resultTemplate) {
                 }
                 else if (attr.kind === "template-literal") {
                     const attrStart = attr.position.start.offset;
-                    const start = (0, astro_1.getAttributeValueStartOffset)(attr, ctx);
-                    const end = (0, astro_1.getAttributeEndOffset)(attr, ctx);
+                    const start = (0, astro_1.calcAttributeValueStartOffset)(attr, ctx);
+                    const end = (0, astro_1.calcAttributeEndOffset)(attr, ctx);
                     script.appendOriginal(start);
                     script.appendScript("{");
                     script.appendOriginal(end);
@@ -182,7 +196,7 @@ function processTemplate(ctx, resultTemplate) {
                 }
             }
             // Process for start tag close
-            const closing = (0, astro_1.getSelfClosingTag)(node, parents, ctx);
+            const closing = (0, astro_1.getSelfClosingTag)(node, ctx);
             if (closing && closing.end === ">") {
                 script.appendOriginal(closing.offset - 1);
                 script.appendScript("/");
@@ -215,23 +229,19 @@ function processTemplate(ctx, resultTemplate) {
         }
         else if (node.type === "comment") {
             const start = node.position.start.offset;
-            const length = 4 + node.value.length + 3;
+            const end = (0, astro_1.getEndOffset)(node, ctx);
+            const length = end - start;
             script.appendOriginal(start);
-            let targetType;
-            if (fragmentOpened) {
-                script.appendOriginal(start + 1);
-                script.appendScript(`></`);
-                script.skipOriginalOffset(length - 2);
-                targetType = types_1.AST_NODE_TYPES.JSXFragment;
+            if (!fragmentOpened) {
+                openRootFragment(start);
             }
-            else {
-                script.appendScript(`0;`);
-                targetType = types_1.AST_NODE_TYPES.ExpressionStatement;
-                script.skipOriginalOffset(length);
-            }
-            script.addRestoreNodeProcess((scriptNode, result) => {
+            script.appendOriginal(start + 1);
+            script.appendScript(`></`);
+            script.skipOriginalOffset(length - 2);
+            script.appendOriginal(end);
+            script.addRestoreNodeProcess((scriptNode, context) => {
                 if (scriptNode.range[0] === start &&
-                    scriptNode.type === targetType) {
+                    scriptNode.type === types_1.AST_NODE_TYPES.JSXFragment) {
                     delete scriptNode.children;
                     delete scriptNode.openingFragment;
                     delete scriptNode.closingFragment;
@@ -239,27 +249,10 @@ function processTemplate(ctx, resultTemplate) {
                     const commentNode = scriptNode;
                     commentNode.type = "AstroHTMLComment";
                     commentNode.value = node.value;
-                    if (fragmentOpened) {
-                        const removeTokenSet = new Set([
-                            (token) => token.value === "<" &&
-                                token.range[0] === scriptNode.range[0],
-                            (token) => token.value === ">" &&
-                                token.range[1] === scriptNode.range[1],
-                        ]);
-                        const tokens = result.ast.tokens || [];
-                        for (let index = tokens.length - 1; index >= 0; index--) {
-                            const token = tokens[index];
-                            for (const rt of removeTokenSet) {
-                                if (rt(token)) {
-                                    tokens.splice(index, 1);
-                                    removeTokenSet.delete(rt);
-                                    if (!removeTokenSet.size) {
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
+                    context.addRemoveToken((token) => token.value === "<" &&
+                        token.range[0] === scriptNode.range[0]);
+                    context.addRemoveToken((token) => token.value === ">" &&
+                        token.range[1] === scriptNode.range[1]);
                     return true;
                 }
                 return false;
@@ -271,40 +264,49 @@ function processTemplate(ctx, resultTemplate) {
         }
         else if (node.type === "doctype") {
             const start = node.position.start.offset;
-            const end = node.position.end.offset;
+            const end = (0, astro_1.getEndOffset)(node, ctx);
+            const length = end - start;
             script.appendOriginal(start);
-            let targetType;
-            if (fragmentOpened) {
-                script.appendScript(`<></>`);
-                targetType = types_1.AST_NODE_TYPES.JSXFragment;
-            }
-            else {
-                script.appendScript(`0;`);
-                targetType = types_1.AST_NODE_TYPES.ExpressionStatement;
+            if (!fragmentOpened) {
+                openRootFragment(start);
             }
-            script.skipOriginalOffset(end - start);
-            script.addRestoreNodeProcess((scriptNode) => {
+            script.appendOriginal(start + 1);
+            script.appendScript(`></`);
+            script.skipOriginalOffset(length - 2);
+            script.appendOriginal(end);
+            script.addRestoreNodeProcess((scriptNode, context) => {
                 if (scriptNode.range[0] === start &&
-                    scriptNode.type === targetType) {
+                    scriptNode.type === types_1.AST_NODE_TYPES.JSXFragment) {
                     delete scriptNode.children;
                     delete scriptNode.openingFragment;
                     delete scriptNode.closingFragment;
                     delete scriptNode.expression;
                     const doctypeNode = scriptNode;
                     doctypeNode.type = "AstroDoctype";
+                    context.addRemoveToken((token) => token.value === "<" &&
+                        token.range[0] === scriptNode.range[0]);
+                    context.addRemoveToken((token) => token.value === ">" &&
+                        token.range[1] === scriptNode.range[1]);
                     return true;
                 }
                 return false;
             });
             script.addToken("HTMLDocType", [start, end]);
         }
-    }, (node, parents) => {
+        else {
+            const start = node.position.start.offset;
+            script.appendOriginal(start);
+            if (!fragmentOpened) {
+                openRootFragment(start);
+            }
+        }
+    }, (node, [parent]) => {
         if ((0, astro_1.isTag)(node)) {
-            const closing = (0, astro_1.getSelfClosingTag)(node, parents, ctx);
+            const closing = (0, astro_1.getSelfClosingTag)(node, ctx);
             if (!closing) {
-                const end = (0, astro_1.getEndTag)(node, parents, ctx);
+                const end = (0, astro_1.getEndTag)(node, ctx);
                 if (!end) {
-                    const offset = (0, astro_1.getContentEndOffset)(node, parents, ctx);
+                    const offset = (0, astro_1.calcContentEndOffset)(node, ctx);
                     script.appendOriginal(offset);
                     script.appendScript(`</${node.name}>`);
                     script.addRestoreNodeProcess((scriptNode, _result, parent) => {
@@ -321,7 +323,6 @@ function processTemplate(ctx, resultTemplate) {
             }
         }
         // Process for multiple tag
-        const parent = parents[0];
         if (((0, astro_1.isTag)(node) || node.type === "comment") &&
             parent.type === "expression") {
             const index = parent.children.indexOf(node);
@@ -330,17 +331,20 @@ function processTemplate(ctx, resultTemplate) {
                 const before = parent.children[index - 1];
                 if (before &&
                     ((0, astro_1.isTag)(before) || before.type === "comment")) {
-                    const end = (0, astro_1.isTag)(node)
-                        ? (0, astro_1.getTagEndOffset)(node, parents, ctx)
-                        : (0, astro_1.getCommentEndOffset)(node, ctx);
+                    const end = (0, astro_1.getEndOffset)(node, ctx);
                     script.appendOriginal(end);
                     script.appendScript("</>");
                 }
             }
         }
     });
+    if (fragmentOpened) {
+        const last = resultTemplate.ast.children[resultTemplate.ast.children.length - 1];
+        const end = (0, astro_1.getEndOffset)(last, ctx);
+        script.appendOriginal(end);
+        script.appendScript("</>");
+    }
     script.appendOriginal(ctx.code.length);
-    script.appendScript("</>");
     return script;
     /**
      * Generate unique id

package/lib/parser/script.js

@@ -30,7 +30,9 @@ function parseScript(code, ctx) {
         return { ast: result };
     }
     catch (e) {
-        (0, debug_1.debug)("[script] parsing error:", e.message, `@ ${JSON.stringify(code)}`);
+        (0, debug_1.debug)("[script] parsing error:", e.message, `@ ${JSON.stringify(code)}
+
+${code}`);
         throw e;
     }
     finally {

package/lib/visitor-keys.js

@@ -4,12 +4,11 @@ exports.KEYS = void 0;
 const eslint_visitor_keys_1 = require("eslint-visitor-keys");
 const astroKeys = {
     Program: ["body"],
-    AstroRootFragment: ["children"],
+    AstroFragment: ["children"],
     AstroHTMLComment: [],
     AstroDoctype: [],
     AstroShorthandAttribute: ["name", "value"],
     AstroTemplateLiteralAttribute: ["name", "value"],
     AstroRawText: [],
-    AstroFragment: ["children"],
 };
 exports.KEYS = (0, eslint_visitor_keys_1.unionWith)(astroKeys);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "astro-eslint-parser",
-    "version": "0.0.14",
-    "description": "Astro parser for ESLint",
+    "version": "0.0.17",
+    "description": "Astro component parser for ESLint",
     "main": "lib/index.js",
     "files": [
         "lib"
@@ -19,7 +19,7 @@
         "cover": "nyc --reporter=lcov npm run test",
         "debug": "mocha --require ts-node/register/transpile-only \"tests/src/**/*.ts\" --reporter dot --timeout 60000",
         "preversion": "npm run lint && npm test",
-        "update-fixtures": "ts-node --transpile-only ./tools/update-fixtures.ts",
+        "update-fixtures": "DEBUG='astro-eslint-parser' ts-node --transpile-only ./tools/update-fixtures.ts",
         "debug-parser": "ts-node --transpile-only ./tools/parser-test.ts",
         "eslint-playground": "eslint tests/fixtures --ext .astro --config .eslintrc-for-playground.js --format codeframe",
         "benchmark": "ts-node --transpile-only benchmark/index.ts"
@@ -60,6 +60,7 @@
         "@types/semver": "^7.3.9",
         "@typescript-eslint/eslint-plugin": "^5.4.0",
         "@typescript-eslint/parser": "^5.4.0",
+        "astro-eslint-parser": ">=0.0.15",
         "benchmark": "^2.1.4",
         "chai": "^4.3.4",
         "code-red": "^0.2.3",
@@ -87,6 +88,6 @@
         "string-replace-loader": "^3.0.3",
         "ts-node": "^10.4.0",
         "typescript": "~4.6.0",
-        "vue-eslint-parser": "^8.0.1"
+        "vue-eslint-parser": "^9.0.0"
     }
 }