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

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) {
@@ -29,9 +26,8 @@ function extractComponentInfo(doc) {
     };
 }
 /**
- * Detects whether the parsed Svelte template contains slot usage.
- *
- * Supports:
+ * Slot usage can take several forms whose mapping to psblock node names is
+ * not derivable from this code:
  * - Svelte 4: `<slot>` element (parsed as psblock `#ps:SlotElement`)
  * - Svelte 5: `{@render children()}` (parsed as psblock `#ps:RenderTag`)
  * - Standard `<slot>` elements
@@ -41,7 +37,6 @@ function detectSlots(doc) {
         (n.type === 'psblock' && (n.nodeName === '#ps:SlotElement' || n.nodeName === '#ps:RenderTag')));
 }
 /**
- * Extracts the instance `<script>` block from a Svelte component source.
  * Prefers the instance script over `<script context="module">`.
  */
 function extractSvelteScript(source) {
@@ -63,9 +58,8 @@ function extractSvelteScript(source) {
             offset: contentStart,
         };
         if (!isModule) {
-            return block; // Prefer instance script
+            return block;
         }
-        // Remember module script as fallback
         moduleBlock ??= block;
     }
     return moduleBlock;

package/lib/parse-block.d.ts

@@ -1,17 +1,6 @@
 import type { SvelteParser } from './parser.js';
 import type { ChildToken, Token } from '@markuplint/parser-utils';
 import type { SvelteBlock } from './svelte-parser/index.js';
-/**
- * Extracts the open and close tag tokens from a Svelte block construct
- * (e.g., `{#each}...{/each}`, `{#key}...{/key}`).
- * Locates the closing `{/xxx}` tag via regex and computes the opening token
- * based on the block's child fragment boundaries.
- *
- * @param parser - The SvelteParser instance used to slice source fragments
- * @param token - The child token representing the entire block range
- * @param originBlockNode - The Svelte AST block node being parsed
- * @returns An object containing the `openToken` and `closeToken` for the block
- */
 export declare function parseBlock(parser: SvelteParser, token: ChildToken, originBlockNode: SvelteBlock): {
     openToken: Token;
     closeToken: Token;

package/lib/parse-block.js

@@ -1,14 +1,3 @@
-/**
- * Extracts the open and close tag tokens from a Svelte block construct
- * (e.g., `{#each}...{/each}`, `{#key}...{/key}`).
- * Locates the closing `{/xxx}` tag via regex and computes the opening token
- * based on the block's child fragment boundaries.
- *
- * @param parser - The SvelteParser instance used to slice source fragments
- * @param token - The child token representing the entire block range
- * @param originBlockNode - The Svelte AST block node being parsed
- * @returns An object containing the `openToken` and `closeToken` for the block
- */
 export function parseBlock(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 parser, token, 
@@ -16,6 +5,9 @@ parser, token,
 originBlockNode) {
     const range = token.raw;
     /**
+     * The close tag is the final `{/xxx}`; intermediate `{:xxx}` clauses
+     * (e.g. `{:else}`, `{:then}`) must not be matched, hence the `$` anchor.
+     *
      * `{#xxx}...{:xxx}...{/xxx}`
      *             find___^
      */
@@ -24,9 +16,6 @@ originBlockNode) {
     if (eachCloseStartIndex == null) {
         throw new SyntaxError('Block close tag not found');
     }
-    /**
-     * `{/xxx}`
-     */
     const closeToken = parser.sliceFragment(token.offset + eachCloseStartIndex, originBlockNode.end);
     const fragment = originBlockNode.type === 'IfBlock'
         ? originBlockNode.consequent.nodes

package/lib/parser.d.ts

@@ -18,35 +18,11 @@ export declare class SvelteParser extends Parser<SvelteNode> {
     };
     parse(raw: string, options?: ParseOptions): import("@markuplint/ml-ast").MLASTDocument;
     parseError(error: any): ParserError;
-    /**
-     * Converts a Svelte AST node into markuplint node tree items.
-     * Dispatches on the node type to handle Text, Comment, ExpressionTag,
-     * elements (Component, RegularElement), and control flow blocks
-     * (IfBlock, EachBlock, AwaitBlock, KeyBlock, SnippetBlock).
-     *
-     * @param originNode - The Svelte AST node to convert
-     * @param parentNode - The parent node in the markuplint tree, or null for root nodes
-     * @param depth - The nesting depth of the node
-     * @returns An array of markuplint node tree items
-     */
     nodeize(originNode: SvelteNode, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
-    /**
-     * Visits a text token, converting `<script>` tags embedded in Svelte template
-     * text into preprocessor-specific blocks rather than treating them as raw text.
-     *
-     * @param token - The child token representing the text content
-     * @returns An array of markuplint node tree items
-     */
     visitText(token: ChildToken): readonly MLASTNodeTreeItem[];
     /**
-     * Visits a preprocessor-specific block token and enforces that exactly one
-     * block node is produced. Throws a ParserError if the result is empty
-     * or contains multiple nodes.
-     *
-     * @param token - The child token with node name and fragment flag
-     * @param childNodes - The child Svelte AST nodes within the block
-     * @param blockBehavior - The block behavior, or null
-     * @returns A single-element tuple containing the preprocessor-specific block
+     * Invariant: exactly one block node must be produced; an empty or
+     * multi-node result indicates a parse error.
      */
     visitPsBlock(token: ChildToken & {
         readonly nodeName: string;
@@ -68,6 +44,11 @@ export declare class SvelteParser extends Parser<SvelteNode> {
      * Directive resolution (`bind:`, `class:`, `on:`, etc.) and IDL attribute
      * mapping are now handled declaratively by svelte-spec's directivePatterns
      * and ml-core's acceptedAttrNames.
+     * Because directivePatterns are applied later by ml-core's MLAttr
+     * constructor, the attribute returned here carries only parser-detectable
+     * flags; for example, `on:click` without a value shows
+     * `isDynamicValue: false` at the parser level but resolves to `true`
+     * at the core level.
      *
      * @param token - The token representing the attribute
      * @returns The parsed attribute node with Svelte-specific metadata

package/lib/parser.js

@@ -47,17 +47,6 @@ export class SvelteParser extends Parser {
         }
         return super.parseError(error);
     }
-    /**
-     * Converts a Svelte AST node into markuplint node tree items.
-     * Dispatches on the node type to handle Text, Comment, ExpressionTag,
-     * elements (Component, RegularElement), and control flow blocks
-     * (IfBlock, EachBlock, AwaitBlock, KeyBlock, SnippetBlock).
-     *
-     * @param originNode - The Svelte AST node to convert
-     * @param parentNode - The parent node in the markuplint tree, or null for root nodes
-     * @param depth - The nesting depth of the node
-     * @returns An array of markuplint node tree items
-     */
     nodeize(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     originNode, parentNode, depth) {
@@ -215,13 +204,6 @@ export class SvelteParser extends Parser {
             }
         }
     }
-    /**
-     * Visits a text token, converting `<script>` tags embedded in Svelte template
-     * text into preprocessor-specific blocks rather than treating them as raw text.
-     *
-     * @param token - The child token representing the text content
-     * @returns An array of markuplint node tree items
-     */
     visitText(token) {
         const nodes = super.visitText(token, {
             researchTags: false,
@@ -240,14 +222,8 @@ export class SvelteParser extends Parser {
         });
     }
     /**
-     * Visits a preprocessor-specific block token and enforces that exactly one
-     * block node is produced. Throws a ParserError if the result is empty
-     * or contains multiple nodes.
-     *
-     * @param token - The child token with node name and fragment flag
-     * @param childNodes - The child Svelte AST nodes within the block
-     * @param blockBehavior - The block behavior, or null
-     * @returns A single-element tuple containing the preprocessor-specific block
+     * Invariant: exactly one block node must be produced; an empty or
+     * multi-node result indicates a parse error.
      */
     visitPsBlock(token, childNodes = [], blockBehavior = null) {
         const nodes = super.visitPsBlock(token, childNodes, blockBehavior);
@@ -284,6 +260,11 @@ export class SvelteParser extends Parser {
      * Directive resolution (`bind:`, `class:`, `on:`, etc.) and IDL attribute
      * mapping are now handled declaratively by svelte-spec's directivePatterns
      * and ml-core's acceptedAttrNames.
+     * Because directivePatterns are applied later by ml-core's MLAttr
+     * constructor, the attribute returned here carries only parser-detectable
+     * flags; for example, `on:click` without a value shows
+     * `isDynamicValue: false` at the parser level but resolves to `true`
+     * at the core level.
      *
      * @param token - The token representing the attribute
      * @returns The parsed attribute node with Svelte-specific metadata
@@ -329,15 +310,6 @@ export class SvelteParser extends Parser {
     detectElementType(nodeName) {
         return super.detectElementType(nodeName, /^[A-Z]|\./);
     }
-    /**
-     * Parses a Svelte `{#await}` block into its constituent preprocessor-specific blocks:
-     * the await expression, optional `{:then}` branch, optional `{:catch}` branch,
-     * and the closing `{/await}` tag.
-     *
-     * @param token - The child token representing the entire await block
-     * @param originBlockNode - The Svelte AST AwaitBlock node
-     * @returns An array of preprocessor-specific block nodes
-     */
     #parseAwaitBlock(token, 
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     originBlockNode) {
@@ -473,15 +445,6 @@ export class SvelteParser extends Parser {
         })[0]);
         return expressions;
     }
-    /**
-     * Parses a Svelte `{#each}` block into its constituent preprocessor-specific blocks:
-     * the each expression, optional `{:else}` fallback branch,
-     * and the closing `{/each}` tag.
-     *
-     * @param token - The child token representing the entire each block
-     * @param originBlockNode - The Svelte AST EachBlock node
-     * @returns An array of preprocessor-specific block nodes
-     */
     #parseEachBlock(token, 
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     originBlockNode) {
@@ -540,16 +503,6 @@ export class SvelteParser extends Parser {
         }, undefined, { type: 'end', expression: closeToken.raw })[0]);
         return expressions;
     }
-    /**
-     * Recursively traverses a Svelte `{#if}` block and its chained `{:else if}` / `{:else}`
-     * branches, producing a flat list of token segments with their conditional type labels
-     * and child node arrays.
-     *
-     * @param originBlockNode - The Svelte AST IfBlock node to traverse
-     * @param start - The source offset where this block segment begins
-     * @param type - The conditional branch type: 'if', 'elseif', or 'else'
-     * @returns A flat array of token segments with children and type labels
-     */
     #traverseIfBlock(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     originBlockNode, start, type = 'if') {
@@ -578,6 +531,9 @@ export class SvelteParser extends Parser {
             const start = result.at(-1)?.children.at(-1)?.end ?? originBlockNode.end;
             const end = originBlockNode.end;
             const tag = this.sliceFragment(start, end);
+            // The raw content is empty in recursive `elseif` calls because the
+            // outermost call emits the single `{/if}` closer; pushing only
+            // non-empty tags avoids duplicating the closer.
             if (tag.raw) {
                 result.push({ ...tag, children: [], type: '/if' });
             }

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

@@ -1,23 +1,15 @@
 import type { AST } from 'svelte/compiler';
-/** Union of Svelte AST node types that can appear as children in a Svelte template fragment. */
 export type SvelteNode = AST.Text | AST.Comment | AST.Tag | AST.ElementLike | AST.Block;
-/** Represents a Svelte `{#if}` block with consequent, alternate, and elseif branches. */
 export type SvelteIfBlock = AST.IfBlock;
-/** Represents a Svelte `{#each}` block with iteration body and optional fallback. */
 export type SvelteEachBlock = AST.EachBlock;
-/** Represents a Svelte `{#await}` block with pending, then, and catch branches. */
 export type SvelteAwaitBlock = AST.AwaitBlock;
 /**
- * Parses a Svelte template string into an array of top-level AST nodes
- * using the Svelte compiler's modern parser mode.
- *
- * @param template - The raw Svelte template source code
- * @returns An array of top-level Svelte AST nodes from the template fragment
+ * The `modern: true` option opts into Svelte 5's modern AST format,
+ * which is required to receive Svelte 5 node types such as
+ * `SnippetBlock`, `RenderTag`, and `SvelteBoundary`.
  */
 export declare function svelteParse(template: string): SvelteNode[];
-/** Union of all Svelte directive and attribute types that can appear on elements. */
 export type SvelteDirective = Directive | AST.Attribute | AST.SpreadAttribute;
-/** Union of all Svelte block types that have opening/closing tag syntax. */
 export type SvelteBlock = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock | AST.SvelteBoundary;
 type Directive = AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective;
 export {};

package/lib/svelte-parser/index.js

@@ -1,10 +1,8 @@
 import { parse } from 'svelte/compiler';
 /**
- * Parses a Svelte template string into an array of top-level AST nodes
- * using the Svelte compiler's modern parser mode.
- *
- * @param template - The raw Svelte template source code
- * @returns An array of top-level Svelte AST nodes from the template fragment
+ * The `modern: true` option opts into Svelte 5's modern AST format,
+ * which is required to receive Svelte 5 node types such as
+ * `SnippetBlock`, `RenderTag`, and `SvelteBoundary`.
  */
 export function svelteParse(template) {
     const ast = parse(template, { modern: true });

package/lib/sveltekit-parser.d.ts

@@ -4,6 +4,11 @@ import { HtmlParser } from '@markuplint/html-parser';
  * Extends the standard HTML parser to handle SvelteKit placeholder tags
  * such as `%sveltekit.head%` and `%sveltekit.body%`, which are treated
  * as opaque preprocessor-specific blocks.
+ *
+ * Unlike `SvelteParser`, the app template is plain HTML whose `%sveltekit.*%`
+ * placeholders are replaced by SvelteKit at build time, so the template engine
+ * parser pattern (extending `HtmlParser` with `ignoreTags`) is the correct
+ * architectural choice and `svelte/compiler` is intentionally not involved.
  */
 declare class SvelteKitTemplateParser extends HtmlParser {
     constructor();

package/lib/sveltekit-parser.js

@@ -4,6 +4,11 @@ import { HtmlParser } from '@markuplint/html-parser';
  * Extends the standard HTML parser to handle SvelteKit placeholder tags
  * such as `%sveltekit.head%` and `%sveltekit.body%`, which are treated
  * as opaque preprocessor-specific blocks.
+ *
+ * Unlike `SvelteParser`, the app template is plain HTML whose `%sveltekit.*%`
+ * placeholders are replaced by SvelteKit at build time, so the template engine
+ * parser pattern (extending `HtmlParser` with `ignoreTags`) is the correct
+ * architectural choice and `svelte/compiler` is intentionally not involved.
  */
 class SvelteKitTemplateParser extends HtmlParser {
     constructor() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/svelte-parser",
-	"version": "5.0.0-rc.4",
+	"version": "5.0.0-rc.5",
 	"description": "Svelte 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": {
@@ -40,10 +40,10 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "5.0.0-rc.4",
-		"@markuplint/ml-ast": "5.0.0-rc.4",
-		"@markuplint/parser-utils": "5.0.0-rc.4",
-		"svelte": "5.55.4"
+		"@markuplint/html-parser": "5.0.0-rc.5",
+		"@markuplint/ml-ast": "5.0.0-rc.5",
+		"@markuplint/parser-utils": "5.0.0-rc.5",
+		"svelte": "5.55.7"
 	},
-	"gitHead": "97a6339bbae23f556de5d307b3ce2ef7cfd9402d"
+	"gitHead": "8d87463af2ff3f1b83fb28da20f1819362cf3555"
 }