#2328

Build # #2328

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/787ace81693d1dc7cddba8551acac6ff83ee6637">787ace816<a href="https://github.com/markuplint/markuplint/commit/787ace81693d1dc7cddba8551acac6ff83ee6637">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/92fb9a392e336744e4a759c7b63d45b3c0f83db2">92fb9a392</a>">92fb9a392</a><a href="https://github.com/markuplint/markuplint/commit/787ace81693d1dc7cddba8551acac6ff83ee6637"> into 7a533de2a">7a533de2a</a>

Run Details

3077 of 4362 branches covered (70.54%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

5864 of 7649 relevant lines covered (76.66%)

94.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.87

/packages/@markuplint/astro-parser/src/parse.ts

import type { ASTAttribute, ASTNode, ASTStyleNode } from './astro-parser';
import type {
        MLASTElement,
        MLASTElementCloseTag,
        MLASTNode,
        MLASTParentNode,
        MLASTPreprocessorSpecificBlock,
        MLASTTag,
        MLASTText,
        NamespaceURI,
        Parse,
} from '@markuplint/ml-ast';

import { flattenNodes, parseRawTag } from '@markuplint/html-parser';
import { getEndCol, getEndLine, isPotentialCustomElementName, sliceFragment, uuid } from '@markuplint/parser-utils';

import { AstroCompileError, astroParse } from './astro-parser';
import { attrTokenizer } from './attr-tokenizer';

export const parse: Parse = rawCode => {
        const ast = astroParse(rawCode);

        if (ast instanceof AstroCompileError) {
                return {
                        nodeList: [],
                        isFragment: true,
                        parseError: ast.stack || ast.message,
                };
        }

        if (!ast.html) {
                return {
                        nodeList: [],
                        isFragment: false,
                };
        }

        const htmlRawNodeList = traverse(ast.html, null, 'http://www.w3.org/1999/xhtml', rawCode);
        if (ast.style) {
                const styleNodes = parseStyle(ast.style, 'http://www.w3.org/1999/xhtml', rawCode, 0);
                htmlRawNodeList.push(...styleNodes);
        }

        const nodeList: MLASTNode[] = flattenNodes(htmlRawNodeList, rawCode);

        // Remove `</template>`
        const templateEndTagIndex = nodeList.findIndex(node => /\s*<\/\s*template\s*>\s*/i.test(node.raw));
        if (templateEndTagIndex !== -1) {
                const templateEndTag = nodeList[templateEndTagIndex];
                for (const node of nodeList) {
                        if (node.nextNode && node.nextNode.uuid === templateEndTag.uuid) {
                                node.nextNode = null;
                        }
                }
                nodeList.splice(templateEndTagIndex, 1);
        }

        return {
                nodeList,
                isFragment: true,
        };
};

function traverse(
        rootNode: ASTNode,
        parentNode: MLASTParentNode | null = null,
        scopeNS: NamespaceURI,
        rawHtml: string,
        offset?: number,
): MLASTNode[] {
        const nodeList: MLASTNode[] = [];

        if (!rootNode.children) {
                return nodeList;
        }

        let prevNode: MLASTNode | null = null;
        for (const astNode of rootNode.children) {
                const node = nodeize(astNode, prevNode, parentNode, scopeNS, rawHtml, offset);
                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(
        originNode: ASTNode,
        prevNode: MLASTNode | null,
        parentNode: MLASTParentNode | null,
        scopeNS: NamespaceURI,
        rawHtml: string,
        offset = 0,
): MLASTNode | MLASTNode[] | null {
        const nextNode = null;
        const startOffset = originNode.start + offset;
        const endOffset = originNode.end + 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': {
                        const node: MLASTText = {
                                uuid: uuid(),
                                raw,
                                startOffset,
                                endOffset,
                                startLine,
                                endLine,
                                startCol,
                                endCol,
                                nodeName: '#text',
                                type: 'text',
                                parentNode,
                                prevNode,
                                nextNode,
                                isFragment: false,
                                isGhost: false,
                        };
                        return node;
                }
                case 'MustacheTag': {
                        if (!originNode.expression.children || originNode.expression.children.length === 0) {
                                return {
                                        uuid: uuid(),
                                        raw,
                                        startOffset,
                                        endOffset,
                                        startLine,
                                        endLine,
                                        startCol,
                                        endCol,
                                        nodeName: originNode.type,
                                        type: 'psblock',
                                        parentNode,
                                        prevNode,
                                        nextNode,
                                        isFragment: false,
                                        isGhost: false,
                                };
                        }
                        // console.log(originNode, originNode.expression);
                        let stub = raw;
                        const blocks: MLASTPreprocessorSpecificBlock[] = [];
                        const chunks = (originNode.expression.codeChunks as string[]).map((chunk, i) => {
                                if (i === 0) {
                                        return `{${chunk}`;
                                } else if (i === originNode.expression.codeChunks.length - 1) {
                                        return `${chunk}}`;
                                }
                                return chunk;
                        });
                        for (const chunk of chunks) {
                                const i = stub.indexOf(chunk);
                                if (i === -1) {
                                        throw new Error(`Invalid chunk: "${chunk}" from ${raw}`);
                                }
                                const prevBlock = blocks[blocks.length - 1];
                                const prevBlockEndOffset = prevBlock ? prevBlock.endOffset : originNode.start;
                                const loc = sliceFragment(rawHtml, prevBlockEndOffset + i, prevBlockEndOffset + i + chunk.length);
                                blocks.push({
                                        uuid: uuid(),
                                        raw: chunk,
                                        startOffset: loc.startOffset,
                                        endOffset: loc.endOffset,
                                        startLine: loc.startLine,
                                        endLine: loc.endLine,
                                        startCol: loc.startCol,
                                        endCol: loc.endCol,
                                        nodeName: originNode.type,
                                        type: 'psblock',
                                        parentNode,
                                        prevNode,
                                        nextNode,
                                        isFragment: false,
                                        isGhost: false,
                                });
                                stub = stub.slice(i + chunk.length);
                        }
                        if (blocks[0]) {
                                const childNodes = traverse(originNode.expression, blocks[0], scopeNS, rawHtml, blocks[0].endOffset);
                                blocks[0].childNodes = childNodes;
                        }
                        return blocks;
                }
                case 'Comment': {
                        return {
                                uuid: uuid(),
                                raw,
                                startOffset,
                                endOffset,
                                startLine,
                                endLine,
                                startCol,
                                endCol,
                                nodeName: '#comment',
                                type: 'comment',
                                parentNode,
                                prevNode,
                                nextNode,
                                isFragment: false,
                                isGhost: false,
                        };
                }
                case 'InlineComponent':
                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.name,
                                originNode,
                                scopeNS,
                                rawHtml,
                                startLine,
                                startCol,
                                startOffset,
                                parentNode,
                                prevNode,
                                nextNode,
                                offset,
                        );
                }
                case 'Fragment': {
                        return originNode.children ? traverse(originNode, parentNode, scopeNS, rawHtml, offset) : null;
                }
                default: {
                        return null;
                }
        }
}

function parseElement(
        nodeName: string,
        originNode: ASTNode | ASTStyleNode,
        scopeNS: NamespaceURI,
        rawHtml: string,
        startLine: number,
        startCol: number,
        startOffset: number,
        parentNode: MLASTParentNode | null,
        prevNode: MLASTNode | null,
        nextNode: MLASTNode | null,
        offset: number,
) {
        const { raw } = sliceFragment(rawHtml, originNode.start + offset, originNode.end + offset);
        let childrenStart: number;
        let childrenEnd: number;
        if (originNode.children && originNode.children[0]) {
                childrenStart = originNode.children[0].start + offset;
                childrenEnd = originNode.children[originNode.children.length - 1].end + offset;
        } else if (originNode.content) {
                childrenStart = originNode.content.start + offset;
                childrenEnd = originNode.content.end + offset;
        } else if (/\/>$/.test(raw)) {
                childrenStart = originNode.end + offset;
                childrenEnd = originNode.end + offset;
        } else {
                const expectedEndTag = `</${nodeName}>`;
                const endTagStart = originNode.end + offset - expectedEndTag.length;
                childrenStart = endTagStart;
                childrenEnd = endTagStart;
        }
        const startTagStartOffset = originNode.start + offset;
        const startTagEndOffset = childrenStart;
        const startTagRaw = rawHtml.slice(startTagStartOffset, startTagEndOffset);
        const tagTokens = parseRawTag(startTagRaw, startLine, startCol, startOffset);
        const tagName = tagTokens.tagName;
        let endTag: MLASTElementCloseTag | null = null;
        if (childrenEnd < originNode.end + offset) {
                const endTagLoc = sliceFragment(rawHtml, childrenEnd, originNode.end + offset);
                const endTagTokens = parseRawTag(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: '>',
                        isCustomElement: isCustomComponentName(endTagName),
                };
        }

        const startTag: MLASTTag = {
                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,
                attributes: originNode.attributes.map((attr: ASTAttribute) => attrTokenizer(attr, rawHtml, offset)),
                hasSpreadAttr: false,
                parentNode,
                prevNode,
                nextNode,
                pearNode: endTag,
                selfClosingSolidus: tagTokens.selfClosingSolidus,
                endSpace: tagTokens.endSpace,
                isFragment: false,
                isGhost: false,
                tagOpenChar: '<',
                tagCloseChar: '>',
                isCustomElement: isCustomComponentName(tagName),
        };
        if (endTag) {
                endTag.pearNode = startTag;
        }
        startTag.childNodes = traverse(originNode, startTag, scopeNS, rawHtml, offset);
        return startTag;
}

function parseStyle(nodes: ASTStyleNode[], scopeNS: NamespaceURI, rawHtml: string, offset: number) {
        const result: MLASTElement[] = [];
        for (const node of nodes) {
                const { startLine, startCol, startOffset } = sliceFragment(rawHtml, node.start, node.end);
                const styleEl = parseElement(
                        'style',
                        node,
                        scopeNS,
                        rawHtml,
                        startLine,
                        startCol,
                        startOffset,
                        null,
                        null,
                        null,
                        offset,
                );
                result.push(styleEl);
        }
        return result;
}

function isCustomComponentName(name: string) {
        return isPotentialCustomElementName(name) || /[A-Z]|\./.test(name);
}

1	import type { ASTAttribute, ASTNode, ASTStyleNode } from './astro-parser';
2	import type {
3	MLASTElement,
4	MLASTElementCloseTag,
5	MLASTNode,
6	MLASTParentNode,
7	MLASTPreprocessorSpecificBlock,
8	MLASTTag,
9	MLASTText,
10	NamespaceURI,
11	Parse,
12	} from '@markuplint/ml-ast';
13
14	import { flattenNodes, parseRawTag } from '@markuplint/html-parser';	1✔
15	import { getEndCol, getEndLine, isPotentialCustomElementName, sliceFragment, uuid } from '@markuplint/parser-utils';	1✔
16
17	import { AstroCompileError, astroParse } from './astro-parser';	1✔
18	import { attrTokenizer } from './attr-tokenizer';	1✔
19
20	export const parse: Parse = rawCode => {	1✔
21	const ast = astroParse(rawCode);	7✔
22
23	if (ast instanceof AstroCompileError) {	7!
24	return {	×
25	nodeList: [],
26	isFragment: true,
27	parseError: ast.stack \|\| ast.message,	×
28	};
29	}
30
31	if (!ast.html) {	7!
32	return {	×
33	nodeList: [],
34	isFragment: false,
35	};
36	}
37
38	const htmlRawNodeList = traverse(ast.html, null, 'http://www.w3.org/1999/xhtml', rawCode);	7✔
39	if (ast.style) {	7✔
40	const styleNodes = parseStyle(ast.style, 'http://www.w3.org/1999/xhtml', rawCode, 0);	7✔
41	htmlRawNodeList.push(...styleNodes);	7✔
42	}
43
44	const nodeList: MLASTNode[] = flattenNodes(htmlRawNodeList, rawCode);	7✔
45
46	// Remove `</template>`
47	const templateEndTagIndex = nodeList.findIndex(node => /\s<\/\stemplate\s>\s/i.test(node.raw));	56✔
48	if (templateEndTagIndex !== -1) {	7!
49	const templateEndTag = nodeList[templateEndTagIndex];	×
50	for (const node of nodeList) {	×
51	if (node.nextNode && node.nextNode.uuid === templateEndTag.uuid) {	×
52	node.nextNode = null;	×
53	}
54	}
55	nodeList.splice(templateEndTagIndex, 1);	×
56	}
57
58	return {	7✔
59	nodeList,
60	isFragment: true,
61	};
62	};
63
64	function traverse(
65	rootNode: ASTNode,
66	parentNode: MLASTParentNode \| null = null,	×
67	scopeNS: NamespaceURI,
68	rawHtml: string,
69	offset?: number,
70	): MLASTNode[] {
71	const nodeList: MLASTNode[] = [];	26✔
72
73	if (!rootNode.children) {	26✔
74	return nodeList;	1✔
75	}
76
77	let prevNode: MLASTNode \| null = null;	25✔
78	for (const astNode of rootNode.children) {	25✔
79	const node = nodeize(astNode, prevNode, parentNode, scopeNS, rawHtml, offset);	38✔
80	if (!node) {	38!
81	continue;	×
82	}
83	const nodes = Array.isArray(node) ? node : [node];	38✔
84	for (const node of nodes) {	38✔
85	if (prevNode) {	39✔
86	if (node.type !== 'endtag') {	19✔
87	prevNode.nextNode = node;	19✔
88	}
89	node.prevNode = prevNode;	19✔
90	}
91	prevNode = node;	39✔
92	nodeList.push(node);	39✔
93	}
94	}
95	return nodeList;	25✔
96	}
97
98	function nodeize(
99	originNode: ASTNode,
100	prevNode: MLASTNode \| null,
101	parentNode: MLASTParentNode \| null,
102	scopeNS: NamespaceURI,
103	rawHtml: string,
104	offset = 0,	15✔
105	): MLASTNode \| MLASTNode[] \| null {
106	const nextNode = null;	38✔
107	const startOffset = originNode.start + offset;	38✔
108	const endOffset = originNode.end + offset;	38✔
109	const { startLine, endLine, startCol, endCol, raw } = sliceFragment(rawHtml, startOffset, endOffset);	38✔
110
111	if (	38✔
112	scopeNS === 'http://www.w3.org/1999/xhtml' &&	85✔
113	originNode.type === 'Element' &&
114	originNode.name?.toLowerCase() === 'svg'	36!
115	) {
116	scopeNS = 'http://www.w3.org/2000/svg';	2✔
117	} else if (scopeNS === 'http://www.w3.org/2000/svg' && parentNode && parentNode.nodeName === 'foreignObject') {	36✔
118	scopeNS = 'http://www.w3.org/1999/xhtml';	1✔
119	}
120
121	switch (originNode.type) {	38!
122	case 'Text': {
123	const node: MLASTText = {	16✔
124	uuid: uuid(),
125	raw,
126	startOffset,
127	endOffset,
128	startLine,
129	endLine,
130	startCol,
131	endCol,
132	nodeName: '#text',
133	type: 'text',
134	parentNode,
135	prevNode,
136	nextNode,
137	isFragment: false,
138	isGhost: false,
139	};
140	return node;	16✔
141	}
142	case 'MustacheTag': {
143	if (!originNode.expression.children \|\| originNode.expression.children.length === 0) {	3✔
144	return {	2✔
145	uuid: uuid(),
146	raw,
147	startOffset,
148	endOffset,
149	startLine,
150	endLine,
151	startCol,
152	endCol,
153	nodeName: originNode.type,
154	type: 'psblock',
155	parentNode,
156	prevNode,
157	nextNode,
158	isFragment: false,
159	isGhost: false,
160	};
161	}
162	// console.log(originNode, originNode.expression);
163	let stub = raw;	1✔
164	const blocks: MLASTPreprocessorSpecificBlock[] = [];	1✔
165	const chunks = (originNode.expression.codeChunks as string[]).map((chunk, i) => {	1✔
166	if (i === 0) {	2✔
167	return `{${chunk}`;	1✔
168	} else if (i === originNode.expression.codeChunks.length - 1) {	1✔
169	return `${chunk}}`;	1✔
170	}
171	return chunk;	×
172	});
173	for (const chunk of chunks) {	1✔
174	const i = stub.indexOf(chunk);	2✔
175	if (i === -1) {	2!
176	throw new Error(`Invalid chunk: "${chunk}" from ${raw}`);	×
177	}
178	const prevBlock = blocks[blocks.length - 1];	2✔
179	const prevBlockEndOffset = prevBlock ? prevBlock.endOffset : originNode.start;	2✔
180	const loc = sliceFragment(rawHtml, prevBlockEndOffset + i, prevBlockEndOffset + i + chunk.length);	2✔
181	blocks.push({	2✔
182	uuid: uuid(),
183	raw: chunk,
184	startOffset: loc.startOffset,
185	endOffset: loc.endOffset,
186	startLine: loc.startLine,
187	endLine: loc.endLine,
188	startCol: loc.startCol,
189	endCol: loc.endCol,
190	nodeName: originNode.type,
191	type: 'psblock',
192	parentNode,
193	prevNode,
194	nextNode,
195	isFragment: false,
196	isGhost: false,
197	});
198	stub = stub.slice(i + chunk.length);	2✔
199	}
200	if (blocks[0]) {	1✔
201	const childNodes = traverse(originNode.expression, blocks[0], scopeNS, rawHtml, blocks[0].endOffset);	1✔
202	blocks[0].childNodes = childNodes;	1✔
203	}
204	return blocks;	1✔
205	}
206	case 'Comment': {
207	return {	1✔
208	uuid: uuid(),
209	raw,
210	startOffset,
211	endOffset,
212	startLine,
213	endLine,
214	startCol,
215	endCol,
216	nodeName: '#comment',
217	type: 'comment',
218	parentNode,
219	prevNode,
220	nextNode,
221	isFragment: false,
222	isGhost: false,
223	};
224	}
225	case 'InlineComponent':
226	case 'Element': {
227	if (originNode.name?.toLowerCase() === '!doctype') {	17!
228	return {	1✔
229	uuid: uuid(),
230	raw,
231	name: originNode.name,
232	publicId: '',
233	systemId: '',
234	startOffset,
235	endOffset,
236	startLine,
237	endLine,
238	startCol,
239	endCol,
240	nodeName: '#doctype',
241	type: 'doctype',
242	parentNode,
243	prevNode,
244	nextNode,
245	isFragment: false,
246	isGhost: false,
247	};
248	}
249	return parseElement(	16✔
250	originNode.name,
251	originNode,
252	scopeNS,
253	rawHtml,
254	startLine,
255	startCol,
256	startOffset,
257	parentNode,
258	prevNode,
259	nextNode,
260	offset,
261	);
262	}
263	case 'Fragment': {
264	return originNode.children ? traverse(originNode, parentNode, scopeNS, rawHtml, offset) : null;	1!
265	}
266	default: {
267	return null;	×
268	}
269	}
270	}
271
272	function parseElement(
273	nodeName: string,
274	originNode: ASTNode \| ASTStyleNode,
275	scopeNS: NamespaceURI,
276	rawHtml: string,
277	startLine: number,
278	startCol: number,
279	startOffset: number,
280	parentNode: MLASTParentNode \| null,
281	prevNode: MLASTNode \| null,
282	nextNode: MLASTNode \| null,
283	offset: number,
284	) {
285	const { raw } = sliceFragment(rawHtml, originNode.start + offset, originNode.end + offset);	17✔
286	let childrenStart: number;
287	let childrenEnd: number;
288	if (originNode.children && originNode.children[0]) {	17✔
289	childrenStart = originNode.children[0].start + offset;	11✔
290	childrenEnd = originNode.children[originNode.children.length - 1].end + offset;	11✔
291	} else if (originNode.content) {	6✔
292	childrenStart = originNode.content.start + offset;	1✔
293	childrenEnd = originNode.content.end + offset;	1✔
294	} else if (/\/>$/.test(raw)) {	5✔
295	childrenStart = originNode.end + offset;	2✔
296	childrenEnd = originNode.end + offset;	2✔
297	} else {
298	const expectedEndTag = `</${nodeName}>`;	3✔
299	const endTagStart = originNode.end + offset - expectedEndTag.length;	3✔
300	childrenStart = endTagStart;	3✔
301	childrenEnd = endTagStart;	3✔
302	}
303	const startTagStartOffset = originNode.start + offset;	17✔
304	const startTagEndOffset = childrenStart;	17✔
305	const startTagRaw = rawHtml.slice(startTagStartOffset, startTagEndOffset);	17✔
306	const tagTokens = parseRawTag(startTagRaw, startLine, startCol, startOffset);	17✔
307	const tagName = tagTokens.tagName;	17✔
308	let endTag: MLASTElementCloseTag \| null = null;	17✔
309	if (childrenEnd < originNode.end + offset) {	17✔
310	const endTagLoc = sliceFragment(rawHtml, childrenEnd, originNode.end + offset);	15✔
311	const endTagTokens = parseRawTag(endTagLoc.raw, endTagLoc.startLine, endTagLoc.startCol, endTagLoc.startOffset);	15✔
312	const endTagName = endTagTokens.tagName;	15✔
313	endTag = {	15✔
314	uuid: uuid(),
315	raw: endTagLoc.raw,
316	startOffset: endTagLoc.startOffset,
317	endOffset: endTagLoc.endOffset,
318	startLine: endTagLoc.startLine,
319	endLine: endTagLoc.endLine,
320	startCol: endTagLoc.startCol,
321	endCol: endTagLoc.endCol,
322	nodeName: endTagName,
323	type: 'endtag',
324	namespace: scopeNS,
325	attributes: endTagTokens.attrs,
326	parentNode,
327	prevNode,
328	nextNode,
329	pearNode: null,
330	isFragment: false,
331	isGhost: false,
332	tagOpenChar: '</',
333	tagCloseChar: '>',
334	isCustomElement: isCustomComponentName(endTagName),
335	};
336	}
337
338	const startTag: MLASTTag = {	17✔
339	uuid: uuid(),
340	raw: startTagRaw,
341	startOffset,
342	endOffset: startOffset + startTagRaw.length,
343	startLine,
344	endLine: getEndLine(startTagRaw, startLine),
345	startCol,
346	endCol: getEndCol(startTagRaw, startCol),
347	nodeName: tagName,
348	type: 'starttag',
349	namespace: scopeNS,
350	attributes: originNode.attributes.map((attr: ASTAttribute) => attrTokenizer(attr, rawHtml, offset)),	5✔
351	hasSpreadAttr: false,
352	parentNode,
353	prevNode,
354	nextNode,
355	pearNode: endTag,
356	selfClosingSolidus: tagTokens.selfClosingSolidus,
357	endSpace: tagTokens.endSpace,
358	isFragment: false,
359	isGhost: false,
360	tagOpenChar: '<',
361	tagCloseChar: '>',
362	isCustomElement: isCustomComponentName(tagName),
363	};
364	if (endTag) {	17✔
365	endTag.pearNode = startTag;	15✔
366	}
367	startTag.childNodes = traverse(originNode, startTag, scopeNS, rawHtml, offset);	17✔
368	return startTag;	17✔
369	}
370
371	function parseStyle(nodes: ASTStyleNode[], scopeNS: NamespaceURI, rawHtml: string, offset: number) {
372	const result: MLASTElement[] = [];	7✔
373	for (const node of nodes) {	7✔
374	const { startLine, startCol, startOffset } = sliceFragment(rawHtml, node.start, node.end);	1✔
375	const styleEl = parseElement(	1✔
376	'style',
377	node,
378	scopeNS,
379	rawHtml,
380	startLine,
381	startCol,
382	startOffset,
383	null,
384	null,
385	null,
386	offset,
387	);
388	result.push(styleEl);	1✔
389	}
390	return result;	7✔
391	}
392
393	function isCustomComponentName(name: string) {
394	return isPotentialCustomElementName(name) \|\| /[A-Z]\|\./.test(name);	32✔
395	}

markuplint / markuplint / #2328

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous