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

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { parser } from './parser.js';

package/lib/index.js

@@ -0,0 +1 @@
+export { parser } from './parser.js';

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

@@ -0,0 +1,60 @@
+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';
+export declare class SvelteParser extends Parser<SvelteNode> {
+    #private;
+    readonly specificBindDirective: ReadonlySet<string>;
+    constructor();
+    tokenize(): {
+        ast: SvelteNode[];
+        isFragment: boolean;
+    };
+    parse(raw: string, options?: ParseOptions): import("@markuplint/ml-ast").MLASTDocument;
+    parseError(error: any): ParserError;
+    nodeize(originNode: SvelteNode, parentNode: MLASTParentNode | null, depth: number): readonly import("@markuplint/ml-ast").MLASTNodeTreeItem[];
+    visitPsBlock(token: ChildToken & {
+        readonly nodeName: string;
+    }, childNodes?: readonly SvelteNode[], conditionalType?: MLASTPreprocessorSpecificBlockConditionalType): readonly [MLASTPreprocessorSpecificBlock];
+    visitChildren(children: readonly SvelteNode[], parentNode: MLASTParentNode | null): never[];
+    visitAttr(token: Token): (import("@markuplint/ml-ast").MLASTSpreadAttr & {
+        __rightText?: string | undefined;
+    }) | {
+        isDynamicValue: true | undefined;
+        isDirective: true | undefined;
+        isDuplicatable: boolean;
+        potentialName: string | undefined;
+        type: "attr";
+        nodeName: string;
+        spacesBeforeName: import("@markuplint/ml-ast").MLASTToken;
+        name: import("@markuplint/ml-ast").MLASTToken;
+        spacesBeforeEqual: import("@markuplint/ml-ast").MLASTToken;
+        equal: import("@markuplint/ml-ast").MLASTToken;
+        spacesAfterEqual: import("@markuplint/ml-ast").MLASTToken;
+        startQuote: import("@markuplint/ml-ast").MLASTToken;
+        value: import("@markuplint/ml-ast").MLASTToken;
+        endQuote: import("@markuplint/ml-ast").MLASTToken;
+        potentialValue?: string | undefined;
+        valueType?: "string" | "number" | "boolean" | "code" | undefined;
+        candidate?: string | undefined;
+        uuid: string;
+        raw: string;
+        startOffset: number;
+        endOffset: number;
+        startLine: number;
+        endLine: number;
+        startCol: number;
+        endCol: number;
+        __rightText?: string | undefined;
+    };
+    /**
+     * > A lowercase tag, like `<div>`, denotes a regular HTML element.
+     * A capitalised tag, such as `<Widget>` or `<Namespace.Widget>`, indicates a component.
+     *
+     * @see https://svelte.io/docs/basic-markup#tags
+     * @param nodeName
+     * @returns
+     */
+    detectElementType(nodeName: string): import("@markuplint/ml-ast").ElementType;
+}
+export declare const parser: SvelteParser;

package/lib/parser.js

@@ -0,0 +1,500 @@
+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 { blockOrTags, svelteParse } from './svelte-parser/index.js';
+export class SvelteParser extends Parser {
+    constructor() {
+        super({
+            endTagType: 'xml',
+            tagNameCaseSensitive: true,
+            ignoreTags: [
+                {
+                    type: 'Script',
+                    start: '<script',
+                    end: '</script>',
+                },
+                {
+                    type: 'Style',
+                    start: '<style',
+                    end: '</style>',
+                },
+            ],
+            maskChar: '-',
+        });
+        _SvelteParser_instances.add(this);
+        this.specificBindDirective = new Set(['group', 'this']);
+    }
+    tokenize() {
+        return {
+            ast: svelteParse(this.rawCode),
+            isFragment: true,
+        };
+    }
+    parse(raw, options) {
+        return super.parse(raw, {
+            ...options,
+            ignoreFrontMatter: false,
+        });
+    }
+    parseError(error) {
+        if (error instanceof Error && 'start' in error && 'end' in error && 'frame' in error) {
+            // @ts-ignore
+            const token = this.sliceFragment(error.start.character, error.end.character);
+            throw new ParserError(error.message + '\n' + error.frame, token);
+        }
+        return super.parseError(error);
+    }
+    nodeize(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    originNode, parentNode, depth) {
+        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({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'Comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'ExpressionTag': {
+                return this.visitPsBlock({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: 'ExpressionTag',
+                });
+            }
+            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
+                    : token.raw.replace(reEndTag, '').length + token.startOffset;
+                const startTagLocation = this.sliceFragment(token.startOffset, startTagEndOffset);
+                return this.visitElement({
+                    ...startTagLocation,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.name,
+                    namespace: getNamespace(originNode.name, parentNamespace),
+                }, originNode.fragment.nodes, {
+                    createEndTagToken: () => {
+                        if (!reEndTag.test(token.raw)) {
+                            return null;
+                        }
+                        const endTagRawMatched = token.raw.match(reEndTag);
+                        if (!endTagRawMatched) {
+                            throw new Error('Parse error');
+                        }
+                        const endTagRaw = endTagRawMatched[0];
+                        const endTagStartOffset = token.startOffset + token.raw.lastIndexOf(endTagRaw);
+                        const endTagEndOffset = endTagStartOffset + endTagRaw.length;
+                        const endTagLocation = this.sliceFragment(endTagStartOffset, endTagEndOffset);
+                        return {
+                            ...endTagLocation,
+                            depth,
+                            parentNode,
+                        };
+                    },
+                });
+            }
+            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);
+            }
+        }
+    }
+    visitPsBlock(token, childNodes = [], conditionalType = null) {
+        const nodes = super.visitPsBlock(token, childNodes, conditionalType);
+        const block = nodes.at(0);
+        if (!block || block.type !== 'psblock') {
+            throw new ParserError('Parse error', token);
+        }
+        if (nodes.length > 1) {
+            throw new ParserError('Parse error', nodes.at(1));
+        }
+        return [block];
+    }
+    visitChildren(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    children, parentNode) {
+        const siblings = super.visitChildren(children, parentNode);
+        if (siblings.length > 0) {
+            throw new ParserError('Discovered child nodes with differing hierarchy levels', siblings[0]);
+        }
+        return [];
+    }
+    visitAttr(token) {
+        const attr = super.visitAttr(token, {
+            quoteSet: [
+                { start: '"', end: '"', type: 'string' },
+                { start: "'", end: "'", type: 'string' },
+                { start: '{', end: '}', type: 'script' },
+            ],
+            startState: 
+            // is shorthand attribute
+            token.raw.trim().startsWith('{') ? AttrState.BeforeValue : AttrState.BeforeName,
+        });
+        if (attr.type === 'spread') {
+            return attr;
+        }
+        let isDynamicValue = attr.startQuote.raw === '{' || undefined;
+        let potentialName;
+        let isDirective;
+        let isDuplicatable = false;
+        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;
+            }
+        }
+        if (attr.startQuote.raw === '{' && attr.endQuote.raw === '}') {
+            isDynamicValue = true;
+        }
+        return {
+            ...attr,
+            isDynamicValue,
+            isDirective,
+            isDuplicatable,
+            potentialName,
+        };
+    }
+    /**
+     * > A lowercase tag, like `<div>`, denotes a regular HTML element.
+     * A capitalised tag, such as `<Widget>` or `<Namespace.Widget>`, indicates a component.
+     *
+     * @see https://svelte.io/docs/basic-markup#tags
+     * @param nodeName
+     * @returns
+     */
+    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
+     *
+     * `}...{: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;
+        }
+        else {
+            thenExpEndCharOffset = thenExpStart + rawPendingNodesBelow.indexOf('}') + 1;
+        }
+        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;
+        }
+        else {
+            catchExpEndCharOffset = catchExpStart + rawThenNodesBelow.indexOf('}') + 1;
+        }
+        catchToken = this.sliceFragment(token.startOffset + catchExpStart, catchExpEndCharOffset);
+    }
+    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, 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);
+        }
+        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',
+            });
+        }
+    }
+    {
+        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' });
+        }
+    }
+    return result;
+};
+export const parser = new SvelteParser();

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

@@ -0,0 +1,9 @@
+/// <reference types="svelte" />
+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

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

package/lib/sveltekit-parser.d.ts

@@ -0,0 +1,6 @@
+import { HtmlParser } from '@markuplint/html-parser';
+declare class SvelteKitTemplateParser extends HtmlParser {
+    constructor();
+}
+export declare const parser: SvelteKitTemplateParser;
+export {};

package/lib/sveltekit-parser.js

@@ -0,0 +1,15 @@
+import { HtmlParser } from '@markuplint/html-parser';
+class SvelteKitTemplateParser extends HtmlParser {
+    constructor() {
+        super({
+            ignoreTags: [
+                {
+                    type: 'sveltekit-placeholder',
+                    start: '%sveltekit.',
+                    end: '%',
+                },
+            ],
+        });
+    }
+}
+export const parser = new SvelteKitTemplateParser();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/svelte-parser",
-	"version": "4.7.0-alpha.0",
+	"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,6 +30,6 @@
 		"@markuplint/html-parser": "4.6.2",
 		"@markuplint/ml-ast": "4.3.1",
 		"@markuplint/parser-utils": "4.6.2",
-		"svelte": "next"
+		"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