@markuplint/svelte-parser 4.7.12 → 4.18.0

package/lib/index.d.ts

@@ -1 +1,8 @@
+/**
+ * @module
+ * Svelte component parser for markuplint. Provides a parser that transforms Svelte
+ * template syntax into markuplint's AST, supporting Svelte-specific constructs such as
+ * `{#if}`, `{#each}`, `{#await}`, `{#key}`, `{#snippet}`, expression tags,
+ * and bind/class/event directives.
+ */
 export { parser } from './parser.js';

package/lib/index.js

@@ -1 +1,8 @@
+/**
+ * @module
+ * Svelte component parser for markuplint. Provides a parser that transforms Svelte
+ * template syntax into markuplint's AST, supporting Svelte-specific constructs such as
+ * `{#if}`, `{#each}`, `{#await}`, `{#key}`, `{#snippet}`, expression tags,
+ * and bind/class/event directives.
+ */
 export { parser } from './parser.js';

package/lib/parse-block.d.ts

@@ -1,6 +1,17 @@
 import type { SvelteParser } from './parser.js';
 import type { ChildToken, Token } from '@markuplint/parser-utils';
 import type { SvelteBlock } from './svelte-parser/index.js';
+/**
+ * Extracts the open and close tag tokens from a Svelte block construct
+ * (e.g., `{#each}...{/each}`, `{#key}...{/key}`).
+ * Locates the closing `{/xxx}` tag via regex and computes the opening token
+ * based on the block's child fragment boundaries.
+ *
+ * @param parser - The SvelteParser instance used to slice source fragments
+ * @param token - The child token representing the entire block range
+ * @param originBlockNode - The Svelte AST block node being parsed
+ * @returns An object containing the `openToken` and `closeToken` for the block
+ */
 export declare function parseBlock(parser: SvelteParser, token: ChildToken, originBlockNode: SvelteBlock): {
     openToken: Token;
     closeToken: Token;

package/lib/parse-block.js

@@ -1,3 +1,14 @@
+/**
+ * Extracts the open and close tag tokens from a Svelte block construct
+ * (e.g., `{#each}...{/each}`, `{#key}...{/key}`).
+ * Locates the closing `{/xxx}` tag via regex and computes the opening token
+ * based on the block's child fragment boundaries.
+ *
+ * @param parser - The SvelteParser instance used to slice source fragments
+ * @param token - The child token representing the entire block range
+ * @param originBlockNode - The Svelte AST block node being parsed
+ * @returns An object containing the `openToken` and `closeToken` for the block
+ */
 export function parseBlock(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 parser, token, 

package/lib/parser.d.ts

@@ -2,6 +2,13 @@ import type { SvelteNode } from './svelte-parser/index.js';
 import type { MLASTNodeTreeItem, MLASTParentNode, MLASTPreprocessorSpecificBlock, MLASTPreprocessorSpecificBlockConditionalType } from '@markuplint/ml-ast';
 import type { ChildToken, ParseOptions, Token } from '@markuplint/parser-utils';
 import { ParserError, Parser } from '@markuplint/parser-utils';
+/**
+ * Parser implementation for Svelte component templates.
+ * Extends the base Parser to handle Svelte elements, text, comments,
+ * expression tags, control flow blocks (`{#if}`, `{#each}`, `{#await}`,
+ * `{#key}`, `{#snippet}`), directives (`bind:`, `class:`, `on:`),
+ * and shorthand attribute syntax.
+ */
 export declare class SvelteParser extends Parser<SvelteNode> {
     #private;
     readonly specificBindDirective: ReadonlySet<string>;
@@ -12,13 +19,58 @@ export declare class SvelteParser extends Parser<SvelteNode> {
     };
     parse(raw: string, options?: ParseOptions): import("@markuplint/ml-ast").MLASTDocument;
     parseError(error: any): ParserError;
+    /**
+     * Converts a Svelte AST node into markuplint node tree items.
+     * Dispatches on the node type to handle Text, Comment, ExpressionTag,
+     * elements (Component, RegularElement), and control flow blocks
+     * (IfBlock, EachBlock, AwaitBlock, KeyBlock, SnippetBlock).
+     *
+     * @param originNode - The Svelte AST node to convert
+     * @param parentNode - The parent node in the markuplint tree, or null for root nodes
+     * @param depth - The nesting depth of the node
+     * @returns An array of markuplint node tree items
+     */
     nodeize(originNode: SvelteNode, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    /**
+     * Visits a text token, converting `<script>` tags embedded in Svelte template
+     * text into preprocessor-specific blocks rather than treating them as raw text.
+     *
+     * @param token - The child token representing the text content
+     * @returns An array of markuplint node tree items
+     */
     visitText(token: ChildToken): readonly MLASTNodeTreeItem[];
+    /**
+     * Visits a preprocessor-specific block token and enforces that exactly one
+     * block node is produced. Throws a ParserError if the result is empty
+     * or contains multiple nodes.
+     *
+     * @param token - The child token with node name and fragment flag
+     * @param childNodes - The child Svelte AST nodes within the block
+     * @param conditionalType - The conditional block type identifier, or null
+     * @returns A single-element tuple containing the preprocessor-specific block
+     */
     visitPsBlock(token: ChildToken & {
         readonly nodeName: string;
         readonly isFragment: boolean;
     }, childNodes?: readonly SvelteNode[], conditionalType?: MLASTPreprocessorSpecificBlockConditionalType): readonly [MLASTPreprocessorSpecificBlock];
+    /**
+     * Visits child nodes and verifies that no sibling nodes with differing
+     * hierarchy levels are produced. Throws a ParserError if unexpected
+     * sibling nodes are discovered.
+     *
+     * @param children - The child Svelte AST nodes to visit
+     * @param parentNode - The parent node in the markuplint tree
+     * @returns An empty array (all children are attached via the visitor)
+     */
     visitChildren(children: readonly SvelteNode[], parentNode: MLASTParentNode | null): never[];
+    /**
+     * Visits an attribute token, handling Svelte-specific syntax including
+     * curly-brace expression values, shorthand attributes (`{name}`),
+     * `bind:` / `class:` directives, and duplicatable class attributes.
+     *
+     * @param token - The token representing the attribute
+     * @returns The parsed attribute node with Svelte-specific metadata
+     */
     visitAttr(token: Token): (import("@markuplint/ml-ast").MLASTSpreadAttr & {
         __rightText?: string;
     }) | {

package/lib/parser.js

@@ -8,6 +8,13 @@ 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';
+/**
+ * Parser implementation for Svelte component templates.
+ * Extends the base Parser to handle Svelte elements, text, comments,
+ * expression tags, control flow blocks (`{#if}`, `{#each}`, `{#await}`,
+ * `{#key}`, `{#snippet}`), directives (`bind:`, `class:`, `on:`),
+ * and shorthand attribute syntax.
+ */
 export class SvelteParser extends Parser {
     constructor() {
         super({
@@ -49,6 +56,17 @@ export class SvelteParser extends Parser {
         }
         return super.parseError(error);
     }
+    /**
+     * Converts a Svelte AST node into markuplint node tree items.
+     * Dispatches on the node type to handle Text, Comment, ExpressionTag,
+     * elements (Component, RegularElement), and control flow blocks
+     * (IfBlock, EachBlock, AwaitBlock, KeyBlock, SnippetBlock).
+     *
+     * @param originNode - The Svelte AST node to convert
+     * @param parentNode - The parent node in the markuplint tree, or null for root nodes
+     * @param depth - The nesting depth of the node
+     * @returns An array of markuplint node tree items
+     */
     nodeize(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     originNode, parentNode, depth) {
@@ -205,6 +223,13 @@ export class SvelteParser extends Parser {
             }
         }
     }
+    /**
+     * Visits a text token, converting `<script>` tags embedded in Svelte template
+     * text into preprocessor-specific blocks rather than treating them as raw text.
+     *
+     * @param token - The child token representing the text content
+     * @returns An array of markuplint node tree items
+     */
     visitText(token) {
         const nodes = super.visitText(token, {
             researchTags: false,
@@ -221,6 +246,16 @@ export class SvelteParser extends Parser {
             return node;
         });
     }
+    /**
+     * Visits a preprocessor-specific block token and enforces that exactly one
+     * block node is produced. Throws a ParserError if the result is empty
+     * or contains multiple nodes.
+     *
+     * @param token - The child token with node name and fragment flag
+     * @param childNodes - The child Svelte AST nodes within the block
+     * @param conditionalType - The conditional block type identifier, or null
+     * @returns A single-element tuple containing the preprocessor-specific block
+     */
     visitPsBlock(token, childNodes = [], conditionalType = null) {
         const nodes = super.visitPsBlock(token, childNodes, conditionalType);
         const block = nodes.at(0);
@@ -232,6 +267,15 @@ export class SvelteParser extends Parser {
         }
         return [block];
     }
+    /**
+     * Visits child nodes and verifies that no sibling nodes with differing
+     * hierarchy levels are produced. Throws a ParserError if unexpected
+     * sibling nodes are discovered.
+     *
+     * @param children - The child Svelte AST nodes to visit
+     * @param parentNode - The parent node in the markuplint tree
+     * @returns An empty array (all children are attached via the visitor)
+     */
     visitChildren(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     children, parentNode) {
@@ -241,6 +285,14 @@ export class SvelteParser extends Parser {
         }
         return [];
     }
+    /**
+     * Visits an attribute token, handling Svelte-specific syntax including
+     * curly-brace expression values, shorthand attributes (`{name}`),
+     * `bind:` / `class:` directives, and duplicatable class attributes.
+     *
+     * @param token - The token representing the attribute
+     * @returns The parsed attribute node with Svelte-specific metadata
+     */
     visitAttr(token) {
         const attr = super.visitAttr(token, {
             quoteSet: [
@@ -388,14 +440,15 @@ originBlockNode) {
         }
         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]);
+    const expressions = [
+        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,

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

@@ -1,10 +1,23 @@
 import type { AST } from 'svelte/compiler';
+/** Union of Svelte AST node types that can appear as children in a Svelte template fragment. */
 export type SvelteNode = AST.Text | AST.Comment | AST.Tag | AST.ElementLike | AST.Block;
+/** Represents a Svelte `{#if}` block with consequent, alternate, and elseif branches. */
 export type SvelteIfBlock = AST.IfBlock;
+/** Represents a Svelte `{#each}` block with iteration body and optional fallback. */
 export type SvelteEachBlock = AST.EachBlock;
+/** Represents a Svelte `{#await}` block with pending, then, and catch branches. */
 export type SvelteAwaitBlock = AST.AwaitBlock;
+/**
+ * Parses a Svelte template string into an array of top-level AST nodes
+ * using the Svelte compiler's modern parser mode.
+ *
+ * @param template - The raw Svelte template source code
+ * @returns An array of top-level Svelte AST nodes from the template fragment
+ */
 export declare function svelteParse(template: string): SvelteNode[];
+/** Union of all Svelte directive and attribute types that can appear on elements. */
 export type SvelteDirective = Directive | AST.Attribute | AST.SpreadAttribute;
+/** Union of all Svelte block types that have opening/closing tag syntax. */
 export type SvelteBlock = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock | AST.SvelteBoundary;
 type Directive = AST.AnimateDirective | AST.BindDirective | AST.ClassDirective | AST.LetDirective | AST.OnDirective | AST.StyleDirective | AST.TransitionDirective | AST.UseDirective;
 export {};

package/lib/svelte-parser/index.js

@@ -1,4 +1,11 @@
 import { parse } from 'svelte/compiler';
+/**
+ * Parses a Svelte template string into an array of top-level AST nodes
+ * using the Svelte compiler's modern parser mode.
+ *
+ * @param template - The raw Svelte template source code
+ * @returns An array of top-level Svelte AST nodes from the template fragment
+ */
 export function svelteParse(template) {
     const ast = parse(template, { modern: true });
     return ast.fragment.nodes ?? [];

package/lib/sveltekit-parser.d.ts

@@ -1,4 +1,10 @@
 import { HtmlParser } from '@markuplint/html-parser';
+/**
+ * Parser for SvelteKit app template files (e.g., `app.html`).
+ * Extends the standard HTML parser to handle SvelteKit placeholder tags
+ * such as `%sveltekit.head%` and `%sveltekit.body%`, which are treated
+ * as opaque preprocessor-specific blocks.
+ */
 declare class SvelteKitTemplateParser extends HtmlParser {
     constructor();
 }

package/lib/sveltekit-parser.js

@@ -1,4 +1,10 @@
 import { HtmlParser } from '@markuplint/html-parser';
+/**
+ * Parser for SvelteKit app template files (e.g., `app.html`).
+ * Extends the standard HTML parser to handle SvelteKit placeholder tags
+ * such as `%sveltekit.head%` and `%sveltekit.body%`, which are treated
+ * as opaque preprocessor-specific blocks.
+ */
 class SvelteKitTemplateParser extends HtmlParser {
     constructor() {
         super({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/svelte-parser",
-	"version": "4.7.12",
+	"version": "4.18.0",
 	"description": "Svelte parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -29,10 +29,10 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.6.22",
-		"@markuplint/ml-ast": "4.4.10",
-		"@markuplint/parser-utils": "4.8.10",
-		"svelte": "5.38.10"
+		"@markuplint/html-parser": "4.18.0",
+		"@markuplint/ml-ast": "4.18.0",
+		"@markuplint/parser-utils": "4.18.0",
+		"svelte": "5.55.4"
 	},
-	"gitHead": "6213ea30269ef404f030e67bbcc7fc7443ec1060"
+	"gitHead": "1885af6349def3f19df975b9e9c399dd47361de1"
 }