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

package/LICENSE

@@ -0,0 +1,21 @@
+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.

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,7 @@
+import type { SvelteParser } from './parser.js';
+import type { ChildToken, Token } from '@markuplint/parser-utils';
+import type { SvelteBlock } from './svelte-parser/index.js';
+export declare function parseBlock(parser: SvelteParser, token: ChildToken, originBlockNode: SvelteBlock): {
+    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/parser.d.ts

@@ -0,0 +1,61 @@
+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;
+        readonly isFragment: boolean;
+    }, 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;
+    }) | {
+        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;
+        valueType?: "string" | "number" | "boolean" | "code";
+        candidate?: string;
+        uuid: string;
+        raw: string;
+        startOffset: number;
+        endOffset: number;
+        startLine: number;
+        endLine: number;
+        startCol: number;
+        endCol: number;
+        __rightText?: string;
+    };
+    /**
+     * > 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,501 @@
+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';
+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) {
+        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({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'Comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'ExpressionTag': {
+                return this.visitPsBlock({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: 'ExpressionTag',
+                    isFragment: false,
+                });
+            }
+            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,
+                        isFragment: false,
+                    }, 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',
+                        isFragment: true,
+                    }, originNode.fragment.nodes)[0],
+                    this.visitPsBlock({
+                        ...closeToken,
+                        depth,
+                        parentNode,
+                        nodeName: '/key',
+                        isFragment: true,
+                    })[0],
+                ];
+            }
+            case 'SnippetBlock': {
+                const { openToken, closeToken } = parseBlock(this, {
+                    ...token,
+                    depth,
+                    parentNode,
+                }, originNode);
+                return [
+                    this.visitPsBlock({
+                        ...openToken,
+                        depth,
+                        parentNode,
+                        nodeName: 'snippet',
+                        isFragment: false,
+                    }, originNode.body.nodes)[0],
+                    this.visitPsBlock({
+                        ...closeToken,
+                        depth,
+                        parentNode,
+                        nodeName: '/snippet',
+                        isFragment: false,
+                    })[0],
+                ];
+            }
+            default: {
+                const childNodes = 'fragment' in originNode ? originNode.fragment.nodes : [];
+                return this.visitPsBlock({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.type,
+                    isFragment: true,
+                }, 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',
+        isFragment: false,
+    }, originBlockNode.pending?.nodes, 'await')[0]);
+    if (thenToken) {
+        expressions.push(this.visitPsBlock({
+            ...thenToken,
+            depth: token.depth,
+            parentNode: token.parentNode,
+            nodeName: 'await:then',
+            isFragment: false,
+        }, originBlockNode.then?.nodes, 'await:then')[0]);
+    }
+    if (catchToken) {
+        expressions.push(this.visitPsBlock({
+            ...catchToken,
+            depth: token.depth,
+            parentNode: token.parentNode,
+            nodeName: 'await:catch',
+            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) {
+        expressions.push(this.visitPsBlock({
+            ...elseToken,
+            depth: token.depth,
+            parentNode: token.parentNode,
+            nodeName: 'each:empty',
+            isFragment: false,
+        }, originBlockNode.fallback?.nodes, 'each:empty')[0]);
+    }
+    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);
+        }
+        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,12 @@
+import type { AST } from 'svelte/compiler';
+export type SvelteNode = AST.Text | Tag | ElementLike | AST.Comment | SvelteBlock;
+export type SvelteIfBlock = AST.IfBlock;
+export type SvelteEachBlock = AST.EachBlock;
+export type SvelteAwaitBlock = AST.AwaitBlock;
+export declare function svelteParse(template: string): SvelteNode[];
+export type SvelteDirective = Directive | AST.Attribute | AST.SpreadAttribute;
+export type SvelteBlock = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock;
+type Tag = AST.ExpressionTag | AST.HtmlTag | AST.ConstTag | AST.DebugTag | AST.RenderTag;
+type Directive = AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective;
+type ElementLike = AST.Component | AST.TitleElement | AST.SlotElement | AST.RegularElement | AST.SvelteBody | AST.SvelteComponent | AST.SvelteDocument | AST.SvelteElement | AST.SvelteFragment | AST.SvelteHead | AST.SvelteOptionsRaw | AST.SvelteSelf | AST.SvelteWindow;
+export {};

package/lib/svelte-parser/index.js

@@ -0,0 +1,5 @@
+import { parse } from 'svelte/compiler';
+export function svelteParse(template) {
+    const ast = parse(template, { modern: true });
+    return ast.fragment.nodes ?? [];
+}

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",
 	"description": "Svelte parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -9,13 +9,18 @@
 	"type": "module",
 	"exports": {
 		".": {
-			"import": "./lib/index.js"
+			"import": "./lib/index.js",
+			"types": "./lib/index.d.ts"
 		},
 		"./kit": {
-			"import": "./lib/sveltekit-parser.js"
+			"import": "./lib/sveltekit-parser.js",
+			"types": "./lib/sveltekit-parser.d.ts"
 		}
 	},
 	"types": "lib/index.d.ts",
+	"files": [
+		"lib"
+	],
 	"publishConfig": {
 		"access": "public"
 	},
@@ -24,9 +29,10 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.6.2",
-		"@markuplint/ml-ast": "4.3.1",
-		"@markuplint/parser-utils": "4.6.2",
-		"svelte": "next"
-	}
+		"@markuplint/html-parser": "4.6.10",
+		"@markuplint/ml-ast": "4.4.7",
+		"@markuplint/parser-utils": "4.7.1",
+		"svelte": "5.1.3"
+	},
+	"gitHead": "fab5b494f0bdc491aa83cb2c8722738d557fbefd"
 }

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