@markuplint/svelte-parser 4.6.2 → 4.7.0-alpha.1

package/lib/parse-block.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="svelte" />
+import type { SvelteParser } from './parser.js';
+import type { ChildToken, Token } from '@markuplint/parser-utils';
+import type { Block } from 'svelte/compiler';
+export declare function parseBlock(parser: SvelteParser, token: ChildToken, originBlockNode: Block): {
+    openToken: Token;
+    closeToken: Token;
+};

package/lib/parse-block.js

@@ -0,0 +1,47 @@
+export function parseBlock(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+parser, token, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+originBlockNode) {
+    const range = token.raw;
+    /**
+     * `{#xxx}...{:xxx}...{/xxx}`
+     *             find___^
+     */
+    // eslint-disable-next-line regexp/strict
+    const eachCloseStartIndex = range.match(/{\s*\/[a-z]+\s*}$/)?.index;
+    if (eachCloseStartIndex == null) {
+        throw new SyntaxError('Block close tag not found');
+    }
+    /**
+     * `{/xxx}`
+     */
+    const closeToken = parser.sliceFragment(token.startOffset + eachCloseStartIndex, originBlockNode.end);
+    const fragment = originBlockNode.type === 'IfBlock'
+        ? originBlockNode.consequent.nodes
+        : originBlockNode.type === 'AwaitBlock'
+            ? originBlockNode.pending?.nodes
+            : originBlockNode.type === 'KeyBlock'
+                ? originBlockNode.fragment.nodes
+                : originBlockNode.body.nodes;
+    const fragStart = fragment?.at(0)?.start;
+    const fragEnd = fragment?.at(-1)?.end;
+    /**
+     * This token does not guarantee an open tag.
+     * For example, it might include `:then` or `:else`.
+     * Therefore, this variable is not used in
+     * `EachBlock` or `AwaitBlock`.
+     * It is only used in `KeyBlock` and `SnippetBlock`.
+     */
+    let openToken;
+    if (fragStart != null && fragEnd != null) {
+        openToken = parser.sliceFragment(token.startOffset, fragStart);
+    }
+    else {
+        openToken = parser.sliceFragment(token.startOffset, eachCloseStartIndex);
+    }
+    return {
+        openToken,
+        closeToken,
+    };
+}

package/lib/parse-blokc.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="svelte" />
+import type { SvelteParser } from './parser.js';
+import type { ChildToken, Token } from '@markuplint/parser-utils';
+import type { Block } from 'svelte/compiler';
+export declare function parseBlock(parser: SvelteParser, token: ChildToken, originBlockNode: Block): {
+    openToken: Token;
+    closeToken: Token;
+};

package/lib/parse-blokc.js

@@ -0,0 +1,47 @@
+export function parseBlock(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+parser, token, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+originBlockNode) {
+    const range = token.raw;
+    /**
+     * `{#xxx}...{:xxx}...{/xxx}`
+     *             find___^
+     */
+    // eslint-disable-next-line regexp/strict
+    const eachCloseStartIndex = range.match(/{\s*\/[a-z]+\s*}$/)?.index;
+    if (eachCloseStartIndex == null) {
+        throw new SyntaxError('Block close tag not found');
+    }
+    /**
+     * `{/xxx}`
+     */
+    const closeToken = parser.sliceFragment(token.startOffset + eachCloseStartIndex, originBlockNode.end);
+    const fragment = originBlockNode.type === 'IfBlock'
+        ? originBlockNode.consequent.nodes
+        : originBlockNode.type === 'AwaitBlock'
+            ? originBlockNode.pending?.nodes
+            : originBlockNode.type === 'KeyBlock'
+                ? originBlockNode.fragment.nodes
+                : originBlockNode.body.nodes;
+    const fragStart = fragment?.at(0)?.start;
+    const fragEnd = fragment?.at(-1)?.end;
+    /**
+     * This token does not guarantee an open tag.
+     * For example, it might include `:then` or `:else`.
+     * Therefore, this variable is not used in
+     * `EachBlock` or `AwaitBlock`.
+     * It is only used in `KeyBlock` and `SnippetBlock`.
+     */
+    let openToken;
+    if (fragStart != null && fragEnd != null) {
+        openToken = parser.sliceFragment(token.startOffset, fragStart);
+    }
+    else {
+        openToken = parser.sliceFragment(token.startOffset, eachCloseStartIndex);
+    }
+    return {
+        openToken,
+        closeToken,
+    };
+}

package/lib/parser.d.ts

@@ -1,14 +1,13 @@
-/// <reference types="svelte" />
 import type { SvelteNode } from './svelte-parser/index.js';
 import type { MLASTParentNode, MLASTPreprocessorSpecificBlock, MLASTPreprocessorSpecificBlockConditionalType } from '@markuplint/ml-ast';
 import type { ChildToken, ParseOptions, Token } from '@markuplint/parser-utils';
 import { ParserError, Parser } from '@markuplint/parser-utils';
-declare class SvelteParser extends Parser<SvelteNode> {
+export declare class SvelteParser extends Parser<SvelteNode> {
     #private;
     readonly specificBindDirective: ReadonlySet<string>;
     constructor();
     tokenize(): {
-        ast: import("svelte/types/compiler/interfaces").TemplateNode[];
+        ast: SvelteNode[];
         isFragment: boolean;
     };
     parse(raw: string, options?: ParseOptions): import("@markuplint/ml-ast").MLASTDocument;
@@ -57,7 +56,5 @@ declare class SvelteParser extends Parser<SvelteNode> {
      * @returns
      */
     detectElementType(nodeName: string): import("@markuplint/ml-ast").ElementType;
-    visitExpression(token: ChildToken, originBlockNode: SvelteNode): MLASTPreprocessorSpecificBlock[];
 }
 export declare const parser: SvelteParser;
-export {};

package/lib/parser.js

@@ -3,11 +3,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_traverseIfBlock;
+var _SvelteParser_instances, _SvelteParser_parseAwaitBlock, _SvelteParser_parseEachBlock, _SvelteParser_traverseIfBlock;
 import { getNamespace } from '@markuplint/html-parser';
 import { ParserError, Parser, AttrState } from '@markuplint/parser-utils';
-import { svelteParse } from './svelte-parser/index.js';
-class SvelteParser extends Parser {
+import { parseBlock } from './parse-block.js';
+import { blockOrTags, svelteParse } from './svelte-parser/index.js';
+export class SvelteParser extends Parser {
     constructor() {
         super({
             endTagType: 'xml',
@@ -52,8 +53,21 @@ class SvelteParser extends Parser {
     nodeize(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     originNode, parentNode, depth) {
-        const token = this.sliceFragment(originNode.start, originNode.end);
+        let token = this.sliceFragment(originNode.start, originNode.end);
         const parentNamespace = parentNode && 'namespace' in parentNode ? parentNode.namespace : 'http://www.w3.org/1999/xhtml';
+        /**
+         * Temporarily correct location shift issue with the new parser.
+         */
+        if (blockOrTags.includes(originNode.type) && !token.raw.startsWith('{')) {
+            let start = token.startOffset;
+            while (this.rawCode[start] !== '{') {
+                start--;
+            }
+            token = {
+                ...token,
+                ...this.sliceFragment(start, originNode.end),
+            };
+        }
         switch (originNode.type) {
             case 'Text': {
                 return this.visitText({
@@ -69,17 +83,17 @@ class SvelteParser extends Parser {
                     parentNode,
                 });
             }
-            case 'MustacheTag': {
+            case 'ExpressionTag': {
                 return this.visitPsBlock({
                     ...token,
                     depth,
                     parentNode,
-                    nodeName: 'MustacheTag',
+                    nodeName: 'ExpressionTag',
                 });
             }
-            case 'InlineComponent':
-            case 'Element': {
-                const children = originNode.children ?? [];
+            case 'Component':
+            case 'RegularElement': {
+                const children = originNode.fragment.nodes ?? [];
                 const reEndTag = new RegExp(`</${originNode.name}\\s*>$`, 'i');
                 const startTagEndOffset = children.length > 0
                     ? children[0]?.start ?? 0
@@ -91,7 +105,7 @@ class SvelteParser extends Parser {
                     parentNode,
                     nodeName: originNode.name,
                     namespace: getNamespace(originNode.name, parentNamespace),
-                }, originNode.children, {
+                }, originNode.fragment.nodes, {
                     createEndTagToken: () => {
                         if (!reEndTag.test(token.raw)) {
                             return null;
@@ -112,12 +126,89 @@ class SvelteParser extends Parser {
                     },
                 });
             }
-            default: {
-                return this.visitExpression({
+            case 'IfBlock': {
+                const expressions = [];
+                const ifElseBlocks = __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_traverseIfBlock).call(this, originNode, token.startOffset);
+                for (const ifElseBlock of ifElseBlocks) {
+                    const expression = this.visitPsBlock({
+                        ...ifElseBlock,
+                        depth,
+                        parentNode,
+                        nodeName: ifElseBlock.type,
+                    }, ifElseBlock.children, {
+                        if: 'if',
+                        elseif: 'if:elseif',
+                        else: 'if:else',
+                        '/if': 'end',
+                    }[ifElseBlock.type])[0];
+                    expressions.push(expression);
+                }
+                return expressions;
+            }
+            case 'EachBlock': {
+                return __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_parseEachBlock).call(this, {
+                    ...token,
+                    depth,
+                    parentNode,
+                }, originNode);
+            }
+            case 'AwaitBlock': {
+                return __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_parseAwaitBlock).call(this, {
+                    ...token,
+                    depth,
+                    parentNode,
+                }, originNode);
+            }
+            case 'KeyBlock': {
+                const { openToken, closeToken } = parseBlock(this, {
+                    ...token,
+                    depth,
+                    parentNode,
+                }, originNode);
+                return [
+                    this.visitPsBlock({
+                        ...openToken,
+                        depth,
+                        parentNode,
+                        nodeName: 'key',
+                    }, originNode.fragment.nodes)[0],
+                    this.visitPsBlock({
+                        ...closeToken,
+                        depth,
+                        parentNode,
+                        nodeName: '/key',
+                    })[0],
+                ];
+            }
+            case 'SnippetBlock': {
+                const { openToken, closeToken } = parseBlock(this, {
                     ...token,
                     depth,
                     parentNode,
                 }, originNode);
+                return [
+                    this.visitPsBlock({
+                        ...openToken,
+                        depth,
+                        parentNode,
+                        nodeName: 'snippet',
+                    }, originNode.body.nodes)[0],
+                    this.visitPsBlock({
+                        ...closeToken,
+                        depth,
+                        parentNode,
+                        nodeName: '/snippet',
+                    })[0],
+                ];
+            }
+            default: {
+                const childNodes = 'fragment' in originNode ? originNode.fragment.nodes : [];
+                return this.visitPsBlock({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.type,
+                }, childNodes);
             }
         }
     }
@@ -200,134 +291,199 @@ class SvelteParser extends Parser {
     detectElementType(nodeName) {
         return super.detectElementType(nodeName, /^[A-Z]|\./);
     }
-    visitExpression(token, 
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    originBlockNode) {
-        const props = ['', 'else', 'pending', 'then', 'catch'];
-        const expressions = [];
-        if (originBlockNode.type === 'IfBlock') {
-            const ifElseBlocks = __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_traverseIfBlock).call(this, originBlockNode);
-            for (const ifElseBlock of ifElseBlocks) {
-                const expression = this.visitPsBlock({
-                    ...ifElseBlock,
-                    depth: token.depth,
-                    parentNode: token.parentNode,
-                    nodeName: ifElseBlock.nodeName,
-                }, ifElseBlock.children, {
-                    if: 'if',
-                    elseif: 'if:elseif',
-                    else: 'if:else',
-                    '/if': 'end',
-                }[ifElseBlock.nodeName])[0];
-                expressions.push(expression);
-            }
-            return expressions;
+}
+_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
+     *
+     * `}...{: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}`
+     */
+    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;
         }
-        const blockType = originBlockNode.type.toLowerCase().replace('block', '');
-        const nodeList = new Map();
-        for (const prop of props) {
-            let node = (originBlockNode[prop] ?? originBlockNode);
-            if (nodeList.has(node)) {
-                continue;
-            }
-            if (node.type === 'ElseBlock' && node.children?.[0]?.elseif) {
-                node = node.children[0];
-                while (node != null) {
-                    if (!['IfBlock', 'ElseBlock'].includes(node.type)) {
-                        break;
-                    }
-                    const type = node.elseif ? 'if:elseif' : 'if:else';
-                    nodeList.set(node, type);
-                    node = node.else ?? node.children?.[0] ?? null;
-                }
-                continue;
-            }
-            const typeMap = {
-                if: 'if',
-                else: 'if:else',
-                each: 'each',
-                pending: 'await',
-                then: 'await:then', // eslint-disable-line unicorn/no-thenable
-                catch: 'await:catch',
-            };
-            const type = typeMap[prop || blockType] ?? null;
-            nodeList.set(node, type);
+        else {
+            thenExpEndCharOffset = thenExpStart + rawPendingNodesBelow.indexOf('}') + 1;
         }
-        let lastChild = null;
-        for (const [node, _type] of nodeList.entries()) {
-            let type = _type;
-            let start = node.start;
-            let end = node.end;
-            if (type === 'await') {
-                start = originBlockNode.start;
-            }
-            end = node.children?.[0]?.start ?? end;
-            if (type === 'if:else' && originBlockNode.type === 'EachBlock') {
-                type = 'each:empty';
-                start = lastChild?.end ?? start;
-            }
-            if (['if:else', 'if:elseif'].includes(type) &&
-                originBlockNode.type === 'IfBlock') {
-                start = lastChild?.end ?? start;
-            }
-            const tag = this.sliceFragment(start, end);
-            if (type === 'if:else' && node.type === 'ElseBlock' && node.children?.[0]?.type === 'IfBlock') {
-                type = 'if:elseif';
-            }
-            if (node.children && Array.isArray(node.children)) {
-                lastChild = node.children.at(-1) ?? null;
-            }
-            if (tag.raw === '') {
-                continue;
-            }
-            const expression = this.visitPsBlock({
-                ...tag,
-                depth: token.depth,
-                parentNode: token.parentNode,
-                nodeName: type ?? blockType,
-            }, node.children, type)[0];
-            expressions.push(expression);
+        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 lastText = this.sliceFragment(lastChild?.end ?? originBlockNode.end, originBlockNode.end);
-        if (lastText.raw) {
-            // Cut before whitespace
-            const index = lastText.raw.search(/\S/);
-            const lastToken = this.sliceFragment(lastText.startOffset + index, originBlockNode.end);
-            if (lastToken.raw) {
-                const expression = this.visitPsBlock({
-                    ...lastToken,
-                    depth: token.depth,
-                    parentNode: token.parentNode,
-                    nodeName: '/' + blockType,
-                }, [], 'end')[0];
-                expressions.push(expression);
-            }
+        else {
+            catchExpEndCharOffset = catchExpStart + rawThenNodesBelow.indexOf('}') + 1;
         }
-        return expressions;
+        catchToken = this.sliceFragment(token.startOffset + catchExpStart, catchExpEndCharOffset);
     }
-}
-_SvelteParser_instances = new WeakSet(), _SvelteParser_traverseIfBlock = function _SvelteParser_traverseIfBlock(
+    const expressions = [];
+    expressions.push(this.visitPsBlock({
+        ...awaitExpToken,
+        depth: token.depth,
+        parentNode: token.parentNode,
+        nodeName: 'await',
+    }, originBlockNode.pending?.nodes, 'await')[0]);
+    if (thenToken) {
+        expressions.push(this.visitPsBlock({
+            ...thenToken,
+            depth: token.depth,
+            parentNode: token.parentNode,
+            nodeName: 'await:then',
+        }, originBlockNode.then?.nodes, 'await:then')[0]);
+    }
+    if (catchToken) {
+        expressions.push(this.visitPsBlock({
+            ...catchToken,
+            depth: token.depth,
+            parentNode: token.parentNode,
+            nodeName: 'await:catch',
+        }, originBlockNode.catch?.nodes, 'await:catch')[0]);
+    }
+    expressions.push(this.visitPsBlock({
+        ...closeToken,
+        depth: token.depth,
+        parentNode: token.parentNode,
+        nodeName: '/await',
+    }, 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',
+    }, originBlockNode.body.nodes, 'each')[0]);
+    if (elseToken) {
+        expressions.push(this.visitPsBlock({
+            ...elseToken,
+            depth: token.depth,
+            parentNode: token.parentNode,
+            nodeName: 'each:empty',
+        }, originBlockNode.fallback?.nodes, 'each:empty')[0]);
+    }
+    expressions.push(this.visitPsBlock({
+        ...closeToken,
+        depth: token.depth,
+        parentNode: token.parentNode,
+        nodeName: '/each',
+    }, undefined, 'end')[0]);
+    return expressions;
+}, _SvelteParser_traverseIfBlock = function _SvelteParser_traverseIfBlock(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originBlockNode, start, nodeName = 'if') {
+originBlockNode, start, type = 'if') {
     const result = [];
-    start = start ?? originBlockNode.start;
-    const end = originBlockNode.children?.[0]?.start ?? originBlockNode.end;
+    const end = originBlockNode.consequent.nodes?.[0]?.start ?? originBlockNode.end;
     const tag = this.sliceFragment(start, end);
-    const children = originBlockNode.children ?? [];
-    result.push({ ...tag, children, nodeName });
-    if (originBlockNode.else) {
-        if (originBlockNode.else.children[0].type === 'IfBlock') {
-            const elseif = __classPrivateFieldGet(this, _SvelteParser_instances, "m", _SvelteParser_traverseIfBlock).call(this, originBlockNode.else.children[0], children.at(-1)?.end, 'elseif');
+    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);
         }
         else {
             const start = children.at(-1)?.end ?? originBlockNode.end;
-            const end = originBlockNode.else.children[0].start;
+            const end = originBlockNode.alternate.nodes?.[0]?.start;
             const tag = this.sliceFragment(start, end);
             result.push({
                 ...tag,
-                children: originBlockNode.else.children,
-                nodeName: 'else',
+                children: originBlockNode.alternate.nodes,
+                type: 'else',
             });
         }
     }
@@ -336,7 +492,7 @@ originBlockNode, start, nodeName = 'if') {
         const end = originBlockNode.end;
         const tag = this.sliceFragment(start, end);
         if (tag.raw) {
-            result.push({ ...tag, children: [], nodeName: '/if' });
+            result.push({ ...tag, children: [], type: '/if' });
         }
     }
     return result;

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

@@ -1,5 +1,9 @@
 /// <reference types="svelte" />
-import type { Directive, TemplateNode, Attribute, SpreadAttribute } from 'svelte/types/compiler/interfaces';
-export type SvelteNode = TemplateNode;
+import type { Attribute, AwaitBlock, Block, Comment, Directive, EachBlock, ElementLike, IfBlock, SpreadAttribute, Tag, Text } from 'svelte/compiler';
+export type SvelteNode = Text | Tag | ElementLike | Comment | Block;
+export type SvelteIfBlock = IfBlock;
+export type SvelteEachBlock = EachBlock;
+export type SvelteAwaitBlock = AwaitBlock;
 export declare function svelteParse(template: string): SvelteNode[];
 export type SvelteDirective = Directive | Attribute | SpreadAttribute;
+export declare const blockOrTags: string[];

package/lib/svelte-parser/index.js

@@ -1,10 +1,16 @@
 import { parse } from 'svelte/compiler';
 export function svelteParse(template) {
-    const ast = parse(template, { customElement: true });
-    const start = ast.html.start;
-    const children = ast.html.children ?? [];
-    if (children[0] && children[0].end === start) {
-        children.shift();
-    }
-    return children;
+    const ast = parse(template, { modern: true });
+    return ast.fragment.nodes ?? [];
 }
+export const blockOrTags = [
+    'IfBlock',
+    'EachBlock',
+    'AwaitBlock',
+    'KeyBlock',
+    'SnippetBlock',
+    'HtmlTag',
+    'DebugTag',
+    'ConstTag',
+    'RenderTag',
+];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/svelte-parser",
-	"version": "4.6.2",
+	"version": "4.7.0-alpha.1",
 	"description": "Svelte parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -16,6 +16,9 @@
 		}
 	},
 	"types": "lib/index.d.ts",
+	"files": [
+		"lib"
+	],
 	"publishConfig": {
 		"access": "public"
 	},
@@ -27,7 +30,6 @@
 		"@markuplint/html-parser": "4.6.2",
 		"@markuplint/ml-ast": "4.3.1",
 		"@markuplint/parser-utils": "4.6.2",
-		"svelte": "4.2.16"
-	},
-	"gitHead": "ca7dc6bf40eac4f2813e492878f889eb77751a70"
+		"svelte": "5.0.0-next.141"
+	}
 }

package/CHANGELOG.md

@@ -1,16 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-## [4.6.2](https://github.com/markuplint/markuplint/compare/@markuplint/svelte-parser@4.6.1...@markuplint/svelte-parser@4.6.2) (2024-05-12)
-
-**Note:** Version bump only for package @markuplint/svelte-parser
-
-## [4.6.1](https://github.com/markuplint/markuplint/compare/@markuplint/svelte-parser@4.6.1-alpha.0...@markuplint/svelte-parser@4.6.1) (2024-05-04)
-
-**Note:** Version bump only for package @markuplint/svelte-parser
-
-## [4.6.1-alpha.0](https://github.com/markuplint/markuplint/compare/@markuplint/svelte-parser@4.6.0...@markuplint/svelte-parser@4.6.1-alpha.0) (2024-05-04)
-
-**Note:** Version bump only for package @markuplint/svelte-parser

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017-2024 Yusuke Hirao
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.