astro-eslint-parser 0.2.2 → 0.4.0

package/README.md

@@ -17,7 +17,7 @@ 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).
+At least it works fine with a [withastro/docs](https://github.com/withastro/docs) repository.
 
 [@astrojs/compiler]: https://github.com/withastro/compiler
 
@@ -41,7 +41,10 @@ npm install --save-dev eslint astro-eslint-parser
 
 ## 📖 Usage
 
-1. Write `overrides.parser` option into your `.eslintrc.*` file.
+**First, we recommend using [eslint-plugin-astro] rather than just the parser.**  
+The following usage it are for introducing only the parser. This is not useful for most people. It can be useful if you create your own plugin.
+
+1. Write `overrides[*].parser` option into your `.eslintrc.*` file.
 
     ```json
     {
@@ -126,6 +129,48 @@ module.exports = {
 }
 ```
 
+### parserOptions.astroFeatures
+
+You can use `parserOptions.astroFeatures` property to specify how to parse related to Astro component features. For example:
+
+```json
+{
+    "parser": "astro-eslint-parser",
+    "parserOptions": {
+        "astroFeatures": {
+            "syntax": "auto",
+        }
+    }
+}
+```
+
+### parserOptions.vueFeatures.syntax
+
+You can use `parserOptions.vueFeatures.syntax` property to choose whether to parse as Astro Component (`*.astro`) or Astro Markdown Page (`*.md`).  
+If `"astro"` is specified, it will be parsed as `*.astro`. If `"markdown"` is specified, it will be parsed as `*.md`. If `"auto"` is specified, it will be automatically selected from the file extensions.  
+For example:
+
+```json
+{
+    "parser": "astro-eslint-parser",
+    "parserOptions": {
+        "astroFeatures": {
+            "syntax": "auto", // or "astro", or "markdown"
+        }
+    }
+}
+```
+
+#### Known Limitations on Markdown Pages
+
+There are some known limitations when parsing Markdown Pages for ESLint integration.
+
+- Incompatible with ESLint's [indent] rule. Turn off the [indent] rule in the markdown file. Otherwise the file syntax will be broken.
+- Incompatible with [eslint-plugin-markdown]. eslint-plugin-markdown separates the contents of markdown by the processor. So using this parser doesn't work because the parser doesn't know the whole markdown.
+
+[indent]: https://eslint.org/docs/rules/indent
+[eslint-plugin-markdown]: https://github.com/eslint/eslint-plugin-markdown
+
 ## :computer: Editor Integrations
 
 ### Visual Studio Code

package/lib/context/script.d.ts

@@ -4,8 +4,10 @@ import type { ESLintExtendedProgram } from "../types";
 declare class RestoreNodeProcessContext {
     readonly result: ESLintExtendedProgram;
     readonly removeTokens: Set<(token: TSESTree.Token) => boolean>;
-    constructor(result: ESLintExtendedProgram);
+    private readonly parentMap;
+    constructor(result: ESLintExtendedProgram, parentMap: Map<TSESTree.Node, TSESTree.Node | null>);
     addRemoveToken(test: (token: TSESTree.Token) => boolean): void;
+    getParent(node: TSESTree.Node): TSESTree.Node | null;
 }
 export declare class ScriptContext {
     private readonly ctx;
@@ -16,11 +18,12 @@ export declare class ScriptContext {
     private readonly tokens;
     private readonly restoreNodeProcesses;
     constructor(ctx: Context);
+    get originalCode(): string;
     skipOriginalOffset(offset: number): void;
     appendOriginal(index: number): void;
     appendScript(fragment: string): void;
     addToken(type: TSESTree.Token["type"], range: TSESTree.Range): void;
-    addRestoreNodeProcess(process: (node: TSESTree.Node, context: RestoreNodeProcessContext, parent: TSESTree.Node) => boolean): void;
+    addRestoreNodeProcess(process: (node: TSESTree.Node, context: RestoreNodeProcessContext) => boolean): void;
     /**
      * Restore AST nodes
      */

package/lib/context/script.js

@@ -3,13 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScriptContext = void 0;
 const traverse_1 = require("../traverse");
 class RestoreNodeProcessContext {
-    constructor(result) {
+    constructor(result, parentMap) {
         this.removeTokens = new Set();
         this.result = result;
+        this.parentMap = parentMap;
     }
     addRemoveToken(test) {
         this.removeTokens.add(test);
     }
+    getParent(node) {
+        return this.parentMap.get(node) || null;
+    }
 }
 class ScriptContext {
     constructor(ctx) {
@@ -21,6 +25,9 @@ class ScriptContext {
         this.restoreNodeProcesses = [];
         this.ctx = ctx;
     }
+    get originalCode() {
+        return this.ctx.code;
+    }
     skipOriginalOffset(offset) {
         this.consumedIndex += offset;
     }
@@ -41,6 +48,9 @@ class ScriptContext {
         this.fragments.push({ start, end: this.script.length });
     }
     addToken(type, range) {
+        if (range[0] >= range[1]) {
+            return;
+        }
         this.tokens.push(this.ctx.buildToken(type, range));
     }
     addRestoreNodeProcess(process) {
@@ -76,12 +86,12 @@ class ScriptContext {
         for (const token of result.ast.comments || []) {
             this.remapLocation(token);
         }
-        const context = new RestoreNodeProcessContext(result);
+        const context = new RestoreNodeProcessContext(result, traversed);
         let restoreNodeProcesses = this.restoreNodeProcesses;
         for (const [node, parent] of traversed) {
             if (!parent)
                 continue;
-            restoreNodeProcesses = restoreNodeProcesses.filter((proc) => !proc(node, context, parent));
+            restoreNodeProcesses = restoreNodeProcesses.filter((proc) => !proc(node, context));
         }
         if (context.removeTokens.size) {
             const tokens = result.ast.tokens || [];

package/lib/index.d.ts

@@ -1,9 +1,13 @@
-import { parseForESLint } from "./parser";
+import { parseForESLint as parseAstro } from "./parser";
+import { parseForESLint as parseMarkdown } from "./markdown";
 import { parseTemplate, ParseTemplateResult } from "./astro-tools";
 import * as AST from "./ast";
 import { traverseNodes } from "./traverse";
 import { ParseError } from "./errors";
 export { AST, ParseError };
-export { parseForESLint };
+/**
+ * Parse source code
+ */
+export declare function parseForESLint(code: string, options?: any): ReturnType<typeof parseAstro | typeof parseMarkdown>;
 export declare const VisitorKeys: import("eslint").SourceCode.VisitorKeys;
 export { traverseNodes, parseTemplate, ParseTemplateResult };

package/lib/index.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 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 markdown_1 = require("./markdown");
 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"));
@@ -35,6 +35,18 @@ Object.defineProperty(exports, "traverseNodes", { enumerable: true, get: functio
 const visitor_keys_1 = require("./visitor-keys");
 const errors_1 = require("./errors");
 Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
+/**
+ * Parse source code
+ */
+function parseForESLint(code, options) {
+    const syntax = options?.astroFeatures?.syntax ?? "auto";
+    if (syntax === "markdown" ||
+        (syntax === "auto" && options?.filePath?.endsWith(".md"))) {
+        return (0, markdown_1.parseForESLint)(code, options);
+    }
+    return (0, parser_1.parseForESLint)(code, options);
+}
+exports.parseForESLint = parseForESLint;
 // Keys
 // eslint-disable-next-line @typescript-eslint/naming-convention -- ignore
 exports.VisitorKeys = visitor_keys_1.KEYS;

package/lib/markdown/frontmatter.d.ts

@@ -0,0 +1,9 @@
+export declare type MarkdownContent = {
+    range: [number, number];
+    value: string;
+};
+/** Parse frontmatter */
+export declare function parseFrontmatter(code: string): {
+    frontmatter: MarkdownContent | null;
+    content: MarkdownContent;
+};

package/lib/markdown/frontmatter.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatter = void 0;
+/** Parse frontmatter */
+function parseFrontmatter(code) {
+    if (!code.startsWith("---") || code[3] === "-") {
+        return {
+            frontmatter: null,
+            content: {
+                range: [0, code.length],
+                value: code,
+            },
+        };
+    }
+    let closeIndex = code.indexOf("\n---", 3);
+    let contentOpenIndex = closeIndex + 4;
+    if (closeIndex === -1) {
+        closeIndex = code.length;
+        contentOpenIndex = code.length;
+    }
+    let openIndex = 3;
+    if (code[openIndex] === "\r") {
+        openIndex++;
+    }
+    if (code[openIndex] === "\n") {
+        openIndex++;
+    }
+    if (openIndex < closeIndex && code[closeIndex] === "\n") {
+        closeIndex--;
+    }
+    if (openIndex < closeIndex && code[closeIndex] === "\r") {
+        closeIndex++;
+    }
+    if (code[contentOpenIndex] === "\r") {
+        contentOpenIndex++;
+    }
+    if (code[contentOpenIndex] === "\n") {
+        contentOpenIndex++;
+    }
+    const frontmatter = code.slice(openIndex, closeIndex + 1);
+    const content = code.slice(contentOpenIndex);
+    return {
+        frontmatter: {
+            range: [openIndex, closeIndex + 1],
+            value: frontmatter,
+        },
+        content: {
+            range: [contentOpenIndex, code.length],
+            value: content,
+        },
+    };
+}
+exports.parseFrontmatter = parseFrontmatter;

package/lib/markdown/index.d.ts

@@ -0,0 +1,19 @@
+import type { ScopeManager } from "eslint-scope";
+import type { AstroProgram } from "../ast";
+import type { ParseResult } from "@astrojs/compiler/node";
+/**
+ * Parse source code
+ */
+export declare function parseForESLint(code: string, options?: any): {
+    ast: AstroProgram;
+    services: Record<string, any> & {
+        isAstro: true;
+        getAstroAst: () => ParseResult;
+        isAstroMarkdown: true;
+        getAstroMarkdownFrontmatter: () => any;
+    };
+    visitorKeys: {
+        [type: string]: string[];
+    };
+    scopeManager: ScopeManager;
+};

package/lib/markdown/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseForESLint = void 0;
+const context_1 = require("../context");
+const mdast_util_from_markdown_service_1 = require("./mdast-util-from-markdown-service");
+const frontmatter_1 = require("./frontmatter");
+const process_markdown_1 = require("./process-markdown");
+const parser_1 = require("../parser");
+const sort_1 = require("../parser/sort");
+const script_1 = require("../context/script");
+const yaml_1 = require("./yaml");
+/**
+ * Parse source code
+ */
+function parseForESLint(code, options) {
+    const { frontmatter, content } = (0, frontmatter_1.parseFrontmatter)(code);
+    const ctx = new context_1.Context(code);
+    const root = (0, mdast_util_from_markdown_service_1.parseMarkdown)(content.value);
+    const scriptContext = new script_1.ScriptContext(ctx);
+    let yamlResult;
+    if (frontmatter) {
+        scriptContext.appendOriginal(frontmatter.range[0]);
+        yamlResult = (0, yaml_1.parseYaml)(frontmatter);
+        if (yamlResult) {
+            scriptContext.skipOriginalOffset(yamlResult.setupValueRange[0] - frontmatter.range[0]);
+            scriptContext.appendOriginal(yamlResult.setupValueRange[1]);
+            scriptContext.skipOriginalOffset(frontmatter.range[1] - yamlResult.setupValueRange[1]);
+            scriptContext.addToken("YAMLToken", [
+                frontmatter.range[0],
+                yamlResult.before,
+            ]);
+            scriptContext.addToken("YAMLToken", [
+                yamlResult.after,
+                frontmatter.range[1],
+            ]);
+        }
+        else {
+            scriptContext.skipOriginalOffset(frontmatter.range[1] - frontmatter.range[0]);
+            scriptContext.addToken("YAMLToken", [
+                frontmatter.range[0],
+                frontmatter.range[1],
+            ]);
+        }
+    }
+    (0, process_markdown_1.processMarkdown)(scriptContext, root, content.range[0]);
+    scriptContext.appendOriginal(code.length);
+    const resultAstro = (0, parser_1.parseForESLint)(scriptContext.script, options);
+    scriptContext.restore(resultAstro);
+    (0, sort_1.sort)(resultAstro.ast.comments);
+    (0, sort_1.sort)(resultAstro.ast.tokens);
+    (0, parser_1.extractTokens)(resultAstro, ctx);
+    resultAstro.services = Object.assign(resultAstro.services || {}, {
+        isAstroMarkdown: true,
+        getAstroMarkdownFrontmatter() {
+            return yamlResult?.getYamlValue();
+        },
+    });
+    return resultAstro;
+}
+exports.parseForESLint = parseForESLint;

package/lib/markdown/mdast-util-from-markdown-service.d.ts

@@ -0,0 +1,5 @@
+import type * as mdast from "mdast";
+/**
+ * Parse code by `mdast-util-from-markdown`
+ */
+export declare function parseMarkdown(code: string): mdast.Root;

package/lib/markdown/mdast-util-from-markdown-service.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdown = void 0;
+const synckit_1 = require("synckit");
+const parseSync = (0, synckit_1.createSyncFn)(require.resolve("./mdast-util-from-markdown-worker"));
+/**
+ * Parse code by `mdast-util-from-markdown`
+ */
+function parseMarkdown(code) {
+    return parseSync(code);
+}
+exports.parseMarkdown = parseMarkdown;

package/lib/markdown/mdast-util-from-markdown-worker.d.ts

@@ -0,0 +1,2 @@
+import type * as mdast from "mdast";
+export declare type ParseSyncFunction = (source: string) => mdast.Root;

package/lib/markdown/mdast-util-from-markdown-worker.js

@@ -0,0 +1,8 @@
+"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 { fromMarkdown } = await dynamicImport("mdast-util-from-markdown");
+    return fromMarkdown(source);
+});

package/lib/markdown/process-markdown.d.ts

@@ -0,0 +1,6 @@
+import type * as mdast from "mdast";
+import type { ScriptContext } from "../context/script";
+/**
+ * Process the markdown ast to generate a ScriptContext.
+ */
+export declare function processMarkdown(script: ScriptContext, root: mdast.Root, offset: number): void;

package/lib/markdown/process-markdown.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMarkdown = void 0;
+const types_1 = require("@typescript-eslint/types");
+/**
+ * Process the markdown ast to generate a ScriptContext.
+ */
+function processMarkdown(script, root, offset) {
+    walk(root, (node) => {
+        const start = node.position.start.offset + offset;
+        const end = node.position.end.offset + offset;
+        script.appendOriginal(start);
+        if (node.type === "code" || node.type === "inlineCode") {
+            script.appendScript(`<></>`);
+            script.skipOriginalOffset(end - start);
+            script.addRestoreNodeProcess((scriptNode, context) => {
+                if (scriptNode.range[0] === start &&
+                    scriptNode.type === types_1.AST_NODE_TYPES.JSXFragment) {
+                    delete scriptNode.openingFragment;
+                    delete scriptNode.closingFragment;
+                    delete scriptNode.expression;
+                    delete scriptNode.children;
+                    const text = script.originalCode.slice(start, end);
+                    const mdNode = scriptNode;
+                    mdNode.type = "AstroRawText";
+                    mdNode.value = text;
+                    mdNode.raw = text;
+                    let parent = context.getParent(scriptNode);
+                    while (parent) {
+                        let update = false;
+                        if (parent.range[0] > scriptNode.range[0]) {
+                            parent.range[0] = scriptNode.range[0];
+                            parent.loc.start = {
+                                line: scriptNode.loc.start.line,
+                                column: scriptNode.loc.start.column,
+                            };
+                            update = true;
+                        }
+                        if (parent.range[1] < scriptNode.range[1]) {
+                            parent.range[1] = scriptNode.range[1];
+                            parent.loc.end = {
+                                line: scriptNode.loc.end.line,
+                                column: scriptNode.loc.end.column,
+                            };
+                            update = true;
+                        }
+                        if (!update) {
+                            break;
+                        }
+                        parent = context.getParent(parent);
+                    }
+                    return true;
+                }
+                return false;
+            });
+            script.addToken(types_1.AST_TOKEN_TYPES.JSXText, [start, end]);
+        }
+    }, (node) => {
+        // const start = node.position!.start.offset! + offset
+        const end = node.position.end.offset + offset;
+        script.appendOriginal(end);
+    });
+    script.addRestoreNodeProcess((scriptNode) => {
+        if (scriptNode.type === "JSXText") {
+            const rawNode = scriptNode;
+            rawNode.type = "AstroRawText";
+        }
+        return false;
+    });
+}
+exports.processMarkdown = processMarkdown;
+/** walk nodes */
+function walk(parent, enter, leave, parents = []) {
+    const currParents = [parent, ...parents];
+    if ("children" in parent) {
+        for (const node of parent.children) {
+            enter(node, currParents);
+            walk(node, enter, leave, currParents);
+            leave(node, currParents);
+        }
+    }
+}

package/lib/markdown/yaml.d.ts

@@ -0,0 +1,9 @@
+import type { MarkdownContent } from "./frontmatter";
+export declare type FrontmatterYAMLResult = {
+    before: number;
+    setupValueRange: [number, number];
+    after: number;
+    getYamlValue: () => any;
+};
+/** Parse for yaml */
+export declare function parseYaml(frontmatter: MarkdownContent): FrontmatterYAMLResult | null;

package/lib/markdown/yaml.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYaml = void 0;
+const yaml_1 = require("yaml");
+/** Parse for yaml */
+function parseYaml(frontmatter) {
+    const doc = (0, yaml_1.parseDocument)(frontmatter.value, { keepSourceTokens: true });
+    const range = getSetupRange(doc);
+    if (!range) {
+        return null;
+    }
+    let before = range[0];
+    let after = range[1];
+    while (isSpace(frontmatter.value[before - 1])) {
+        before--;
+    }
+    while (isSpace(frontmatter.value[after])) {
+        after++;
+    }
+    return {
+        before: before + frontmatter.range[0],
+        setupValueRange: [
+            range[0] + frontmatter.range[0],
+            range[1] + frontmatter.range[0],
+        ],
+        after: after + frontmatter.range[0],
+        getYamlValue: () => doc.toJS(),
+    };
+}
+exports.parseYaml = parseYaml;
+/**  Checks whether the given char is spaces, or not */
+function isSpace(c) {
+    return c && !c.trim();
+}
+/** Get setup range */
+function getSetupRange(ast) {
+    if (!ast.contents) {
+        return null;
+    }
+    if (!(0, yaml_1.isMap)(ast.contents)) {
+        return null;
+    }
+    for (const item of ast.contents.items) {
+        if (!(0, yaml_1.isScalar)(item.key) || !(0, yaml_1.isScalar)(item.value)) {
+            continue;
+        }
+        if (item.key.value !== "setup") {
+            continue;
+        }
+        if (item.value.type === "PLAIN") {
+            return [item.value.range[0], item.value.range[1]];
+        }
+        if (item.value.type === "QUOTE_DOUBLE" ||
+            item.value.type === "QUOTE_SINGLE") {
+            return [item.value.range[0] + 1, item.value.range[1] - 1];
+        }
+        if (item.value.type === "BLOCK_FOLDED" ||
+            item.value.type === "BLOCK_LITERAL") {
+            const cst = item.value.srcToken;
+            let blockStart = cst.offset;
+            for (const token of cst.props) {
+                if (isCommentOrSpace(token) ||
+                    token.type === "block-scalar-header") {
+                    blockStart = token.offset + token.source.length;
+                    continue;
+                }
+                /* istanbul ignore next */
+                throw new Error(`Unknown token:${token.type}`);
+            }
+            return [blockStart, item.value.range[1]];
+        }
+        break;
+    }
+    return null;
+}
+/**
+ * Checks whether the given cst is comments, spaces, or not
+ */
+function isCommentOrSpace(node) {
+    if (node.type === "space" ||
+        node.type === "newline" ||
+        node.type === "comment") {
+        return true;
+    }
+    return false;
+}

package/lib/parser/index.d.ts

@@ -1,6 +1,8 @@
+import type { Context } from "../context";
 import type { AstroProgram } from "../ast";
 import type { ScopeManager } from "eslint-scope";
 import type { ParseResult } from "@astrojs/compiler";
+import type { ESLintExtendedProgram } from "../types";
 /**
  * Parse source code
  */
@@ -15,3 +17,5 @@ export declare function parseForESLint(code: string, options?: any): {
     };
     scopeManager: ScopeManager;
 };
+/** Extract tokens */
+export declare function extractTokens(ast: ESLintExtendedProgram, ctx: Context): void;

package/lib/parser/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseForESLint = void 0;
+exports.extractTokens = exports.parseForESLint = void 0;
 const visitor_keys_1 = require("../visitor-keys");
 const types_1 = require("@typescript-eslint/types");
 const script_1 = require("./script");
@@ -69,3 +69,4 @@ function extractTokens(ast, ctx) {
         return /^[^\w$]$/iu.test(c);
     }
 }
+exports.extractTokens = extractTokens;

package/lib/parser/process-template.js

@@ -328,7 +328,8 @@ function processTemplate(ctx, resultTemplate) {
                     const offset = (0, astro_1.calcContentEndOffset)(node, ctx);
                     script.appendOriginal(offset);
                     script.appendScript(`</${node.name}>`);
-                    script.addRestoreNodeProcess((scriptNode, _result, parent) => {
+                    script.addRestoreNodeProcess((scriptNode, context) => {
+                        const parent = context.getParent(scriptNode);
                         if (scriptNode.range[0] === offset &&
                             scriptNode.type ===
                                 types_1.AST_NODE_TYPES.JSXClosingElement &&

package/lib/parser/ts-patch.js

@@ -11,6 +11,13 @@ const fs_1 = __importDefault(require("fs"));
  * Apply a patch to parse .astro files as TSX.
  */
 function tsPatch(scriptParserOptions) {
+    let targetExt = ".astro";
+    if (scriptParserOptions.filePath) {
+        const ext = path_1.default.extname(scriptParserOptions.filePath);
+        if (ext) {
+            targetExt = ext;
+        }
+    }
     try {
         // Apply a patch to parse .astro files as TSX.
         const cwd = process.cwd();
@@ -20,13 +27,13 @@ function tsPatch(scriptParserOptions) {
         if (typeof ensureScriptKind === "function" &&
             typeof getScriptKindFromFileName === "function") {
             ts.ensureScriptKind = function (fileName, ...args) {
-                if (fileName.endsWith(".astro")) {
+                if (fileName.endsWith(targetExt)) {
                     return ts.ScriptKind.TSX;
                 }
                 return ensureScriptKind.call(this, fileName, ...args);
             };
             ts.getScriptKindFromFileName = function (fileName, ...args) {
-                if (fileName.endsWith(".astro")) {
+                if (fileName.endsWith(targetExt)) {
                     return ts.ScriptKind.TSX;
                 }
                 return getScriptKindFromFileName.call(this, fileName, ...args);

package/package.json

@@ -1,97 +1,100 @@
 {
-    "name": "astro-eslint-parser",
-    "version": "0.2.2",
-    "description": "Astro component parser for ESLint",
-    "main": "lib/index.js",
-    "files": [
-        "lib"
-    ],
-    "engines": {
-        "node": "^14.17.0 || >=16.0.0"
-    },
-    "scripts": {
-        "prebuild": "npm run -s clean",
-        "build": "tsc --project ./tsconfig.build.json",
-        "clean": "rimraf .nyc_output lib coverage",
-        "lint": "eslint . --ext .js,.ts,.json,.astro,.svelte",
-        "eslint-fix": "npm run lint -- --fix",
-        "test": "mocha --require ts-node/register \"tests/src/**/*.ts\" --reporter dot --timeout 60000",
-        "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": "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"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/ota-meshi/astro-eslint-parser.git"
-    },
-    "keywords": [
-        "astro",
-        "astrojs",
-        "eslint",
-        "parser"
-    ],
-    "author": "Yosuke Ota",
-    "funding": "https://github.com/sponsors/ota-meshi",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/ota-meshi/astro-eslint-parser/issues"
-    },
-    "homepage": "https://github.com/ota-meshi/astro-eslint-parser#readme",
-    "dependencies": {
-        "@astrojs/compiler": "^0.15.2",
-        "@typescript-eslint/types": "^5.25.0",
-        "debug": "^4.3.4",
-        "eslint-visitor-keys": "^3.0.0",
-        "espree": "^9.0.0",
-        "synckit": "^0.7.1"
-    },
-    "devDependencies": {
-        "@ota-meshi/eslint-plugin": "^0.10.0",
-        "@ota-meshi/eslint-plugin-svelte": "^0.34.0",
-        "@types/benchmark": "^2.1.1",
-        "@types/chai": "^4.3.0",
-        "@types/debug": "^4.1.7",
-        "@types/eslint": "^8.0.0",
-        "@types/eslint-scope": "^3.7.0",
-        "@types/eslint-visitor-keys": "^1.0.0",
-        "@types/mocha": "^9.0.0",
-        "@types/node": "^16.0.0",
-        "@types/semver": "^7.3.9",
-        "@typescript-eslint/eslint-plugin": "^5.4.0",
-        "@typescript-eslint/parser": "^5.4.0",
-        "astro-eslint-parser": ">=0.1.0",
-        "benchmark": "^2.1.4",
-        "chai": "^4.3.4",
-        "code-red": "^0.2.3",
-        "eslint": "^8.15.0",
-        "eslint-config-prettier": "^8.3.0",
-        "eslint-formatter-codeframe": "^7.32.1",
-        "eslint-plugin-astro": "^0.8.0",
-        "eslint-plugin-eslint-comments": "^3.2.0",
-        "eslint-plugin-json-schema-validator": "^3.0.0",
-        "eslint-plugin-jsonc": "^2.0.0",
-        "eslint-plugin-node": "^11.1.0",
-        "eslint-plugin-node-dependencies": "^0.8.0",
-        "eslint-plugin-prettier": "^4.0.0",
-        "eslint-plugin-react": "^7.29.4",
-        "eslint-plugin-regexp": "^1.5.0",
-        "estree-walker": "^3.0.0",
-        "locate-character": "^2.0.5",
-        "magic-string": "^0.26.0",
-        "mocha": "^10.0.0",
-        "mocha-chai-jest-snapshot": "^1.1.3",
-        "nyc": "^15.1.0",
-        "prettier": "^2.0.5",
-        "prettier-plugin-astro": "^0.1.0-0",
-        "prettier-plugin-svelte": "^2.7.0",
-        "semver": "^7.3.5",
-        "string-replace-loader": "^3.0.3",
-        "svelte": "^3.48.0",
-        "ts-node": "^10.4.0",
-        "typescript": "~4.7.0"
-    }
+  "name": "astro-eslint-parser",
+  "version": "0.4.0",
+  "description": "Astro component parser for ESLint",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "engines": {
+    "node": "^14.17.0 || >=16.0.0"
+  },
+  "scripts": {
+    "prebuild": "npm run -s clean",
+    "build": "tsc --project ./tsconfig.build.json",
+    "clean": "rimraf .nyc_output lib coverage",
+    "lint": "eslint . --ext .js,.ts,.json,.astro,.svelte",
+    "eslint-fix": "npm run lint -- --fix",
+    "test": "mocha --require ts-node/register \"tests/src/**/*.ts\" --reporter dot --timeout 60000",
+    "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": "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ota-meshi/astro-eslint-parser.git"
+  },
+  "keywords": [
+    "astro",
+    "astrojs",
+    "eslint",
+    "parser"
+  ],
+  "author": "Yosuke Ota",
+  "funding": "https://github.com/sponsors/ota-meshi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ota-meshi/astro-eslint-parser/issues"
+  },
+  "homepage": "https://github.com/ota-meshi/astro-eslint-parser#readme",
+  "dependencies": {
+    "@astrojs/compiler": "^0.18.0",
+    "@typescript-eslint/types": "^5.25.0",
+    "debug": "^4.3.4",
+    "eslint-visitor-keys": "^3.0.0",
+    "espree": "^9.0.0",
+    "mdast-util-from-markdown": "^1.2.0",
+    "synckit": "^0.7.1",
+    "yaml": "^2.1.1"
+  },
+  "devDependencies": {
+    "@ota-meshi/eslint-plugin": "^0.11.0",
+    "@types/benchmark": "^2.1.1",
+    "@types/chai": "^4.3.0",
+    "@types/debug": "^4.1.7",
+    "@types/eslint": "^8.0.0",
+    "@types/eslint-scope": "^3.7.0",
+    "@types/eslint-visitor-keys": "^1.0.0",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^16.0.0",
+    "@types/semver": "^7.3.9",
+    "@typescript-eslint/eslint-plugin": "^5.4.0",
+    "@typescript-eslint/parser": "^5.4.0",
+    "astro-eslint-parser": ">=0.1.0",
+    "benchmark": "^2.1.4",
+    "chai": "^4.3.4",
+    "code-red": "^0.2.3",
+    "eslint": "^8.15.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-formatter-codeframe": "^7.32.1",
+    "eslint-plugin-astro": "^0.14.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-json-schema-validator": "^3.0.0",
+    "eslint-plugin-jsonc": "^2.0.0",
+    "eslint-plugin-jsx-a11y": "^6.5.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-node-dependencies": "^0.9.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-react": "^7.29.4",
+    "eslint-plugin-regexp": "^1.5.0",
+    "eslint-plugin-svelte": "^2.0.0",
+    "estree-walker": "^3.0.0",
+    "locate-character": "^2.0.5",
+    "magic-string": "^0.26.0",
+    "mocha": "^10.0.0",
+    "mocha-chai-jest-snapshot": "^1.1.3",
+    "nyc": "^15.1.0",
+    "prettier": "^2.0.5",
+    "prettier-plugin-astro": "^0.1.0-0",
+    "prettier-plugin-svelte": "^2.7.0",
+    "semver": "^7.3.5",
+    "string-replace-loader": "^3.0.3",
+    "svelte": "^3.48.0",
+    "ts-node": "^10.4.0",
+    "typescript": "~4.7.0"
+  }
 }