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

package/lib/parse-block.js

@@ -27,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'
@@ -48,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,5 +1,5 @@
 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';
 /**
@@ -11,7 +11,6 @@ import { ParserError, Parser } from '@markuplint/parser-utils';
  */
 export declare class SvelteParser extends Parser<SvelteNode> {
     #private;
-    readonly specificBindDirective: ReadonlySet<string>;
     constructor();
     tokenize(): {
         ast: SvelteNode[];
@@ -46,13 +45,13 @@ export declare class SvelteParser extends Parser<SvelteNode> {
      *
      * @param token - The child token with node name and fragment flag
      * @param childNodes - The child Svelte AST nodes within the block
-     * @param conditionalType - The conditional block type identifier, or null
+     * @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
@@ -65,8 +64,10 @@ export declare class SvelteParser extends Parser<SvelteNode> {
     visitChildren(children: readonly SvelteNode[], parentNode: MLASTParentNode | null): never[];
     /**
      * Visits an attribute token, handling Svelte-specific syntax including
-     * curly-brace expression values, shorthand attributes (`{name}`),
-     * `bind:` / `class:` directives, and duplicatable class attributes.
+     * 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
@@ -75,8 +76,6 @@ export declare class SvelteParser extends Parser<SvelteNode> {
         __rightText?: string;
     }) | {
         isDynamicValue: true | undefined;
-        isDirective: true | undefined;
-        isDuplicatable: boolean;
         potentialName: string | undefined;
         type: "attr";
         nodeName: string;
@@ -88,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,10 +1,3 @@
-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';
@@ -33,8 +26,6 @@ export class SvelteParser extends Parser {
             ],
             maskChar: '-',
         });
-        _SvelteParser_instances.add(this);
-        this.specificBindDirective = new Set(['group', 'this']);
     }
     tokenize() {
         return {
@@ -71,7 +62,6 @@ export class SvelteParser extends Parser {
     // 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({
@@ -102,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)) {
@@ -120,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 {
@@ -133,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,
@@ -142,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,
@@ -253,11 +245,11 @@ export class SvelteParser extends Parser {
      *
      * @param token - The child token with node name and fragment flag
      * @param childNodes - The child Svelte AST nodes within the block
-     * @param conditionalType - The conditional block type identifier, or null
+     * @param blockBehavior - The block behavior, or null
      * @returns A single-element tuple containing the preprocessor-specific block
      */
-    visitPsBlock(token, childNodes = [], conditionalType = null) {
-        const nodes = super.visitPsBlock(token, childNodes, conditionalType);
+    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);
@@ -287,8 +279,10 @@ export class SvelteParser extends Parser {
     }
     /**
      * Visits an attribute token, handling Svelte-specific syntax including
-     * curly-brace expression values, shorthand attributes (`{name}`),
-     * `bind:` / `class:` directives, and duplicatable class attributes.
+     * 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
@@ -309,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,
         };
     }
@@ -352,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
+     * @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 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}`
-     */
-    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/package.json

@@ -1,10 +1,13 @@
 {
 	"name": "@markuplint/svelte-parser",
-	"version": "4.7.13",
+	"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.23",
-		"@markuplint/ml-ast": "4.4.11",
-		"@markuplint/parser-utils": "4.8.11",
-		"svelte": "5.50.0"
+		"@markuplint/html-parser": "5.0.0-alpha.0",
+		"@markuplint/ml-ast": "5.0.0-alpha.0",
+		"@markuplint/parser-utils": "5.0.0-alpha.0",
+		"svelte": "5.53.0"
 	},
-	"gitHead": "193ee7c1262bbed95424e38efdf1a8e56ff049f4"
+	"gitHead": "13dcfc84ec83d87360c720e253383b60767e1b56"
 }