@markuplint/astro-parser 4.6.23 → 4.18.3

package/ARCHITECTURE.ja.md

@@ -191,20 +191,48 @@ Astro テンプレートディレクティブは `name:modifier` 構文を使用
 - ショートハンド属性: `{prop}`
 - ネストされた式: `style={{ a: b }}`
 
+### スプレッド属性
+
+スプレッド属性（`{...EXPR}`）は、基底の `Parser.visitAttr()` に委譲する **前**に、`visitAttr()` 内の波括弧対応プリパス（`src/spread-attr.ts` 参照）で抽出されます。プリパスは生のトークンを 1 文字ずつ走査し、以下を考慮します:
+
+- 文字列リテラル（`'`、`"`）
+- `${}` 補間付きテンプレートリテラル
+- 行コメント（`//`）とブロックコメント（`/* */`）
+- バックスラッシュでエスケープされたクォート（連続するバックスラッシュの偶奇判定）
+
+スプレッドトークンに対しては上流の `safeScriptParser`（espree ベース）を意図的に回避します。理由:
+
+1. espree は `{...x as any}` のような TypeScript 構文を理解せず、`as` の手前でスプレッドを誤って終端させる。
+2. espree は「valid な JS プレフィックス」をスプレッドの閉じ `}` を超えて貪欲に伸ばすことがあり、例えば `{...props}>{label}` を二項 `>` 式として解釈してしまい、次の兄弟ノードを呑み込み `Invalid tag syntax` エラーになる。
+
+両方とも [#3824](https://github.com/markuplint/markuplint/issues/3824) で報告された症状です。プリパスは `{...}` 境界を純粋な波括弧マッチング問題として扱うことで両方を解消します。
+
+**波括弧マッチャの既知の制限**:
+
+- 波括弧を含む正規表現リテラル（例: `{...x.match(/}/) ? a : b}`）は認識しません。`/` は常に除算演算子として扱われます。遭遇した場合は変数に切り出して回避してください。
+
+**撤去条件**: `parser-utils/script-parser.ts` が TypeScript 構文を理解し、かつスプレッドの `}` を超えて伸びないように改善された場合、本パッケージの `src/spread-attr.ts` と `visitAttr()` のプリパスは削除し、基底パーサーのパスに戻すことが可能です。
+
+### Raw-text 要素の本文（`<script>`、`<style>`）
+
+`AstroParser.visitElement()` は **要素全体（本文・終了タグを含む）の raw 文字列**を `parser-utils` の `parseCodeFragment()` に渡し、最初のノードを開始タグ、最後のノードを終了タグとして使います。`<script>` や `<style>` の本文をそのまま再トークナイズすると、`/<br\s*\/?>/gi` のような正規表現がタグとして誤読され `Invalid tag syntax` で失敗します（[#3860](https://github.com/markuplint/markuplint/issues/3860)、[#3825](https://github.com/markuplint/markuplint/issues/3825) の v4 backport）。
+
+raw-text の安全性は `parser-utils` 側に委譲しています。`parseCodeFragment()` は `rawTextElements`（既定 `['style', 'script']`）を認識し、本文を次に現れる ASCII 大文字小文字非依存の `</tagName`（タブ/LF/FF/CR/空白/`>` /`/` のいずれかが続く）まで丸ごと消費します（[HTML LS §13.2.5.1](https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions)）。`astro-parser` 側に専用分岐は不要で、`parsedNodes[0]` と `parsedNodes[-1]` がそれぞれ開始タグ・終了タグになる既存フローのまま動作します。
+
 ## jsx-parser との比較
 
-| 機能                           | `astro-parser`                         | `jsx-parser`                                      |
-| ------------------------------ | -------------------------------------- | ------------------------------------------------- |
-| **トークナイザ**               | `astro-eslint-parser`                  | TypeScript ESTree（`@typescript-eslint/parser`）  |
-| **フロントマター**             | サポート（`---...---` psblock）        | 該当なし                                          |
-| **式の構文**                   | `{expr}` を MustacheTag psblock として | `{expr}` を JSXExpressionContainer psblock として |
-| **テンプレートディレクティブ** | `class:list`、`set:html` 等            | 該当なし                                          |
-| **名前空間管理**               | `#updateScopeNS()` で手動管理          | html-parser の `getNamespace()` に委譲            |
-| **コンポーネント検出**         | `/^[A-Z]/` パターン                    | `/^[A-Z]/` パターン                               |
-| **自己閉じタイプ**             | `html+xml`                             | デフォルト（XML のみ）                            |
-| **booleanish 属性**            | 未設定                                 | `booleanish: true`                                |
-| **名前なしフラグメント**       | `<>...</>` サポート                    | `<>...</>` サポート                               |
-| **スプレッド属性**             | 基底パーサーで処理                     | カスタム `visitSpreadAttr()` で IDL ルックアップ  |
+| 機能                           | `astro-parser`                                  | `jsx-parser`                                      |
+| ------------------------------ | ----------------------------------------------- | ------------------------------------------------- |
+| **トークナイザ**               | `astro-eslint-parser`                           | TypeScript ESTree（`@typescript-eslint/parser`）  |
+| **フロントマター**             | サポート（`---...---` psblock）                 | 該当なし                                          |
+| **式の構文**                   | `{expr}` を MustacheTag psblock として          | `{expr}` を JSXExpressionContainer psblock として |
+| **テンプレートディレクティブ** | `class:list`、`set:html` 等                     | 該当なし                                          |
+| **名前空間管理**               | `#updateScopeNS()` で手動管理                   | html-parser の `getNamespace()` に委譲            |
+| **コンポーネント検出**         | `/^[A-Z]/` パターン                             | `/^[A-Z]/` パターン                               |
+| **自己閉じタイプ**             | `html+xml`                                      | デフォルト（XML のみ）                            |
+| **booleanish 属性**            | 未設定                                          | `booleanish: true`                                |
+| **名前なしフラグメント**       | `<>...</>` サポート                             | `<>...</>` サポート                               |
+| **スプレッド属性**             | `visitAttr()` 内の波括弧対応プリパス（TS 対応） | カスタム `visitSpreadAttr()` で IDL ルックアップ  |
 
 ## バージョン互換性
 
@@ -218,11 +246,12 @@ astro-eslint-parser → @astrojs/compiler → Astro 構文サポート
 
 ## 主要ソースファイル
 
-| ファイル          | 用途                                                                                  |
-| ----------------- | ------------------------------------------------------------------------------------- |
-| `parser.ts`       | `AstroParser` クラス — 全オーバーライドメソッドと名前空間スコーピング                 |
-| `astro-parser.ts` | `astroParse()` ラッパー — `astro-eslint-parser` に委譲し、診断を `ParserError` に変換 |
-| `index.ts`        | 公開 API — シングルトン `parser` インスタンスを再エクスポート                         |
+| ファイル          | 用途                                                                                   |
+| ----------------- | -------------------------------------------------------------------------------------- |
+| `parser.ts`       | `AstroParser` クラス — 全オーバーライドメソッドと名前空間スコーピング                  |
+| `astro-parser.ts` | `astroParse()` ラッパー — `astro-eslint-parser` に委譲し、診断を `ParserError` に変換  |
+| `spread-attr.ts`  | `visitAttr()` が使用する波括弧対応スプレッド属性抽出器（上記「スプレッド属性」を参照） |
+| `index.ts`        | 公開 API — シングルトン `parser` インスタンスを再エクスポート                          |
 
 ## ドキュメントマップ
 

package/ARCHITECTURE.md

@@ -191,20 +191,48 @@ Any attribute whose start quote is `{` gets `isDynamicValue: true`. This applies
 - Shorthand attributes: `{prop}`
 - Nested expressions: `style={{ a: b }}`
 
+### Spread Attributes
+
+Spread attributes (`{...EXPR}`) are extracted by a brace-aware pre-pass in `visitAttr()` (see `src/spread-attr.ts`) **before** delegating to the base `Parser.visitAttr()`. The pre-pass walks the raw token character by character with awareness of:
+
+- string literals (`'`, `"`)
+- template literals with `${}` interpolation
+- line (`//`) and block (`/* */`) comments
+- backslash-escaped quotes (counting consecutive backslashes for parity)
+
+This bypasses the upstream `safeScriptParser` (espree-based) for spread tokens because espree:
+
+1. Does not understand TypeScript syntax such as `{...x as any}` and would terminate the spread early at `as`.
+2. May greedily extend a "valid JS prefix" past the spread's closing `}` into surrounding HTML — for example `{...props}>{label}` is interpreted as a binary `>` expression, swallowing the next sibling and producing `Invalid tag syntax`.
+
+Both failure modes were reported in [#3824](https://github.com/markuplint/markuplint/issues/3824). The pre-pass solves them by treating the `{...}` boundary as a pure brace-matching problem.
+
+**Known limitations** of the brace matcher:
+
+- Regular-expression literals containing braces (e.g. `{...x.match(/}/) ? a : b}`) are not recognised — `/` is always treated as a division operator. Rewrite via a variable indirection if encountered.
+
+**Retraction condition**: if `parser-utils/script-parser.ts` is upgraded to handle TypeScript syntax and to stop extending past the spread's `}`, this package's `src/spread-attr.ts` and the `visitAttr()` pre-pass can be removed and the base parser path restored.
+
+### Raw-text Element Bodies (`<script>`, `<style>`)
+
+`AstroParser.visitElement()` hands the **entire element source** (including body and end tag) to `parser-utils`'s `parseCodeFragment()` and uses the first parsed node as the start tag and the last as the end tag. For `<script>` and `<style>`, the body would otherwise be re-tokenized as HTML — and a regex such as `/<br\s*\/?>/gi` inside a script body would be misread as a tag, causing `Invalid tag syntax` ([#3860](https://github.com/markuplint/markuplint/issues/3860), v4 backport of [#3825](https://github.com/markuplint/markuplint/issues/3825)).
+
+Raw-text safety is delegated to `parser-utils`: `parseCodeFragment()` recognizes `rawTextElements` (default `['style', 'script']`) and consumes the body verbatim until the next ASCII-case-insensitive `</tagName` followed by a tab/LF/FF/CR/space/`>` /`/`, per [HTML LS §13.2.5.1](https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions). `astro-parser` requires no special-case branch — the existing `visitElement()` flow continues to work because the start tag and end tag still occupy `parsedNodes[0]` and `parsedNodes[-1]` respectively.
+
 ## Comparison with jsx-parser
 
-| Feature                   | `astro-parser`                  | `jsx-parser`                                    |
-| ------------------------- | ------------------------------- | ----------------------------------------------- |
-| **Tokenizer**             | `astro-eslint-parser`           | TypeScript ESTree (`@typescript-eslint/parser`) |
-| **Frontmatter**           | Supported (`---...---` psblock) | Not applicable                                  |
-| **Expression syntax**     | `{expr}` as MustacheTag psblock | `{expr}` as JSXExpressionContainer psblock      |
-| **Template directives**   | `class:list`, `set:html`, etc.  | Not applicable                                  |
-| **Namespace management**  | Manual via `#updateScopeNS()`   | Delegates to `getNamespace()` from html-parser  |
-| **Component detection**   | `/^[A-Z]/` pattern              | `/^[A-Z]/` pattern                              |
-| **Self-close type**       | `html+xml`                      | Default (XML-only)                              |
-| **Booleanish attributes** | Not configured                  | `booleanish: true`                              |
-| **Nameless fragments**    | `<>...</>` supported            | `<>...</>` supported                            |
-| **Spread attributes**     | Handled by base parser          | Custom `visitSpreadAttr()` with IDL lookup      |
+| Feature                   | `astro-parser`                                   | `jsx-parser`                                    |
+| ------------------------- | ------------------------------------------------ | ----------------------------------------------- |
+| **Tokenizer**             | `astro-eslint-parser`                            | TypeScript ESTree (`@typescript-eslint/parser`) |
+| **Frontmatter**           | Supported (`---...---` psblock)                  | Not applicable                                  |
+| **Expression syntax**     | `{expr}` as MustacheTag psblock                  | `{expr}` as JSXExpressionContainer psblock      |
+| **Template directives**   | `class:list`, `set:html`, etc.                   | Not applicable                                  |
+| **Namespace management**  | Manual via `#updateScopeNS()`                    | Delegates to `getNamespace()` from html-parser  |
+| **Component detection**   | `/^[A-Z]/` pattern                               | `/^[A-Z]/` pattern                              |
+| **Self-close type**       | `html+xml`                                       | Default (XML-only)                              |
+| **Booleanish attributes** | Not configured                                   | `booleanish: true`                              |
+| **Nameless fragments**    | `<>...</>` supported                             | `<>...</>` supported                            |
+| **Spread attributes**     | Brace-aware pre-pass in `visitAttr()` (TS-aware) | Custom `visitSpreadAttr()` with IDL lookup      |
 
 ## Version Compatibility
 
@@ -222,6 +250,7 @@ astro-eslint-parser → @astrojs/compiler → Astro syntax support
 | ----------------- | -------------------------------------------------------------------------------------------------- |
 | `parser.ts`       | `AstroParser` class — all override methods and namespace scoping                                   |
 | `astro-parser.ts` | `astroParse()` wrapper — delegates to `astro-eslint-parser`, converts diagnostics to `ParserError` |
+| `spread-attr.ts`  | Brace-aware spread-attribute extractor used by `visitAttr()` (see Spread Attributes above)         |
 | `index.ts`        | Public API — re-exports the singleton `parser` instance                                            |
 
 ## Documentation Map

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.18.3](https://github.com/markuplint/markuplint/compare/v4.18.2...v4.18.3) (2026-05-10)
+
+### Bug Fixes
+
+- **astro-parser:** preserve spread attributes containing TypeScript and expression-child siblings ([fe76c34](https://github.com/markuplint/markuplint/commit/fe76c34f04b6ce2559c8fbfad01df525781ef34d)), closes [#3824](https://github.com/markuplint/markuplint/issues/3824)
+- **astro-parser:** stop surfacing non-fatal Astro diagnostics as parse errors ([3b51f6c](https://github.com/markuplint/markuplint/commit/3b51f6c34d200c04006c283a62becb5733673fac)), closes [#3823](https://github.com/markuplint/markuplint/issues/3823)
+
+# [4.18.0](https://github.com/markuplint/markuplint/compare/v4.14.1...v4.18.0) (2026-04-22)
+
+**Note:** Version bump only for package @markuplint/astro-parser
+
+## [4.6.24](https://github.com/markuplint/markuplint/compare/@markuplint/astro-parser@4.6.23...@markuplint/astro-parser@4.6.24) (2026-04-21)
+
+**Note:** Version bump only for package @markuplint/astro-parser
+
 ## [4.6.23](https://github.com/markuplint/markuplint/compare/@markuplint/astro-parser@4.6.22...@markuplint/astro-parser@4.6.23) (2026-02-10)
 
 **Note:** Version bump only for package @markuplint/astro-parser

package/docs/maintenance.ja.md

@@ -112,11 +112,12 @@ expect(debugMaps).toStrictEqual([
 
 上流パッケージの変更がこのパーサーに影響を与える可能性があります:
 
-| パッケージ                 | 影響                                                        |
-| -------------------------- | ----------------------------------------------------------- |
-| `@markuplint/parser-utils` | 基底 `Parser` クラスの変更は全オーバーライドメソッドに影響  |
-| `@markuplint/ml-ast`       | AST 型の変更は `nodeize()` の戻り値の型に影響               |
-| `astro-eslint-parser`      | パーサー出力形式の変更は `tokenize()` と `nodeize()` に影響 |
+| パッケージ                               | 影響                                                                                                  |
+| ---------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `@markuplint/parser-utils`               | 基底 `Parser` クラスの変更は全オーバーライドメソッドに影響                                            |
+| `@markuplint/parser-utils/script-parser` | TS 対応と非貪欲なパースが上流に入った場合、`src/spread-attr.ts` と `visitAttr()` のプリパスは削除可能 |
+| `@markuplint/ml-ast`                     | AST 型の変更は `nodeize()` の戻り値の型に影響                                                         |
+| `astro-eslint-parser`                    | パーサー出力形式の変更は `tokenize()` と `nodeize()` に影響                                           |
 
 `astro-eslint-parser` を更新する場合:
 
@@ -131,6 +132,23 @@ yarn upgrade @astrojs/compiler --scope @markuplint/astro-parser --dev
 yarn build --scope @markuplint/astro-parser && yarn test --scope @markuplint/astro-parser
 ```
 
+## dev (v5 RC) からの fix port 手順
+
+`dev` と `v4` は自動マージ不可 — 両方に当てる必要がある fix は手動で port する。最も頻発する port hazard は `Token` のフィールド名差:
+
+| v4 (本ブランチ)                                | dev (v5 RC)                                                 |
+| ---------------------------------------------- | ----------------------------------------------------------- |
+| `token.startOffset` / `startLine` / `startCol` | `token.offset` / `line` / `col`                             |
+| `token.endOffset` / `endLine` / `endCol`       | `#getEndLocation()` ヘルパが `{ offset, line, col }` を返す |
+| `MLASTText` は `parentNode` のみ               | `MLASTText` は `parentNodeUuid` も持つ                      |
+
+dev fix を port する手順:
+
+1. dev のソース変更とテストを両方読む。`token.line` / `token.col` / `token.offset` で assert しているテストは v4 では `startLine` / `startCol` / `startOffset` に書き換える。
+2. v4 のフィールド名でソース変更を適用。`yarn build` で `TS2339` が出れば見落としを fail-fast に検出できる。
+3. dev と同じ `#NNNN` describe id を v4 でも使う — id を揃えると後から両ブランチを grep で対比しやすい。
+4. JSDoc / `parser-class.md` / 該当パッケージの `maintenance.md` Troubleshooting に dev / v4 の Issue・PR を相互リンク。次に port する人が関係を再発見しなくて済む。
+
 ## トラブルシューティング
 
 ### フロントマターが認識されない
@@ -181,3 +199,34 @@ yarn build --scope @markuplint/astro-parser && yarn test --scope @markuplint/ast
 1. 属性名の形式を確認 — 正規表現はコロンが1つだけで、両側に空でない部分が必要
 2. `switch (lowerCaseDirectiveName)` を確認 — ディレクティブプレフィックスがケースにマッチする必要がある
 3. 新しいディレクティブプレフィックスの場合は、新しいケースを追加（レシピ #1 参照）
+
+### スプレッド属性が途中で切れる、または `{...EXPR}` の直後に式の子があると `Invalid tag syntax` が発生する
+
+**症状:** 次のいずれか:
+
+- `{...{ command: 'close' } as any}` が部分的なスプレッドと不正な `as` / `any}` 属性に分割される。
+- `<div {...props}>{label}</div>`（または `{label}` のような式の子をスプレッド属性の直後に持つ要素）が `SyntaxError: Invalid tag syntax: ...` をスローする。
+
+**原因:** 要素の生トークンが、`src/spread-attr.ts` の波括弧対応抽出器ではなく `parser-utils/safeScriptParser`（espree ベース）にルーティングされている。`safeScriptParser` は TypeScript 構文（`as`）を理解せず、また「valid な JS プレフィックス」をスプレッドの `}` を超えて周囲の HTML まで伸ばすことがある（`{...props}>{label}` を二項 `>` 式として解釈）。
+
+**解決策:**
+
+1. `src/parser.ts` の `visitAttr()` が `super.visitAttr()` の **前**に `./spread-attr.js` の `extractSpreadAttribute()` を呼んでいることを確認。順序が重要 — 基底パスにフォールスルーするとバグが発動する。
+2. 新しいエッジケースが報告されたら、`src/spread-attr.spec.ts` で `findMatchingBrace()` のユニットテストとして再現し、波括弧マッチャに追加のエスケープルール（文字列 / テンプレート / コメント / バックスラッシュ）が必要かを判断。
+3. 既知の制限は `src/spread-attr.ts` の JSDoc に記載 — 波括弧を含む正規表現リテラルは扱えない。新たな制限が見つかったらそこに追記。
+
+オリジナルの報告とスプレッド属性を `parser-utils` ではなく本パッケージで処理する根拠については [#3824](https://github.com/markuplint/markuplint/issues/3824) を参照。
+
+### `<script>` または `<style>` の本文で `Invalid tag syntax` が throw する
+
+**症状:** `<script>` 本文の JS/TS に HTML 風の部分文字列（典型的には `/<br\s*\/?>/gi` や `/<\/?p>/gi` のような正規表現）が含まれると `ParserError: SyntaxError: Invalid tag syntax: "..."` で落ちる。`<style>` 本文中の `/* <br = */` のような CSS コメントでも同種の症状が出る。
+
+**原因:** `AstroParser.visitElement()` は要素全体（本文を含む）の raw 文字列を `parser-utils` の `parseCodeFragment()` に渡している。raw-text 認識がないと `parseCodeFragment()` は本文を HTML として再トークナイズし、正規表現中の `<br...>` をタグ開始と解釈、続く `\s`（リテラルなバックスラッシュ）を属性名とみなして throw する。
+
+**解決策:** raw-text の安全性は `parser-utils/parser.ts` の `parseCodeFragment()` 内に実装されている。自閉でない開始タグの `nodeName.toLowerCase()` が `rawTextElements` に含まれる場合、本文は次に現れる ASCII 大文字小文字非依存の `</tagName`（タブ/LF/FF/CR/空白/`>` /`/` のいずれかが続く）まで丸ごと消費される（HTML LS §13.2.5.1）。リグレッションが疑われたら:
+
+1. `npx vitest run packages/@markuplint/astro-parser/src/parser.spec.ts -t "#3860"` で失敗フィクスチャがまだ再現するかを確認。
+2. 修正は `astro-parser` 内ではない。`packages/@markuplint/parser-utils/src/parser.ts` の `parseCodeFragment()` を見て raw-text 分岐が無傷か、close-tag 正規表現が仕様の文字クラスにまだ一致するかを確認する。
+3. 別の上流 parser が `astro-parser` と同様に要素全体の raw を `parseCodeFragment` に渡すケースが追加された場合、追加配線は不要 — 同じ parser-utils 分岐がそのままカバーする。
+
+オリジナルの報告は [#3860](https://github.com/markuplint/markuplint/issues/3860)（[#3825](https://github.com/markuplint/markuplint/issues/3825) の v4 backport）を参照。dev (v5 RC) には [#3859](https://github.com/markuplint/markuplint/pull/3859) が先行マージされている。今後 raw-text 周りの変更を port する際は両 PR を diff 比較すること。

package/docs/maintenance.md

@@ -112,11 +112,12 @@ The second argument `true` to `nodeListToDebugMaps` includes attribute details i
 
 Changes to upstream packages can affect this parser:
 
-| Package                    | Impact                                                           |
-| -------------------------- | ---------------------------------------------------------------- |
-| `@markuplint/parser-utils` | Base `Parser` class changes affect all override methods          |
-| `@markuplint/ml-ast`       | AST type changes affect `nodeize()` return types                 |
-| `astro-eslint-parser`      | Parser output format changes affect `tokenize()` and `nodeize()` |
+| Package                                  | Impact                                                                                                             |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `@markuplint/parser-utils`               | Base `Parser` class changes affect all override methods                                                            |
+| `@markuplint/parser-utils/script-parser` | If TS support and non-greedy parsing land here, `src/spread-attr.ts` and the `visitAttr()` pre-pass can be removed |
+| `@markuplint/ml-ast`                     | AST type changes affect `nodeize()` return types                                                                   |
+| `astro-eslint-parser`                    | Parser output format changes affect `tokenize()` and `nodeize()`                                                   |
 
 When updating `astro-eslint-parser`:
 
@@ -131,6 +132,23 @@ yarn upgrade @astrojs/compiler --scope @markuplint/astro-parser --dev
 yarn build --scope @markuplint/astro-parser && yarn test --scope @markuplint/astro-parser
 ```
 
+## Porting Fixes from dev (v5 RC)
+
+`dev` and `v4` cannot be merged automatically — fixes that need to land on both branches are ported manually. The most common port hazard is the `Token` field rename:
+
+| v4 (this branch)                               | dev (v5 RC)                                                                  |
+| ---------------------------------------------- | ---------------------------------------------------------------------------- |
+| `token.startOffset` / `startLine` / `startCol` | `token.offset` / `line` / `col`                                              |
+| `token.endOffset` / `endLine` / `endCol`       | computed via `#getEndLocation()` helper that returns `{ offset, line, col }` |
+| `MLASTText` has only `parentNode`              | `MLASTText` adds `parentNodeUuid`                                            |
+
+Procedure when porting a dev fix:
+
+1. Read both the dev source change and the dev tests, including any test that asserts on `token.line` / `token.col` / `token.offset` — those need to become `startLine` / `startCol` / `startOffset` on v4.
+2. Apply the source change with the v4 field names. `yarn build` should fail fast with `TS2339` on any field you missed.
+3. Re-run the v4 test fixtures against the same `#NNNN` describe id used on dev — keeping the id stable lets future maintainers grep across both branches.
+4. Cross-link both Issues / PRs in the JSDoc, `parser-class.md`, and the package's `maintenance.md` Troubleshooting entry so the next porter doesn't have to re-discover the relationship.
+
 ## Troubleshooting
 
 ### Frontmatter is not recognized
@@ -181,3 +199,34 @@ yarn build --scope @markuplint/astro-parser && yarn test --scope @markuplint/ast
 1. Verify the attribute name format — the regex requires exactly one colon with non-empty parts on both sides
 2. Check the `switch (lowerCaseDirectiveName)` — the directive prefix must match a case
 3. If it is a new directive prefix, add a new case (see Recipe #1)
+
+### Spread attribute is truncated, or `Invalid tag syntax` is thrown for `{...EXPR}` followed by an expression child
+
+**Symptom:** Either of the following:
+
+- `{...{ command: 'close' } as any}` is split into a partial spread plus bogus `as` / `any}` attributes.
+- `<div {...props}>{label}</div>` (or any element with a spread attribute followed immediately by an expression child like `{label}`) throws `SyntaxError: Invalid tag syntax: ...`.
+
+**Cause:** The element's raw token is being routed through `parser-utils/safeScriptParser` (espree-based) instead of the brace-aware extractor in `src/spread-attr.ts`. `safeScriptParser` does not understand TypeScript syntax (`as`) and may extend a "valid JS prefix" past the spread's `}` into the surrounding HTML (interpreting `{...props}>{label}` as a binary `>` expression).
+
+**Solution:**
+
+1. Confirm `src/parser.ts` `visitAttr()` calls `extractSpreadAttribute()` from `./spread-attr.js` _before_ `super.visitAttr()`. The order matters — falling through to the base path is what triggers the bug.
+2. If a new edge case is reported, reproduce it as a unit test in `src/spread-attr.spec.ts` with `findMatchingBrace()` and decide whether the brace matcher needs an additional escape rule (string / template / comment / backslash).
+3. Known limitations are listed in `src/spread-attr.ts` JSDoc — regular-expression literals containing braces are not handled. Document any additional limitations there.
+
+See [#3824](https://github.com/markuplint/markuplint/issues/3824) for the original report and the rationale for handling spread attributes locally instead of in `parser-utils`.
+
+### `<script>` or `<style>` body throws `Invalid tag syntax`
+
+**Symptom:** A `<script>` body containing JavaScript / TypeScript with HTML-like substrings (most commonly a regex such as `/<br\s*\/?>/gi` or `/<\/?p>/gi`) throws `ParserError: SyntaxError: Invalid tag syntax: "..."`. Same for `<style>` bodies that include CSS comments such as `/* <br = */`.
+
+**Cause:** `AstroParser.visitElement()` passes the entire element source (including body) to `parser-utils`'s `parseCodeFragment()`. Without raw-text awareness, `parseCodeFragment()` would treat the body as HTML and try to tokenize the regex's `<br...>` as a start tag, hitting `\s` (literal backslash) where an attribute name is expected.
+
+**Solution:** Raw-text safety lives in `parser-utils/parser.ts` `parseCodeFragment()` — after a non-self-closing start tag whose `nodeName.toLowerCase()` matches `rawTextElements`, the body is consumed verbatim until the next ASCII-case-insensitive `</tagName` followed by a tab/LF/FF/CR/space/`>` /`/` (HTML LS §13.2.5.1). If a regression appears here:
+
+1. Verify the failing fixture still reproduces by running `npx vitest run packages/@markuplint/astro-parser/src/parser.spec.ts -t "#3860"`.
+2. The fix is _not_ inside `astro-parser` — inspect `packages/@markuplint/parser-utils/src/parser.ts` `parseCodeFragment()` to confirm the raw-text branch is intact and the close-tag regex still matches the spec character class.
+3. If a different upstream parser is added that hands the full element raw to `parseCodeFragment` (similar to `astro-parser`), no extra wiring is needed — the same parser-utils branch covers it.
+
+See [#3860](https://github.com/markuplint/markuplint/issues/3860) (v4 backport of [#3825](https://github.com/markuplint/markuplint/issues/3825)) for the original report. The dev (v5 RC) implementation landed first via [#3859](https://github.com/markuplint/markuplint/pull/3859) — diff-compare both PRs when porting future raw-text changes.

package/lib/astro-parser.d.ts

@@ -2,9 +2,39 @@ import type { RootNode } from '@astrojs/compiler/types';
 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 throws on severity=Error diagnostics and on raw
+ * template syntax errors (unterminated comments, unclosed expressions,
+ * etc.) by raising a `SyntaxError`-derived `ParseError`. Those throws are
+ * caught and normalized to `ParserError`, so the caller sees a single
+ * Tier-3 (per-file violation) error type for every parse failure rather
+ * than a Tier-1 fatal `SyntaxError` that would abort the whole lint run.
+ *
+ * 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,74 @@
 import { ParserError } from '@markuplint/parser-utils';
 import { parseTemplate } from 'astro-eslint-parser';
+/**
+ * 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.
+ *
+ * @see https://github.com/withastro/compiler/blob/main/packages/compiler/shared/types.ts
+ */
+const ASTRO_DIAGNOSTIC_SEVERITY_ERROR = 1;
 /**
  * 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 throws on severity=Error diagnostics and on raw
+ * template syntax errors (unterminated comments, unclosed expressions,
+ * etc.) by raising a `SyntaxError`-derived `ParseError`. Those throws are
+ * caught and normalized to `ParserError`, so the caller sees a single
+ * Tier-3 (per-file violation) error type for every parse failure rather
+ * than a Tier-1 fatal `SyntaxError` that would abort the whole lint run.
+ *
+ * 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 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 (!(error instanceof SyntaxError)) {
+            throw error;
+        }
+        const { lineNumber, column } = error;
+        throw new ParserError(error.message, {
+            line: lineNumber ?? 1,
+            col: 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/parser.d.ts

@@ -54,14 +54,14 @@ declare class AstroParser extends Parser<Node, State> {
     /**
      * Visits an attribute token, handling Astro-specific syntax including
      * curly-brace expression values, shorthand attributes (`{name}`),
-     * and template directives (e.g., `class:list`, `set:html`).
+     * spread attributes (`{...expr}`, including TypeScript and nested
+     * expressions, see #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

@@ -6,6 +6,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _AstroParser_instances, _AstroParser_updateScopeNS;
 import { AttrState, Parser, ParserError } from '@markuplint/parser-utils';
 import { astroParse } from './astro-parser.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,
@@ -201,12 +202,41 @@ class AstroParser extends Parser {
     /**
      * Visits an attribute token, handling Astro-specific syntax including
      * curly-brace expression values, shorthand attributes (`{name}`),
-     * and template directives (e.g., `class:list`, `set:html`).
+     * spread attributes (`{...expr}`, including TypeScript and nested
+     * expressions, see #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) {
+        const spreadHit = extractSpreadAttribute(token.raw);
+        if (spreadHit) {
+            let spreadStartLine = token.startLine;
+            let spreadStartCol = token.startCol;
+            for (const c of spreadHit.leadingSpace) {
+                if (c === '\n') {
+                    spreadStartLine++;
+                    spreadStartCol = 1;
+                }
+                else {
+                    spreadStartCol++;
+                }
+            }
+            const spread = super.visitSpreadAttr({
+                raw: spreadHit.spreadRaw,
+                startOffset: token.startOffset + spreadHit.leadingSpace.length,
+                startLine: spreadStartLine,
+                startCol: spreadStartCol,
+            });
+            // `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' },

package/lib/spread-attr.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Locates the matching closing brace for a JS-like expression that starts at
+ * `raw[start]` (which must be `{`), respecting string literals (`'`, `"`),
+ * template literals with `${}` interpolation, and line/block comments.
+ *
+ * Returns the index of the matching `}`, or -1 if no match is found.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare function findMatchingBrace(raw: string, start: number): number;
+/**
+ * Detects whether the given attribute token starts with an Astro spread
+ * attribute (`{...EXPR}`) and, if so, returns the spread's exact slice plus
+ * the leading whitespace and any leftover trailing text after the spread.
+ *
+ * Returns null when the token is not a spread attribute.
+ *
+ * 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,116 @@
+/**
+ * Counts consecutive backslashes immediately before position `i` in `raw`.
+ * An odd count means the character at `i` is escaped; an even count means
+ * the preceding backslashes are themselves paired escapes.
+ */
+function countPrecedingBackslashes(raw, i) {
+    let n = 0;
+    let j = i - 1;
+    while (j >= 0 && raw[j] === '\\') {
+        n++;
+        j--;
+    }
+    return n;
+}
+/**
+ * Locates the matching closing brace for a JS-like expression that starts at
+ * `raw[start]` (which must be `{`), respecting string literals (`'`, `"`),
+ * template literals with `${}` interpolation, and line/block comments.
+ *
+ * Returns the index of the matching `}`, or -1 if no match is found.
+ *
+ * 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.
+ *
+ * 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.
+ */
+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;
+}
+/**
+ * Detects whether the given attribute token starts with an Astro spread
+ * attribute (`{...EXPR}`) and, if so, returns the spread's exact slice plus
+ * the leading whitespace and any leftover trailing text after the spread.
+ *
+ * Returns null when the token is not a spread attribute.
+ *
+ * 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": "4.6.23",
+	"version": "4.18.3",
 	"description": "astro parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -21,12 +21,12 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "4.4.11",
-		"@markuplint/parser-utils": "4.8.11",
-		"astro-eslint-parser": "1.2.2"
+		"@markuplint/ml-ast": "4.18.0",
+		"@markuplint/parser-utils": "4.18.3",
+		"astro-eslint-parser": "1.4.0"
 	},
 	"devDependencies": {
-		"@astrojs/compiler": "2.13.1"
+		"@astrojs/compiler": "3.0.1"
 	},
-	"gitHead": "193ee7c1262bbed95424e38efdf1a8e56ff049f4"
+	"gitHead": "c53026c2c600bb304f2088589f67303479e92e62"
 }

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

@@ -1,2 +0,0 @@
-import type { MLASTBlockBehavior } from '@markuplint/ml-ast';
-export declare function detectBlockBehavior(raw: string): MLASTBlockBehavior | null;

package/lib/detect-block-behavior.js

@@ -1,12 +0,0 @@
-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);
-    if (!match) {
-        return null;
-    }
-    const type = match.groups?.type === 'map' ? 'each' : 'if';
-    return {
-        type,
-        expression: raw,
-    };
-}