@markuplint/svelte-parser 4.0.0-dev.20 → 4.0.0-dev.23

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2023 Yusuke Hirao
+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

package/README.md

@@ -23,3 +23,15 @@ Add `parser` option to your [configuration](https://markuplint.dev/configuration
   }
 }
 ```
+
+### Use with [SvelteKit](https://kit.svelte.dev/)
+
+```diff
+{
+  "parser": {
+--  ".svelte$": "@markuplint/svelte-parser"
+++  ".svelte$": "@markuplint/svelte-parser",
+++  ".html$": "@markuplint/svelte-parser/kit"
+  }
+}
+```

package/lib/index.d.ts

@@ -1,2 +1 @@
-export { parse } from './parse.js';
-export declare const endTag = "xml";
+export { parser } from './parser.js';

package/lib/index.js

@@ -1,2 +1 @@
-export { parse } from './parse.js';
-export const endTag = 'xml';
+export { parser } from './parser.js';

package/lib/parser.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="svelte" />
+import type { SvelteNode } from './svelte-parser/index.js';
+import type { MLASTParentNode, MLASTPreprocessorSpecificBlock } 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> {
+    readonly specificBindDirective: ReadonlySet<string>;
+    constructor();
+    tokenize(): {
+        ast: import("svelte/types/compiler/interfaces").TemplateNode[];
+        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[]): 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;
+    };
+    detectElementType(nodeName: string): import("@markuplint/ml-ast").ElementType;
+    visitExpression(token: ChildToken, originBlockNode: SvelteNode): MLASTPreprocessorSpecificBlock[];
+}
+export declare const parser: SvelteParser;
+export {};

package/lib/parser.js

@@ -0,0 +1,267 @@
+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 {
+    constructor() {
+        super({
+            endTagType: 'xml',
+            ignoreTags: [
+                {
+                    type: 'Script',
+                    start: '<script',
+                    end: '</script>',
+                },
+                {
+                    type: 'Style',
+                    start: '<style',
+                    end: '</style>',
+                },
+            ],
+            maskChar: '-',
+        });
+        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 'MustacheTag': {
+                return this.visitPsBlock({
+                    ...token,
+                    depth,
+                    parentNode,
+                    nodeName: 'MustacheTag',
+                });
+            }
+            case 'InlineComponent':
+            case 'Element': {
+                const children = originNode.children ?? [];
+                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.children, {
+                    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,
+                        };
+                    },
+                });
+            }
+            default: {
+                return this.visitExpression({
+                    ...token,
+                    depth,
+                    parentNode,
+                }, originNode);
+            }
+        }
+    }
+    visitPsBlock(token, childNodes = []) {
+        const nodes = super.visitPsBlock(token, childNodes);
+        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: '"' },
+                { start: "'", end: "'" },
+                { start: '{', end: '}' },
+            ],
+            quoteInValueChars: [
+                { start: '"', end: '"' },
+                { start: "'", end: "'" },
+                { start: '`', end: '`' },
+                { start: '${', end: '}' },
+            ],
+            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,
+        };
+    }
+    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 = [];
+        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 ? 'elseif' : 'else';
+                    nodeList.set(node, type);
+                    node = node.else ?? node.children?.[0] ?? null;
+                }
+                continue;
+            }
+            let type = prop || blockType;
+            if (prop === 'pending') {
+                type = 'await';
+            }
+            nodeList.set(node, type);
+        }
+        let lastChild = null;
+        for (const [node, type] of nodeList.entries()) {
+            let start = node.start;
+            let end = node.end;
+            if (type === 'await') {
+                start = originBlockNode.start;
+            }
+            end = node.children?.[0]?.start ?? end;
+            if (type === 'else' && originBlockNode.type === 'EachBlock') {
+                start = lastChild?.end ?? start;
+            }
+            if (['else', 'elseif'].includes(type) && originBlockNode.type === 'IfBlock') {
+                start = lastChild?.end ?? start;
+            }
+            const tag = this.sliceFragment(start, end);
+            if (node.children && Array.isArray(node.children)) {
+                lastChild = node.children.at(-1) ?? null;
+            }
+            const expression = this.visitPsBlock({
+                ...tag,
+                depth: token.depth,
+                parentNode: token.parentNode,
+                nodeName: type,
+            }, node.children)[0];
+            expressions.push(expression);
+        }
+        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,
+                })[0];
+                expressions.push(expression);
+            }
+        }
+        return expressions;
+    }
+}
+export const parser = new SvelteParser();

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.0.0-dev.20+6b35da16",
+	"version": "4.0.0-dev.23+d6f2aa9bc",
 	"description": "Svelte parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -10,6 +10,9 @@
 	"exports": {
 		".": {
 			"import": "./lib/index.js"
+		},
+		"./kit": {
+			"import": "./lib/sveltekit-parser.js"
 		}
 	},
 	"types": "lib/index.d.ts",
@@ -21,10 +24,10 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.0.0-dev.20+6b35da16",
-		"@markuplint/ml-ast": "4.0.0-dev.20+6b35da16",
-		"@markuplint/parser-utils": "4.0.0-dev.20+6b35da16",
-		"svelte": "^4.2.8"
+		"@markuplint/html-parser": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/ml-ast": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/parser-utils": "4.0.0-dev.23+d6f2aa9bc",
+		"svelte": "^4.2.9"
 	},
-	"gitHead": "6b35da161d94f784953d0adecc2d28502052d92a"
+	"gitHead": "d6f2aa9bc287768466f23b5340e4e0eecfa30d59"
 }

package/lib/attr.d.ts

@@ -1,5 +0,0 @@
-import type { SvelteDirective } from './svelte-parser/index.js';
-import type { MLASTAttr } from '@markuplint/ml-ast';
-export declare function attr(attr: SvelteDirective, rawHTML: string): MLASTAttr | {
-    __spreadAttr: true;
-};

package/lib/attr.js

@@ -1,61 +0,0 @@
-import { defaultValueDelimiters, parseAttr, sliceFragment } from '@markuplint/parser-utils';
-import { directiveTokenizer } from './directive-tokenizer.js';
-const mustacheTag = {
-    start: '{',
-    end: '}',
-};
-const specificBindDirective = new Set(['bind:group', 'bind:this']);
-export function attr(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-attr, rawHTML) {
-    const isShorthand = attr.value && Array.isArray(attr.value)
-        ? attr.value.some((val) => val.type === 'AttributeShorthand')
-        : false;
-    const { start, end } = attr;
-    if (attr.type === 'Spread') {
-        return {
-            __spreadAttr: true,
-        };
-    }
-    let token;
-    if (attr.type === 'Attribute' && !isShorthand) {
-        const { raw } = sliceFragment(rawHTML, start, end);
-        token = parseAttr(raw, start, rawHTML, {
-            valueDelimiters: [...defaultValueDelimiters, mustacheTag],
-        });
-    }
-    else {
-        const { raw, startLine, startCol, startOffset } = sliceFragment(rawHTML, start, end);
-        const valueToken = isShorthand
-            ? attr.name
-            : attr.expression && 'start' in attr.expression && 'end' in attr.expression
-                ? sliceFragment(rawHTML, attr.expression.start, attr.expression.end).raw
-                : '';
-        token = directiveTokenizer(raw, valueToken, startLine, startCol, startOffset);
-    }
-    if (!specificBindDirective.has(token.name.raw) && /^bind:/i.test(token.name.raw)) {
-        // Remove "bind:"
-        token.potentialName = token.name.raw.slice(5);
-        token.isDirective = undefined;
-        token.isDynamicValue = true;
-    }
-    if (isShorthand) {
-        token.potentialName = token.value.raw.trim();
-        token.isDirective = undefined;
-        token.isDynamicValue = true;
-    }
-    const [baseName, subName] = token.name.raw.split(':');
-    if (baseName?.toLowerCase() === 'class') {
-        token.isDuplicatable = true;
-        if (subName) {
-            token.potentialName = 'class';
-            token.isDynamicValue = true;
-        }
-    }
-    if (token.startQuote.raw === '{' && token.endQuote.raw === '}') {
-        token.isDynamicValue = true;
-    }
-    return {
-        ...token,
-    };
-}

package/lib/directive-tokenizer.d.ts

@@ -1,2 +0,0 @@
-import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
-export declare function directiveTokenizer(raw: string, rawValue: string, line: number, col: number, startOffset: number): MLASTHTMLAttr;

package/lib/directive-tokenizer.js

@@ -1,16 +0,0 @@
-import { AttrState, attrTokenizer } from '@markuplint/parser-utils';
-export function directiveTokenizer(raw, rawValue, line, col, startOffset) {
-    const nameOnly = raw.trim().startsWith('{') && raw.trim().endsWith('}');
-    const directiveToken = attrTokenizer(raw, line, col, startOffset, [
-        { start: '"', end: '"' },
-        { start: "'", end: "'" },
-        { start: '{', end: '}' },
-    ], nameOnly ? AttrState.BeforeValue : AttrState.BeforeName, [
-        { start: '"', end: '"' },
-        { start: "'", end: "'" },
-        { start: '`', end: '`' },
-        { start: '${', end: '}' },
-    ]);
-    directiveToken.isDirective = true;
-    return directiveToken;
-}

package/lib/nodeize.d.ts

@@ -1,3 +0,0 @@
-import type { SvelteNode } from './svelte-parser/index.js';
-import type { MLASTNode, MLASTParentNode, ParserOptions } from '@markuplint/ml-ast';
-export declare function nodeize(originNode: SvelteNode, prevNode: MLASTNode | null, parentNode: MLASTParentNode | null, rawHtml: string, options?: ParserOptions): MLASTNode | MLASTNode[] | null;

package/lib/nodeize.js

@@ -1,290 +0,0 @@
-import { getNamespace } from '@markuplint/html-parser';
-import { detectElementType, sliceFragment, uuid, tagParser } from '@markuplint/parser-utils';
-import { attr } from './attr.js';
-import { parseCtrlBlock } from './parse-ctrl-block.js';
-import { traverse } from './traverse.js';
-export function nodeize(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-prevNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-parentNode, rawHtml, options) {
-    const nextNode = null;
-    const { startOffset, endOffset, startLine, endLine, startCol, endCol, raw } = sliceFragment(rawHtml, originNode.start, originNode.end);
-    const parentNamespace = parentNode && 'namespace' in parentNode ? parentNode.namespace : 'http://www.w3.org/1999/xhtml';
-    switch (originNode.type) {
-        case 'Text': {
-            const node = {
-                uuid: uuid(),
-                raw,
-                startOffset,
-                endOffset,
-                startLine,
-                endLine,
-                startCol,
-                endCol,
-                nodeName: '#text',
-                type: 'text',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-            return node;
-        }
-        case 'MustacheTag': {
-            return {
-                uuid: uuid(),
-                raw,
-                startOffset,
-                endOffset,
-                startLine,
-                endLine,
-                startCol,
-                endCol,
-                nodeName: '#ps:MustacheTag',
-                type: 'psblock',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-        }
-        case 'InlineComponent':
-        case 'Element': {
-            const children = originNode.children ?? [];
-            const reEndTag = new RegExp(`</${originNode.name}\\s*>$`, 'i');
-            const startTagEndOffset = children.length > 0 ? children[0]?.start ?? 0 : raw.replace(reEndTag, '').length + startOffset;
-            const startTagLocation = sliceFragment(rawHtml, startOffset, startTagEndOffset);
-            let endTag = null;
-            if (reEndTag.test(raw)) {
-                const endTagRawMatched = raw.match(reEndTag);
-                if (!endTagRawMatched) {
-                    throw new Error('Parse error');
-                }
-                const endTagRaw = endTagRawMatched[0];
-                const endTagStartOffset = startOffset + raw.lastIndexOf(endTagRaw);
-                const endTagEndOffset = endTagStartOffset + endTagRaw.length;
-                const endTagLocation = sliceFragment(rawHtml, endTagStartOffset, endTagEndOffset);
-                const namespace = getNamespace(originNode.name, parentNamespace);
-                endTag = {
-                    uuid: uuid(),
-                    raw: endTagRaw,
-                    startOffset: endTagStartOffset,
-                    endOffset: endTagEndOffset,
-                    startLine: endTagLocation.startLine,
-                    endLine: endTagLocation.endLine,
-                    startCol: endTagLocation.startCol,
-                    endCol: endTagLocation.endCol,
-                    nodeName: originNode.name,
-                    type: 'endtag',
-                    namespace,
-                    attributes: [],
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    pearNode: null,
-                    isFragment: false,
-                    isGhost: false,
-                    tagOpenChar: '</',
-                    tagCloseChar: '>',
-                };
-            }
-            const directives = originNode.attributes.map(a => attr(a, rawHtml)) ?? [];
-            const attributes = directives.filter((d) => !('__spreadAttr' in d));
-            const hasSpreadAttr = directives.some(d => '__spreadAttr' in d);
-            const tagTokens = tagParser(startTagLocation.raw, startTagLocation.startLine, startTagLocation.startCol, startTagLocation.startOffset);
-            const namespace = getNamespace(originNode.name, parentNamespace);
-            const startTag = {
-                uuid: uuid(),
-                ...startTagLocation,
-                nodeName: originNode.name,
-                type: 'starttag',
-                namespace,
-                elementType: detectElementType(originNode.name, options?.authoredElementName, /[.A-Z]/),
-                attributes,
-                hasSpreadAttr,
-                parentNode,
-                prevNode,
-                nextNode,
-                pearNode: endTag,
-                selfClosingSolidus: tagTokens.selfClosingSolidus,
-                endSpace: tagTokens.afterAttrSpaces,
-                isFragment: false,
-                isGhost: false,
-                tagOpenChar: '<',
-                tagCloseChar: '>',
-            };
-            if (endTag) {
-                endTag.pearNode = startTag;
-            }
-            if (originNode.children) {
-                startTag.childNodes = traverse(originNode.children, startTag, rawHtml, options);
-            }
-            return startTag;
-        }
-        case 'IfBlock': {
-            const ifBlocks = parseCtrlBlock('if', originNode, raw, rawHtml, startOffset, parentNode, prevNode, nextNode, options);
-            return ifBlocks;
-        }
-        case 'EachBlock': {
-            return parseCtrlBlock('each', originNode, raw, rawHtml, startOffset, parentNode, prevNode, nextNode, options);
-        }
-        case 'AwaitBlock': {
-            const pendingNode = originNode.pending;
-            const pendingTag = sliceFragment(rawHtml, originNode.start, pendingNode.start);
-            const pending = {
-                uuid: uuid(),
-                ...pendingTag,
-                nodeName: pendingNode.type,
-                type: 'psblock',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-            if (pendingNode.children) {
-                pending.childNodes = traverse(pendingNode.children, pending, rawHtml, options);
-            }
-            let then = null;
-            if (originNode.then) {
-                const thenNode = originNode.then;
-                const thenTag = sliceFragment(rawHtml, thenNode.start, (thenNode.children && thenNode.children[0] && thenNode.children[0].start) ?? thenNode.end);
-                then = {
-                    uuid: uuid(),
-                    ...thenTag,
-                    nodeName: thenNode.type,
-                    type: 'psblock',
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-                if (thenNode.children) {
-                    then.childNodes = traverse(thenNode.children, then, rawHtml, options);
-                }
-            }
-            let awaitCatch = null;
-            if (originNode.catch) {
-                const awaitCatchNode = originNode.catch;
-                const awaitCatchTag = sliceFragment(rawHtml, awaitCatchNode.start, (awaitCatchNode.children && awaitCatchNode.children[0] && awaitCatchNode.children[0].start) ??
-                    awaitCatchNode.end);
-                awaitCatch = {
-                    uuid: uuid(),
-                    ...awaitCatchTag,
-                    nodeName: awaitCatchNode.type,
-                    type: 'psblock',
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-                if (awaitCatchNode.children) {
-                    awaitCatch.childNodes = traverse(awaitCatchNode.children, awaitCatch, rawHtml, options);
-                }
-            }
-            // eslint-disable-next-line regexp/strict
-            const reEndTag = /{\s*\/await\s*}$/i;
-            let endTag = null;
-            if (reEndTag.test(raw)) {
-                const endTagRawMatched = raw.match(reEndTag);
-                if (!endTagRawMatched) {
-                    throw new Error('Parse error');
-                }
-                const endTagRaw = endTagRawMatched[0];
-                const endTagStartOffset = startOffset + raw.indexOf(endTagRaw);
-                const endTagEndOffset = endTagStartOffset + endTagRaw.length;
-                const endTagLocation = sliceFragment(rawHtml, endTagStartOffset, endTagEndOffset);
-                endTag = {
-                    uuid: uuid(),
-                    raw: endTagRaw,
-                    startOffset: endTagStartOffset,
-                    endOffset: endTagEndOffset,
-                    startLine: endTagLocation.startLine,
-                    endLine: endTagLocation.endLine,
-                    startCol: endTagLocation.startCol,
-                    endCol: endTagLocation.endCol,
-                    nodeName: originNode.type,
-                    type: 'psblock',
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-            }
-            const tags = [pending];
-            if (then) {
-                tags.push(then);
-            }
-            if (awaitCatch) {
-                tags.push(awaitCatch);
-            }
-            if (endTag) {
-                tags.push(endTag);
-            }
-            return tags;
-        }
-        default: {
-            const startTag = {
-                uuid: uuid(),
-                raw,
-                startOffset,
-                endOffset,
-                startLine,
-                endLine,
-                startCol,
-                endCol,
-                nodeName: originNode.name || originNode.type,
-                type: 'psblock',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-            let endTag = null;
-            if (originNode.children) {
-                startTag.childNodes = traverse(originNode.children, startTag, rawHtml, options);
-                const firstChild = startTag.childNodes[0];
-                if (firstChild) {
-                    startTag.endOffset = firstChild.startOffset;
-                    startTag.endLine = firstChild.startLine;
-                    startTag.endCol = firstChild.startCol;
-                    startTag.raw = rawHtml.slice(startTag.startOffset, startTag.endOffset);
-                }
-                const lastChild = startTag.childNodes.at(-1);
-                if (lastChild && lastChild.endOffset > startTag.endOffset) {
-                    const startOffset = lastChild.endOffset;
-                    const startLine = lastChild.endLine;
-                    const startCol = lastChild.endCol;
-                    const raw = rawHtml.slice(startOffset, endOffset);
-                    endTag = {
-                        uuid: uuid(),
-                        raw,
-                        startOffset,
-                        endOffset,
-                        startLine,
-                        endLine,
-                        startCol,
-                        endCol,
-                        nodeName: originNode.name || originNode.type,
-                        type: 'psblock',
-                        parentNode,
-                        prevNode,
-                        nextNode,
-                        isFragment: false,
-                        isGhost: false,
-                    };
-                }
-            }
-            return endTag == null ? startTag : [startTag, endTag];
-        }
-    }
-}

package/lib/parse-ctrl-block.d.ts

@@ -1,3 +0,0 @@
-import type { SvelteNode } from './svelte-parser/index.js';
-import type { MLASTNode, MLASTParentNode, MLASTPreprocessorSpecificBlock, ParserOptions } from '@markuplint/ml-ast';
-export declare function parseCtrlBlock(ctrlName: 'if' | 'each', originNode: SvelteNode, raw: string, rawHtml: string, startOffset: number, parentNode: MLASTParentNode | null, prevNode: MLASTNode | null, nextNode: MLASTNode | null, options?: ParserOptions): MLASTPreprocessorSpecificBlock[];

package/lib/parse-ctrl-block.js

@@ -1,171 +0,0 @@
-import { sliceFragment, uuid } from '@markuplint/parser-utils';
-import { traverse } from './traverse.js';
-export function parseCtrlBlock(ctrlName, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originNode, raw, rawHtml, startOffset, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-parentNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-prevNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nextNode, options) {
-    if (ctrlName === 'if') {
-        return parseIfBlock(originNode, raw, rawHtml, startOffset, originNode.start, parentNode, prevNode, nextNode, options);
-    }
-    const children = originNode.children ?? [];
-    // eslint-disable-next-line regexp/strict
-    const reEndTag = /{\s*\/each\s*}$/i;
-    const startTagEndOffset = children.length > 0 ? children[0]?.start ?? 0 : raw.replace(reEndTag, '').length + startOffset;
-    const startTagLocation = sliceFragment(rawHtml, startOffset, startTagEndOffset);
-    const tag = {
-        uuid: uuid(),
-        ...startTagLocation,
-        nodeName: originNode.type,
-        type: 'psblock',
-        parentNode,
-        prevNode,
-        nextNode,
-        isFragment: false,
-        isGhost: false,
-    };
-    if (originNode.children) {
-        tag.childNodes = traverse(originNode.children, tag, rawHtml, options);
-    }
-    let elseTag = null;
-    if (originNode.else) {
-        const elseNode = originNode.else;
-        const elseTagStartOffset = children.length > 0 ? children.at(-1)?.end ?? 0 : startTagLocation.endOffset;
-        const elseTagLocation = sliceFragment(rawHtml, elseTagStartOffset, elseNode.start);
-        elseTag = {
-            uuid: uuid(),
-            ...elseTagLocation,
-            nodeName: elseNode.type,
-            type: 'psblock',
-            parentNode,
-            prevNode,
-            nextNode,
-            isFragment: false,
-            isGhost: false,
-        };
-        if (elseNode.children) {
-            elseTag.childNodes = traverse(elseNode.children, elseTag, rawHtml, options);
-        }
-    }
-    let endTag = null;
-    const endTagRawMatched = raw.match(reEndTag);
-    if (endTagRawMatched) {
-        const endTagRaw = endTagRawMatched[0];
-        const endTagStartOffset = originNode.end - endTagRaw.length;
-        const endTagEndOffset = originNode.end;
-        const endTagLocation = sliceFragment(rawHtml, endTagStartOffset, endTagEndOffset);
-        endTag = {
-            uuid: uuid(),
-            raw: endTagRaw,
-            startOffset: endTagStartOffset,
-            endOffset: endTagEndOffset,
-            startLine: endTagLocation.startLine,
-            endLine: endTagLocation.endLine,
-            startCol: endTagLocation.startCol,
-            endCol: endTagLocation.endCol,
-            nodeName: originNode.type,
-            type: 'psblock',
-            parentNode,
-            prevNode,
-            nextNode,
-            isFragment: false,
-            isGhost: false,
-        };
-    }
-    const tags = [tag];
-    if (elseTag) {
-        tags.push(elseTag);
-    }
-    if (endTag) {
-        tags.push(endTag);
-    }
-    return tags;
-}
-function parseIfBlock(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originNode, raw, rawHtml, statementStartOffset, tokenStartOffset, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-parentNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-prevNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nextNode, options) {
-    const children = originNode.children ?? [];
-    const startTagEndOffset = children[0]?.start ?? tokenStartOffset;
-    const startTagLocation = sliceFragment(rawHtml, tokenStartOffset, startTagEndOffset);
-    const tag = {
-        uuid: uuid(),
-        ...startTagLocation,
-        nodeName: originNode.elseif ? 'ElseIfBlock' : originNode.type,
-        type: 'psblock',
-        parentNode,
-        prevNode,
-        nextNode,
-        isFragment: false,
-        isGhost: false,
-    };
-    if (originNode.children) {
-        tag.childNodes = traverse(originNode.children, tag, rawHtml, options);
-    }
-    const elseOrElseIfTags = [];
-    if (originNode.else) {
-        const elseNode = originNode.else;
-        const elseTagStartOffset = children.length > 0 ? children.at(-1)?.end ?? 0 : startTagLocation.endOffset;
-        const elseTagLocation = sliceFragment(rawHtml, elseTagStartOffset, elseNode.start);
-        if (elseNode.children) {
-            if (elseNode.children.length === 1 && elseNode.children[0]?.type === 'IfBlock') {
-                const elseIfTags = parseIfBlock(elseNode.children[0], elseTagLocation.raw, rawHtml, statementStartOffset, originNode.children?.[0]?.end ?? startTagLocation.endOffset, parentNode, null, null, options);
-                elseOrElseIfTags.push(...elseIfTags);
-            }
-            else {
-                const elseTag = {
-                    uuid: uuid(),
-                    ...elseTagLocation,
-                    nodeName: elseNode.type,
-                    type: 'psblock',
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-                elseTag.childNodes = traverse(elseNode.children, elseTag, rawHtml, options);
-                elseOrElseIfTags.push(elseTag);
-            }
-        }
-    }
-    if (originNode.elseif) {
-        return [tag, ...elseOrElseIfTags];
-    }
-    // eslint-disable-next-line regexp/strict
-    const endTagRawMatched = raw.match(/{\s*\/if\s*}/);
-    if (!endTagRawMatched) {
-        throw new Error('Missing the end token `{/if}`');
-    }
-    const endTagRaw = endTagRawMatched[0];
-    const endTagStartOffset = originNode.end - endTagRaw.length;
-    const endTagEndOffset = originNode.end;
-    const endTagLocation = sliceFragment(rawHtml, endTagStartOffset, endTagEndOffset);
-    const endTag = {
-        uuid: uuid(),
-        raw: endTagRaw,
-        startOffset: endTagStartOffset,
-        endOffset: endTagEndOffset,
-        startLine: endTagLocation.startLine,
-        endLine: endTagLocation.endLine,
-        startCol: endTagLocation.startCol,
-        endCol: endTagLocation.endCol,
-        nodeName: originNode.type,
-        type: 'psblock',
-        parentNode,
-        prevNode,
-        nextNode,
-        isFragment: false,
-        isGhost: false,
-    };
-    return [tag, ...elseOrElseIfTags, endTag];
-}

package/lib/parse.d.ts

@@ -1,2 +0,0 @@
-import type { Parse } from '@markuplint/ml-ast';
-export declare const parse: Parse;

package/lib/parse.js

@@ -1,47 +0,0 @@
-import { flattenNodes, ParserError, ignoreBlock, restoreNode } from '@markuplint/parser-utils';
-import { svelteParse } from './svelte-parser/index.js';
-import { traverse } from './traverse.js';
-export const parse = (rawCode, options) => {
-    const blocks = ignoreBlock(rawCode, [
-        {
-            type: 'Script',
-            start: '<script',
-            end: '</script>',
-        },
-        {
-            type: 'Style',
-            start: '<style',
-            end: '</style>',
-        },
-    ], '-');
-    let ast;
-    try {
-        ast = svelteParse(blocks.replaced);
-    }
-    catch (error) {
-        if (error instanceof Error && 'start' in error && 'end' in error && 'frame' in error) {
-            // @ts-ignore
-            const raw = rawCode.slice(error.start.character, error.end.character);
-            throw new ParserError(
-            // @ts-ignore
-            error.message + '\n' + error.frame, {
-                // @ts-ignore
-                line: error.start.line,
-                // @ts-ignore
-                col: error.start.column,
-                raw,
-            });
-        }
-        return {
-            nodeList: [],
-            isFragment: true,
-            parseError: error instanceof Error ? error.message : new Error(`${error}`).message,
-        };
-    }
-    const nodes = traverse(ast, null, blocks.replaced, options);
-    const nodeList = restoreNode(flattenNodes(nodes, blocks.replaced), blocks);
-    return {
-        nodeList,
-        isFragment: true,
-    };
-};

package/lib/traverse.d.ts

@@ -1,3 +0,0 @@
-import type { SvelteNode } from './svelte-parser/index.js';
-import type { MLASTNode, MLASTParentNode, ParserOptions } from '@markuplint/ml-ast';
-export declare function traverse(astNodes: readonly SvelteNode[], parentNode: MLASTParentNode | null | undefined, rawHtml: string, options?: ParserOptions): MLASTNode[];

package/lib/traverse.js

@@ -1,38 +0,0 @@
-import { nodeize } from './nodeize.js';
-export function traverse(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-astNodes, parentNode = null, rawHtml, options) {
-    const nodeList = [];
-    let prevNode = null;
-    for (const astNode of astNodes) {
-        const nodes = nodeize(astNode, prevNode, parentNode, rawHtml, options);
-        if (!nodes) {
-            continue;
-        }
-        let node;
-        if (Array.isArray(nodes)) {
-            const lastNode = nodes.at(-1);
-            if (!lastNode) {
-                continue;
-            }
-            node = lastNode;
-        }
-        else {
-            node = nodes;
-        }
-        if (prevNode) {
-            if (node.type !== 'endtag') {
-                prevNode.nextNode = node;
-            }
-            node.prevNode = prevNode;
-        }
-        prevNode = node;
-        if (Array.isArray(nodes)) {
-            nodeList.push(...nodes);
-        }
-        else {
-            nodeList.push(nodes);
-        }
-    }
-    return nodeList;
-}