@markuplint/vue-parser 4.6.23 → 5.0.0-alpha.0

package/ARCHITECTURE.ja.md

@@ -79,9 +79,10 @@ Parser<ASTNode, State>  (@markuplint/parser-utils)
 | `nodeize()`           | vue-eslint-parser AST ノード（VText、VElement、VExpressionContainer）を markuplint AST に変換 |
 | `flattenNodes()`      | 基底のフラット化を拡張し、兄弟ノード間にテンプレートコメントを注入                            |
 | `afterFlattenNodes()` | `exposeWhiteSpace: false`、`exposeInvalidNode: false`、`concatText: false` で基底を呼び出す   |
-| `visitAttr()`         | Vue ディレクティブの省略形を `potentialName`/`isDirective` メタデータに解決                   |
 | `detectElementType()` | PascalCase コンポーネントと Vue 組み込みコンポーネントを検出                                  |
 
+> **注記:** `visitAttr()` オーバーライドは削除されました。Vue ディレクティブ処理（`v-bind`、`v-on`、`v-model`、`v-slot` など）は `@markuplint/vue-spec` の `directivePatterns` で管理されています。
+
 ### `duplicatableAttrs`
 
 `'class'` と `'style'` を含む `Set<string>` -- `v-bind:class` と `class` が同一要素に共存できるように、重複可能な属性を定義します。
@@ -134,9 +135,11 @@ Parser<ASTNode, State>  (@markuplint/parser-utils)
 
 この2パスアプローチが必要な理由は、vue-eslint-parser がコメントをメインノードツリーとは別に提供するため、正しい位置にインターリーブする必要があるからです。
 
-## 属性処理（visitAttr）
+## ディレクティブ処理（@markuplint/vue-spec の directivePatterns）
+
+Vue ディレクティブの解決はパーサー自体ではなく、`@markuplint/vue-spec` で定義された `directivePatterns` によって管理されています。spec がディレクティブを `potentialName`、`isDirective`、`isDynamicValue` メタデータにマッピングするパターンを宣言します。
 
-`visitAttr()` メソッドはまず `super.visitAttr(token)` を呼び出し、その後 Vue 固有のディレクティブ解決を適用します。
+> **二段階解決:** パーサーレベルのテスト（`index.spec.ts`）はパーサー自体が設定する raw AST 値を示します（例: 波括弧式のみ `isDynamicValue: true`）。コアレベルのテスト（`ml-core` や `rules`）は `ml-core` の `MLAttr` コンストラクタが `directivePatterns` を適用した後の最終解決値を示します。例えば、値なしの `on:click` はパーサーレベルでは `isDynamicValue: false` ですが、コアレベルでは `directivePatterns` マッチにより `isDynamicValue: true` に解決されます。
 
 ### クォートセット
 
@@ -228,6 +231,22 @@ Parser<ASTNode, State>  (@markuplint/parser-utils)
 
 vue-eslint-parser 依存は Vue 2 と Vue 3 の両方のテンプレート構文をサポートしています。パーサーは AST レベルで Vue バージョンを区別しません -- どちらも同じ `VElement`、`VText`、`VExpressionContainer` ノードタイプを生成します。Vue 3 固有の機能（`<Teleport>` や `<Suspense>` など）はパーサーレベルの変更ではなく、要素タイプ検出を通じて処理されます。
 
+## 制約事項
+
+### `v-if` / `v-for` の `blockBehavior` 未対応
+
+他のフレームワークパーサー（Svelte、Pug、Alpine、JSX、Astro）は条件分岐/ループ構文に `blockBehavior` を設定し、コアエンジンが `conditionalChildNodes()` を通じて全てのありうる子ノードパターンを列挙できるようにしています。Vue パーサーはこれを**サポートしていません**。そのため、`permitted-contents` などのルールは Vue テンプレートの `v-if`/`v-else` 分岐や `v-for` イテレーション全体のコンテンツモデル検証ができません。
+
+**実装が困難な理由:**
+
+Alpine.js では条件分岐とループに決まったパターン — `<template x-for="...">` / `<template x-if="...">` — を使用しており、`<template>` 要素をそのまま PSBlock に変換できます。Vue のディレクティブは根本的に異なる仕組みで動作します:
+
+1. **ディレクティブは任意の要素に付与可能**: `v-if`、`v-for`、`v-else`、`v-else-if` は任意の要素に配置できます（例: `<div v-if="...">`、`<li v-for="...">`）。要素は属性検証のために有効な HTML 要素として残しつつ、コンテンツモデル解析のためにブロックとしても機能させる必要があります — この二重の役割は現在のパーサーアーキテクチャではサポートされていません。
+
+2. **兄弟要素ベースの分岐**: `v-else` と `v-else-if` はラッパーブロックの子構造ではなく、**兄弟**要素の属性です。条件グループの構築には、現在のノード単位の `nodeize()` モデルを超えた兄弟間解析が必要です。
+
+現在の Vue パーサーはこれらのディレクティブを属性レベルでのみ処理しており（`isDirective: true`）、属性検証エラーは抑制されますが、構造的なブロック情報はコアエンジンに提供されません。
+
 ## 主要ソースファイル
 
 | ファイル                  | 用途                                                              |

package/ARCHITECTURE.md

@@ -79,9 +79,10 @@ The parser maintains internal state through the `State` type:
 | `nodeize()`           | Converts vue-eslint-parser AST nodes (VText, VElement, VExpressionContainer) to markuplint AST |
 | `flattenNodes()`      | Extends base flattening to inject template comments between sibling nodes                      |
 | `afterFlattenNodes()` | Calls base with `exposeWhiteSpace: false`, `exposeInvalidNode: false`, `concatText: false`     |
-| `visitAttr()`         | Resolves Vue directive shorthands to `potentialName`/`isDirective` metadata                    |
 | `detectElementType()` | Detects PascalCase components and Vue built-in components                                      |
 
+> **Note:** The `visitAttr()` override has been removed. Vue directive handling (`v-bind`, `v-on`, `v-model`, `v-slot`, etc.) is now managed via `directivePatterns` in `@markuplint/vue-spec`.
+
 ### `duplicatableAttrs`
 
 A `Set<string>` containing `'class'` and `'style'` -- attributes that may appear multiple times on a single element (via `v-bind:class` alongside `class`).
@@ -134,9 +135,11 @@ The `flattenNodes()` method extends the base `Parser.flattenNodes()` to inject t
 
 This two-pass approach is necessary because vue-eslint-parser provides comments separately from the main node tree, and they must be interleaved at the correct positions.
 
-## Attribute Processing (visitAttr)
+## Directive Handling (directivePatterns in @markuplint/vue-spec)
+
+Vue directive resolution is managed by `directivePatterns` defined in `@markuplint/vue-spec`, not by the parser itself. The spec declares patterns that the core engine uses to map directives to `potentialName`, `isDirective`, and `isDynamicValue` metadata.
 
-The `visitAttr()` method calls `super.visitAttr(token)` first, then applies Vue-specific directive resolution.
+> **Two-stage resolution:** Parser-level tests (`index.spec.ts`) show raw AST values where `isDynamicValue` and `isDirective` reflect only what the parser itself sets (e.g., curly-brace expressions). Core-level tests (`ml-core` and `rules`) show the final resolved values after `directivePatterns` are applied by `ml-core`'s `MLAttr` constructor. For example, `on:click` without a value shows `isDynamicValue: false` at the parser level, but resolves to `isDynamicValue: true` at the core level via the `directivePatterns` match.
 
 ### Quote Set
 
@@ -228,6 +231,22 @@ These settings reflect that Vue's template parser handles whitespace and node va
 
 The vue-eslint-parser dependency supports both Vue 2 and Vue 3 template syntax. The parser does not distinguish between Vue versions at the AST level -- both produce the same `VElement`, `VText`, and `VExpressionContainer` node types. Vue 3-specific features like `<Teleport>` and `<Suspense>` are handled through element type detection rather than parser-level changes.
 
+## Limitations
+
+### No `blockBehavior` support for `v-if` / `v-for`
+
+Other framework parsers (Svelte, Pug, Alpine, JSX, Astro) set `blockBehavior` on their conditional/loop constructs so that the core engine can enumerate all possible child node patterns via `conditionalChildNodes()`. The Vue parser does **not** support this. As a result, rules like `permitted-contents` cannot validate content models across `v-if`/`v-else` branches or `v-for` iterations in Vue templates.
+
+**Why this is difficult to implement:**
+
+In Alpine.js, conditionals and loops use a fixed pattern — `<template x-for="...">` / `<template x-if="...">` — where the `<template>` element can be cleanly converted into a PSBlock. Vue's directives work fundamentally differently:
+
+1. **Directives attach to arbitrary elements**: `v-if`, `v-for`, `v-else`, and `v-else-if` can appear on any element (e.g., `<div v-if="...">`, `<li v-for="...">`). The element must remain a valid HTML element for attribute validation while simultaneously acting as a block for content model analysis — a dual role the current parser architecture does not support.
+
+2. **Sibling-based branching**: `v-else` and `v-else-if` are attributes on **sibling** elements, not child constructs of a wrapper block. Building conditional groups requires cross-sibling analysis that goes beyond the current per-node `nodeize()` model.
+
+The current Vue parser handles these directives at the attribute level only (`isDirective: true`), which suppresses attribute validation errors but does not provide structural block information to the core engine.
+
 ## Key Source Files
 
 | File                      | Purpose                                                              |

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.0.0-alpha.0](https://github.com/markuplint/markuplint/compare/v4.14.1...v5.0.0-alpha.0) (2026-02-20)
+
+### Bug Fixes
+
+- **ml-core:** improve detection of namespace ([5b507ad](https://github.com/markuplint/markuplint/commit/5b507ad7c19c5015b8ce587845d901e31dfa6518))
+- **vue-parser:** update vue-eslint-parser to 10.3.0 and fix TS4053 errors ([b4633ea](https://github.com/markuplint/markuplint/commit/b4633eaeeb55c3b969127071094fde8e51bfb451))
+
+- refactor(vue-parser)!: update for simplified AST token properties ([b7e52df](https://github.com/markuplint/markuplint/commit/b7e52df21b6af0a4f2b61b327e60ed609f4359cc))
+
+### BREAKING CHANGES
+
+- Replace startOffset/endOffset with offset and
+  offset + raw.length in flattenNodes comment handling.
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+
 ## [4.6.23](https://github.com/markuplint/markuplint/compare/@markuplint/vue-parser@4.6.22...@markuplint/vue-parser@4.6.23) (2026-02-10)
 
 **Note:** Version bump only for package @markuplint/vue-parser

package/SKILL.md

@@ -14,12 +14,12 @@ detection, update vue-eslint-parser version support, and fix comment injection.
 
 `$ARGUMENTS` specifies the task. Supported tasks:
 
-| Task                            | Description                                      |
-| ------------------------------- | ------------------------------------------------ |
-| `add-directive`                 | Add or modify a Vue directive in visitAttr()     |
-| `modify-element-type-detection` | Update detectElementType() matchers              |
-| `update-vue-version-support`    | Handle vue-eslint-parser API changes             |
-| `fix-comment-injection`         | Fix template comment injection in flattenNodes() |
+| Task                            | Description                                                   |
+| ------------------------------- | ------------------------------------------------------------- |
+| `add-directive`                 | Add or modify a Vue directive in directivePatterns (vue-spec) |
+| `modify-element-type-detection` | Update detectElementType() matchers                           |
+| `update-vue-version-support`    | Handle vue-eslint-parser API changes                          |
+| `fix-comment-injection`         | Fix template comment injection in flattenNodes()              |
 
 If omitted, defaults to `add-directive`.
 
@@ -35,11 +35,11 @@ Also read:
 
 ## Task: add-directive
 
-Add or modify a Vue directive in `visitAttr()`. Follow recipe #1 in `docs/maintenance.md`.
+Add or modify a Vue directive in `directivePatterns` (`@markuplint/vue-spec`). Follow recipe #1 in `docs/maintenance.md`.
 
 ### Step 1: Understand the directive
 
-1. Read `src/parser.ts` and find the `visitAttr()` method
+1. Open `@markuplint/vue-spec` (`packages/@markuplint/vue-spec/src/index.ts`) and find the `directivePatterns` array
 2. Identify where in the priority chain the new directive should be processed
 3. Determine whether the directive needs `potentialName`, `isDirective`, or `isDynamicValue`
 
@@ -134,4 +134,4 @@ Fix template comment injection in `flattenNodes()`. Follow recipe #4 in `docs/ma
 3. **Use `isDirective: true`** for directives with no HTML equivalent (e.g., `v-if`, `v-for`).
 4. **Test with `nodeListToDebugMaps`** — this is the standard assertion pattern for parser tests.
 5. **Add JSDoc comments** to all new public methods and properties.
-6. **Preserve directive priority order** in `visitAttr()` — `v-on` before `v-bind` before `v-model` before `v-slot` before generic `v-`.
+6. **Preserve directive priority order** in `directivePatterns` — `.prop` shorthand before `v-bind` with modifiers before `v-bind`/`:` before `v-on`/`@` before `v-model` before `v-slot`/`#` before generic `v-`.

package/docs/maintenance.ja.md

@@ -49,7 +49,7 @@ expect(doc.nodeList[0].elementType).toBe('authored');
 
 ### 1. Vue ディレクティブの追加・変更
 
-1. `src/parser.ts` を読み、`visitAttr()` メソッドを見つける
+1. `@markuplint/vue-spec`（`packages/@markuplint/vue-spec/src/index.ts`）を開き、`directivePatterns` 配列を確認する
 2. 優先チェーン内の正しい位置を特定:
    - `v-on` / `@`（イベントバインディング） — 最初
    - `v-bind` / `:`（プロパティバインディング） — 2番目
@@ -158,12 +158,12 @@ yarn test --scope @markuplint/vue-parser
 
 **症状:** `v-custom` のような Vue ディレクティブが `isDirective: true` としてマークされず、通常の HTML 属性として扱われる。
 
-**原因:** `visitAttr()` でディレクティブパターンがマッチしないか、新しいディレクティブブロックが汎用 `v-*` キャッチオールの後に配置されている。
+**原因:** `directivePatterns`（`@markuplint/vue-spec` で定義）でディレクティブパターンがマッチしないか、新しいパターンが汎用 `v-*` キャッチオールの後に配置されている。
 
 **解決策:**
 
 1. ディレクティブブロックの正規表現パターンを確認 — 完全な属性名にマッチすることを確認
-2. ブロックが `visitAttr()` 末尾の汎用 `v-*` キャッチオールの前に配置されていることを確認
+2. パターンが `directivePatterns` 配列内の汎用 `v-*` キャッチオールの前に配置されていることを確認
 3. 返却オブジェクトに `isDirective: true as const` が含まれていることを検証
 
 ### テンプレートコメントが AST に含まれていない

package/docs/maintenance.md

@@ -49,7 +49,7 @@ expect(doc.nodeList[0].elementType).toBe('authored');
 
 ### 1. Adding or Modifying a Vue Directive
 
-1. Read `src/parser.ts` and find the `visitAttr()` method
+1. Open `@markuplint/vue-spec` (`packages/@markuplint/vue-spec/src/index.ts`) and find the `directivePatterns` array
 2. Identify the correct position in the priority chain:
    - `v-on` / `@` (event binding) — first
    - `v-bind` / `:` (property binding) — second
@@ -158,12 +158,12 @@ yarn test --scope @markuplint/vue-parser
 
 **Symptom:** A Vue directive like `v-custom` is treated as a regular HTML attribute instead of being marked as `isDirective: true`.
 
-**Cause:** The directive pattern does not match in `visitAttr()`, or the new directive block is placed after the generic `v-*` catch-all.
+**Cause:** The directive pattern does not match in `directivePatterns` (defined in `@markuplint/vue-spec`), or the new pattern is placed after the generic `v-*` catch-all.
 
 **Solution:**
 
 1. Check the regex pattern in your directive block — ensure it matches the full attribute name
-2. Ensure the block is placed before the generic `v-*` catch-all at the end of `visitAttr()`
+2. Ensure the pattern is placed before the generic `v-*` catch-all in the `directivePatterns` array
 3. Verify the return object includes `isDirective: true as const`
 
 ### Template comments are missing from the AST

package/lib/parser.d.ts

@@ -1,6 +1,5 @@
 import type { ASTNode, ASTComment } from './vue-parser/index.js';
 import type { MLASTParentNode, MLASTNodeTreeItem } from '@markuplint/ml-ast';
-import type { Token } from '@markuplint/parser-utils';
 import { ParserError, Parser } from '@markuplint/parser-utils';
 type State = {
     comments: readonly ASTComment[];
@@ -12,11 +11,10 @@ type State = {
  * Recognizes Vue built-in components and PascalCase user components.
  */
 declare class VueParser extends Parser<ASTNode, State> {
-    readonly duplicatableAttrs: Set<string>;
     constructor();
     tokenize(): {
-        ast: (import("vue-eslint-parser/ast/nodes").VElement | import("vue-eslint-parser/ast/nodes").VText | import("vue-eslint-parser/ast/nodes").VExpressionContainer)[];
-        isFragment: boolean;
+        readonly ast: ASTNode[];
+        readonly isFragment: boolean;
     };
     parseError(error: any): ParserError;
     /**
@@ -40,19 +38,6 @@ declare class VueParser extends Parser<ASTNode, State> {
      */
     flattenNodes(nodeTree: readonly MLASTNodeTreeItem[]): MLASTNodeTreeItem[];
     afterFlattenNodes(nodeList: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
-    /**
-     * Visits an attribute token and resolves Vue-specific directive shorthands.
-     * Handles `v-on` / `@` (event binding), `v-bind` / `:` (property binding),
-     * `v-model`, `v-slot` / `#`, and other `v-` prefixed directives.
-     *
-     * @param token - The token representing the attribute
-     * @returns The parsed attribute node with Vue-specific metadata
-     */
-    visitAttr(token: Token): (import("@markuplint/ml-ast").MLASTHTMLAttr & {
-        __rightText?: string;
-    }) | (import("@markuplint/ml-ast").MLASTSpreadAttr & {
-        __rightText?: string;
-    });
     /**
      * > In SFCs, it's recommended to use `PascalCase` tag names
      * > for child components to differentiate from native HTML elements.

package/lib/parser.js

@@ -13,7 +13,6 @@ class VueParser extends Parser {
         }, {
             comments: [],
         });
-        this.duplicatableAttrs = new Set(['class', 'style']);
     }
     tokenize() {
         const ast = vueParse(this.rawCode);
@@ -73,7 +72,6 @@ class VueParser extends Parser {
                     depth,
                     parentNode,
                     nodeName: originNode.name,
-                    namespace: originNode.namespace,
                 }, originNode.children, {
                     createEndTagToken: () => {
                         if (!originNode.endTag) {
@@ -103,9 +101,13 @@ class VueParser extends Parser {
         const newNodeList = [];
         let prevNode = null;
         for (const node of nodeList) {
-            const lastOffset = prevNode?.endOffset ?? node.parentNode?.endOffset ?? 0;
+            const lastOffset = prevNode
+                ? prevNode.offset + prevNode.raw.length
+                : node.parentNode
+                    ? node.parentNode.offset + node.parentNode.raw.length
+                    : 0;
             const betweenComment = this.state.comments.find(comment => {
-                return lastOffset <= comment.range[0] && comment.range[1] <= node.startOffset;
+                return lastOffset <= comment.range[0] && comment.range[1] <= node.offset;
             });
             if (betweenComment) {
                 const token = this.sliceFragment(betweenComment.range[0], betweenComment.range[1]);
@@ -135,108 +137,6 @@ class VueParser extends Parser {
             concatText: false,
         });
     }
-    /**
-     * Visits an attribute token and resolves Vue-specific directive shorthands.
-     * Handles `v-on` / `@` (event binding), `v-bind` / `:` (property binding),
-     * `v-model`, `v-slot` / `#`, and other `v-` prefixed directives.
-     *
-     * @param token - The token representing the attribute
-     * @returns The parsed attribute node with Vue-specific metadata
-     */
-    visitAttr(token) {
-        const attr = super.visitAttr(token);
-        if (attr.type === 'spread') {
-            return attr;
-        }
-        {
-            /**
-             * `v-on`
-             */
-            const [, directive, potentialName] = attr.name.raw.match(/^(v-on:|@)([^.]+)(?:\.([^.]+))?$/i) ?? [];
-            if (directive && potentialName) {
-                return {
-                    ...attr,
-                    potentialName: `on${potentialName.toLowerCase()}`,
-                    isDynamicValue: true,
-                };
-            }
-        }
-        {
-            /**
-             * `v-bind`
-             */
-            const [, directive, potentialName, modifier] = attr.name.raw.match(/^(v-bind:|:)([^.]+)(?:\.([^.]+))?$/i) ?? [];
-            if (directive && potentialName) {
-                if (this.duplicatableAttrs.has(potentialName.toLowerCase())) {
-                    this.updateAttr(attr, { isDuplicatable: true });
-                }
-                if (!modifier) {
-                    return {
-                        ...attr,
-                        potentialName,
-                        isDynamicValue: true,
-                    };
-                }
-                switch (modifier) {
-                    case '.attr': {
-                        return {
-                            ...attr,
-                            potentialName,
-                            isDynamicValue: true,
-                        };
-                    }
-                    /* eslint-disable unicorn/no-useless-switch-case */
-                    case '.prop':
-                    case '.camel':
-                    default: {
-                        const name = `v-bind:${potentialName}${modifier ?? ''}`;
-                        return {
-                            ...attr,
-                            potentialName: attr.name.raw === name ? undefined : name,
-                            isDirective: true,
-                        };
-                    }
-                    /* eslint-enable unicorn/no-useless-switch-case */
-                }
-            }
-        }
-        {
-            /**
-             * `v-model`
-             */
-            const [, directive] = attr.name.raw.match(/^(v-model)(?:\.([^.]+))?$/i) ?? [];
-            if (directive) {
-                return {
-                    ...attr,
-                    isDirective: true,
-                };
-            }
-        }
-        {
-            /**
-             * `v-slot`
-             */
-            const slotName = (attr.name.raw.match(/^(v-slot:|#)(.+)$/i) ?? [])[2];
-            const name = `v-slot:${slotName}`;
-            if (slotName) {
-                return {
-                    ...attr,
-                    potentialName: attr.name.raw === name ? undefined : name,
-                    isDirective: true,
-                };
-            }
-        }
-        /**
-         * If directives
-         */
-        if (attr.name.raw.startsWith('v-')) {
-            return {
-                ...attr,
-                isDirective: true,
-            };
-        }
-        return attr;
-    }
     /**
      * > In SFCs, it's recommended to use `PascalCase` tag names
      * > for child components to differentiate from native HTML elements.

package/lib/vue-parser/index.d.ts

@@ -8,7 +8,10 @@ export type VueTokens = VueESLintParser.AST.ESLintProgram;
  * @returns The parsed AST program node containing the template body
  */
 export declare function vueParse(vueTemplate: string): VueTokens;
+export type VElement = VueESLintParser.AST.VElement;
+export type VText = VueESLintParser.AST.VText;
+export type VExpressionContainer = VueESLintParser.AST.VExpressionContainer;
 /** Union of AST node types that can appear as children in a Vue template. */
-export type ASTNode = VueESLintParser.AST.VElement | VueESLintParser.AST.VText | VueESLintParser.AST.VExpressionContainer;
+export type ASTNode = VElement | VText | VExpressionContainer;
 /** Represents a comment token in the Vue template AST with location information. */
 export type ASTComment = VueESLintParser.AST.Token & VueESLintParser.AST.HasLocation;

package/package.json

@@ -1,10 +1,13 @@
 {
 	"name": "@markuplint/vue-parser",
-	"version": "4.6.23",
+	"version": "5.0.0-alpha.0",
 	"description": "Vue parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
+	"engines": {
+		"node": ">=22"
+	},
 	"type": "module",
 	"exports": {
 		".": {
@@ -21,10 +24,10 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.6.23",
-		"@markuplint/ml-ast": "4.4.11",
-		"@markuplint/parser-utils": "4.8.11",
-		"vue-eslint-parser": "10.2.0"
+		"@markuplint/html-parser": "5.0.0-alpha.0",
+		"@markuplint/ml-ast": "5.0.0-alpha.0",
+		"@markuplint/parser-utils": "5.0.0-alpha.0",
+		"vue-eslint-parser": "10.4.0"
 	},
-	"gitHead": "193ee7c1262bbed95424e38efdf1a8e56ff049f4"
+	"gitHead": "13dcfc84ec83d87360c720e253383b60767e1b56"
 }