@markuplint/astro-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/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,51 @@
+import type { Node } from './astro-parser.js';
+import type { MLASTParentNode, MLASTNodeTreeItem } from '@markuplint/ml-ast';
+import type { ChildToken, Token } from '@markuplint/parser-utils';
+import { Parser } from '@markuplint/parser-utils';
+type State = {
+    scopeNS: string;
+};
+declare class AstroParser extends Parser<Node, State> {
+    #private;
+    constructor();
+    tokenize(): {
+        ast: Node[];
+        isFragment: boolean;
+    };
+    nodeize(originNode: Node, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    afterFlattenNodes(nodeList: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    visitElement(token: ChildToken, childNodes: readonly Node[]): readonly MLASTNodeTreeItem[];
+    visitChildren(children: readonly Node[], parentNode: MLASTParentNode | null): never[];
+    visitAttr(token: Token): (import("@markuplint/ml-ast").MLASTSpreadAttr & {
+        __rightText?: string | undefined;
+    }) | {
+        isDynamicValue: true | undefined;
+        isDirective: true | undefined;
+        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;
+        isDuplicatable: boolean;
+        uuid: string;
+        raw: string;
+        startOffset: number;
+        endOffset: number;
+        startLine: number;
+        endLine: number;
+        startCol: number;
+        endCol: number;
+        __rightText?: string | undefined;
+    };
+}
+export declare const parser: AstroParser;
+export {};

package/lib/parser.js

@@ -0,0 +1,214 @@
+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 _AstroParser_instances, _AstroParser_updateScopeNS;
+import { AttrState, Parser, ParserError } from '@markuplint/parser-utils';
+import { astroParse } from './astro-parser.js';
+class AstroParser extends Parser {
+    constructor() {
+        super({
+            endTagType: 'xml',
+            selfCloseType: 'html+xml',
+        }, {
+            scopeNS: 'http://www.w3.org/1999/xhtml',
+        });
+        _AstroParser_instances.add(this);
+    }
+    tokenize() {
+        return {
+            ast: astroParse(this.rawCode).children,
+            isFragment: true,
+        };
+    }
+    nodeize(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    originNode, parentNode, depth) {
+        if (!originNode.position) {
+            throw new TypeError("Node doesn't have position");
+        }
+        const startOffset = originNode.position.start.offset;
+        const endOffset = originNode.position.end?.offset;
+        const token = this.sliceFragment(startOffset, endOffset);
+        __classPrivateFieldGet(this, _AstroParser_instances, "m", _AstroParser_updateScopeNS).call(this, originNode, parentNode);
+        switch (originNode.type) {
+            case 'doctype': {
+                return this.visitDoctype({
+                    ...token,
+                    depth,
+                    parentNode,
+                    name: originNode.value,
+                    publicId: '',
+                    systemId: '',
+                });
+            }
+            case 'text': {
+                if (parentNode?.type === 'psblock') {
+                    return [];
+                }
+                return this.visitText({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case 'component':
+            case 'custom-element':
+            case 'fragment':
+            case 'element': {
+                const tagToken = token.raw ? token : this.sliceFragment(0);
+                return this.visitElement({
+                    ...tagToken,
+                    depth,
+                    parentNode,
+                }, originNode.children);
+            }
+            case 'expression': {
+                const firstChild = originNode.children.at(0);
+                const lastChild = originNode.children.at(-1);
+                let startExpressionRaw = token.raw;
+                let startExpressionStartLine = token.startLine;
+                let startExpressionStartCol = token.startCol;
+                const nodes = [];
+                if (firstChild && lastChild && firstChild !== lastChild) {
+                    const startExpressionEndOffset = firstChild.position?.end?.offset ?? endOffset ?? startOffset;
+                    const startExpressionLocation = this.sliceFragment(startOffset, startExpressionEndOffset);
+                    startExpressionRaw = startExpressionLocation.raw;
+                    startExpressionStartLine = startExpressionLocation.startLine;
+                    startExpressionStartCol = startExpressionLocation.startCol;
+                    const closeExpressionLocation = this.sliceFragment(lastChild.position?.start.offset ?? startOffset, endOffset);
+                    nodes.push(...this.visitPsBlock({
+                        ...closeExpressionLocation,
+                        depth,
+                        parentNode,
+                        nodeName: 'MustacheTag',
+                    }));
+                }
+                nodes.push(...this.visitPsBlock({
+                    raw: startExpressionRaw,
+                    startOffset,
+                    startLine: startExpressionStartLine,
+                    startCol: startExpressionStartCol,
+                    depth,
+                    parentNode,
+                    nodeName: 'MustacheTag',
+                }, originNode.children));
+                return nodes;
+            }
+            default: {
+                return [];
+            }
+        }
+    }
+    afterFlattenNodes(nodeList) {
+        return super.afterFlattenNodes(nodeList, {
+            exposeInvalidNode: false,
+        });
+    }
+    visitElement(token, 
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    childNodes) {
+        const parsedNodes = this.parseCodeFragment(token);
+        const startTagNode = parsedNodes.at(0);
+        if (!startTagNode || startTagNode.type !== 'starttag') {
+            throw new ParserError('Not found start tag', startTagNode ?? token);
+        }
+        return super.visitElement(startTagNode, childNodes, {
+            overwriteProps: {
+                namespace: this.state.scopeNS,
+            },
+            createEndTagToken: () => {
+                if (startTagNode.selfClosingSolidus?.raw === '/') {
+                    return null;
+                }
+                const endTagNode = parsedNodes.at(-1);
+                if (endTagNode?.type !== 'endtag') {
+                    return null;
+                }
+                return endTagNode ?? null;
+            },
+        });
+    }
+    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;
+        }
+        const isDynamicValue = attr.startQuote.raw === '{' || undefined;
+        let potentialName;
+        let isDirective;
+        if (isDynamicValue && attr.name.raw === '') {
+            potentialName = attr.value.raw;
+        }
+        /**
+         * Detects Template Directive
+         *
+         * @see https://docs.astro.build/en/reference/directives-reference/
+         */
+        const [, directive] = attr.name.raw.match(/^([^:]+):([^:]+)$/) ?? [];
+        if (directive) {
+            const lowerCaseDirectiveName = directive.toLowerCase();
+            switch (lowerCaseDirectiveName) {
+                case 'class': {
+                    potentialName = lowerCaseDirectiveName;
+                    break;
+                }
+                default: {
+                    isDirective = true;
+                }
+            }
+        }
+        return {
+            ...attr,
+            isDynamicValue,
+            isDirective,
+            potentialName,
+        };
+    }
+}
+_AstroParser_instances = new WeakSet(), _AstroParser_updateScopeNS = function _AstroParser_updateScopeNS(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+originNode, parentNode) {
+    const parentNS = this.state.scopeNS;
+    if (parentNS === 'http://www.w3.org/1999/xhtml' &&
+        originNode.type === 'element' &&
+        originNode.name?.toLowerCase() === 'svg') {
+        this.state.scopeNS = 'http://www.w3.org/2000/svg';
+    }
+    else if (parentNS === 'http://www.w3.org/2000/svg' && parentNode && parentNode.nodeName === 'foreignObject') {
+        this.state.scopeNS = 'http://www.w3.org/1999/xhtml';
+    }
+};
+export const parser = new AstroParser();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/astro-parser",
-	"version": "4.0.0-dev.20+6b35da16",
+	"version": "4.0.0-dev.23+d6f2aa9bc",
 	"description": "astro parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -21,11 +21,12 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@astrojs/parser": "0.22.2",
-		"@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",
-		"astro-eslint-parser": "^0.16.0"
+		"@markuplint/ml-ast": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/parser-utils": "4.0.0-dev.23+d6f2aa9bc",
+		"astro-eslint-parser": "^0.16.2"
 	},
-	"gitHead": "6b35da161d94f784953d0adecc2d28502052d92a"
+	"devDependencies": {
+		"@astrojs/compiler": "^2.5.0"
+	},
+	"gitHead": "d6f2aa9bc287768466f23b5340e4e0eecfa30d59"
 }

package/lib/attr-tokenizer.d.ts

@@ -1,3 +0,0 @@
-import type { AttributeNode } from './astro-parser.js';
-import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
-export declare function attrTokenizer(attr: AttributeNode, nextAttr: AttributeNode | null, rawHtml: string, startTag: string, startTagEndOffset: number): MLASTHTMLAttr;

package/lib/attr-tokenizer.js

@@ -1,57 +0,0 @@
-import { defaultValueDelimiters, getSpaceBefore, parseAttr, sliceFragment } from '@markuplint/parser-utils';
-const mustacheTag = {
-    start: '{',
-    end: '}',
-};
-export function attrTokenizer(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-attr, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nextAttr, rawHtml, startTag, startTagEndOffset) {
-    if (!attr.position) {
-        throw new TypeError("Attr doesn't have position");
-    }
-    if (attr.position.end) {
-        throw new TypeError('Node may is an attribute because it has end position');
-    }
-    let nextAttrBeforeSpaceOffset;
-    if (nextAttr) {
-        if (!nextAttr.position) {
-            throw new TypeError("NextAttr doesn't have position");
-        }
-        if (nextAttr.position.end) {
-            throw new TypeError('NextAttr Node may is an attribute because it has end position');
-        }
-        nextAttrBeforeSpaceOffset = getSpaceBefore(nextAttr.position.start.offset, rawHtml).startOffset;
-    }
-    else {
-        const close = /(\/?>)$/.exec(startTag)?.[1] ?? '';
-        nextAttrBeforeSpaceOffset = startTagEndOffset - close.length;
-    }
-    const { raw, startOffset } = sliceFragment(rawHtml, attr.position.start.offset, nextAttrBeforeSpaceOffset);
-    const result = parseAttr(raw, startOffset, rawHtml, {
-        valueDelimiters: [...defaultValueDelimiters, mustacheTag],
-    });
-    if (result.startQuote.raw === mustacheTag.start) {
-        result.isDynamicValue = true;
-    }
-    /**
-     * Detects Template Directive
-     *
-     * @see https://docs.astro.build/en/reference/directives-reference/
-     */
-    const [, directive] = result.name.raw.match(/^([^:]+):([^:]+)$/) ?? [];
-    if (directive) {
-        const lowerCaseDirectiveName = directive.toLowerCase();
-        switch (lowerCaseDirectiveName) {
-            case 'class': {
-                result.potentialName = lowerCaseDirectiveName;
-                break;
-            }
-            default: {
-                result.isDirective = true;
-            }
-        }
-    }
-    return result;
-}

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,337 +0,0 @@
-import { parse as htmlParse } from '@markuplint/html-parser';
-import { flattenNodes, detectElementType, getEndCol, getEndLine, sliceFragment, uuid, tagParser, } from '@markuplint/parser-utils';
-import { astroParse } from './astro-parser.js';
-import { attrTokenizer } from './attr-tokenizer.js';
-export const parse = (rawCode, options = {}) => {
-    const ast = astroParse(rawCode);
-    const htmlRawNodeList = traverse(ast, null, 'http://www.w3.org/1999/xhtml', rawCode, 0, options);
-    const firstOffset = htmlRawNodeList[0]?.startOffset ?? 0;
-    if (firstOffset > 0) {
-        const head = rawCode.slice(0, firstOffset);
-        const ast = htmlParse(head, {
-            ...options,
-            ignoreFrontMatter: true,
-        });
-        const headNodes = ast.nodeList.filter(node => {
-            return !node.isGhost;
-        });
-        htmlRawNodeList.unshift(...headNodes);
-    }
-    const nodeList = flattenNodes(htmlRawNodeList, rawCode);
-    return {
-        nodeList,
-        isFragment: true,
-    };
-};
-function traverse(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-rootNode, parentNode = null, scopeNS, rawHtml, offset, options, inExpression) {
-    const nodeList = [];
-    if (!('children' in rootNode)) {
-        return nodeList;
-    }
-    if (rootNode.children.length === 0) {
-        return nodeList;
-    }
-    let prevNode = null;
-    for (const astNode of rootNode.children) {
-        const node = nodeize(astNode, prevNode, parentNode, scopeNS, rawHtml, offset, options, inExpression);
-        if (!node) {
-            continue;
-        }
-        const nodes = Array.isArray(node) ? node : [node];
-        for (const node of nodes) {
-            if (prevNode) {
-                if (node.type !== 'endtag') {
-                    prevNode.nextNode = node;
-                }
-                node.prevNode = prevNode;
-            }
-            prevNode = node;
-            nodeList.push(node);
-        }
-    }
-    return nodeList;
-}
-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, scopeNS, rawHtml, offset = 0, options, inExpression) {
-    if (!originNode.position) {
-        throw new TypeError("Node doesn't have position");
-    }
-    const nextNode = null;
-    const startOffset = originNode.position.start.offset + offset;
-    const endOffset = (originNode.position.end?.offset ?? originNode.position.start.offset) + offset;
-    const { startLine, endLine, startCol, endCol, raw } = sliceFragment(rawHtml, startOffset, endOffset);
-    if (scopeNS === 'http://www.w3.org/1999/xhtml' &&
-        originNode.type === 'element' &&
-        originNode.name?.toLowerCase() === 'svg') {
-        scopeNS = 'http://www.w3.org/2000/svg';
-    }
-    else if (scopeNS === 'http://www.w3.org/2000/svg' && parentNode && parentNode.nodeName === 'foreignObject') {
-        scopeNS = 'http://www.w3.org/1999/xhtml';
-    }
-    switch (originNode.type) {
-        case 'text': {
-            if (inExpression) {
-                return null;
-            }
-            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 'expression': {
-            let _endOffset = endOffset;
-            let _startLine = startLine;
-            let _endLine = endLine;
-            let _startCol = startCol;
-            let _endCol = endCol;
-            let _raw = raw;
-            let closeExpression = null;
-            const firstChild = originNode.children[0];
-            const lastChild = originNode.children.at(-1);
-            if (firstChild && lastChild && firstChild !== lastChild) {
-                _endOffset = firstChild.position?.end?.offset ?? endOffset;
-                const startLoc = sliceFragment(rawHtml, startOffset, _endOffset);
-                _startLine = startLoc.startLine;
-                _endLine = startLoc.endLine;
-                _startCol = startLoc.startCol;
-                _endCol = startLoc.endCol;
-                _raw = startLoc.raw;
-                const closeStartOffset = lastChild.position?.start.offset ?? startOffset;
-                const closeLoc = sliceFragment(rawHtml, closeStartOffset, endOffset);
-                closeExpression = {
-                    uuid: uuid(),
-                    raw: closeLoc.raw,
-                    startOffset: closeStartOffset,
-                    endOffset: closeLoc.endOffset,
-                    startLine: closeLoc.startLine,
-                    endLine: closeLoc.endLine,
-                    startCol: closeLoc.startCol,
-                    endCol: closeLoc.endCol,
-                    nodeName: 'MustacheTag',
-                    type: 'psblock',
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-            }
-            const node = {
-                uuid: uuid(),
-                raw: _raw,
-                startOffset,
-                endOffset: _endOffset,
-                startLine: _startLine,
-                endLine: _endLine,
-                startCol: _startCol,
-                endCol: _endCol,
-                nodeName: 'MustacheTag',
-                type: 'psblock',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-            if (originNode.children.length > 0) {
-                node.childNodes = traverse(originNode, parentNode, scopeNS, rawHtml, offset, options, true);
-            }
-            if (closeExpression) {
-                return [node, closeExpression];
-            }
-            return node;
-        }
-        case 'comment': {
-            return {
-                uuid: uuid(),
-                raw,
-                startOffset,
-                endOffset,
-                startLine,
-                endLine,
-                startCol,
-                endCol,
-                nodeName: '#comment',
-                type: 'comment',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-        }
-        case 'component':
-        case 'custom-element':
-        case 'fragment':
-        case 'element': {
-            if (originNode.name?.toLowerCase() === '!doctype') {
-                return {
-                    uuid: uuid(),
-                    raw,
-                    name: originNode.name,
-                    publicId: '',
-                    systemId: '',
-                    startOffset,
-                    endOffset,
-                    startLine,
-                    endLine,
-                    startCol,
-                    endCol,
-                    nodeName: '#doctype',
-                    type: 'doctype',
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    isFragment: false,
-                    isGhost: false,
-                };
-            }
-            return parseElement(originNode, scopeNS, rawHtml, startLine, startCol, startOffset, parentNode, prevNode, nextNode, offset, options);
-        }
-        default: {
-            return null;
-        }
-    }
-}
-function parseElement(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-originNode, scopeNS, rawHtml, startLine, startCol, 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, offset, options) {
-    if (!originNode.position) {
-        throw new TypeError("Node doesn't have position");
-    }
-    let startTagRaw;
-    let childrenStart;
-    let childrenEnd;
-    if (originNode.children[0]) {
-        childrenStart = (originNode.children[0].position?.start?.offset ?? 0) + offset;
-        childrenEnd = (originNode.children.at(-1)?.position?.end?.offset ?? 0) + offset;
-        const startTagStartOffset = originNode.position.start.offset + offset;
-        const startTagEndOffset = childrenStart;
-        startTagRaw = rawHtml.slice(startTagStartOffset, startTagEndOffset);
-    }
-    else {
-        childrenStart = offset + (originNode.position.end?.offset ?? nextNode?.endOffset ?? rawHtml.length - offset);
-        childrenEnd = childrenStart;
-        const startTagStartOffset = originNode.position.start.offset + offset;
-        let startTagEndOffset = childrenStart;
-        startTagRaw = rawHtml.slice(startTagStartOffset, startTagEndOffset);
-        const expectedCloseTag = `</${originNode.name}>`;
-        if (startTagRaw.includes(expectedCloseTag)) {
-            childrenStart -= expectedCloseTag.length;
-            childrenEnd = childrenStart;
-            startTagRaw = startTagRaw.replace(expectedCloseTag, '');
-        }
-        else {
-            let startTagRawMasked = startTagRaw;
-            for (const attr of originNode.attributes) {
-                startTagRawMasked = startTagRawMasked.replace(attr.value, ' '.repeat(attr.value.length));
-            }
-            const closeChars = '>';
-            const closeOffset = startTagRawMasked.indexOf(closeChars) + closeChars.length;
-            startTagEndOffset = startTagStartOffset + closeOffset;
-            startTagRaw = rawHtml.slice(startTagStartOffset, startTagEndOffset);
-        }
-        // console.log({
-        // 	originNode,
-        // 	attrs: originNode.attributes,
-        // 	startTagRaw,
-        // 	startTagStartOffset,
-        // 	startTagEndOffset,
-        // 	expectedCloseTag,
-        // 	childrenStart,
-        // 	childrenEnd,
-        // });
-    }
-    const tagTokens = tagParser(startTagRaw, startLine, startCol, startOffset);
-    const tagName = tagTokens.tagName;
-    let endTag = null;
-    if (childrenEnd < (originNode.position.end?.offset ?? 0) + offset) {
-        const endTagLoc = sliceFragment(rawHtml, childrenEnd, (originNode.position.end?.offset ?? 0) + offset);
-        const endTagTokens = tagParser(endTagLoc.raw, endTagLoc.startLine, endTagLoc.startCol, endTagLoc.startOffset);
-        const endTagName = endTagTokens.tagName;
-        endTag = {
-            uuid: uuid(),
-            raw: endTagLoc.raw,
-            startOffset: endTagLoc.startOffset,
-            endOffset: endTagLoc.endOffset,
-            startLine: endTagLoc.startLine,
-            endLine: endTagLoc.endLine,
-            startCol: endTagLoc.startCol,
-            endCol: endTagLoc.endCol,
-            nodeName: endTagName,
-            type: 'endtag',
-            namespace: scopeNS,
-            attributes: endTagTokens.attrs,
-            parentNode,
-            prevNode,
-            nextNode,
-            pearNode: null,
-            isFragment: false,
-            isGhost: false,
-            tagOpenChar: '</',
-            tagCloseChar: '>',
-        };
-    }
-    const startTag = {
-        uuid: uuid(),
-        raw: startTagRaw,
-        startOffset,
-        endOffset: startOffset + startTagRaw.length,
-        startLine,
-        endLine: getEndLine(startTagRaw, startLine),
-        startCol,
-        endCol: getEndCol(startTagRaw, startCol),
-        nodeName: tagName,
-        type: 'starttag',
-        namespace: scopeNS,
-        elementType: detectElementType(tagName, options?.authoredElementName, /^[A-Z]|\./),
-        attributes: originNode.attributes.map((
-        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-        attr, i) => attrTokenizer(attr, originNode.attributes[i + 1] ?? null, rawHtml, startTagRaw, startOffset + startTagRaw.length)),
-        hasSpreadAttr: false,
-        parentNode,
-        prevNode,
-        nextNode,
-        pearNode: endTag,
-        selfClosingSolidus: tagTokens.selfClosingSolidus,
-        endSpace: tagTokens.afterAttrSpaces,
-        isFragment: false,
-        isGhost: false,
-        tagOpenChar: '<',
-        tagCloseChar: '>',
-    };
-    if (endTag) {
-        endTag.pearNode = startTag;
-    }
-    startTag.childNodes = ['style', 'script'].includes(tagName)
-        ? undefined
-        : traverse(originNode, startTag, scopeNS, rawHtml, offset, options);
-    return startTag;
-}