@markuplint/astro-parser 5.0.0-rc.4 → 5.0.0-rc.5

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.0.0-rc.5](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.4...v5.0.0-rc.5) (2026-08-28)
+
+### Bug Fixes
+
+- **astro-parser:** discriminate astro-eslint-parser ParseError from Tier 1 SyntaxError ([f961bf8](https://github.com/markuplint/markuplint/commit/f961bf8a89e3713565b06ff51bd214e6d69dea3e))
+- **astro-parser:** preserve spread attributes containing TypeScript and expression-child siblings ([0e4c64d](https://github.com/markuplint/markuplint/commit/0e4c64d90f77f9350a4895f24ba07ec90eda6546)), closes [#3856](https://github.com/markuplint/markuplint/issues/3856)
+- **astro-parser:** stop surfacing non-fatal Astro diagnostics as parse errors ([3a2c262](https://github.com/markuplint/markuplint/commit/3a2c262316e58196838ab075d5a554751cd976ac)), closes [#3834](https://github.com/markuplint/markuplint/issues/3834) [#3823](https://github.com/markuplint/markuplint/issues/3823)
+
 # [5.0.0-rc.4](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.3...v5.0.0-rc.4) (2026-04-19)
 
 **Note:** Version bump only for package @markuplint/astro-parser

package/lib/astro-parser.d.ts

@@ -1,10 +1,45 @@
 import type { RootNode } from '@astrojs/compiler/types';
+/**
+ * `@astrojs/compiler` is a dev dependency used only for these type
+ * definitions; the runtime AST actually comes from `astro-eslint-parser`.
+ * When upgrading `astro-eslint-parser`, also update `@astrojs/compiler` to
+ * the version it uses internally, otherwise the types drift from the
+ * runtime AST shape.
+ */
 export type { RootNode, ElementNode, CustomElementNode, ComponentNode, FragmentNode, AttributeNode, Node, } from '@astrojs/compiler/types';
 /**
- * Parses an Astro component source string into the Astro compiler's root AST node.
- * Delegates to astro-eslint-parser and converts any diagnostics into ParserErrors.
+ * ## Diagnostic handling policy
+ *
+ * Only **severity=Error** Astro diagnostics surface as a `ParserError`.
+ * Warning / Information / Hint diagnostics are passed through silently
+ * because the AST is still fully populated for those levels and Astro's own
+ * tooling (the language server, `astro check`) owns the user-facing message
+ * — markuplint must not surface them as fatal `parse-error`s (#3823).
+ *
+ * Concretely, the `is:inline` Hint that Astro emits for a `<script>` tag
+ * carrying any non-`src` attribute, and the `set:html` Warning for
+ * `set:html` overwriting children, both reach this wrapper but do not
+ * abort parsing.
+ *
+ * ## Error normalization
+ *
+ * `parseTemplate()` itself raises an `astro-eslint-parser` `ParseError`
+ * (extending `SyntaxError`) on severity=Error diagnostics and on raw
+ * template syntax errors (unterminated comments, unclosed expressions,
+ * etc.). Those — and only those — are normalized to `ParserError`, so the
+ * caller sees a single Tier-3 (per-file violation) error type for every
+ * parse failure. Any other throw, including a genuine `SyntaxError` from a
+ * markuplint invariant break, is allowed to propagate so the standard
+ * `isFatalError()` gate further up the stack can classify it as Tier 1.
+ *
+ * The defensive `find(severity === Error)` after `parseTemplate()` is dead
+ * code today (upstream gates internally) but is retained as a safety net
+ * if a future `astro-eslint-parser` ever stops gating severity=Error.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/3823
+ * @see https://docs.astro.build/en/reference/directives-reference/#isinline
+ * @see https://docs.astro.build/en/guides/client-side-scripts/#script-processing
  *
- * @param code - The raw Astro component source code
- * @returns The root AST node produced by the Astro compiler
+ * @throws {ParserError} on severity=Error Astro diagnostics or on raw upstream syntax errors
  */
 export declare function astroParse(code: string): RootNode;

package/lib/astro-parser.js

@@ -1,19 +1,88 @@
 import { ParserError } from '@markuplint/parser-utils';
 import { parseTemplate } from 'astro-eslint-parser';
 /**
- * Parses an Astro component source string into the Astro compiler's root AST node.
- * Delegates to astro-eslint-parser and converts any diagnostics into ParserErrors.
+ * Astro tags each diagnostic with a VS Code-style severity
+ * (1=Error, 2=Warning, 3=Information, 4=Hint). The compiler exposes the
+ * enum as types-only via `@astrojs/compiler/types` — there is no runtime
+ * value to import — so the fatal level is mirrored as a literal here.
  *
- * @param code - The raw Astro component source code
- * @returns The root AST node produced by the Astro compiler
+ * @see https://github.com/withastro/compiler/blob/main/packages/compiler/shared/types.ts
+ */
+const ASTRO_DIAGNOSTIC_SEVERITY_ERROR = 1;
+/**
+ * Type guard for `astro-eslint-parser`'s `ParseError` class. The class
+ * extends `SyntaxError` and carries a unique `originalAST` instance
+ * property; the duck-type check on that property identifies it without
+ * depending on the constructor name (which a future bundler could mangle).
+ *
+ * Why a positive identity check matters: `isFatalError()` from
+ * `@markuplint/shared` classifies *every* `SyntaxError` as Tier 1
+ * (implementation bug, must propagate). The Astro upstream chose to
+ * subclass `SyntaxError` for ergonomic reasons, but the value it raises is
+ * semantically a per-file parse failure that markuplint must convert to
+ * `ParserError` (Tier 3). See `isFatalError()` in `@markuplint/shared` —
+ * Tier 1 covers only errors raised by markuplint's own code.
+ */
+function isAstroEslintParseError(error) {
+    return error instanceof SyntaxError && 'originalAST' in error;
+}
+/**
+ * ## Diagnostic handling policy
+ *
+ * Only **severity=Error** Astro diagnostics surface as a `ParserError`.
+ * Warning / Information / Hint diagnostics are passed through silently
+ * because the AST is still fully populated for those levels and Astro's own
+ * tooling (the language server, `astro check`) owns the user-facing message
+ * — markuplint must not surface them as fatal `parse-error`s (#3823).
+ *
+ * Concretely, the `is:inline` Hint that Astro emits for a `<script>` tag
+ * carrying any non-`src` attribute, and the `set:html` Warning for
+ * `set:html` overwriting children, both reach this wrapper but do not
+ * abort parsing.
+ *
+ * ## Error normalization
+ *
+ * `parseTemplate()` itself raises an `astro-eslint-parser` `ParseError`
+ * (extending `SyntaxError`) on severity=Error diagnostics and on raw
+ * template syntax errors (unterminated comments, unclosed expressions,
+ * etc.). Those — and only those — are normalized to `ParserError`, so the
+ * caller sees a single Tier-3 (per-file violation) error type for every
+ * parse failure. Any other throw, including a genuine `SyntaxError` from a
+ * markuplint invariant break, is allowed to propagate so the standard
+ * `isFatalError()` gate further up the stack can classify it as Tier 1.
+ *
+ * The defensive `find(severity === Error)` after `parseTemplate()` is dead
+ * code today (upstream gates internally) but is retained as a safety net
+ * if a future `astro-eslint-parser` ever stops gating severity=Error.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/3823
+ * @see https://docs.astro.build/en/reference/directives-reference/#isinline
+ * @see https://docs.astro.build/en/guides/client-side-scripts/#script-processing
+ *
+ * @throws {ParserError} on severity=Error Astro diagnostics or on raw upstream syntax errors
  */
 export function astroParse(code) {
-    const { result } = parseTemplate(code);
-    if (result.diagnostics[0]) {
-        const error = result.diagnostics[0];
-        throw new ParserError(error.text, {
-            line: error.location.line,
-            col: error.location.column,
+    let result;
+    try {
+        ({ result } = parseTemplate(code));
+    }
+    catch (error) {
+        if (!isAstroEslintParseError(error)) {
+            throw error;
+        }
+        throw new ParserError(error.message, {
+            line: typeof error.lineNumber === 'number' ? error.lineNumber : 1,
+            col: typeof error.column === 'number' ? error.column : 0,
+        });
+    }
+    // Defensive: if a future `astro-eslint-parser` stops gating severity=Error
+    // diagnostics internally, surface them here so they never silently leak
+    // past the wrapper as a non-fatal pass-through.
+    const fatal = result.diagnostics.find(d => d.severity === ASTRO_DIAGNOSTIC_SEVERITY_ERROR);
+    if (fatal) {
+        throw new ParserError(fatal.text, {
+            line: fatal.location.line,
+            col: fatal.location.column,
         });
     }
     return result.ast;

package/lib/component-scanner.js

@@ -1,7 +1,4 @@
 import { parser } from './parser.js';
-/**
- * Extracts root element information from a parsed MLAST document.
- */
 function extractComponentInfo(doc) {
     const root = doc.nodeList.find((n) => n.type === 'starttag' && n.depth === 0 && !n.isFragment);
     if (!root) {
@@ -28,15 +25,9 @@ function extractComponentInfo(doc) {
         col: root.col,
     };
 }
-/**
- * Detects whether the parsed Astro template contains `<slot>` elements.
- */
 function detectSlots(doc) {
     return doc.nodeList.some(n => n.type === 'starttag' && n.nodeName === 'slot');
 }
-/**
- * Extracts the frontmatter block (`---...---`) from an Astro component source.
- */
 function extractAstroFrontmatter(source) {
     const re = /^(?:\s*\n)?---\r?\n/;
     const startMatch = re.exec(source);

package/lib/detect-block-behavior.d.ts

@@ -1,10 +1,2 @@
 import type { MLASTBlockBehavior } from '@markuplint/ml-ast';
-/**
- * Detects the block behavior of an Astro expression by inspecting its raw
- * source for `.map()` or `.filter()` array method calls. Maps `.map()` to
- * `'each'` (iteration) and `.filter()` to `'if'` (conditional filtering).
- *
- * @param raw - The raw source text of the expression to analyze
- * @returns The detected block behavior, or `null` if no recognized pattern is found
- */
 export declare function detectBlockBehavior(raw: string): MLASTBlockBehavior | null;

package/lib/detect-block-behavior.js

@@ -1,11 +1,3 @@
-/**
- * Detects the block behavior of an Astro expression by inspecting its raw
- * source for `.map()` or `.filter()` array method calls. Maps `.map()` to
- * `'each'` (iteration) and `.filter()` to `'if'` (conditional filtering).
- *
- * @param raw - The raw source text of the expression to analyze
- * @returns The detected block behavior, or `null` if no recognized pattern is found
- */
 export function detectBlockBehavior(raw) {
     const re = /\.+\s*(?<type>map|filter)\s*\((?:function\s*\(.[^\n\r{\u2028\u2029]*\{.*return\s*$|.+=>\s*\(?\s*)/;
     const match = raw.match(re);

package/lib/parser.d.ts

@@ -7,6 +7,11 @@ import { Parser } from '@markuplint/parser-utils';
  * Extends the base Parser to handle Astro-specific syntax including frontmatter blocks,
  * expression containers (`{}`), component/element/fragment types, Astro directives
  * (e.g., `class:list`, `set:html`), and shorthand attributes.
+ *
+ * When forward-porting a fix from the `v4` branch, beware the `Token` field
+ * rename: v4 uses `startOffset` / `startLine` / `startCol` where this branch
+ * uses `offset` / `line` / `col` (also in AST properties asserted in spec
+ * files). The build surfaces mismatches as `TS2339`.
  */
 declare class AstroParser extends Parser<Node> {
     constructor();
@@ -31,6 +36,17 @@ declare class AstroParser extends Parser<Node> {
      * the start tag, then delegating to the base visitElement with Astro-specific
      * options including nameless fragment support.
      *
+     * This hands the entire element source (including body and end tag) to
+     * `parseCodeFragment()`. Raw-text safety for `<script>` and `<style>`
+     * bodies is owned by parser-utils' `parseCodeFragment()` (its
+     * `rawTextElements` handling per HTML LS 13.2.5.1); without it, HTML-like
+     * substrings in a script body (e.g. a regex matching a `<br>` tag) would
+     * be re-tokenized as tags and throw `Invalid tag syntax` (#3825). If that
+     * regression reappears, the fix belongs in parser-utils, not here.
+     *
+     * @see https://github.com/markuplint/markuplint/issues/3825
+     * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
+     *
      * @param token - The child token representing the element
      * @param childNodes - The child Astro AST nodes within the element
      * @returns An array of markuplint node tree items
@@ -49,14 +65,14 @@ declare class AstroParser extends Parser<Node> {
     /**
      * Visits an attribute token, handling Astro-specific syntax including
      * curly-brace expression values, shorthand attributes (`{name}`),
+     * spread attributes (`{...expr}`, including TypeScript and nested
+     * expressions, see #3856; root cause originally reported as #3824),
      * and template directives (e.g., `class:list`, `set:html`).
      *
      * @param token - The token representing the attribute
      * @returns The parsed attribute node with Astro-specific metadata
      */
-    visitAttr(token: Token): (import("@markuplint/ml-ast").MLASTSpreadAttr & {
-        __rightText?: string;
-    }) | {
+    visitAttr(token: Token): import("@markuplint/ml-ast").MLASTSpreadAttr | {
         isDynamicValue: true | undefined;
         isDirective: true | undefined;
         potentialName: string | undefined;

package/lib/parser.js

@@ -1,17 +1,26 @@
 import { AttrState, Parser, ParserError } from '@markuplint/parser-utils';
 import { astroParse } from './astro-parser.js';
 import { detectBlockBehavior } from './detect-block-behavior.js';
+import { extractSpreadAttribute } from './spread-attr.js';
 /**
  * Parser implementation for Astro component templates.
  * Extends the base Parser to handle Astro-specific syntax including frontmatter blocks,
  * expression containers (`{}`), component/element/fragment types, Astro directives
  * (e.g., `class:list`, `set:html`), and shorthand attributes.
+ *
+ * When forward-porting a fix from the `v4` branch, beware the `Token` field
+ * rename: v4 uses `startOffset` / `startLine` / `startCol` where this branch
+ * uses `offset` / `line` / `col` (also in AST properties asserted in spec
+ * files). The build surfaces mismatches as `TS2339`.
  */
 class AstroParser extends Parser {
     constructor() {
         super({
+            // Astro requires explicit closing tags like XML.
             endTagType: 'xml',
+            // Accepts both HTML void elements and XML-style self-closing (`<Component />`).
             selfCloseType: 'html+xml',
+            // Distinguishes components (`<MyComp>`) from HTML elements (`<div>`).
             tagNameCaseSensitive: true,
         });
     }
@@ -145,6 +154,17 @@ class AstroParser extends Parser {
      * the start tag, then delegating to the base visitElement with Astro-specific
      * options including nameless fragment support.
      *
+     * This hands the entire element source (including body and end tag) to
+     * `parseCodeFragment()`. Raw-text safety for `<script>` and `<style>`
+     * bodies is owned by parser-utils' `parseCodeFragment()` (its
+     * `rawTextElements` handling per HTML LS 13.2.5.1); without it, HTML-like
+     * substrings in a script body (e.g. a regex matching a `<br>` tag) would
+     * be re-tokenized as tags and throw `Invalid tag syntax` (#3825). If that
+     * regression reappears, the fix belongs in parser-utils, not here.
+     *
+     * @see https://github.com/markuplint/markuplint/issues/3825
+     * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
+     *
      * @param token - The child token representing the element
      * @param childNodes - The child Astro AST nodes within the element
      * @returns An array of markuplint node tree items
@@ -196,12 +216,45 @@ class AstroParser extends Parser {
     /**
      * Visits an attribute token, handling Astro-specific syntax including
      * curly-brace expression values, shorthand attributes (`{name}`),
+     * spread attributes (`{...expr}`, including TypeScript and nested
+     * expressions, see #3856; root cause originally reported as #3824),
      * and template directives (e.g., `class:list`, `set:html`).
      *
      * @param token - The token representing the attribute
      * @returns The parsed attribute node with Astro-specific metadata
      */
     visitAttr(token) {
+        // The spread pre-pass MUST run before `super.visitAttr()`: falling
+        // through to the base path routes the token through the espree-based
+        // `safeScriptParser`, which reproduces the truncation and
+        // `Invalid tag syntax` failures of #3824 / #3856.
+        const spreadHit = extractSpreadAttribute(token.raw);
+        if (spreadHit) {
+            let spreadLine = token.line;
+            let spreadCol = token.col;
+            for (const c of spreadHit.leadingSpace) {
+                if (c === '\n') {
+                    spreadLine++;
+                    spreadCol = 1;
+                }
+                else {
+                    spreadCol++;
+                }
+            }
+            const spread = super.visitSpreadAttr({
+                raw: spreadHit.spreadRaw,
+                offset: token.offset + spreadHit.leadingSpace.length,
+                line: spreadLine,
+                col: spreadCol,
+            });
+            // `extractSpreadAttribute` already validates the `{...EXPR}` shape
+            // so `super.visitSpreadAttr` is expected to return a node here.
+            // Falling through to the generic attr path is a defensive safeguard
+            // against future shape changes in the parent class.
+            if (spread) {
+                return spreadHit.leftover ? { ...spread, __rightText: spreadHit.leftover } : spread;
+            }
+        }
         const attr = super.visitAttr(token, {
             quoteSet: [
                 { start: '"', end: '"', type: 'string' },
@@ -224,6 +277,12 @@ class AstroParser extends Parser {
         /**
          * Detects Template Directive
          *
+         * `class:` is special-cased with `potentialName: 'class'` so markuplint
+         * rules for the standard `class` attribute still apply to `class:list`.
+         * Every other `prefix:name` pattern gets `isDirective: true`, which
+         * tells markuplint it is framework-specific and must not be validated
+         * as a standard HTML attribute.
+         *
          * @see https://docs.astro.build/en/reference/directives-reference/
          */
         const [, directive] = attr.name.raw.match(/^([^:]+):([^:]+)$/) ?? [];

package/lib/spread-attr.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Why this exists: `safeScriptParser` (espree-based) does not understand
+ * TypeScript syntax such as `{...x as any}` and may also extend a "valid JS
+ * prefix" past the spread's closing brace into surrounding HTML
+ * (e.g. `{...props}>{label}` is parsed as a binary `>` expression),
+ * misclassifying both the spread end and any expression-child siblings.
+ * See https://github.com/markuplint/markuplint/issues/3824 (v4) and
+ * https://github.com/markuplint/markuplint/issues/3856 (dev/v5).
+ *
+ * Known limitation: regular-expression literals containing braces
+ * (e.g. `{...x.match(/}/) ? a : b}`) are not recognised — `/` is always
+ * treated as a division operator. Such patterns are vanishingly rare in
+ * Astro spread attributes; rewrite via a variable indirection if needed.
+ *
+ * This is intentionally a minimal brace matcher, not a full JavaScript
+ * lexer: when a new edge case is reported, extend the string / comment /
+ * escape branches with the minimum change rather than introducing a lexer.
+ *
+ * Retraction condition: if parser-utils' `script-parser.ts` is upgraded to
+ * handle TypeScript syntax and to stop extending past the spread's closing
+ * `}`, this module and the `visitAttr()` pre-pass in `parser.ts` can be
+ * removed and the base parser path restored.
+ */
+export declare function findMatchingBrace(raw: string, start: number): number;
+/**
+ * Exported so the brace-matching logic can be unit-tested independently of
+ * the parser pipeline.
+ */
+export declare function extractSpreadAttribute(raw: string): {
+    leadingSpace: string;
+    spreadRaw: string;
+    leftover: string;
+} | null;

package/lib/spread-attr.js

@@ -0,0 +1,109 @@
+function countPrecedingBackslashes(raw, i) {
+    let n = 0;
+    let j = i - 1;
+    while (j >= 0 && raw[j] === '\\') {
+        n++;
+        j--;
+    }
+    return n;
+}
+/**
+ * Why this exists: `safeScriptParser` (espree-based) does not understand
+ * TypeScript syntax such as `{...x as any}` and may also extend a "valid JS
+ * prefix" past the spread's closing brace into surrounding HTML
+ * (e.g. `{...props}>{label}` is parsed as a binary `>` expression),
+ * misclassifying both the spread end and any expression-child siblings.
+ * See https://github.com/markuplint/markuplint/issues/3824 (v4) and
+ * https://github.com/markuplint/markuplint/issues/3856 (dev/v5).
+ *
+ * Known limitation: regular-expression literals containing braces
+ * (e.g. `{...x.match(/}/) ? a : b}`) are not recognised — `/` is always
+ * treated as a division operator. Such patterns are vanishingly rare in
+ * Astro spread attributes; rewrite via a variable indirection if needed.
+ *
+ * This is intentionally a minimal brace matcher, not a full JavaScript
+ * lexer: when a new edge case is reported, extend the string / comment /
+ * escape branches with the minimum change rather than introducing a lexer.
+ *
+ * Retraction condition: if parser-utils' `script-parser.ts` is upgraded to
+ * handle TypeScript syntax and to stop extending past the spread's closing
+ * `}`, this module and the `visitAttr()` pre-pass in `parser.ts` can be
+ * removed and the base parser path restored.
+ */
+export function findMatchingBrace(raw, start) {
+    if (raw[start] !== '{')
+        return -1;
+    let depth = 0;
+    let inString = null;
+    const templateBraceStack = [];
+    for (let i = start; i < raw.length; i++) {
+        const c = raw[i];
+        if (inString) {
+            if (inString === '`') {
+                if (c === '`' && countPrecedingBackslashes(raw, i) % 2 === 0) {
+                    inString = null;
+                }
+                else if (c === '$' && raw[i + 1] === '{') {
+                    templateBraceStack.push(depth);
+                    inString = null;
+                    depth++;
+                    i++;
+                }
+            }
+            else if (c === inString && countPrecedingBackslashes(raw, i) % 2 === 0) {
+                inString = null;
+            }
+            continue;
+        }
+        if (c === '/' && raw[i + 1] === '/') {
+            while (i < raw.length && raw[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (c === '/' && raw[i + 1] === '*') {
+            i += 2;
+            while (i < raw.length - 1 && !(raw[i] === '*' && raw[i + 1] === '/'))
+                i++;
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === '`') {
+            inString = c;
+            continue;
+        }
+        if (c === '{') {
+            depth++;
+        }
+        else if (c === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+            if (templateBraceStack.length > 0 && depth === templateBraceStack.at(-1)) {
+                templateBraceStack.pop();
+                inString = '`';
+            }
+        }
+    }
+    return -1;
+}
+/**
+ * Exported so the brace-matching logic can be unit-tested independently of
+ * the parser pipeline.
+ */
+export function extractSpreadAttribute(raw) {
+    const leadingMatch = /^\s*/.exec(raw);
+    const leadingSpace = leadingMatch?.[0] ?? '';
+    const remaining = raw.slice(leadingSpace.length);
+    // eslint-disable-next-line regexp/strict
+    if (!/^{\s*\.{3}[^.]/.test(remaining)) {
+        return null;
+    }
+    const end = findMatchingBrace(remaining, 0);
+    if (end < 0)
+        return null;
+    return {
+        leadingSpace,
+        spreadRaw: remaining.slice(0, end + 1),
+        leftover: remaining.slice(end + 1),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/astro-parser",
-	"version": "5.0.0-rc.4",
+	"version": "5.0.0-rc.5",
 	"description": "astro parser for markuplint",
 	"repository": {
 		"type": "git",
@@ -10,7 +10,7 @@
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"engines": {
-		"node": ">=22"
+		"node": ">=24"
 	},
 	"type": "module",
 	"exports": {
@@ -32,12 +32,12 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "5.0.0-rc.4",
-		"@markuplint/parser-utils": "5.0.0-rc.4",
+		"@markuplint/ml-ast": "5.0.0-rc.5",
+		"@markuplint/parser-utils": "5.0.0-rc.5",
 		"astro-eslint-parser": "1.4.0"
 	},
 	"devDependencies": {
 		"@astrojs/compiler": "3.0.1"
 	},
-	"gitHead": "97a6339bbae23f556de5d307b3ce2ef7cfd9402d"
+	"gitHead": "8d87463af2ff3f1b83fb28da20f1819362cf3555"
 }