@markuplint/svelte-parser 4.7.12 → 5.0.0-alpha.0

package/lib/index.d.ts

@@ -1 +1,8 @@
+/**
+ * @module
+ * Svelte component parser for markuplint. Provides a parser that transforms Svelte
+ * template syntax into markuplint's AST, supporting Svelte-specific constructs such as
+ * `{#if}`, `{#each}`, `{#await}`, `{#key}`, `{#snippet}`, expression tags,
+ * and bind/class/event directives.
+ */
 export { parser } from './parser.js';

package/lib/index.js

@@ -1 +1,8 @@
+/**
+ * @module
+ * Svelte component parser for markuplint. Provides a parser that transforms Svelte
+ * template syntax into markuplint's AST, supporting Svelte-specific constructs such as
+ * `{#if}`, `{#each}`, `{#await}`, `{#key}`, `{#snippet}`, expression tags,
+ * and bind/class/event directives.
+ */
 export { parser } from './parser.js';

package/lib/parse-block.d.ts

@@ -1,6 +1,17 @@
 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,3 +1,14 @@
+/**
+ * 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,7 +27,7 @@ originBlockNode) {
     /**
      * `{/xxx}`
      */
-    const closeToken = parser.sliceFragment(token.startOffset + eachCloseStartIndex, originBlockNode.end);
+    const closeToken = parser.sliceFragment(token.offset + eachCloseStartIndex, originBlockNode.end);
     const fragment = originBlockNode.type === 'IfBlock'
         ? originBlockNode.consequent.nodes
         : originBlockNode.type === 'AwaitBlock'
@@ -37,10 +48,10 @@ originBlockNode) {
      */
     let openToken;
     if (fragStart != null && fragEnd != null) {
-        openToken = parser.sliceFragment(token.startOffset, fragStart);
+        openToken = parser.sliceFragment(token.offset, fragStart);
     }
     else {
-        openToken = parser.sliceFragment(token.startOffset, eachCloseStartIndex);
+        openToken = parser.sliceFragment(token.offset, eachCloseStartIndex);
     }
     return {
         openToken,

package/lib/parser.d.ts

@@ -1,10 +1,16 @@
 import type { SvelteNode } from './svelte-parser/index.js';
-import type { MLASTNodeTreeItem, MLASTParentNode, MLASTPreprocessorSpecificBlock, MLASTPreprocessorSpecificBlockConditionalType } from '@markuplint/ml-ast';
+import type { MLASTNodeTreeItem, MLASTParentNode, MLASTPreprocessorSpecificBlock, MLASTBlockBehavior } from '@markuplint/ml-ast';
 import type { ChildToken, ParseOptions, Token } from '@markuplint/parser-utils';
 import { ParserError, Parser } from '@markuplint/parser-utils';
+/**
+ * Parser implementation for Svelte component templates.
+ * Extends the base Parser to handle Svelte elements, text, comments,
+ * expression tags, control flow blocks (`{#if}`, `{#each}`, `{#await}`,
+ * `{#key}`, `{#snippet}`), directives (`bind:`, `class:`, `on:`),
+ * and shorthand attribute syntax.
+ */
 export declare class SvelteParser extends Parser<SvelteNode> {
     #private;
-    readonly specificBindDirective: ReadonlySet<string>;
     constructor();
     tokenize(): {
         ast: SvelteNode[];
@@ -12,19 +18,64 @@ 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
+     */
     visitPsBlock(token: ChildToken & {
         readonly nodeName: string;
         readonly isFragment: boolean;
-    }, childNodes?: readonly SvelteNode[], conditionalType?: MLASTPreprocessorSpecificBlockConditionalType): readonly [MLASTPreprocessorSpecificBlock];
+    }, childNodes?: readonly SvelteNode[], blockBehavior?: MLASTBlockBehavior | null): readonly [MLASTPreprocessorSpecificBlock];
+    /**
+     * Visits child nodes and verifies that no sibling nodes with differing
+     * hierarchy levels are produced. Throws a ParserError if unexpected
+     * sibling nodes are discovered.
+     *
+     * @param children - The child Svelte AST nodes to visit
+     * @param parentNode - The parent node in the markuplint tree
+     * @returns An empty array (all children are attached via the visitor)
+     */
     visitChildren(children: readonly SvelteNode[], parentNode: MLASTParentNode | null): never[];
+    /**
+     * Visits an attribute token, handling Svelte-specific syntax including
+     * curly-brace expression values and shorthand attributes (`{name}`).
+     * Directive resolution (`bind:`, `class:`, `on:`, etc.) and IDL attribute
+     * mapping are now handled declaratively by svelte-spec's directivePatterns
+     * and ml-core's useIDLAttributeNames.
+     *
+     * @param token - The token representing the attribute
+     * @returns The parsed attribute node with Svelte-specific metadata
+     */
     visitAttr(token: Token): (import("@markuplint/ml-ast").MLASTSpreadAttr & {
         __rightText?: string;
     }) | {
         isDynamicValue: true | undefined;
-        isDirective: true | undefined;
-        isDuplicatable: boolean;
         potentialName: string | undefined;
         type: "attr";
         nodeName: string;
@@ -36,17 +87,16 @@ export declare class SvelteParser extends Parser<SvelteNode> {
         startQuote: import("@markuplint/ml-ast").MLASTToken;
         value: import("@markuplint/ml-ast").MLASTToken;
         endQuote: import("@markuplint/ml-ast").MLASTToken;
+        isDirective?: true;
         potentialValue?: string;
         valueType?: "string" | "number" | "boolean" | "code";
         candidate?: string;
+        isDuplicatable: boolean;
         uuid: string;
         raw: string;
-        startOffset: number;
-        endOffset: number;
-        startLine: number;
-        endLine: number;
-        startCol: number;
-        endCol: number;
+        offset: number;
+        line: number;
+        col: number;
         __rightText?: string;
     };
     /**

package/lib/parser.js

@@ -1,13 +1,13 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _SvelteParser_instances, _SvelteParser_parseAwaitBlock, _SvelteParser_parseEachBlock, _SvelteParser_traverseIfBlock;
-import { getNamespace } from '@markuplint/html-parser';
 import { ParserError, Parser, AttrState } from '@markuplint/parser-utils';
 import { parseBlock } from './parse-block.js';
 import { svelteParse } from './svelte-parser/index.js';
+/**
+ * Parser implementation for Svelte component templates.
+ * Extends the base Parser to handle Svelte elements, text, comments,
+ * expression tags, control flow blocks (`{#if}`, `{#each}`, `{#await}`,
+ * `{#key}`, `{#snippet}`), directives (`bind:`, `class:`, `on:`),
+ * and shorthand attribute syntax.
+ */
 export class SvelteParser extends Parser {
     constructor() {
         super({
@@ -26,8 +26,6 @@ export class SvelteParser extends Parser {
             ],
             maskChar: '-',
         });
-        _SvelteParser_instances.add(this);
-        this.specificBindDirective = new Set(['group', 'this']);
     }
     tokenize() {
         return {
@@ -49,11 +47,21 @@ 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) {
         const token = this.sliceFragment(originNode.start, originNode.end);
-        const parentNamespace = parentNode && 'namespace' in parentNode ? parentNode.namespace : 'http://www.w3.org/1999/xhtml';
         switch (originNode.type) {
             case 'Text': {
                 return this.visitText({
@@ -84,14 +92,13 @@ export class SvelteParser extends Parser {
                 const reEndTag = new RegExp(`</${originNode.name}\\s*>$`, 'i');
                 const startTagEndOffset = children.length > 0
                     ? (children[0]?.start ?? 0)
-                    : token.raw.replace(reEndTag, '').length + token.startOffset;
-                const startTagLocation = this.sliceFragment(token.startOffset, startTagEndOffset);
+                    : token.raw.replace(reEndTag, '').length + token.offset;
+                const startTagLocation = this.sliceFragment(token.offset, startTagEndOffset);
                 return this.visitElement({
                     ...startTagLocation,
                     depth,
                     parentNode,
                     nodeName: originNode.name,
-                    namespace: getNamespace(originNode.name, parentNamespace),
                 }, originNode.fragment.nodes, {
                     createEndTagToken: () => {
                         if (!reEndTag.test(token.raw)) {
@@ -102,7 +109,7 @@ export class SvelteParser extends Parser {
                             throw new Error('Parse error');
                         }
                         const endTagRaw = endTagRawMatched[0];
-                        const endTagStartOffset = token.startOffset + token.raw.lastIndexOf(endTagRaw);
+                        const endTagStartOffset = token.offset + token.raw.lastIndexOf(endTagRaw);
                         const endTagEndOffset = endTagStartOffset + endTagRaw.length;
                         const endTagLocation = this.sliceFragment(endTagStartOffset, endTagEndOffset);
                         return {
@@ -115,7 +122,7 @@ export class SvelteParser extends Parser {
             }
             case 'IfBlock': {
                 const expressions = [];
-                const ifElseBlocks = __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_traverseIfBlock).call(this, originNode, token.startOffset);
+                const ifElseBlocks = this.#traverseIfBlock(originNode, token.offset);
                 for (const ifElseBlock of ifElseBlocks) {
                     const expression = this.visitPsBlock({
                         ...ifElseBlock,
@@ -124,24 +131,27 @@ export class SvelteParser extends Parser {
                         nodeName: ifElseBlock.type,
                         isFragment: false,
                     }, ifElseBlock.children, {
-                        if: 'if',
-                        elseif: 'if:elseif',
-                        else: 'if:else',
-                        '/if': 'end',
-                    }[ifElseBlock.type])[0];
+                        type: {
+                            if: 'if',
+                            elseif: 'if:elseif',
+                            else: 'if:else',
+                            '/if': 'end',
+                        }[ifElseBlock.type],
+                        expression: ifElseBlock.raw,
+                    })[0];
                     expressions.push(expression);
                 }
                 return expressions;
             }
             case 'EachBlock': {
-                return __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_parseEachBlock).call(this, {
+                return this.#parseEachBlock({
                     ...token,
                     depth,
                     parentNode,
                 }, originNode);
             }
             case 'AwaitBlock': {
-                return __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_parseAwaitBlock).call(this, {
+                return this.#parseAwaitBlock({
                     ...token,
                     depth,
                     parentNode,
@@ -205,6 +215,13 @@ 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,
@@ -221,8 +238,18 @@ export class SvelteParser extends Parser {
             return node;
         });
     }
-    visitPsBlock(token, childNodes = [], conditionalType = null) {
-        const nodes = super.visitPsBlock(token, childNodes, conditionalType);
+    /**
+     * 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
+     */
+    visitPsBlock(token, childNodes = [], blockBehavior = null) {
+        const nodes = super.visitPsBlock(token, childNodes, blockBehavior);
         const block = nodes.at(0);
         if (!block || block.type !== 'psblock') {
             throw new ParserError('Parse error', token);
@@ -232,6 +259,15 @@ export class SvelteParser extends Parser {
         }
         return [block];
     }
+    /**
+     * Visits child nodes and verifies that no sibling nodes with differing
+     * hierarchy levels are produced. Throws a ParserError if unexpected
+     * sibling nodes are discovered.
+     *
+     * @param children - The child Svelte AST nodes to visit
+     * @param parentNode - The parent node in the markuplint tree
+     * @returns An empty array (all children are attached via the visitor)
+     */
     visitChildren(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     children, parentNode) {
@@ -241,6 +277,16 @@ export class SvelteParser extends Parser {
         }
         return [];
     }
+    /**
+     * Visits an attribute token, handling Svelte-specific syntax including
+     * curly-brace expression values and shorthand attributes (`{name}`).
+     * Directive resolution (`bind:`, `class:`, `on:`, etc.) and IDL attribute
+     * mapping are now handled declaratively by svelte-spec's directivePatterns
+     * and ml-core's useIDLAttributeNames.
+     *
+     * @param token - The token representing the attribute
+     * @returns The parsed attribute node with Svelte-specific metadata
+     */
     visitAttr(token) {
         const attr = super.visitAttr(token, {
             quoteSet: [
@@ -257,35 +303,17 @@ export class SvelteParser extends Parser {
         }
         let isDynamicValue = attr.startQuote.raw === '{' || undefined;
         let potentialName;
-        let isDirective;
-        let isDuplicatable = false;
+        // Shorthand {name} → potentialName = value
         if (isDynamicValue && attr.name.raw === '') {
             potentialName = attr.value.raw;
         }
-        const [baseName, subName] = attr.name.raw.split(':');
-        if (subName) {
-            isDirective = true;
-            if (baseName === 'bind' && !this.specificBindDirective.has(subName)) {
-                potentialName = subName;
-                isDirective = undefined;
-                isDynamicValue = true;
-            }
-        }
-        if (baseName?.toLowerCase() === 'class') {
-            isDuplicatable = true;
-            if (subName) {
-                potentialName = 'class';
-                isDynamicValue = true;
-            }
-        }
+        // Final curly brace check
         if (attr.startQuote.raw === '{' && attr.endQuote.raw === '}') {
             isDynamicValue = true;
         }
         return {
             ...attr,
             isDynamicValue,
-            isDirective,
-            isDuplicatable,
             potentialName,
         };
     }
@@ -300,217 +328,260 @@ export class SvelteParser extends Parser {
     detectElementType(nodeName) {
         return super.detectElementType(nodeName, /^[A-Z]|\./);
     }
-}
-_SvelteParser_instances = new WeakSet(), _SvelteParser_parseAwaitBlock = function _SvelteParser_parseAwaitBlock(token, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originBlockNode) {
-    const { closeToken } = parseBlock(this, token, originBlockNode);
-    const pendingNodes = originBlockNode.pending?.nodes ?? [];
-    const thenNodes = originBlockNode.then?.nodes ?? [];
-    const pendingEnd = pendingNodes.at(-1)?.end;
-    const thenEnd = thenNodes.at(-1)?.end;
-    // @ts-ignore - new Svelte Compiler Type doesn't support `start` and `end` yet.
-    const awaitConditionEnd = originBlockNode.expression.end;
     /**
-     * `{#await expression}...{:then name}...{:catch name}...{/await}`
-     *            find___^ and cut
+     * 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.
      *
-     * `}...{:then name}...{:catch name}...{/await}`
-     */
-    const rawAwaitConditionBelow = this.rawCode.slice(awaitConditionEnd, originBlockNode.end);
-    /**
-     * `}...{:then name}...{:catch name}...{/await}`
-     *  ^___find
-     */
-    const awaitExpEnd = awaitConditionEnd + rawAwaitConditionBelow.indexOf('}') + 1;
-    /**
-     * `{#await expression}`
-     */
-    const awaitExpToken = this.sliceFragment(token.startOffset, awaitExpEnd);
-    let thenToken = null;
-    /**
-     * `{#await expression}...{:then name}...{:catch name}...{/await}`
-     *                 find___^
-     */
-    const thenExpStart = pendingEnd ?? awaitExpEnd;
-    /**
-     * `{:then name}...{:catch name}...{/await}`
+     * @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
      */
-    const rawPendingNodesBelow = this.rawCode.slice(thenExpStart, originBlockNode.end);
-    if (
-    // eslint-disable-next-line regexp/strict
-    /^{\s*:then[\s|}]/.test(rawPendingNodesBelow)) {
-        let thenExpEndCharOffset;
-        if (originBlockNode.value) {
-            const thenIdentifierEnd = 
-            // @ts-ignore - new Svelte Compiler Type doesn't support `start` and `end` yet.
-            originBlockNode.value.end;
-            const rawThenExpCloseCharAndBelow = this.rawCode.slice(thenIdentifierEnd, originBlockNode.end);
-            const thenExpEndCharIndex = rawThenExpCloseCharAndBelow.indexOf('}') + 1;
-            thenExpEndCharOffset = thenIdentifierEnd + thenExpEndCharIndex;
+    #parseAwaitBlock(token, 
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    originBlockNode) {
+        const { closeToken } = parseBlock(this, token, originBlockNode);
+        const pendingNodes = originBlockNode.pending?.nodes ?? [];
+        const thenNodes = originBlockNode.then?.nodes ?? [];
+        const pendingEnd = pendingNodes.at(-1)?.end;
+        const thenEnd = thenNodes.at(-1)?.end;
+        // @ts-ignore - new Svelte Compiler Type doesn't support `start` and `end` yet.
+        const awaitConditionEnd = originBlockNode.expression.end;
+        /**
+         * `{#await expression}...{:then name}...{:catch name}...{/await}`
+         *            find___^ and cut
+         *
+         * `}...{:then name}...{:catch name}...{/await}`
+         */
+        const rawAwaitConditionBelow = this.rawCode.slice(awaitConditionEnd, originBlockNode.end);
+        /**
+         * `}...{:then name}...{:catch name}...{/await}`
+         *  ^___find
+         */
+        const awaitExpEnd = awaitConditionEnd + rawAwaitConditionBelow.indexOf('}') + 1;
+        /**
+         * `{#await expression}`
+         */
+        const awaitExpToken = this.sliceFragment(token.offset, awaitExpEnd);
+        let thenToken = null;
+        /**
+         * `{#await expression}...{:then name}...{:catch name}...{/await}`
+         *                 find___^
+         */
+        const thenExpStart = pendingEnd ?? awaitExpEnd;
+        /**
+         * `{:then name}...{:catch name}...{/await}`
+         */
+        const rawPendingNodesBelow = this.rawCode.slice(thenExpStart, originBlockNode.end);
+        if (
+        // eslint-disable-next-line regexp/strict
+        /^{\s*:then[\s|}]/.test(rawPendingNodesBelow)) {
+            let thenExpEndCharOffset;
+            if (originBlockNode.value) {
+                const thenIdentifierEnd = 
+                // @ts-ignore - new Svelte Compiler Type doesn't support `start` and `end` yet.
+                originBlockNode.value.end;
+                const rawThenExpCloseCharAndBelow = this.rawCode.slice(thenIdentifierEnd, originBlockNode.end);
+                const thenExpEndCharIndex = rawThenExpCloseCharAndBelow.indexOf('}') + 1;
+                thenExpEndCharOffset = thenIdentifierEnd + thenExpEndCharIndex;
+            }
+            else {
+                thenExpEndCharOffset = thenExpStart + rawPendingNodesBelow.indexOf('}') + 1;
+            }
+            thenToken = this.sliceFragment(token.offset + thenExpStart, thenExpEndCharOffset);
         }
-        else {
-            thenExpEndCharOffset = thenExpStart + rawPendingNodesBelow.indexOf('}') + 1;
+        let catchToken = null;
+        /**
+         * `{#await expression}...{:then name}...{:catch name}...{/await}`
+         *                                find___^
+         *
+         * If `then` block is not found:
+         *
+         * `{#await expression}...{:catch name}...{/await}`
+         *                 find___^
+         */
+        const catchExpStart = thenToken
+            ? (thenEnd ?? thenToken.offset + thenToken.raw.length)
+            : (pendingEnd ?? awaitExpEnd);
+        /**
+         * `{:catch name}...{/await}`
+         */
+        const rawThenNodesBelow = this.rawCode.slice(catchExpStart, originBlockNode.end);
+        if (
+        // eslint-disable-next-line regexp/strict
+        /^{\s*:catch[\s|}]/.test(rawThenNodesBelow)) {
+            let catchExpEndCharOffset;
+            if (originBlockNode.error) {
+                const catchIdentifierEnd = 
+                // @ts-ignore - new Svelte Compiler Type doesn't support `start` and `end` yet.
+                originBlockNode.error.end;
+                const rawCatchExpCloseCharAndBelow = this.rawCode.slice(catchIdentifierEnd, originBlockNode.end);
+                const catchExpEndCharIndex = rawCatchExpCloseCharAndBelow.indexOf('}') + 1;
+                catchExpEndCharOffset = catchIdentifierEnd + catchExpEndCharIndex;
+            }
+            else {
+                catchExpEndCharOffset = catchExpStart + rawThenNodesBelow.indexOf('}') + 1;
+            }
+            catchToken = this.sliceFragment(token.offset + catchExpStart, catchExpEndCharOffset);
         }
-        thenToken = this.sliceFragment(token.startOffset + thenExpStart, thenExpEndCharOffset);
-    }
-    let catchToken = null;
-    /**
-     * `{#await expression}...{:then name}...{:catch name}...{/await}`
-     *                                find___^
-     *
-     * If `then` block is not found:
-     *
-     * `{#await expression}...{:catch name}...{/await}`
-     *                 find___^
-     */
-    const catchExpStart = thenToken
-        ? (thenEnd ?? thenToken.startOffset + thenToken.raw.length)
-        : (pendingEnd ?? awaitExpEnd);
-    /**
-     * `{:catch name}...{/await}`
-     */
-    const rawThenNodesBelow = this.rawCode.slice(catchExpStart, originBlockNode.end);
-    if (
-    // eslint-disable-next-line regexp/strict
-    /^{\s*:catch[\s|}]/.test(rawThenNodesBelow)) {
-        let catchExpEndCharOffset;
-        if (originBlockNode.error) {
-            const catchIdentifierEnd = 
-            // @ts-ignore - new Svelte Compiler Type doesn't support `start` and `end` yet.
-            originBlockNode.error.end;
-            const rawCatchExpCloseCharAndBelow = this.rawCode.slice(catchIdentifierEnd, originBlockNode.end);
-            const catchExpEndCharIndex = rawCatchExpCloseCharAndBelow.indexOf('}') + 1;
-            catchExpEndCharOffset = catchIdentifierEnd + catchExpEndCharIndex;
+        const expressions = [
+            this.visitPsBlock({
+                ...awaitExpToken,
+                depth: token.depth,
+                parentNode: token.parentNode,
+                nodeName: 'await',
+                isFragment: false,
+            }, originBlockNode.pending?.nodes, {
+                type: 'await',
+                expression: awaitExpToken.raw,
+            })[0],
+        ];
+        if (thenToken) {
+            expressions.push(this.visitPsBlock({
+                ...thenToken,
+                depth: token.depth,
+                parentNode: token.parentNode,
+                nodeName: 'await:then',
+                isFragment: false,
+            }, originBlockNode.then?.nodes, {
+                type: 'await:then',
+                expression: thenToken.raw,
+            })[0]);
         }
-        else {
-            catchExpEndCharOffset = catchExpStart + rawThenNodesBelow.indexOf('}') + 1;
+        if (catchToken) {
+            expressions.push(this.visitPsBlock({
+                ...catchToken,
+                depth: token.depth,
+                parentNode: token.parentNode,
+                nodeName: 'await:catch',
+                isFragment: false,
+            }, originBlockNode.catch?.nodes, {
+                type: 'await:catch',
+                expression: catchToken.raw,
+            })[0]);
         }
-        catchToken = this.sliceFragment(token.startOffset + catchExpStart, catchExpEndCharOffset);
-    }
-    const expressions = [];
-    expressions.push(this.visitPsBlock({
-        ...awaitExpToken,
-        depth: token.depth,
-        parentNode: token.parentNode,
-        nodeName: 'await',
-        isFragment: false,
-    }, originBlockNode.pending?.nodes, 'await')[0]);
-    if (thenToken) {
         expressions.push(this.visitPsBlock({
-            ...thenToken,
+            ...closeToken,
             depth: token.depth,
             parentNode: token.parentNode,
-            nodeName: 'await:then',
+            nodeName: '/await',
             isFragment: false,
-        }, originBlockNode.then?.nodes, 'await:then')[0]);
+        }, undefined, {
+            type: 'end',
+            expression: closeToken.raw,
+        })[0]);
+        return expressions;
     }
-    if (catchToken) {
+    /**
+     * 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) {
+        const expressions = [];
+        /**
+         * `{/each}`
+         */
+        const { closeToken } = parseBlock(this, token, originBlockNode);
+        /**
+         * `{#each expression as name}...{:else}...{/each}`
+         *                     find___^
+         */
+        const bodyStart = originBlockNode.body.nodes.at(0)?.start ?? closeToken.offset;
+        /**
+         * `{#each expression as name}...{:else}...{/each}`
+         *                               find___^
+         */
+        const fallbackScopeStart = originBlockNode.fallback?.nodes.at(0)?.start ?? closeToken.offset;
+        /**
+         * `{#each expression as name}...{:else}`
+         */
+        const rawUntilFallbackScope = this.rawCode.slice(token.offset, fallbackScopeStart);
+        let elseToken = null;
+        /**
+         * `{#each expression as name}...{:else}`
+         *                        find___^
+         */
+        // eslint-disable-next-line regexp/strict
+        const elseTokenStart = rawUntilFallbackScope.match(/{\s*:else\s*}$/)?.index;
+        if (elseTokenStart != null) {
+            elseToken = this.sliceFragment(token.offset + elseTokenStart, fallbackScopeStart);
+        }
+        const eachToken = this.sliceFragment(token.offset, bodyStart);
         expressions.push(this.visitPsBlock({
-            ...catchToken,
+            ...eachToken,
             depth: token.depth,
             parentNode: token.parentNode,
-            nodeName: 'await:catch',
+            nodeName: 'each',
             isFragment: false,
-        }, originBlockNode.catch?.nodes, 'await:catch')[0]);
-    }
-    expressions.push(this.visitPsBlock({
-        ...closeToken,
-        depth: token.depth,
-        parentNode: token.parentNode,
-        nodeName: '/await',
-        isFragment: false,
-    }, undefined, 'end')[0]);
-    return expressions;
-}, _SvelteParser_parseEachBlock = function _SvelteParser_parseEachBlock(token, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originBlockNode) {
-    const expressions = [];
-    /**
-     * `{/each}`
-     */
-    const { closeToken } = parseBlock(this, token, originBlockNode);
-    /**
-     * `{#each expression as name}...{:else}...{/each}`
-     *                     find___^
-     */
-    const bodyStart = originBlockNode.body.nodes.at(0)?.start ?? closeToken.startOffset;
-    /**
-     * `{#each expression as name}...{:else}...{/each}`
-     *                               find___^
-     */
-    const fallbackScopeStart = originBlockNode.fallback?.nodes.at(0)?.start ?? closeToken.startOffset;
-    /**
-     * `{#each expression as name}...{:else}`
-     */
-    const rawUntilFallbackScope = this.rawCode.slice(token.startOffset, fallbackScopeStart);
-    let elseToken = null;
-    /**
-     * `{#each expression as name}...{:else}`
-     *                        find___^
-     */
-    // eslint-disable-next-line regexp/strict
-    const elseTokenStart = rawUntilFallbackScope.match(/{\s*:else\s*}$/)?.index;
-    if (elseTokenStart != null) {
-        elseToken = this.sliceFragment(token.startOffset + elseTokenStart, fallbackScopeStart);
-    }
-    const eachToken = this.sliceFragment(token.startOffset, bodyStart);
-    expressions.push(this.visitPsBlock({
-        ...eachToken,
-        depth: token.depth,
-        parentNode: token.parentNode,
-        nodeName: 'each',
-        isFragment: false,
-    }, originBlockNode.body.nodes, 'each')[0]);
-    if (elseToken) {
+        }, originBlockNode.body.nodes, { type: 'each', expression: eachToken.raw })[0]);
+        if (elseToken) {
+            expressions.push(this.visitPsBlock({
+                ...elseToken,
+                depth: token.depth,
+                parentNode: token.parentNode,
+                nodeName: 'each:empty',
+                isFragment: false,
+            }, originBlockNode.fallback?.nodes, { type: 'each:empty', expression: elseToken.raw })[0]);
+        }
         expressions.push(this.visitPsBlock({
-            ...elseToken,
+            ...closeToken,
             depth: token.depth,
             parentNode: token.parentNode,
-            nodeName: 'each:empty',
+            nodeName: '/each',
             isFragment: false,
-        }, originBlockNode.fallback?.nodes, 'each:empty')[0]);
+        }, undefined, { type: 'end', expression: closeToken.raw })[0]);
+        return expressions;
     }
-    expressions.push(this.visitPsBlock({
-        ...closeToken,
-        depth: token.depth,
-        parentNode: token.parentNode,
-        nodeName: '/each',
-        isFragment: false,
-    }, undefined, 'end')[0]);
-    return expressions;
-}, _SvelteParser_traverseIfBlock = function _SvelteParser_traverseIfBlock(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originBlockNode, start, type = 'if') {
-    const result = [];
-    const end = originBlockNode.consequent.nodes?.[0]?.start ?? originBlockNode.end;
-    const tag = this.sliceFragment(start, end);
-    const children = originBlockNode.consequent.nodes;
-    result.push({ ...tag, children, type });
-    if (originBlockNode.alternate) {
-        if (originBlockNode.alternate.nodes?.[0]?.type === 'IfBlock') {
-            const elseif = __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_traverseIfBlock).call(this, originBlockNode.alternate.nodes[0], children.at(-1)?.end ?? start, 'elseif');
-            result.push(...elseif);
+    /**
+     * 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') {
+        const result = [];
+        const end = originBlockNode.consequent.nodes?.[0]?.start ?? originBlockNode.end;
+        const tag = this.sliceFragment(start, end);
+        const children = originBlockNode.consequent.nodes;
+        result.push({ ...tag, children, type });
+        if (originBlockNode.alternate) {
+            if (originBlockNode.alternate.nodes?.[0]?.type === 'IfBlock') {
+                const elseif = this.#traverseIfBlock(originBlockNode.alternate.nodes[0], children.at(-1)?.end ?? start, 'elseif');
+                result.push(...elseif);
+            }
+            else {
+                const start = children.at(-1)?.end ?? originBlockNode.end;
+                const end = originBlockNode.alternate.nodes?.[0]?.start;
+                const tag = this.sliceFragment(start, end);
+                result.push({
+                    ...tag,
+                    children: originBlockNode.alternate.nodes,
+                    type: 'else',
+                });
+            }
         }
-        else {
-            const start = children.at(-1)?.end ?? originBlockNode.end;
-            const end = originBlockNode.alternate.nodes?.[0]?.start;
+        {
+            const start = result.at(-1)?.children.at(-1)?.end ?? originBlockNode.end;
+            const end = originBlockNode.end;
             const tag = this.sliceFragment(start, end);
-            result.push({
-                ...tag,
-                children: originBlockNode.alternate.nodes,
-                type: 'else',
-            });
-        }
-    }
-    {
-        const start = result.at(-1)?.children.at(-1)?.end ?? originBlockNode.end;
-        const end = originBlockNode.end;
-        const tag = this.sliceFragment(start, end);
-        if (tag.raw) {
-            result.push({ ...tag, children: [], type: '/if' });
+            if (tag.raw) {
+                result.push({ ...tag, children: [], type: '/if' });
+            }
         }
+        return result;
     }
-    return result;
-};
+}
 export const parser = new SvelteParser();

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

@@ -1,10 +1,23 @@
 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
+ */
 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,4 +1,11 @@
 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
+ */
 export function svelteParse(template) {
     const ast = parse(template, { modern: true });
     return ast.fragment.nodes ?? [];

package/lib/sveltekit-parser.d.ts

@@ -1,4 +1,10 @@
 import { HtmlParser } from '@markuplint/html-parser';
+/**
+ * Parser for SvelteKit app template files (e.g., `app.html`).
+ * 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.
+ */
 declare class SvelteKitTemplateParser extends HtmlParser {
     constructor();
 }

package/lib/sveltekit-parser.js

@@ -1,4 +1,10 @@
 import { HtmlParser } from '@markuplint/html-parser';
+/**
+ * Parser for SvelteKit app template files (e.g., `app.html`).
+ * 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.
+ */
 class SvelteKitTemplateParser extends HtmlParser {
     constructor() {
         super({

package/package.json

@@ -1,10 +1,13 @@
 {
 	"name": "@markuplint/svelte-parser",
-	"version": "4.7.12",
+	"version": "5.0.0-alpha.0",
 	"description": "Svelte parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
+	"engines": {
+		"node": ">=22"
+	},
 	"type": "module",
 	"exports": {
 		".": {
@@ -29,10 +32,10 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.6.22",
-		"@markuplint/ml-ast": "4.4.10",
-		"@markuplint/parser-utils": "4.8.10",
-		"svelte": "5.38.10"
+		"@markuplint/html-parser": "5.0.0-alpha.0",
+		"@markuplint/ml-ast": "5.0.0-alpha.0",
+		"@markuplint/parser-utils": "5.0.0-alpha.0",
+		"svelte": "5.53.0"
 	},
-	"gitHead": "6213ea30269ef404f030e67bbcc7fc7443ec1060"
+	"gitHead": "13dcfc84ec83d87360c720e253383b60767e1b56"
 }