astro-eslint-parser 0.0.0

package/lib/context/script.d.ts

@@ -0,0 +1,29 @@
+import type { ParseResult } from "@astrojs/compiler";
+import type { Context } from ".";
+import type { ESLintExtendedProgram } from "../parser";
+import type { TSESTree } from "@typescript-eslint/types";
+/**
+ * Process the template to generate a ScriptContext.
+ */
+export declare function processTemplate(ctx: Context, resultTemplate: ParseResult): ScriptContext;
+export declare class ScriptContext {
+    private readonly ctx;
+    script: string;
+    private consumedIndex;
+    private readonly offsets;
+    private readonly fragments;
+    private readonly tokens;
+    private readonly restoreNodeProcesses;
+    constructor(ctx: Context);
+    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, result: ESLintExtendedProgram) => boolean): void;
+    /**
+     * Restore AST nodes
+     */
+    restore(result: ESLintExtendedProgram): void;
+    private remapLocation;
+    private getRemapRange;
+}

package/lib/context/script.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptContext = exports.processTemplate = void 0;
+const traverse_1 = require("../traverse");
+const types_1 = require("@typescript-eslint/types");
+const errors_1 = require("../errors");
+const astro_1 = require("../astro");
+/**
+ * Process the template to generate a ScriptContext.
+ */
+function processTemplate(ctx, resultTemplate) {
+    const script = new ScriptContext(ctx);
+    const frontmatter = resultTemplate.ast.children.find((n) => n.type === "frontmatter");
+    let fragmentOpened = false;
+    if (!frontmatter) {
+        script.appendScript("<>");
+        fragmentOpened = true;
+    }
+    (0, astro_1.walkElements)(resultTemplate.ast, (node, parent) => {
+        if (node.type === "frontmatter") {
+            const start = node.position.start.offset;
+            script.appendOriginal(start);
+            script.skipOriginalOffset(3);
+            const end = node.position.end.offset;
+            script.appendOriginal(end - 3);
+            script.appendScript(";<>");
+            fragmentOpened = true;
+            script.skipOriginalOffset(3);
+            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) {
+                            result.ast.body.splice(index, 1);
+                            break;
+                        }
+                    }
+                }
+                return true;
+            });
+            script.addToken(types_1.AST_TOKEN_TYPES.Punctuator, [
+                node.position.start.offset,
+                node.position.start.offset + 3,
+            ]);
+            script.addToken(types_1.AST_TOKEN_TYPES.Punctuator, [end - 3, end]);
+        }
+        else if ((0, astro_1.isTag)(node)) {
+            for (const attr of node.attributes) {
+                if (attr.kind === "shorthand") {
+                    const start = attr.position.start.offset;
+                    script.appendOriginal(start);
+                    script.appendScript(`${attr.name}=`);
+                    script.addRestoreNodeProcess((scriptNode) => {
+                        if (scriptNode.type === types_1.AST_NODE_TYPES.JSXAttribute &&
+                            scriptNode.range[0] === start) {
+                            const attrNode = scriptNode;
+                            attrNode.type = "AstroShorthandAttribute";
+                            const locs = ctx.getLocations(...attrNode.value.expression.range);
+                            attrNode.name.range = locs.range;
+                            attrNode.name.loc = locs.loc;
+                            return true;
+                        }
+                        return false;
+                    });
+                }
+                else if (attr.kind === "template-literal") {
+                    const start = (0, astro_1.getAttributeValueStartOffset)(attr, ctx.code);
+                    const end = (0, astro_1.getAttributeEndOffset)(attr, ctx.code);
+                    script.appendOriginal(start);
+                    script.appendScript("{");
+                    script.appendOriginal(end);
+                    script.appendScript("}");
+                    script.addRestoreNodeProcess((scriptNode) => {
+                        if (scriptNode.type === types_1.AST_NODE_TYPES.JSXAttribute &&
+                            scriptNode.range[0] === start) {
+                            const attrNode = scriptNode;
+                            attrNode.type = "AstroTemplateLiteralAttribute";
+                            return true;
+                        }
+                        return false;
+                    });
+                }
+            }
+            const end = getVoidSelfClosingTag(node, parent, ctx);
+            if (end && end.end === ">") {
+                script.appendOriginal(end.offset - 1);
+                script.appendScript("/");
+            }
+            if (node.name === "script" || node.name === "style") {
+                const text = node.children[0];
+                if (text && text.type === "text") {
+                    const styleNodeStart = node.position.start.offset;
+                    const start = text.position.start.offset;
+                    script.appendOriginal(start);
+                    script.skipOriginalOffset(text.value.length);
+                    script.addRestoreNodeProcess((scriptNode) => {
+                        if (scriptNode.type === types_1.AST_NODE_TYPES.JSXElement &&
+                            scriptNode.range[0] === styleNodeStart) {
+                            const textNode = Object.assign({ type: types_1.AST_NODE_TYPES.JSXText, value: text.value, raw: text.value, parent: scriptNode }, ctx.getLocations(start, start + text.value.length));
+                            scriptNode.children = [textNode];
+                            return true;
+                        }
+                        return false;
+                    });
+                    script.addToken(types_1.AST_TOKEN_TYPES.JSXText, [
+                        start,
+                        start + text.value.length,
+                    ]);
+                }
+            }
+        }
+        else if (node.type === "comment") {
+            const start = node.position.start.offset;
+            const length = 4 + node.value.length + 3;
+            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;
+            }
+            script.skipOriginalOffset(length);
+            script.addRestoreNodeProcess((scriptNode) => {
+                if (scriptNode.range[0] === start &&
+                    scriptNode.type === targetType) {
+                    delete scriptNode.children;
+                    delete scriptNode.openingFragment;
+                    delete scriptNode.closingFragment;
+                    delete scriptNode.expression;
+                    const commentNode = scriptNode;
+                    commentNode.type = "AstroHTMLComment";
+                    commentNode.value = node.value;
+                    return true;
+                }
+                return false;
+            });
+            script.addToken("HTMLComment", [
+                start,
+                start + length,
+            ]);
+        }
+        else if (node.type === "doctype") {
+            const start = node.position.start.offset;
+            const end = node.position.end.offset;
+            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;
+            }
+            script.skipOriginalOffset(end - start);
+            script.addRestoreNodeProcess((scriptNode) => {
+                if (scriptNode.range[0] === start &&
+                    scriptNode.type === targetType) {
+                    delete scriptNode.children;
+                    delete scriptNode.openingFragment;
+                    delete scriptNode.closingFragment;
+                    delete scriptNode.expression;
+                    const doctypeNode = scriptNode;
+                    doctypeNode.type = "AstroDoctype";
+                    return true;
+                }
+                return false;
+            });
+            script.addToken("HTMLDocType", [start, end]);
+        }
+    });
+    script.appendOriginal(ctx.code.length);
+    script.appendScript("</>");
+    return script;
+}
+exports.processTemplate = processTemplate;
+/**
+ * If the given tag is a void tag, get the self-closing tag.
+ */
+function getVoidSelfClosingTag(node, parent, ctx) {
+    if (node.type === "fragment") {
+        return false;
+    }
+    if (node.children.length > 0) {
+        return false;
+    }
+    const code = ctx.code;
+    let nextElementIndex = code.length;
+    const childIndex = parent.children.indexOf(node);
+    if (childIndex === parent.children.length - 1) {
+        // last
+        nextElementIndex = parent.position.end.offset;
+        nextElementIndex = code.lastIndexOf("</", nextElementIndex);
+    }
+    else {
+        const next = parent.children[childIndex + 1];
+        nextElementIndex = next.position.start.offset;
+    }
+    const endOffset = (0, astro_1.getStartTagEndOffset)(node, code);
+    if (code.slice(endOffset, nextElementIndex).trim()) {
+        // has end tag
+        return null;
+    }
+    return {
+        offset: endOffset,
+        end: code.slice(endOffset - 2, endOffset) === "/>" ? "/>" : ">",
+    };
+}
+class ScriptContext {
+    constructor(ctx) {
+        this.script = "";
+        this.consumedIndex = 0;
+        this.offsets = [];
+        this.fragments = [];
+        this.tokens = [];
+        this.restoreNodeProcesses = [];
+        this.ctx = ctx;
+    }
+    skipOriginalOffset(offset) {
+        this.consumedIndex += offset;
+    }
+    appendOriginal(index) {
+        this.offsets.push({
+            original: this.consumedIndex,
+            script: this.script.length,
+        });
+        this.script += this.ctx.code.slice(this.consumedIndex, index);
+        this.consumedIndex = index;
+    }
+    appendScript(fragment) {
+        const start = this.script.length;
+        this.script += fragment;
+        this.fragments.push({ start, end: this.script.length });
+    }
+    addToken(type, range) {
+        this.tokens.push(this.ctx.buildToken(type, range));
+    }
+    addRestoreNodeProcess(process) {
+        this.restoreNodeProcesses.push(process);
+    }
+    /**
+     * 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);
+        }
+        // remap locations
+        const traversed = new Set();
+        (0, traverse_1.traverseNodes)(result.ast, {
+            visitorKeys: result.visitorKeys,
+            enterNode: (node) => {
+                if (!traversed.has(node)) {
+                    traversed.add(node);
+                    this.remapLocation(node);
+                }
+            },
+            leaveNode: (_node) => {
+                // noop
+            },
+        });
+        const tokens = [...this.tokens];
+        for (const token of result.ast.tokens || []) {
+            if (this.fragments.some((f) => f.start <= token.range[0] && token.range[1] <= f.end)) {
+                continue;
+            }
+            this.remapLocation(token);
+            tokens.push(token);
+        }
+        result.ast.tokens = tokens;
+        for (const token of result.ast.comments || []) {
+            this.remapLocation(token);
+        }
+        // Process for Astro
+        delete last.expression.closingFragment;
+        delete last.expression.openingFragment;
+        last.expression.type =
+            "AstroRootFragment";
+        let restoreNodeProcesses = this.restoreNodeProcesses;
+        for (const node of traversed) {
+            restoreNodeProcesses = restoreNodeProcesses.filter((proc) => !proc(node, result));
+        }
+        // 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]);
+        }
+    }
+    remapLocation(node) {
+        let [start, end] = node.range;
+        const startFragment = this.fragments.find((f) => f.start <= start && start < f.end);
+        if (startFragment) {
+            start = startFragment.end;
+        }
+        const endFragment = this.fragments.find((f) => f.start < end && end <= f.end);
+        if (endFragment) {
+            end = endFragment.start;
+        }
+        if (end < start) {
+            const w = start;
+            start = end;
+            end = w;
+        }
+        const locs = this.ctx.getLocations(...this.getRemapRange(start, end));
+        node.loc = locs.loc;
+        node.range = locs.range;
+        if (node.start != null) {
+            delete node.start;
+        }
+        if (node.end != null) {
+            delete node.end;
+        }
+    }
+    getRemapRange(start, end) {
+        let lastStart = this.offsets[0];
+        let lastEnd = this.offsets[0];
+        for (const offset of this.offsets) {
+            if (offset.script <= start) {
+                lastStart = offset;
+            }
+            if (offset.script < end) {
+                lastEnd = offset;
+            }
+            else {
+                if (offset.script === end) {
+                    const remapStart = lastStart.original + (start - lastStart.script);
+                    if (this.tokens.some((t) => t.range[0] <= remapStart &&
+                        offset.original <= t.range[1])) {
+                        lastEnd = offset;
+                    }
+                }
+                break;
+            }
+        }
+        const remapStart = lastStart.original + (start - lastStart.script);
+        const remapEnd = lastEnd.original + (end - lastEnd.script);
+        return [remapStart, remapEnd];
+    }
+}
+exports.ScriptContext = ScriptContext;

package/lib/debug.d.ts

@@ -0,0 +1,2 @@
+import debugFactory from "debug";
+export declare const debug: debugFactory.Debugger;

package/lib/debug.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = void 0;
+const debug_1 = __importDefault(require("debug"));
+exports.debug = (0, debug_1.default)("astro-eslint-parser");

package/lib/errors.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "./context";
+/**
+ * Astro parse errors.
+ */
+export declare class ParseError extends SyntaxError {
+    index: number;
+    lineNumber: number;
+    column: number;
+    /**
+     * Initialize this ParseError instance.
+     */
+    constructor(message: string, offset: number, ctx: Context);
+}

package/lib/errors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = void 0;
+/**
+ * Astro parse errors.
+ */
+class ParseError extends SyntaxError {
+    /**
+     * Initialize this ParseError instance.
+     */
+    constructor(message, offset, ctx) {
+        super(message);
+        this.index = offset;
+        const loc = ctx.getLocFromIndex(offset);
+        this.lineNumber = loc.line;
+        this.column = loc.column;
+    }
+}
+exports.ParseError = ParseError;

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import { parseForESLint } from "./parser";
+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 };

package/lib/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 AST = __importStar(require("./ast"));
+exports.AST = AST;
+const traverse_1 = require("./traverse");
+Object.defineProperty(exports, "traverseNodes", { enumerable: true, get: function () { return traverse_1.traverseNodes; } });
+const visitor_keys_1 = require("./visitor-keys");
+const errors_1 = require("./errors");
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
+// Keys
+// eslint-disable-next-line @typescript-eslint/naming-convention -- ignore
+exports.VisitorKeys = visitor_keys_1.KEYS;

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

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

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

@@ -0,0 +1,22 @@
+"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"];
+/**
+ * Parse code by `@astrojs/compiler`
+ */
+function parse(code, options) {
+    const ast = JSON.parse(service.parse(code, options).ast);
+    return { ast };
+}
+exports.parse = parse;

package/lib/parser/astro-parser/parse.d.ts

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

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

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const service = __importStar(require("./astrojs-compiler-service"));
+const astro_1 = require("../../astro");
+/**
+ * Parse code by `@astrojs/compiler`
+ */
+function parse(code) {
+    const ast = service.parse(code, { position: true }).ast;
+    fixLocations(ast, code);
+    return { ast };
+}
+exports.parse = parse;
+/**
+ * Fix locations
+ */
+function fixLocations(node, code) {
+    // FIXME: Adjust because the parser does not return the correct location.
+    let start = 0;
+    (0, astro_1.walk)(node, 
+    // eslint-disable-next-line complexity -- ignore
+    (node) => {
+        if (node.type === "frontmatter") {
+            start = node.position.start.offset = tokenIndex(code, "---", start);
+            start = node.position.end.offset =
+                tokenIndex(code, "---", start + 3 + node.value.length) + 3;
+        }
+        else if (node.type === "fragment" ||
+            node.type === "element" ||
+            node.type === "component" ||
+            node.type === "custom-element") {
+            if (!node.position) {
+                node.position = { start: {}, end: {} };
+            }
+            start = node.position.start.offset = tokenIndex(code, "<", start);
+            start += 1;
+            if (node.type === "element" ||
+                node.type === "component" ||
+                node.type === "custom-element") {
+                start += node.name.length;
+            }
+            if (!node.attributes.length) {
+                start = (0, astro_1.getStartTagEndOffset)(node, code);
+            }
+        }
+        else if (node.type === "attribute") {
+            fixLocationForAttr(node, code, start);
+            start = (0, astro_1.getAttributeEndOffset)(node, code);
+        }
+        else if (node.type === "comment") {
+            node.position.start.offset = tokenIndex(code, "<!--", start);
+            start = (0, astro_1.getCommentEndOffset)(node, code);
+        }
+        else if (node.type === "text") {
+            start = node.position.start.offset = tokenIndex(code, node.value, start);
+            start += node.value.length;
+        }
+        else if (node.type === "expression") {
+            start = node.position.start.offset = tokenIndex(code, "{", start);
+            start += 1;
+        }
+        else if (node.type === "doctype") {
+            if (!node.position) {
+                node.position = { start: {}, end: {} };
+            }
+            start = node.position.start.offset = tokenIndex(code, "<!", start);
+            start += 2;
+            start = node.position.end.offset =
+                code.indexOf(">", start) + 1;
+        }
+        else if (node.type === "root") {
+            // noop
+        }
+    }, (node, parent) => {
+        if (node.type === "attribute") {
+            const attributes = parent.attributes;
+            if (attributes[attributes.length - 1] === node) {
+                start = (0, astro_1.getStartTagEndOffset)(parent, code);
+            }
+            return;
+        }
+        if (node.type === "expression") {
+            start = tokenIndex(code, "}", start) + 1;
+        }
+        else if (node.type === "fragment") {
+            start = tokenIndex(code, "</>", start) + 3;
+        }
+        else if (node.type === "element" ||
+            node.type === "component" ||
+            node.type === "custom-element") {
+            if (!node.position.end) {
+                return;
+            }
+            start =
+                tokenIndex(code, `</${node.name}`, start) +
+                    2 +
+                    node.name.length;
+            start = tokenIndex(code, ">", start) + 1;
+        }
+        else {
+            return;
+        }
+        if (node.position.end) {
+            node.position.end.offset = start;
+        }
+    });
+}
+/**
+ * Fix locations
+ */
+function fixLocationForAttr(node, code, start) {
+    if (node.kind === "empty") {
+        node.position.start.offset = tokenIndex(code, node.name, start);
+    }
+    else if (node.kind === "quoted") {
+        node.position.start.offset = tokenIndex(code, node.name, start);
+    }
+    else if (node.kind === "expression") {
+        node.position.start.offset = tokenIndex(code, node.name, start);
+    }
+    else if (node.kind === "shorthand") {
+        node.position.start.offset = tokenIndex(code, "{", start);
+    }
+    else if (node.kind === "spread") {
+        node.position.start.offset = tokenIndex(code, "{", start);
+    }
+    else if (node.kind === "template-literal") {
+        node.position.start.offset = tokenIndex(code, node.name, start);
+    }
+    else {
+        throw new Error(`Unknown attr kind: ${node.kind}`);
+    }
+}
+/**
+ * Get token index
+ */
+function tokenIndex(string, token, position) {
+    const index = token.trim() === token ? (0, astro_1.skipSpaces)(string, position) : position;
+    if (string.startsWith(token, index)) {
+        return index;
+    }
+    throw new Error(`Unknown token at ${index}, expected: ${JSON.stringify(token)}, actual: ${JSON.stringify(string.slice(index, index + 10))}`);
+}