#3346

Build # #3346

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/b53c51209a881a4770561e3267d1a83abd0f29d6">b53c51209<a href="https://github.com/markuplint/markuplint/commit/b53c51209a881a4770561e3267d1a83abd0f29d6">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/f5b0e17c90c8869913badfe496c9de4ff92923ac">f5b0e17c9</a>">f5b0e17c9</a><a href="https://github.com/markuplint/markuplint/commit/b53c51209a881a4770561e3267d1a83abd0f29d6"> into 0e6d0b21b">0e6d0b21b</a>

Run Details

3863 of 5679 branches covered (68.02%)

Branch coverage included in aggregate %.

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

6915 of 9509 relevant lines covered (72.72%)

362.96 hits per line

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

89.74

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

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

markuplint / markuplint / #3346

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