@markuplint/svelte-parser 3.12.0 → 4.0.0-alpha.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2019 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';
-export declare const endTag = 'xml';
+export { parser } from './parser.js';

package/lib/index.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.endTag = exports.parse = void 0;
-var parse_1 = require("./parse");
-Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_1.parse; } });
-exports.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/svelte-parser/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="svelte" />
 import type { Directive, TemplateNode, Attribute, SpreadAttribute } from 'svelte/types/compiler/interfaces';
 export type SvelteNode = TemplateNode;
-export default function svelteParse(template: string): SvelteNode[];
+export declare function svelteParse(template: string): SvelteNode[];
 export type SvelteDirective = Directive | Attribute | SpreadAttribute;

package/lib/svelte-parser/index.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const compiler_1 = require("svelte/compiler");
-function svelteParse(template) {
-    var _a;
-    const ast = (0, compiler_1.parse)(template, { customElement: true });
+import { parse } from 'svelte/compiler';
+export function svelteParse(template) {
+    const ast = parse(template, { customElement: true });
     const start = ast.html.start;
-    const children = (_a = ast.html.children) !== null && _a !== void 0 ? _a : [];
+    const children = ast.html.children ?? [];
     if (children[0] && children[0].end === start) {
         children.shift();
     }
     return children;
 }
-exports.default = svelteParse;

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,12 +1,20 @@
 {
 	"name": "@markuplint/svelte-parser",
-	"version": "3.12.0",
+	"version": "4.0.0-alpha.10",
 	"description": "Svelte parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"private": false,
-	"main": "lib/index.js",
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./lib/index.js"
+		},
+		"./kit": {
+			"import": "./lib/sveltekit-parser.js"
+		}
+	},
 	"types": "lib/index.d.ts",
 	"publishConfig": {
 		"access": "public"
@@ -16,11 +24,10 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "3.13.0",
-		"@markuplint/ml-ast": "3.2.0",
-		"@markuplint/parser-utils": "3.13.0",
-		"svelte": "^4.2.7",
-		"tslib": "^2.6.2"
+		"@markuplint/html-parser": "4.0.0-alpha.10",
+		"@markuplint/ml-ast": "4.0.0-alpha.10",
+		"@markuplint/parser-utils": "4.0.0-alpha.10",
+		"svelte": "^4.2.9"
 	},
-	"gitHead": "b37b749d7ac0f9e6cbd022ee7031bc020c6677d3"
+	"gitHead": "b41153ea665aa8f091daf6114a06047f4ccb8350"
 }

package/lib/attr.d.ts

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

package/lib/attr.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attr = void 0;
-const tslib_1 = require("tslib");
-const parser_utils_1 = require("@markuplint/parser-utils");
-const directive_tokenizer_1 = tslib_1.__importDefault(require("./directive-tokenizer"));
-const mustacheTag = {
-    start: '{',
-    end: '}',
-};
-const specificBindDirective = ['bind:group', 'bind:this'];
-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 } = (0, parser_utils_1.sliceFragment)(rawHTML, start, end);
-        token = (0, parser_utils_1.parseAttr)(raw, start, rawHTML, {
-            valueDelimiters: [...parser_utils_1.defaultValueDelimiters, mustacheTag],
-        });
-    }
-    else {
-        const { raw, startLine, startCol, startOffset } = (0, parser_utils_1.sliceFragment)(rawHTML, start, end);
-        const valueToken = isShorthand
-            ? attr.name
-            : attr.expression && 'start' in attr.expression && 'end' in attr.expression
-                ? (0, parser_utils_1.sliceFragment)(rawHTML, attr.expression.start, attr.expression.end).raw
-                : '';
-        token = (0, directive_tokenizer_1.default)(raw, valueToken, startLine, startCol, startOffset);
-    }
-    if (!specificBindDirective.includes(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 === null || baseName === void 0 ? void 0 : 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,
-    };
-}
-exports.attr = attr;

package/lib/directive-tokenizer.d.ts

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

package/lib/directive-tokenizer.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const html_parser_1 = require("@markuplint/html-parser");
-const parser_utils_1 = require("@markuplint/parser-utils");
-// eslint-disable-next-line no-control-regex
-const reNameOnly = /^[^\x00-\x1f\x7f-\x9f {>/=]+/;
-// eslint-disable-next-line no-control-regex
-const reBeforeStructure = /^(\s*)([^\x00-\x1f\x7f-\x9f {>/=]+)(\s*)(=)(\s*){(\s*)$/;
-const reBeforeStructureWithoutName = /^{(\s*)$/;
-const reAfterStructure = /(\s*)}/;
-function directiveTokenizer(raw, rawValue, line, col, startOffset) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    let spacesBeforeAttrString = '';
-    let nameChars = '';
-    let spacesBeforeEqualChars = '';
-    let equalChars = null;
-    let spacesAfterEqualChars = '';
-    let valueChars = '';
-    const [before, after] = raw.split(rawValue);
-    const beforeMatchedMap = before === null || before === void 0 ? void 0 : before.match(reBeforeStructure);
-    const beforeWithoutNameMatchedMap = before === null || before === void 0 ? void 0 : before.match(reBeforeStructureWithoutName);
-    const afterMatchedMap = after === null || after === void 0 ? void 0 : after.match(reAfterStructure);
-    if (beforeMatchedMap && afterMatchedMap) {
-        spacesBeforeAttrString = (_a = beforeMatchedMap[1]) !== null && _a !== void 0 ? _a : '';
-        nameChars = (_b = beforeMatchedMap[2]) !== null && _b !== void 0 ? _b : '';
-        spacesBeforeEqualChars = (_c = beforeMatchedMap[3]) !== null && _c !== void 0 ? _c : '';
-        equalChars = (_d = beforeMatchedMap[4]) !== null && _d !== void 0 ? _d : null;
-        spacesAfterEqualChars = (_e = beforeMatchedMap[5]) !== null && _e !== void 0 ? _e : '';
-        valueChars = ((_f = beforeMatchedMap[6]) !== null && _f !== void 0 ? _f : '') + rawValue + ((_g = afterMatchedMap[1]) !== null && _g !== void 0 ? _g : '');
-    }
-    else if (beforeWithoutNameMatchedMap && afterMatchedMap) {
-        valueChars = ((_h = beforeWithoutNameMatchedMap[1]) !== null && _h !== void 0 ? _h : '') + rawValue + ((_j = afterMatchedMap[1]) !== null && _j !== void 0 ? _j : '');
-    }
-    else if (reNameOnly.test(raw)) {
-        const token = (0, html_parser_1.attrTokenizer)(raw, line, col, startOffset);
-        token.isDirective = true;
-        return token;
-    }
-    else {
-        throw new SyntaxError('Illegal attribute token');
-    }
-    let offset = startOffset;
-    const attrToken = (0, parser_utils_1.tokenizer)(raw, line, col, offset);
-    const spacesBeforeName = (0, parser_utils_1.tokenizer)(spacesBeforeAttrString, line, col, offset);
-    line = spacesBeforeName.endLine;
-    col = spacesBeforeName.endCol;
-    offset = spacesBeforeName.endOffset;
-    const name = (0, parser_utils_1.tokenizer)(nameChars, line, col, offset);
-    line = name.endLine;
-    col = name.endCol;
-    offset = name.endOffset;
-    const spacesBeforeEqual = (0, parser_utils_1.tokenizer)(spacesBeforeEqualChars, line, col, offset);
-    line = spacesBeforeEqual.endLine;
-    col = spacesBeforeEqual.endCol;
-    offset = spacesBeforeEqual.endOffset;
-    const equal = (0, parser_utils_1.tokenizer)(equalChars, line, col, offset);
-    line = equal.endLine;
-    col = equal.endCol;
-    offset = equal.endOffset;
-    const spacesAfterEqual = (0, parser_utils_1.tokenizer)(spacesAfterEqualChars, line, col, offset);
-    line = spacesAfterEqual.endLine;
-    col = spacesAfterEqual.endCol;
-    offset = spacesAfterEqual.endOffset;
-    const startQuote = (0, parser_utils_1.tokenizer)('{', line, col, offset);
-    line = startQuote.endLine;
-    col = startQuote.endCol;
-    offset = startQuote.endOffset;
-    const value = (0, parser_utils_1.tokenizer)(valueChars, line, col, offset);
-    line = value.endLine;
-    col = value.endCol;
-    offset = value.endOffset;
-    const endQuote = (0, parser_utils_1.tokenizer)('}', line, col, offset);
-    line = endQuote.endLine;
-    col = endQuote.endCol;
-    offset = endQuote.endOffset;
-    const result = {
-        type: 'html-attr',
-        uuid: (0, parser_utils_1.uuid)(),
-        raw: attrToken.raw,
-        startOffset: attrToken.startOffset,
-        endOffset: attrToken.endOffset,
-        startLine: attrToken.startLine,
-        endLine: attrToken.endLine,
-        startCol: attrToken.startCol,
-        endCol: attrToken.endCol,
-        spacesBeforeName,
-        name,
-        spacesBeforeEqual,
-        equal,
-        spacesAfterEqual,
-        startQuote,
-        value,
-        endQuote,
-        isDirective: true,
-        isDuplicatable: false,
-        nodeName: name.raw,
-        parentNode: null,
-        nextNode: null,
-        prevNode: null,
-        isFragment: false,
-        isGhost: false,
-    };
-    return result;
-}
-exports.default = directiveTokenizer;

package/lib/nodeize.d.ts

@@ -1,9 +0,0 @@
-import type { SvelteNode } from './svelte-parser';
-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;