3506001997

Build # 3506001997

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/tbranyen/diffhtml/commit/<a class=hub.com/tbranyen/diffhtml/commit/<a class="double-link" href="https://git"><a class=hub.com/tbranyen/diffhtml/commit/<a class="double-link" href="https://git"><a class=hub.com/tbranyen/diffhtml/commit/55661e28f5b830e7e5fa7e27b63a9124f5baf7f3">55661e28f<a href="https://github.com/tbranyen/diffhtml/commit/55661e28f5b830e7e5fa7e27b63a9124f5baf7f3">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tbranyen/diffhtml/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tbranyen/diffhtml/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tbranyen/diffhtml/commit/55661e28f5b830e7e5fa7e27b63a9124f5baf7f3&quot;&gt;55661e28f&lt;/a&gt;&lt;a href=&quot;https://github.com/tbranyen/diffhtml/commit/55661e28f5b830e7e5fa7e27b63a9124f5baf7f3&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tbranyen/diffhtml/commit/55661e28f5b830e7e5fa7e27b63a9124&lt;/a&gt;f5baf7f3">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tbranyen/diffhtml/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tbranyen/diffhtml/commit/<a class="double-link" href="https://github.com/tbranyen/diffhtml/commit/76143e3cdd948dd0e1c374847e33aadcc792237c">76143e3cd</a><a href="https://github.com/tbranyen/diffhtml/commit/55661e28f5b830e7e5fa7e27b63a9124f5baf7f3">&amp;quot;&amp;gt;76143e3cd&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;76143e3cd&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/tbranyen/diffhtml/commit/55661e28f5b830e7e5fa7e27b63a9124f5baf&lt;/a&gt;7f3&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tbranyen/diffhtml/commit/<a class="double-link" href="https://github.com/tbranyen/diffhtml/commit/8d0e8b738">8d0e8b738">8d0e8b738</a>

Pull Request Pull Request #283: HTML Parser Rewrite

Run Details

646 of 686 branches covered (94.17%)

443 of 443 new or added lines in 6 files covered. (100.0%)

3502 of 3545 relevant lines covered (98.79%)

511.87 hits per line

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

97.23

/packages/diffhtml/lib/util/parse.js

import createTree from '../tree/create';
import getConfig from './config';
import {
  NODE_TYPE,
  EMPTY,
  TransactionConfig,
  VTree,
  ParserConfig,
} from './types';

const rawElementsDefaults = [
  'script',
  'noscript',
  'style',
  'template',
];

/**
 *
 * @see https://developer.mozilla.org/en-US/docs/Glossary/Void_element
 */
const voidElementsDefaults = [
  'area',
  'base',
  'br',
  'col',
  'embed',
  'hr',
  'img',
  'input',
  'link',
  'meta',
  'param',
  'source',
  'track',
  'wbr',
];

/**
 * These are elements that support omitting a closing tag when certain criteria
 * are met.
 *
 * @see https://html.spec.whatwg.org/multipage/syntax.html#syntax-tag-omission
 * @type {any}
 */
const endTagOmissionRules = {
  li: { li: EMPTY.NUM },
  dt: { dt: EMPTY.NUM, dd: EMPTY.NUM },
  dd: { dt: EMPTY.NUM, dd: EMPTY.NUM },
  td: { td: EMPTY.NUM, th: EMPTY.NUM },
  th: { td: EMPTY.NUM, th: EMPTY.NUM },
  tbody: { tbody: EMPTY.NUM, tfoot: EMPTY.NUM },
  tfoot: { tbody: EMPTY.NUM, tfoot: EMPTY.NUM },
};

// List of regular expressions to match various HTML features.
export const openComment = /<!--/g;
export const closeComment = /-->/g;

// Extract the tagName from an opening tag. There must not be any whitespace
// between the opening angle bracket and the word/namespace.
export const openTag = /<([^\s\\/>]*)\s?/g;
export const closeTag = /\s?(\/>)|(<\/(.*?)>)/g;

// Find all values within quotes and up to `>`. Support interpolated values
// with __DIFFHTML_TOKEN__ format.
export const attribute = /([^>\/\n ])*?(["'])(?:(?=(\\?))\3.)*?\2|.*?(?=\/>|>|\n| )/gsm;
export const parseAttr = /([^=]*)=(.*)|([^>])/gsm;

// Text nodes are anything that isn't <.
export const text = /([^<]*)/g;

/**
 * Removes "", '', or `` wrapping quotes from attributes when they are
 * parsed directly from the markup.
 *
 * @param {string} value
 * @return {string}
 */
function removeQuotes(value) {
  if (typeof value !== 'string') {
    return value;
  }

  const quotes = ['"', '\''];
  const rootQuote = quotes.indexOf(value[0]);
  const hasRootQuote = rootQuote !== -1;
  const trailingQuote = hasRootQuote && quotes.indexOf(value[value.length - 1]);

  if (rootQuote !== -1 && trailingQuote === rootQuote) {
    return value.slice(1, value.length - 1);
  }

  return value;
}

/**
 * Parses HTML and returns a root element
 *
 * @param {String} html - String of HTML markup to parse into a Virtual Tree
 * @param {TransactionConfig=} options - Contains additional options
 * @return {VTree} - Parsed Virtual Tree Element
 */
export default function parse(html, options = {}) {
  // Always start with a fragment container when parsing.
  const root = createTree('#document-fragment', null, []);

  // If no markup is provided, return an empty text node. This is a fast path
  // to circumvent extra work in this case.
  if (!html) {
    root.childNodes.push(createTree('#text', EMPTY.STR));
    return root;
  }

  // If there are no parser configuration options passed, use an empty object.
  if (!options.parser) {
    /** @type {ParserConfig} */
    options.parser = EMPTY.OBJ;
  }

  // Elements that have all nested children converted into text, like script
  // and style tags.
  const blockText = new Set(
    /** @type {string[]} */(
      getConfig(
        'rawElements',
        rawElementsDefaults,
        'array',
        options.parser,
      )
    ),
  );

  // Elements that are automatically self closed, and never contain children.
  const voidElements = new Set(
    /** @type {string[]} */(
      getConfig(
        'voidElements',
        voidElementsDefaults,
        'array',
        options.parser,
      )
    ),
  );

  // If there are no brackets, we can avoid some extra work by treating this as
  // text. This is a fast path for text.
  if (!html.includes('<') && !html.includes('>')) {
    const newTree = createTree('#text', html);
    root.childNodes.push(newTree);
    return root;
  }

  // Contains the active hierarchy, its length will be that of the deepest
  // element crawled.
  const stack = [root];

  // Cursor into the markup that we use when parsing.
  let i = 0;

  // The active element being crawled.
  let pointer = root;

  // The pointer is open when looking for attributes, self closing, or open
  // tag closing.
  let isOpen = false;

  /**
   * Allow short-circuiting if never found.
   * @type {number|null}
   */
  let lastCommentIndex = html.indexOf('<!--');

  // This loop treats the `i` as a cursor into the markup determining what is
  // being parsed. This is useful for setting the `lastIndex` values of the
  // regular expressions defined above. Once this value matches the length of
  // the input markup, we know we have finished parsing.
  while (i < html.length) {
    // Set the lastIndex for all stateful regexes to avoid slicing the html
    // string and getting the latest match each time.
    openComment.lastIndex = i;
    closeComment.lastIndex = i;
    openTag.lastIndex = i;
    closeTag.lastIndex = i;
    attribute.lastIndex = i;
    text.lastIndex = i;

    // Reset parseAttr for each iteration.
    parseAttr.lastIndex = 0;

    /**
     * First check for open comments this allows bypassing any other parsing
     * if a comment has been opened.
     * @type {Boolean}
     */
    const shouldSeekComment = Boolean(
      lastCommentIndex !== null && lastCommentIndex <= i
    );

    const {
      // @ts-ignore
      index: openCommentIndex,
    } = shouldSeekComment && openComment.exec(html) || EMPTY.OBJ;

    // There are no remaining comments, so skip this check. This is very
    // important for performance reasons, otherwise on every loop tick we are
    // crawling the entire markup for something we know isn't there.
    if (shouldSeekComment) {
      lastCommentIndex = openCommentIndex;
    }
    if (openCommentIndex === -1) {
      lastCommentIndex = null;
    }

    // If an element is a block text element (such as script) we should not
    // parse anything under it, except as text.
    const isBlockElement = pointer && blockText.has(pointer.nodeName);

    // If a comment exists, search for the close and treat everything between
    // as a string. There may be dynamic supplemental values to interpolate,
    // these will be toString'd before injection.
    if (openCommentIndex === i) {
      // Find the first close comment instance.
      let { index: closeCommentIndex } = closeComment.exec(html) || EMPTY.OBJ;

      // Default to the end of the markup if no end comment is found.
      if (closeCommentIndex === -1) {
        closeCommentIndex = html.length;
      }

      const comment = createTree('#comment');
      comment.nodeValue = html.slice(i + 4, closeCommentIndex);
      pointer.childNodes.push(comment);

      i = closeCommentIndex + 3;
      continue;
    }

    // Open tags.
    const {
      0: fullOpenTagMatch,
      1: tagName,
      index: openTagIndex,
    } = openTag.exec(html) || EMPTY.OBJ;

    // Only open a tag if it contains a tag name.
    if (openTagIndex === i && tagName && !isBlockElement) {
      // If a doctype, skip to the end, we don't parse these.
      if (tagName[0] === '!') {
        // Find the next > since the open tag.
        i = html.indexOf('>', openTagIndex) + 1;
        continue;
      }

      // If not a doctype, create an element.
      const newTree = createTree(tagName);

      const supportsEndTagOmission = endTagOmissionRules[tagName];

      // We can't nested a div inside a p, we can't nest an li inside an li
      if (supportsEndTagOmission && supportsEndTagOmission[pointer.nodeName]) {
        stack.pop();
        pointer = stack[stack.length - 1];
      }

      pointer.childNodes.push(newTree);
      pointer = newTree;
      stack.push(pointer);

      isOpen = true;
      i = openTagIndex + fullOpenTagMatch.length;
      continue;
    }

    // Attributes.
    const {
      0: fullAttributeMatch,
      index: attributeIndex,
    } = attribute.exec(html) || EMPTY.OBJ;

    const attributeMatchTrim = attributeIndex === i && fullAttributeMatch.trim();

    if (isOpen && attributeIndex === i) {
      // Skip whitespace
      if (!attributeMatchTrim) {
        i = i + fullAttributeMatch.length + 1;

        // TBD Refactor this so its not duplicated
        if (html[i - 1] === '>') {
          // Self closing
          if (html[i - 2] === '/' || voidElements.has(pointer.nodeName)) {
            stack.pop();
            pointer = stack[stack.length - 1];
          }
          isOpen = false;
        }

        continue;
      }

      const {
        1: key = fullAttributeMatch,
        2: value = fullAttributeMatch,
      } = parseAttr.exec(attributeMatchTrim) || EMPTY.OBJ;

      const isBoolean = key === value || value === undefined;
      const trimKey = key.trim();

      pointer.attributes[trimKey] = isBoolean ? Boolean(value) : removeQuotes(value);

      i = attributeIndex + fullAttributeMatch.length;
      continue;
    }

    // When in a block element, find the nearest closing element, otherwise
    // use the entire input.
    if (isBlockElement) {
      const closeTag = `</${pointer.nodeName}>`;
      let closeTagIndex = html.indexOf(closeTag, i + 1);

      if (closeTagIndex === -1) {
        closeTagIndex = html.length;
      }

      const innerText = html.slice(i, closeTagIndex);

      if (innerText) {
        pointer.childNodes.push(createTree('#text', innerText));
      }

      i = closeTagIndex + closeTag.length;
      isOpen = false;
      stack.pop();
      pointer = stack[stack.length - 1];
      continue;
    }

    // Close opened tags.
    if (html[i] === '>') {
      isOpen = false;
      i = i + 1;

      // Automatically close void elements.
      if (voidElements.has(pointer.nodeName)) {
        stack.pop();
        pointer = stack[stack.length - 1];
      }
      continue;
    }

    // Close tags.
    const {
      0: fullCloseTagMatch,
      index: closeTagIndex,
    } = closeTag.exec(html) || EMPTY.OBJ;

    // Look for closing tags
    if (closeTagIndex === i && fullCloseTagMatch && pointer !== root) {
      if (fullCloseTagMatch[1] === '/') {
        stack.pop();
        pointer = stack[stack.length - 1];
      }
      isOpen = false;
      i = closeTagIndex + fullCloseTagMatch.length;
      continue;
    }

    // Text.
    const {
      0: fullTextMatch,
      index: textIndex,
    } = text.exec(html) || EMPTY.OBJ;

    if (!isOpen && textIndex === i && fullTextMatch.length) {
      const newTree = createTree('#text', fullTextMatch);
      pointer.childNodes.push(newTree);
      i = textIndex + fullTextMatch.length;
      continue;
    }

    // Use remaining values as text
    pointer.childNodes.push(createTree('#text', html.slice(i, html.length)));
    i = html.length;
  }

  // This is an entire document, so only allow the HTML children to be
  // body or head.
  if (root.childNodes.length && root.childNodes[0].nodeName === 'html') {
    // Store elements from before body end and after body end.
    /** @type {{ [name: string]: VTree[] }} */
    const head = { before: [], after: [] };
    /** @type {{ [name: string]: VTree[] }} */
    const body = { after: [] };
    const HTML = root.childNodes[0];

    let beforeHead = true;
    let beforeBody = true;

    // Iterate the children and store elements in the proper array for
    // later concat, replace the current childNodes with this new array.
    HTML.childNodes = HTML.childNodes.filter(el => {
      // If either body or head, allow as a valid element.
      if (el.nodeName === 'body' || el.nodeName === 'head') {
        if (el.nodeName === 'head') beforeHead = false;
        if (el.nodeName === 'body') beforeBody = false;

        return true;
      }
      // Not a valid nested HTML tag element, move to respective container.
      else if (el.nodeType === NODE_TYPE.ELEMENT) {
        if (beforeHead && beforeBody) head.before.push(el);
        else if (!beforeHead && beforeBody) head.after.push(el);
        else if (!beforeBody) body.after.push(el);
      }
    });

    // Ensure the first element is the HEAD tag.
    if (!HTML.childNodes[0] || HTML.childNodes[0].nodeName !== 'head') {
      const headInstance = createTree('head', null, []);

      if (headInstance) {
        const existing = headInstance.childNodes;

        existing.unshift.apply(existing, head.before);
        existing.push.apply(existing, head.after);
        HTML.childNodes.unshift(headInstance);
      }
    }
    else {
      const existing = HTML.childNodes[0].childNodes;

      existing.unshift.apply(existing, head.before);
      existing.push.apply(existing, head.after);
    }

    // Ensure the second element is the body tag.
    if (!HTML.childNodes[1] || HTML.childNodes[1].nodeName !== 'body') {
      const bodyInstance = createTree('body', null, []);

      if (bodyInstance) {
        const existing = bodyInstance.childNodes;

        existing.push.apply(existing, body.after);
        HTML.childNodes.push(bodyInstance);
      }
    }
    else {
      const existing = HTML.childNodes[1].childNodes;
      existing.push.apply(existing, body.after);
    }
  }

  return root;
}

1	import createTree from '../tree/create';	2✔
2	import getConfig from './config';	2✔
3	import {	2✔
4	NODE_TYPE,	2✔
5	EMPTY,	2✔
6	TransactionConfig,	2✔
7	VTree,	2✔
8	ParserConfig,	2✔
9	} from './types';	2✔
10		2✔
11	const rawElementsDefaults = [	2✔
12	'script',	2✔
13	'noscript',	2✔
14	'style',	2✔
15	'template',	2✔
16	];	2✔
17		2✔
18	/**	2✔
19	*	2✔
20	* @see https://developer.mozilla.org/en-US/docs/Glossary/Void_element	2✔
21	*/	2✔
22	const voidElementsDefaults = [	2✔
23	'area',	2✔
24	'base',	2✔
25	'br',	2✔
26	'col',	2✔
27	'embed',	2✔
28	'hr',	2✔
29	'img',	2✔
30	'input',	2✔
31	'link',	2✔
32	'meta',	2✔
33	'param',	2✔
34	'source',	2✔
35	'track',	2✔
36	'wbr',	2✔
37	];	2✔
38		2✔
39	/**	2✔
40	* These are elements that support omitting a closing tag when certain criteria	2✔
41	* are met.	2✔
42	*	2✔
43	* @see https://html.spec.whatwg.org/multipage/syntax.html#syntax-tag-omission	2✔
44	* @type {any}	2✔
45	*/	2✔
46	const endTagOmissionRules = {	2✔
47	li: { li: EMPTY.NUM },	2✔
48	dt: { dt: EMPTY.NUM, dd: EMPTY.NUM },	2✔
49	dd: { dt: EMPTY.NUM, dd: EMPTY.NUM },	2✔
50	td: { td: EMPTY.NUM, th: EMPTY.NUM },	2✔
51	th: { td: EMPTY.NUM, th: EMPTY.NUM },	2✔
52	tbody: { tbody: EMPTY.NUM, tfoot: EMPTY.NUM },	2✔
53	tfoot: { tbody: EMPTY.NUM, tfoot: EMPTY.NUM },	2✔
54	};	2✔
55		2✔
56	// List of regular expressions to match various HTML features.	2✔
57	export const openComment = /<!--/g;	2✔
58	export const closeComment = /-->/g;	2✔
59		2✔
60	// Extract the tagName from an opening tag. There must not be any whitespace	2✔
61	// between the opening angle bracket and the word/namespace.	2✔
62	export const openTag = /<([^\s\\/>]*)\s?/g;	2✔
63	export const closeTag = /\s?(\/>)\|(<\/(.*?)>)/g;	2✔
64		2✔
65	// Find all values within quotes and up to `>`. Support interpolated values	2✔
66	// with __DIFFHTML_TOKEN__ format.	2✔
67	export const attribute = /([^>\/\n ])?(["'])(?:(?=(\\?))\3.)?\2\|.*?(?=\/>\|>\|\n\| )/gsm;	2✔
68	export const parseAttr = /([^=])=(.)\|([^>])/gsm;	2✔
69		2✔
70	// Text nodes are anything that isn't <.	2✔
71	export const text = /([^<]*)/g;	2✔
72		2✔
73	/**	2✔
74	* Removes "", '', or `` wrapping quotes from attributes when they are	2✔
75	* parsed directly from the markup.	2✔
76	*	2✔
77	* @param {string} value	2✔
78	* @return {string}	2✔
79	*/	2✔
80	function removeQuotes(value) {	187✔
81	if (typeof value !== 'string') {	187!
82	return value;	×
83	}	×
84		187✔
85	const quotes = ['"', '\''];	187✔
86	const rootQuote = quotes.indexOf(value[0]);	187✔
87	const hasRootQuote = rootQuote !== -1;	187✔
88	const trailingQuote = hasRootQuote && quotes.indexOf(value[value.length - 1]);	187✔
89		187✔
90	if (rootQuote !== -1 && trailingQuote === rootQuote) {	187✔
91	return value.slice(1, value.length - 1);	176✔
92	}	176✔
93		11✔
94	return value;	11✔
95	}	187✔
96		2✔
97	/**	2✔
98	* Parses HTML and returns a root element	2✔
99	*	2✔
100	* @param {String} html - String of HTML markup to parse into a Virtual Tree	2✔
101	* @param {TransactionConfig=} options - Contains additional options	2✔
102	* @return {VTree} - Parsed Virtual Tree Element	2✔
103	*/	2✔
104	export default function parse(html, options = {}) {	2✔
105	// Always start with a fragment container when parsing.	571✔
106	const root = createTree('#document-fragment', null, []);	571✔
107		571✔
108	// If no markup is provided, return an empty text node. This is a fast path	571✔
109	// to circumvent extra work in this case.	571✔
110	if (!html) {	571✔
111	root.childNodes.push(createTree('#text', EMPTY.STR));	15✔
112	return root;	15✔
113	}	15✔
114		556✔
115	// If there are no parser configuration options passed, use an empty object.	556✔
116	if (!options.parser) {	571✔
117	/** @type {ParserConfig} */	329✔
118	options.parser = EMPTY.OBJ;	329✔
119	}	329✔
120		556✔
121	// Elements that have all nested children converted into text, like script	556✔
122	// and style tags.	556✔
123	const blockText = new Set(	556✔
124	/** @type {string[]} */(	556✔
125	getConfig(	556✔
126	'rawElements',	556✔
127	rawElementsDefaults,	556✔
128	'array',	556✔
129	options.parser,	556✔
130	)	556✔
131	),	556✔
132	);	556✔
133		556✔
134	// Elements that are automatically self closed, and never contain children.	556✔
135	const voidElements = new Set(	556✔
136	/** @type {string[]} */(	556✔
137	getConfig(	556✔
138	'voidElements',	556✔
139	voidElementsDefaults,	556✔
140	'array',	556✔
141	options.parser,	556✔
142	)	556✔
143	),	556✔
144	);	556✔
145		556✔
146	// If there are no brackets, we can avoid some extra work by treating this as	556✔
147	// text. This is a fast path for text.	556✔
148	if (!html.includes('<') && !html.includes('>')) {	571✔
149	const newTree = createTree('#text', html);	35✔
150	root.childNodes.push(newTree);	35✔
151	return root;	35✔
152	}	35✔
153		521✔
154	// Contains the active hierarchy, its length will be that of the deepest	521✔
155	// element crawled.	521✔
156	const stack = [root];	521✔
157		521✔
158	// Cursor into the markup that we use when parsing.	521✔
159	let i = 0;	521✔
160		521✔
161	// The active element being crawled.	521✔
162	let pointer = root;	521✔
163		521✔
164	// The pointer is open when looking for attributes, self closing, or open	521✔
165	// tag closing.	521✔
166	let isOpen = false;	521✔
167		521✔
168	/**	521✔
169	* Allow short-circuiting if never found.	521✔
170	* @type {number\|null}	521✔
171	*/	521✔
172	let lastCommentIndex = html.indexOf('<!--');	521✔
173		521✔
174	// This loop treats the `i` as a cursor into the markup determining what is	521✔
175	// being parsed. This is useful for setting the `lastIndex` values of the	521✔
176	// regular expressions defined above. Once this value matches the length of	521✔
177	// the input markup, we know we have finished parsing.	521✔
178	while (i < html.length) {	571✔
179	// Set the lastIndex for all stateful regexes to avoid slicing the html	3,189✔
180	// string and getting the latest match each time.	3,189✔
181	openComment.lastIndex = i;	3,189✔
182	closeComment.lastIndex = i;	3,189✔
183	openTag.lastIndex = i;	3,189✔
184	closeTag.lastIndex = i;	3,189✔
185	attribute.lastIndex = i;	3,189✔
186	text.lastIndex = i;	3,189✔
187		3,189✔
188	// Reset parseAttr for each iteration.	3,189✔
189	parseAttr.lastIndex = 0;	3,189✔
190		3,189✔
191	/**	3,189✔
192	* First check for open comments this allows bypassing any other parsing	3,189✔
193	* if a comment has been opened.	3,189✔
194	* @type {Boolean}	3,189✔
195	*/	3,189✔
196	const shouldSeekComment = Boolean(	3,189✔
197	lastCommentIndex !== null && lastCommentIndex <= i	3,189✔
198	);	3,189✔
199		3,189✔
200	const {	3,189✔
201	// @ts-ignore	3,189✔
202	index: openCommentIndex,	3,189✔
203	} = shouldSeekComment && openComment.exec(html) \|\| EMPTY.OBJ;	3,189✔
204		3,189✔
205	// There are no remaining comments, so skip this check. This is very	3,189✔
206	// important for performance reasons, otherwise on every loop tick we are	3,189✔
207	// crawling the entire markup for something we know isn't there.	3,189✔
208	if (shouldSeekComment) {	3,189✔
209	lastCommentIndex = openCommentIndex;	531✔
210	}	531✔
211	if (openCommentIndex === -1) {	3,189!
212	lastCommentIndex = null;	×
213	}	×
214		3,189✔
215	// If an element is a block text element (such as script) we should not	3,189✔
216	// parse anything under it, except as text.	3,189✔
217	const isBlockElement = pointer && blockText.has(pointer.nodeName);	3,189✔
218		3,189✔
219	// If a comment exists, search for the close and treat everything between	3,189✔
220	// as a string. There may be dynamic supplemental values to interpolate,	3,189✔
221	// these will be toString'd before injection.	3,189✔
222	if (openCommentIndex === i) {	3,189✔
223	// Find the first close comment instance.	16✔
224	let { index: closeCommentIndex } = closeComment.exec(html) \|\| EMPTY.OBJ;	16✔
225		16✔
226	// Default to the end of the markup if no end comment is found.	16✔
227	if (closeCommentIndex === -1) {	16!
228	closeCommentIndex = html.length;	×
229	}	×
230		16✔
231	const comment = createTree('#comment');	16✔
232	comment.nodeValue = html.slice(i + 4, closeCommentIndex);	16✔
233	pointer.childNodes.push(comment);	16✔
234		16✔
235	i = closeCommentIndex + 3;	16✔
236	continue;	16✔
237	}	16✔
238		3,173✔
239	// Open tags.	3,173✔
240	const {	3,173✔
241	0: fullOpenTagMatch,	3,173✔
242	1: tagName,	3,173✔
243	index: openTagIndex,	3,173✔
244	} = openTag.exec(html) \|\| EMPTY.OBJ;	3,189✔
245		3,189✔
246	// Only open a tag if it contains a tag name.	3,189✔
247	if (openTagIndex === i && tagName && !isBlockElement) {	3,189✔
248	// If a doctype, skip to the end, we don't parse these.	753✔
249	if (tagName[0] === '!') {	753✔
250	// Find the next > since the open tag.	1✔
251	i = html.indexOf('>', openTagIndex) + 1;	1✔
252	continue;	1✔
253	}	1✔
254		752✔
255	// If not a doctype, create an element.	752✔
256	const newTree = createTree(tagName);	752✔
257		752✔
258	const supportsEndTagOmission = endTagOmissionRules[tagName];	752✔
259		752✔
260	// We can't nested a div inside a p, we can't nest an li inside an li	752✔
261	if (supportsEndTagOmission && supportsEndTagOmission[pointer.nodeName]) {	753✔
262	stack.pop();	5✔
263	pointer = stack[stack.length - 1];	5✔
264	}	5✔
265		752✔
266	pointer.childNodes.push(newTree);	752✔
267	pointer = newTree;	752✔
268	stack.push(pointer);	752✔
269		752✔
270	isOpen = true;	752✔
271	i = openTagIndex + fullOpenTagMatch.length;	752✔
272	continue;	752✔
273	}	752✔
274		2,420✔
275	// Attributes.	2,420✔
276	const {	2,420✔
277	0: fullAttributeMatch,	2,420✔
278	index: attributeIndex,	2,420✔
279	} = attribute.exec(html) \|\| EMPTY.OBJ;	3,189✔
280		3,189✔
281	const attributeMatchTrim = attributeIndex === i && fullAttributeMatch.trim();	3,189✔
282		3,189✔
283	if (isOpen && attributeIndex === i) {	3,189✔
284	// Skip whitespace	1,498✔
285	if (!attributeMatchTrim) {	1,498✔
286	i = i + fullAttributeMatch.length + 1;	1,282✔
287		1,282✔
288	// TBD Refactor this so its not duplicated	1,282✔
289	if (html[i - 1] === '>') {	1,282✔
290	// Self closing	752✔
291	if (html[i - 2] === '/' \|\| voidElements.has(pointer.nodeName)) {	752✔
292	stack.pop();	159✔
293	pointer = stack[stack.length - 1];	159✔
294	}	159✔
295	isOpen = false;	752✔
296	}	752✔
297		1,282✔
298	continue;	1,282✔
299	}	1,282✔
300		216✔
301	const {	216✔
302	1: key = fullAttributeMatch,	216✔
303	2: value = fullAttributeMatch,	216✔
304	} = parseAttr.exec(attributeMatchTrim) \|\| EMPTY.OBJ;	1,498!
305		1,498✔
306	const isBoolean = key === value \|\| value === undefined;	1,498✔
307	const trimKey = key.trim();	1,498✔
308		1,498✔
309	pointer.attributes[trimKey] = isBoolean ? Boolean(value) : removeQuotes(value);	1,498✔
310		1,498✔
311	i = attributeIndex + fullAttributeMatch.length;	1,498✔
312	continue;	1,498✔
313	}	1,498✔
314		922✔
315	// When in a block element, find the nearest closing element, otherwise	922✔
316	// use the entire input.	922✔
317	if (isBlockElement) {	3,189✔
318	const closeTag = `</${pointer.nodeName}>`;	51✔
319	let closeTagIndex = html.indexOf(closeTag, i + 1);	51✔
320		51✔
321	if (closeTagIndex === -1) {	51✔
322	closeTagIndex = html.length;	9✔
323	}	9✔
324		51✔
325	const innerText = html.slice(i, closeTagIndex);	51✔
326		51✔
327	if (innerText) {	51✔
328	pointer.childNodes.push(createTree('#text', innerText));	51✔
329	}	51✔
330		51✔
331	i = closeTagIndex + closeTag.length;	51✔
332	isOpen = false;	51✔
333	stack.pop();	51✔
334	pointer = stack[stack.length - 1];	51✔
335	continue;	51✔
336	}	51✔
337		871✔
338	// Close opened tags.	871✔
339	if (html[i] === '>') {	3,189✔
340	isOpen = false;	4✔
341	i = i + 1;	4✔
342		4✔
343	// Automatically close void elements.	4✔
344	if (voidElements.has(pointer.nodeName)) {	4!
345	stack.pop();	×
346	pointer = stack[stack.length - 1];	×
347	}	×
348	continue;	4✔
349	}	4✔
350		867✔
351	// Close tags.	867✔
352	const {	867✔
353	0: fullCloseTagMatch,	867✔
354	index: closeTagIndex,	867✔
355	} = closeTag.exec(html) \|\| EMPTY.OBJ;	3,189✔
356		3,189✔
357	// Look for closing tags	3,189✔
358	if (closeTagIndex === i && fullCloseTagMatch && pointer !== root) {	3,189✔
359	if (fullCloseTagMatch[1] === '/') {	528✔
360	stack.pop();	528✔
361	pointer = stack[stack.length - 1];	528✔
362	}	528✔
363	isOpen = false;	528✔
364	i = closeTagIndex + fullCloseTagMatch.length;	528✔
365	continue;	528✔
366	}	528✔
367		339✔
368	// Text.	339✔
369	const {	339✔
370	0: fullTextMatch,	339✔
371	index: textIndex,	339✔
372	} = text.exec(html) \|\| EMPTY.OBJ;	3,189!
373		3,189✔
374	if (!isOpen && textIndex === i && fullTextMatch.length) {	3,189✔
375	const newTree = createTree('#text', fullTextMatch);	338✔
376	pointer.childNodes.push(newTree);	338✔
377	i = textIndex + fullTextMatch.length;	338✔
378	continue;	338✔
379	}	338✔
380		1✔
381	// Use remaining values as text	1✔
382	pointer.childNodes.push(createTree('#text', html.slice(i, html.length)));	1✔
383	i = html.length;	1✔
384	}	1✔
385		521✔
386	// This is an entire document, so only allow the HTML children to be	521✔
387	// body or head.	521✔
388	if (root.childNodes.length && root.childNodes[0].nodeName === 'html') {	571✔
389	// Store elements from before body end and after body end.	12✔
390	/** @type {{ [name: string]: VTree[] }} */	12✔
391	const head = { before: [], after: [] };	12✔
392	/** @type {{ [name: string]: VTree[] }} */	12✔
393	const body = { after: [] };	12✔
394	const HTML = root.childNodes[0];	12✔
395		12✔
396	let beforeHead = true;	12✔
397	let beforeBody = true;	12✔
398		12✔
399	// Iterate the children and store elements in the proper array for	12✔
400	// later concat, replace the current childNodes with this new array.	12✔
401	HTML.childNodes = HTML.childNodes.filter(el => {	12✔
402	// If either body or head, allow as a valid element.	28✔
403	if (el.nodeName === 'body' \|\| el.nodeName === 'head') {	28✔
404	if (el.nodeName === 'head') beforeHead = false;	15✔
405	if (el.nodeName === 'body') beforeBody = false;	15✔
406		15✔
407	return true;	15✔
408	}	15✔
409	// Not a valid nested HTML tag element, move to respective container.	13✔
410	else if (el.nodeType === NODE_TYPE.ELEMENT) {	13✔
411	if (beforeHead && beforeBody) head.before.push(el);	4✔
412	else if (!beforeHead && beforeBody) head.after.push(el);	3✔
413	else if (!beforeBody) body.after.push(el);	2✔
414	}	4✔
415	});	12✔
416		12✔
417	// Ensure the first element is the HEAD tag.	12✔
418	if (!HTML.childNodes[0] \|\| HTML.childNodes[0].nodeName !== 'head') {	12✔
419	const headInstance = createTree('head', null, []);	2✔
420		2✔
421	if (headInstance) {	2✔
422	const existing = headInstance.childNodes;	2✔
423		2✔
424	existing.unshift.apply(existing, head.before);	2✔
425	existing.push.apply(existing, head.after);	2✔
426	HTML.childNodes.unshift(headInstance);	2✔
427	}	2✔
428	}	2✔
429	else {	10✔
430	const existing = HTML.childNodes[0].childNodes;	10✔
431		10✔
432	existing.unshift.apply(existing, head.before);	10✔
433	existing.push.apply(existing, head.after);	10✔
434	}	10✔
435		12✔
436	// Ensure the second element is the body tag.	12✔
437	if (!HTML.childNodes[1] \|\| HTML.childNodes[1].nodeName !== 'body') {	12✔
438	const bodyInstance = createTree('body', null, []);	7✔
439		7✔
440	if (bodyInstance) {	7✔
441	const existing = bodyInstance.childNodes;	7✔
442		7✔
443	existing.push.apply(existing, body.after);	7✔
444	HTML.childNodes.push(bodyInstance);	7✔
445	}	7✔
446	}	7✔
447	else {	5✔
448	const existing = HTML.childNodes[1].childNodes;	5✔
449	existing.push.apply(existing, body.after);	5✔
450	}	5✔
451	}	12✔
452		521✔
453	return root;	521✔
454	}	571✔

tbranyen / diffhtml / 3506001997

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