#2674

Build # #2674

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/e8631e5c1d3b98049cf1716f0ceb7cdc9ff35cdd">e8631e5c1<a href="https://github.com/markuplint/markuplint/commit/e8631e5c1d3b98049cf1716f0ceb7cdc9ff35cdd">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/941a19ea227fd392e5fe665a860ab41314a75c87">941a19ea2</a>">941a19ea2</a><a href="https://github.com/markuplint/markuplint/commit/e8631e5c1d3b98049cf1716f0ceb7cdc9ff35cdd"> into 0990636f8">0990636f8</a>

Run Details

3606 of 5347 branches covered (67.44%)

Branch coverage included in aggregate %.

21 of 21 new or added lines in 5 files covered. (100.0%)

6588 of 9175 relevant lines covered (71.8%)

302.43 hits per line

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

89.08

/packages/@markuplint/html-parser/src/create-tree.ts

import type {
        MLASTDoctype,
        MLASTElementCloseTag,
        MLASTNode,
        MLASTElement,
        MLASTParentNode,
        MLASTTag,
        MLASTText,
} from '@markuplint/ml-ast';
import type { ElementLocation, Location } from 'parse5/dist/common/token';
import type {
        CommentNode,
        Document,
        DocumentFragment,
        Element,
        Node,
        TextNode,
} from 'parse5/dist/tree-adapters/default';

import { detectElementType, getEndCol, getEndLine, sliceFragment, uuid } from '@markuplint/parser-utils';
import { parse, parseFragment } from 'parse5';

import parseRawTag from './parse-raw-tag';

interface TraversalNode {
        childNodes?: P5Node[];
        content?: P5Fragment;
}

type P5Node = Node & TraversalNode;
type P5LocatableNode = (TextNode | Element | CommentNode) & TraversalNode;
type P5Document = Document & TraversalNode;
type P5Fragment = DocumentFragment & TraversalNode;

const P5_OPTIONS = { sourceCodeLocationInfo: true };

export function createTree(
        rawCode: string,
        isFragment: boolean,
        offsetOffset: number,
        offsetLine: number,
        offsetColumn: number,
) {
        const doc = isFragment
                ? (parseFragment(rawCode, P5_OPTIONS) as P5Fragment)
                : (parse(rawCode, P5_OPTIONS) as P5Document);
        return createTreeRecursive(doc, null, rawCode, offsetOffset, offsetLine, offsetColumn);
}

function createTreeRecursive(
        rootNode: P5Node,
        parentNode: MLASTParentNode | null,
        rawHtml: string,
        offsetOffset: number,
        offsetLine: number,
        offsetColumn: number,
): MLASTNode[] {
        const nodeList: MLASTNode[] = [];

        const childNodes = getChildNodes(rootNode);

        let prevNode: MLASTNode | null = null;
        for (const p5node of childNodes) {
                const node = nodeize(p5node, prevNode, parentNode, rawHtml, offsetOffset, offsetLine, offsetColumn);
                if (!node) {
                        continue;
                }
                if (prevNode) {
                        if (node.type !== 'endtag') {
                                prevNode.nextNode = node;
                        }
                        node.prevNode = prevNode;
                }
                prevNode = node;
                nodeList.push(node);
        }
        return nodeList;
}

function nodeize(
        originNode: P5Node,
        prevNode: MLASTNode | null,
        parentNode: MLASTParentNode | null,
        rawHtml: string,
        offsetOffset: number,
        offsetLine: number,
        offsetColumn: number,
): MLASTNode | null {
        const nextNode = null;
        const location = getLocation(originNode);
        if (!location) {
                const prevToken = prevNode || parentNode;
                const startOffset = prevToken ? prevToken.endOffset : 0;
                const endOffset = prevToken ? prevToken.endOffset : 0;
                const startLine = prevToken ? prevToken.endLine : 0;
                const endLine = prevToken ? prevToken.endLine : 0;
                const startCol = prevToken ? prevToken.endCol : 0;
                const endCol = prevToken ? prevToken.endCol : 0;
                const node: MLASTElement = {
                        uuid: uuid(),
                        raw: '',
                        startOffset: startOffset + offsetOffset,
                        endOffset: endOffset + offsetOffset,
                        startLine: startLine + offsetLine,
                        endLine: endLine + offsetLine,
                        startCol: startCol + (startLine === 1 ? offsetColumn : 0),
                        endCol: endCol + (endLine === 1 ? offsetColumn : 0),
                        nodeName: originNode.nodeName,
                        type: 'starttag',
                        namespace: getNamespace(originNode),
                        elementType: 'html',
                        attributes: [],
                        hasSpreadAttr: false,
                        pearNode: null,
                        tagCloseChar: '',
                        tagOpenChar: '',
                        parentNode,
                        prevNode,
                        nextNode,
                        isFragment: false,
                        isGhost: true,
                };
                node.childNodes = createTreeRecursive(originNode, node, rawHtml, offsetOffset, offsetLine, offsetColumn);
                return node;
        }
        const { startOffset, endOffset, startLine, endLine, startCol, endCol } = location;
        const raw = rawHtml.slice(startOffset, endOffset || startOffset);
        switch (originNode.nodeName) {
                case '#documentType': {
                        return {
                                uuid: uuid(),
                                raw,
                                // @ts-ignore
                                name: originNode.name || '',
                                // @ts-ignore
                                publicId: originNode.publicId || '',
                                // @ts-ignore
                                systemId: originNode.systemId || '',
                                startOffset: startOffset + offsetOffset,
                                endOffset: endOffset + offsetOffset,
                                startLine: startLine + offsetLine,
                                endLine: endLine + offsetLine,
                                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
                                endCol: endCol + (endLine === 1 ? offsetColumn : 0),
                                nodeName: '#doctype',
                                type: 'doctype',
                                parentNode,
                                prevNode,
                                _addPrevNode: 102,
                                nextNode,
                                isFragment: false,
                                isGhost: false,
                        } as MLASTDoctype;
                }
                case '#text': {
                        const node: MLASTText = {
                                uuid: uuid(),
                                raw,
                                startOffset: startOffset + offsetOffset,
                                endOffset: endOffset + offsetOffset,
                                startLine: startLine + offsetLine,
                                endLine: endLine + offsetLine,
                                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
                                endCol: endCol + (endLine === 1 ? offsetColumn : 0),
                                nodeName: '#text',
                                type: 'text',
                                parentNode,
                                prevNode,
                                nextNode,
                                isFragment: false,
                                isGhost: false,
                        };
                        return node;
                }
                case '#comment': {
                        return {
                                uuid: uuid(),
                                raw,
                                startOffset: startOffset + offsetOffset,
                                endOffset: endOffset + offsetOffset,
                                startLine: startLine + offsetLine,
                                endLine: endLine + offsetLine,
                                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
                                endCol: endCol + (endLine === 1 ? offsetColumn : 0),
                                nodeName: '#comment',
                                type: 'comment',
                                parentNode,
                                prevNode,
                                nextNode,
                                isFragment: false,
                                isGhost: false,
                        };
                }
                default: {
                        const tagLoc = 'startTag' in location ? location.startTag : null;
                        const startTagRaw = tagLoc
                                ? rawHtml.slice(tagLoc.startOffset, tagLoc.endOffset)
                                : rawHtml.slice(startOffset, endOffset || startOffset);
                        const tagTokens = parseRawTag(
                                startTagRaw,
                                startLine,
                                startCol,
                                startOffset,
                                offsetOffset,
                                offsetLine,
                                offsetColumn,
                        );
                        const tagName = tagTokens.tagName;
                        let endTag: MLASTElementCloseTag | null = null;
                        let endTagLoc = 'endTag' in location ? location.endTag : null;

                        /**
                         * Patch: Create endTag for SVG Element
                         * @see https://github.com/inikulin/parse5/issues/352
                         */
                        if (
                                !endTagLoc &&
                                'namespaceURI' in originNode &&
                                originNode.namespaceURI === 'http://www.w3.org/2000/svg'
                        ) {
                                const belowRawHTMLFromStartTagEnd = rawHtml.slice(location.endOffset);
                                const endTagMatched = belowRawHTMLFromStartTagEnd.match(new RegExp(`^</\\s*${tagName}[^>]*>`, 'm'));
                                const endTag = endTagMatched && endTagMatched[0];
                                if (endTag) {
                                        endTagLoc = sliceFragment(rawHtml, location.endOffset, location.endOffset + endTag.length);
                                }
                        }

                        if (endTagLoc) {
                                const { startOffset, endOffset, startLine, endLine, startCol, endCol } = endTagLoc;
                                const endTagRaw = rawHtml.slice(startOffset, endOffset);
                                const endTagTokens = parseRawTag(
                                        endTagRaw,
                                        startLine,
                                        startCol,
                                        startOffset,
                                        offsetOffset,
                                        offsetLine,
                                        offsetColumn,
                                );
                                const endTagName = endTagTokens.tagName;
                                endTag = {
                                        uuid: uuid(),
                                        raw: endTagRaw,
                                        startOffset: startOffset + offsetOffset,
                                        endOffset: endOffset + offsetOffset,
                                        startLine: startLine + offsetLine,
                                        endLine: endLine + offsetLine,
                                        startCol: startCol + (startLine === 1 ? offsetColumn : 0),
                                        endCol: endCol + (endLine === 1 ? offsetColumn : 0),
                                        nodeName: endTagName,
                                        type: 'endtag',
                                        namespace: getNamespace(originNode),
                                        attributes: endTagTokens.attrs,
                                        parentNode,
                                        prevNode,
                                        nextNode,
                                        pearNode: null,
                                        isFragment: false,
                                        isGhost: false,
                                        tagOpenChar: '</',
                                        tagCloseChar: '>',
                                };
                        }
                        const _endOffset = startOffset + startTagRaw.length;
                        const _endLine = getEndLine(startTagRaw, startLine);
                        const _endCol = getEndCol(startTagRaw, startCol);
                        const startTag: MLASTTag = {
                                uuid: uuid(),
                                raw: startTagRaw,
                                startOffset: startOffset + offsetOffset,
                                endOffset: _endOffset + offsetOffset,
                                startLine: startLine + offsetLine,
                                endLine: _endLine + offsetLine,
                                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
                                endCol: _endCol + (startLine === _endLine ? offsetColumn : 0),
                                nodeName: tagName,
                                type: 'starttag',
                                namespace: getNamespace(originNode),
                                elementType: detectElementType(tagName),
                                attributes: tagTokens.attrs,
                                hasSpreadAttr: false,
                                parentNode,
                                prevNode,
                                nextNode,
                                pearNode: endTag,
                                selfClosingSolidus: tagTokens.selfClosingSolidus,
                                endSpace: tagTokens.endSpace,
                                isFragment: false,
                                isGhost: false,
                                tagOpenChar: '<',
                                tagCloseChar: '>',
                        };
                        if (endTag) {
                                endTag.pearNode = startTag;
                        }
                        startTag.childNodes = createTreeRecursive(
                                originNode,
                                startTag,
                                rawHtml,
                                offsetOffset,
                                offsetLine,
                                offsetColumn,
                        );
                        return startTag;
                }
        }
}

/**
 * getChildNodes
 *
 * - If node has "content" property then parse as document fragment.
 * - If node is <noscript> then that childNodes is a TextNode. But parse as document fragment it for disabled script.
 */
function getChildNodes(rootNode: P5Node | P5Document | P5Fragment) {
        if (rootNode.nodeName === 'noscript') {
                const textNode = rootNode.childNodes[0];
                if (!textNode || textNode.nodeName !== '#text') {
                        return [];
                }
                // @ts-ignore
                const html: string = textNode.value;

                // @ts-ignore
                const { startOffset, startLine, startCol } = textNode.sourceCodeLocation;

                const breakCount = startLine - 1;
                const indentWidth = startCol - 1;
                const offsetSpaces =
                        ' '.repeat(startOffset - Math.max(breakCount, 0) - Math.max(indentWidth, 0)) +
                        '\n'.repeat(breakCount) +
                        ' '.repeat(indentWidth);

                const fragment = parseFragment(`${offsetSpaces}${html}`, P5_OPTIONS);
                const childNodes = fragment.childNodes.slice(offsetSpaces ? 1 : 0);
                // const childNodes = ('childNodes' in _childNodes && _childNodes.childNodes) || [];

                return childNodes;
        }
        return rootNode.content ? rootNode.content.childNodes : rootNode.childNodes || [];
}

function hasLocation(node: P5Node): node is P5LocatableNode {
        return 'sourceCodeLocation' in node;
}

function getLocation(node: P5Node): Location | ElementLocation | null {
        if (hasLocation(node) && node.sourceCodeLocation) {
                return node.sourceCodeLocation;
        }
        return null;
}

function getNamespace(node: P5Node) {
        if ('namespaceURI' in node) {
                return node.namespaceURI;
        }
        return '';
}

1	import type {
2	MLASTDoctype,
3	MLASTElementCloseTag,
4	MLASTNode,
5	MLASTElement,
6	MLASTParentNode,
7	MLASTTag,
8	MLASTText,
9	} from '@markuplint/ml-ast';
10	import type { ElementLocation, Location } from 'parse5/dist/common/token';
11	import type {
12	CommentNode,
13	Document,
14	DocumentFragment,
15	Element,
16	Node,
17	TextNode,
18	} from 'parse5/dist/tree-adapters/default';
19
20	import { detectElementType, getEndCol, getEndLine, sliceFragment, uuid } from '@markuplint/parser-utils';	2✔
21	import { parse, parseFragment } from 'parse5';	2✔
22
23	import parseRawTag from './parse-raw-tag';	2✔
24
25	interface TraversalNode {
26	childNodes?: P5Node[];
27	content?: P5Fragment;
28	}
29
30	type P5Node = Node & TraversalNode;
31	type P5LocatableNode = (TextNode \| Element \| CommentNode) & TraversalNode;
32	type P5Document = Document & TraversalNode;
33	type P5Fragment = DocumentFragment & TraversalNode;
34
35	const P5_OPTIONS = { sourceCodeLocationInfo: true };	2✔
36
37	export function createTree(	2✔
38	rawCode: string,
39	isFragment: boolean,
40	offsetOffset: number,
41	offsetLine: number,
42	offsetColumn: number,
43	) {
44	const doc = isFragment	43✔
45	? (parseFragment(rawCode, P5_OPTIONS) as P5Fragment)
46	: (parse(rawCode, P5_OPTIONS) as P5Document);
47	return createTreeRecursive(doc, null, rawCode, offsetOffset, offsetLine, offsetColumn);	43✔
48	}
49
50	function createTreeRecursive(
51	rootNode: P5Node,
52	parentNode: MLASTParentNode \| null,
53	rawHtml: string,
54	offsetOffset: number,
55	offsetLine: number,
56	offsetColumn: number,
57	): MLASTNode[] {
58	const nodeList: MLASTNode[] = [];	196✔
59
60	const childNodes = getChildNodes(rootNode);	196✔
61
62	let prevNode: MLASTNode \| null = null;	196✔
63	for (const p5node of childNodes) {	196✔
64	const node = nodeize(p5node, prevNode, parentNode, rawHtml, offsetOffset, offsetLine, offsetColumn);	305✔
65	if (!node) {	305!
66	continue;	×
67	}
68	if (prevNode) {	305✔
69	if (node.type !== 'endtag') {	156✔
70	prevNode.nextNode = node;	156✔
71	}
72	node.prevNode = prevNode;	156✔
73	}
74	prevNode = node;	305✔
75	nodeList.push(node);	305✔
76	}
77	return nodeList;	196✔
78	}
79
80	function nodeize(
81	originNode: P5Node,
82	prevNode: MLASTNode \| null,
83	parentNode: MLASTParentNode \| null,
84	rawHtml: string,
85	offsetOffset: number,
86	offsetLine: number,
87	offsetColumn: number,
88	): MLASTNode \| null {
89	const nextNode = null;	305✔
90	const location = getLocation(originNode);	305✔
91	if (!location) {	305✔
92	const prevToken = prevNode \|\| parentNode;	44✔
93	const startOffset = prevToken ? prevToken.endOffset : 0;	44✔
94	const endOffset = prevToken ? prevToken.endOffset : 0;	44✔
95	const startLine = prevToken ? prevToken.endLine : 0;	44✔
96	const endLine = prevToken ? prevToken.endLine : 0;	44✔
97	const startCol = prevToken ? prevToken.endCol : 0;	44✔
98	const endCol = prevToken ? prevToken.endCol : 0;	44✔
99	const node: MLASTElement = {	44✔
100	uuid: uuid(),
101	raw: '',
102	startOffset: startOffset + offsetOffset,
103	endOffset: endOffset + offsetOffset,
104	startLine: startLine + offsetLine,
105	endLine: endLine + offsetLine,
106	startCol: startCol + (startLine === 1 ? offsetColumn : 0),	44✔
107	endCol: endCol + (endLine === 1 ? offsetColumn : 0),	44✔
108	nodeName: originNode.nodeName,
109	type: 'starttag',
110	namespace: getNamespace(originNode),
111	elementType: 'html',
112	attributes: [],
113	hasSpreadAttr: false,
114	pearNode: null,
115	tagCloseChar: '',
116	tagOpenChar: '',
117	parentNode,
118	prevNode,
119	nextNode,
120	isFragment: false,
121	isGhost: true,
122	};
123	node.childNodes = createTreeRecursive(originNode, node, rawHtml, offsetOffset, offsetLine, offsetColumn);	44✔
124	return node;	44✔
125	}
126	const { startOffset, endOffset, startLine, endLine, startCol, endCol } = location;	261✔
127	const raw = rawHtml.slice(startOffset, endOffset \|\| startOffset);	261!
128	switch (originNode.nodeName) {	261✔
129	case '#documentType': {
130	return {	12✔
131	uuid: uuid(),
132	raw,
133	// @ts-ignore
134	name: originNode.name \|\| '',	12!
135	// @ts-ignore
136	publicId: originNode.publicId \|\| '',	24✔
137	// @ts-ignore
138	systemId: originNode.systemId \|\| '',	24✔
139	startOffset: startOffset + offsetOffset,
140	endOffset: endOffset + offsetOffset,
141	startLine: startLine + offsetLine,
142	endLine: endLine + offsetLine,
143	startCol: startCol + (startLine === 1 ? offsetColumn : 0),	12✔
144	endCol: endCol + (endLine === 1 ? offsetColumn : 0),	12✔
145	nodeName: '#doctype',
146	type: 'doctype',
147	parentNode,
148	prevNode,
149	_addPrevNode: 102,
150	nextNode,
151	isFragment: false,
152	isGhost: false,
153	} as MLASTDoctype;
154	}
155	case '#text': {
156	const node: MLASTText = {	134✔
157	uuid: uuid(),
158	raw,
159	startOffset: startOffset + offsetOffset,
160	endOffset: endOffset + offsetOffset,
161	startLine: startLine + offsetLine,
162	endLine: endLine + offsetLine,
163	startCol: startCol + (startLine === 1 ? offsetColumn : 0),	134✔
164	endCol: endCol + (endLine === 1 ? offsetColumn : 0),	134✔
165	nodeName: '#text',
166	type: 'text',
167	parentNode,
168	prevNode,
169	nextNode,
170	isFragment: false,
171	isGhost: false,
172	};
173	return node;	134✔
174	}
175	case '#comment': {
176	return {	6✔
177	uuid: uuid(),
178	raw,
179	startOffset: startOffset + offsetOffset,
180	endOffset: endOffset + offsetOffset,
181	startLine: startLine + offsetLine,
182	endLine: endLine + offsetLine,
183	startCol: startCol + (startLine === 1 ? offsetColumn : 0),	6!
184	endCol: endCol + (endLine === 1 ? offsetColumn : 0),	6!
185	nodeName: '#comment',
186	type: 'comment',
187	parentNode,
188	prevNode,
189	nextNode,
190	isFragment: false,
191	isGhost: false,
192	};
193	}
194	default: {
195	const tagLoc = 'startTag' in location ? location.startTag : null;	109!
196	const startTagRaw = tagLoc	109!
197	? rawHtml.slice(tagLoc.startOffset, tagLoc.endOffset)
198	: rawHtml.slice(startOffset, endOffset \|\| startOffset);	×
199	const tagTokens = parseRawTag(	109✔
200	startTagRaw,
201	startLine,
202	startCol,
203	startOffset,
204	offsetOffset,
205	offsetLine,
206	offsetColumn,
207	);
208	const tagName = tagTokens.tagName;	109✔
209	let endTag: MLASTElementCloseTag \| null = null;	109✔
210	let endTagLoc = 'endTag' in location ? location.endTag : null;	109✔
211
212	/**
213	* Patch: Create endTag for SVG Element
214	* @see https://github.com/inikulin/parse5/issues/352
215	*/
216	if (	109✔
217	!endTagLoc &&	167✔
218	'namespaceURI' in originNode &&
219	originNode.namespaceURI === 'http://www.w3.org/2000/svg'
220	) {
221	const belowRawHTMLFromStartTagEnd = rawHtml.slice(location.endOffset);	1✔
222	const endTagMatched = belowRawHTMLFromStartTagEnd.match(new RegExp(`^</\\s${tagName}[^>]>`, 'm'));	1✔
223	const endTag = endTagMatched && endTagMatched[0];	1!
224	if (endTag) {	1!
225	endTagLoc = sliceFragment(rawHtml, location.endOffset, location.endOffset + endTag.length);	×
226	}
227	}
228
229	if (endTagLoc) {	109✔
230	const { startOffset, endOffset, startLine, endLine, startCol, endCol } = endTagLoc;	80✔
231	const endTagRaw = rawHtml.slice(startOffset, endOffset);	80✔
232	const endTagTokens = parseRawTag(	80✔
233	endTagRaw,
234	startLine,
235	startCol,
236	startOffset,
237	offsetOffset,
238	offsetLine,
239	offsetColumn,
240	);
241	const endTagName = endTagTokens.tagName;	80✔
242	endTag = {	80✔
243	uuid: uuid(),
244	raw: endTagRaw,
245	startOffset: startOffset + offsetOffset,
246	endOffset: endOffset + offsetOffset,
247	startLine: startLine + offsetLine,
248	endLine: endLine + offsetLine,
249	startCol: startCol + (startLine === 1 ? offsetColumn : 0),	80✔
250	endCol: endCol + (endLine === 1 ? offsetColumn : 0),	80✔
251	nodeName: endTagName,
252	type: 'endtag',
253	namespace: getNamespace(originNode),
254	attributes: endTagTokens.attrs,
255	parentNode,
256	prevNode,
257	nextNode,
258	pearNode: null,
259	isFragment: false,
260	isGhost: false,
261	tagOpenChar: '</',
262	tagCloseChar: '>',
263	};
264	}
265	const _endOffset = startOffset + startTagRaw.length;	109✔
266	const _endLine = getEndLine(startTagRaw, startLine);	109✔
267	const _endCol = getEndCol(startTagRaw, startCol);	109✔
268	const startTag: MLASTTag = {	109✔
269	uuid: uuid(),
270	raw: startTagRaw,
271	startOffset: startOffset + offsetOffset,
272	endOffset: _endOffset + offsetOffset,
273	startLine: startLine + offsetLine,
274	endLine: _endLine + offsetLine,
275	startCol: startCol + (startLine === 1 ? offsetColumn : 0),	109✔
276	endCol: _endCol + (startLine === _endLine ? offsetColumn : 0),	109!
277	nodeName: tagName,
278	type: 'starttag',
279	namespace: getNamespace(originNode),
280	elementType: detectElementType(tagName),
281	attributes: tagTokens.attrs,
282	hasSpreadAttr: false,
283	parentNode,
284	prevNode,
285	nextNode,
286	pearNode: endTag,
287	selfClosingSolidus: tagTokens.selfClosingSolidus,
288	endSpace: tagTokens.endSpace,
289	isFragment: false,
290	isGhost: false,
291	tagOpenChar: '<',
292	tagCloseChar: '>',
293	};
294	if (endTag) {	109✔
295	endTag.pearNode = startTag;	80✔
296	}
297	startTag.childNodes = createTreeRecursive(	109✔
298	originNode,
299	startTag,
300	rawHtml,
301	offsetOffset,
302	offsetLine,
303	offsetColumn,
304	);
305	return startTag;	109✔
306	}
307	}
308	}
309
310	/**
311	* getChildNodes
312	*
313	* - If node has "content" property then parse as document fragment.
314	* - If node is <noscript> then that childNodes is a TextNode. But parse as document fragment it for disabled script.
315	*/
316	function getChildNodes(rootNode: P5Node \| P5Document \| P5Fragment) {
317	if (rootNode.nodeName === 'noscript') {	196✔
318	const textNode = rootNode.childNodes[0];	2✔
319	if (!textNode \|\| textNode.nodeName !== '#text') {	2!
320	return [];	×
321	}
322	// @ts-ignore
323	const html: string = textNode.value;	2✔
324
325	// @ts-ignore
326	const { startOffset, startLine, startCol } = textNode.sourceCodeLocation;	2✔
327
328	const breakCount = startLine - 1;	2✔
329	const indentWidth = startCol - 1;	2✔
330	const offsetSpaces =
331	' '.repeat(startOffset - Math.max(breakCount, 0) - Math.max(indentWidth, 0)) +	2✔
332	'\n'.repeat(breakCount) +
333	' '.repeat(indentWidth);
334
335	const fragment = parseFragment(`${offsetSpaces}${html}`, P5_OPTIONS);	2✔
336	const childNodes = fragment.childNodes.slice(offsetSpaces ? 1 : 0);	2!
337	// const childNodes = ('childNodes' in _childNodes && _childNodes.childNodes) \|\| [];
338
339	return childNodes;	2✔
340	}
341	return rootNode.content ? rootNode.content.childNodes : rootNode.childNodes \|\| [];	194!
342	}
343
344	function hasLocation(node: P5Node): node is P5LocatableNode {
345	return 'sourceCodeLocation' in node;	305✔
346	}
347
348	function getLocation(node: P5Node): Location \| ElementLocation \| null {
349	if (hasLocation(node) && node.sourceCodeLocation) {	305✔
350	return node.sourceCodeLocation;	261✔
351	}
352	return null;	44✔
353	}
354
355	function getNamespace(node: P5Node) {
356	if ('namespaceURI' in node) {	233✔
357	return node.namespaceURI;	233✔
358	}
359	return '';	×
360	}

markuplint / markuplint / #2674

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