#2362

Build # #2362

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/78f41aceae6ada4446e00ff825cdaed400c0f1cd">78f41acea<a href="https://github.com/markuplint/markuplint/commit/78f41aceae6ada4446e00ff825cdaed400c0f1cd">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/594e25fccdf0dca74f4c3f7b2a20e6db3995f17d">594e25fcc</a>">594e25fcc</a><a href="https://github.com/markuplint/markuplint/commit/78f41aceae6ada4446e00ff825cdaed400c0f1cd"> into 55c8865e1">55c8865e1</a>

Run Details

3078 of 4364 branches covered (70.53%)

Branch coverage included in aggregate %.

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

5865 of 7650 relevant lines covered (76.67%)

94.75 hits per line

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

85.56

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

markuplint / markuplint / #2362

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