happy-dom 9.15.0 → 9.17.0

package/src/query-selector/SelectorParser.ts

@@ -14,16 +14,17 @@ import ISelectorPseudo from './ISelectorPseudo';
  * Group 6: Attribute name when there is a value using apostrophe (e.g. "attr1")
  * Group 7: Attribute operator when using apostrophe (e.g. "~")
  * Group 8: Attribute value when using apostrophe (e.g. "value1")
- * Group 9: Attribute name when threre is a value not using apostrophe (e.g. "attr1")
- * Group 10: Attribute operator when not using apostrophe (e.g. "~")
- * Group 11: Attribute value when notusing apostrophe (e.g. "value1")
- * Group 12: Pseudo name when arguments (e.g. "nth-child")
- * Group 13: Arguments of pseudo (e.g. "2n + 1")
- * Group 14: Pseudo name when no arguments (e.g. "empty")
- * Group 15: Combinator.
+ * Group 9: Attribute modifier when using apostrophe (e.g. "i" or "s")
+ * Group 10: Attribute name when threre is a value not using apostrophe (e.g. "attr1")
+ * Group 11: Attribute operator when not using apostrophe (e.g. "~")
+ * Group 12: Attribute value when notusing apostrophe (e.g. "value1")
+ * Group 13: Pseudo name when arguments (e.g. "nth-child")
+ * Group 14: Arguments of pseudo (e.g. "2n + 1")
+ * Group 15: Pseudo name when no arguments (e.g. "empty")
+ * Group 16: Combinator.
  */
 const SELECTOR_REGEXP =
-	/(\*)|([a-zA-Z0-9-]+)|#((?:[a-zA-Z0-9-_]|\\.)+)|\.((?:[a-zA-Z0-9-_]|\\.)+)|\[([a-zA-Z0-9-_]+)\]|\[([a-zA-Z0-9-_]+)([~|^$*]{0,1}) *= *["']{1}([^"']*)["']{1}\]|\[([a-zA-Z0-9-_]+)([~|^$*]{0,1}) *= *([^\]]*)\]|:([a-zA-Z-]+) *\(([^)]+)\)|:([a-zA-Z-]+)|([ ,+>]*)/g;
+	/(\*)|([a-zA-Z0-9-]+)|#((?:[a-zA-Z0-9-_]|\\.)+)|\.((?:[a-zA-Z0-9-_]|\\.)+)|\[([a-zA-Z0-9-_]+)\]|\[([a-zA-Z0-9-_]+) *([~|^$*]{0,1}) *= *["']{1}([^"']*)["']{1} *(s|i){0,1}\]|\[([a-zA-Z0-9-_]+) *([~|^$*]{0,1}) *= *([^\]]*)\]|:([a-zA-Z-]+) *\(([^)]+)\)|:([a-zA-Z-]+)|([ ,+>]*)/g;
 
 /**
  * Escaped Character RegExp.
@@ -117,30 +118,40 @@ export default class SelectorParser {
 					currentSelectorItem.attributes.push({
 						name: match[5].toLowerCase(),
 						operator: null,
-						value: null
+						value: null,
+						modifier: null,
+						regExp: null
 					});
 				} else if (match[6] && match[8] !== undefined) {
 					currentSelectorItem.attributes = currentSelectorItem.attributes || [];
 					currentSelectorItem.attributes.push({
 						name: match[6].toLowerCase(),
 						operator: match[7] || null,
-						value: match[8]
+						value: match[8],
+						modifier: match[9] || null,
+						regExp: this.getAttributeRegExp({
+							operator: match[7],
+							value: match[8],
+							modifier: match[9]
+						})
 					});
-				} else if (match[9] && match[11] !== undefined) {
+				} else if (match[10] && match[12] !== undefined) {
 					currentSelectorItem.attributes = currentSelectorItem.attributes || [];
 					currentSelectorItem.attributes.push({
-						name: match[9].toLowerCase(),
-						operator: match[10] || null,
-						value: match[11]
+						name: match[10].toLowerCase(),
+						operator: match[11] || null,
+						value: match[12],
+						modifier: null,
+						regExp: this.getAttributeRegExp({ operator: match[7], value: match[8] })
 					});
-				} else if (match[12] && match[13]) {
+				} else if (match[13] && match[14]) {
 					currentSelectorItem.pseudos = currentSelectorItem.pseudos || [];
-					currentSelectorItem.pseudos.push(this.getPseudo(match[12], match[13]));
-				} else if (match[14]) {
-					currentSelectorItem.pseudos = currentSelectorItem.pseudos || [];
-					currentSelectorItem.pseudos.push(this.getPseudo(match[14]));
+					currentSelectorItem.pseudos.push(this.getPseudo(match[13], match[14]));
 				} else if (match[15]) {
-					switch (match[15].trim()) {
+					currentSelectorItem.pseudos = currentSelectorItem.pseudos || [];
+					currentSelectorItem.pseudos.push(this.getPseudo(match[15]));
+				} else if (match[16]) {
+					switch (match[16].trim()) {
 						case ',':
 							currentSelectorItem = new SelectorItem({
 								combinator: SelectorCombinatorEnum.descendant
@@ -178,6 +189,47 @@ export default class SelectorParser {
 		return groups;
 	}
 
+	/**
+	 * Returns attribute RegExp.
+	 *
+	 * @param attribute Attribute.
+	 * @param attribute.value Attribute value.
+	 * @param attribute.operator Attribute operator.
+	 * @param attribute.modifier Attribute modifier.
+	 * @returns Attribute RegExp.
+	 */
+	private static getAttributeRegExp(attribute: {
+		value?: string;
+		operator?: string;
+		modifier?: string;
+	}): RegExp | null {
+		const modifier = attribute.modifier === 'i' ? 'i' : '';
+
+		if (!attribute.operator || !attribute.value) {
+			return null;
+		}
+
+		switch (attribute.operator) {
+			// [attribute~="value"] - Contains a specified word.
+			case '~':
+				return new RegExp(`[- ]${attribute.value}|${attribute.value}[- ]`, modifier);
+			// [attribute|="value"] - Starts with the specified word.
+			case '|':
+				return new RegExp(`^${attribute.value}[- ]`, modifier);
+			// [attribute^="value"] - Begins with a specified value.
+			case '^':
+				return new RegExp(`^${attribute.value}`, modifier);
+			// [attribute$="value"] - Ends with a specified value.
+			case '$':
+				return new RegExp(`${attribute.value}$`, modifier);
+			// [attribute*="value"] - Contains a specified value.
+			case '*':
+				return new RegExp(`${attribute.value}`, modifier);
+			default:
+				return null;
+		}
+	}
+
 	/**
 	 * Returns pseudo.
 	 *

package/src/xml-parser/XMLParser.ts

@@ -9,7 +9,7 @@ import PlainTextElements from '../config/PlainTextElements';
 import IDocumentType from '../nodes/document-type/IDocumentType';
 import INode from '../nodes/node/INode';
 import IDocumentFragment from '../nodes/document-fragment/IDocumentFragment';
-import { decode } from 'he';
+import * as Entities from 'entities';
 
 /**
  * Markup RegExp.
@@ -99,7 +99,7 @@ export default class XMLParser {
 							// Plain text between tags.
 
 							currentNode.appendChild(
-								document.createTextNode(xml.substring(lastIndex, match.index))
+								document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex, match.index)))
 							);
 						}
 
@@ -161,13 +161,17 @@ export default class XMLParser {
 							// Comment.
 
 							currentNode.appendChild(
-								document.createComment((match[6] ? '?' : '') + (match[3] || match[4] || match[6]))
+								document.createComment(
+									Entities.decodeHTML((match[6] ? '?' : '') + (match[3] || match[4] || match[6]))
+								)
 							);
 						} else if (match[5]) {
 							// Exclamation mark comment (usually <!DOCTYPE>).
 
+							const exclamationComment = Entities.decodeHTML(match[5]);
 							currentNode.appendChild(
-								this.getDocumentTypeNode(document, match[5]) || document.createComment(match[5])
+								this.getDocumentTypeNode(document, exclamationComment) ||
+									document.createComment(exclamationComment)
 							);
 						} else if (match[6]) {
 							// Processing instruction (not supported by HTML).
@@ -176,7 +180,9 @@ export default class XMLParser {
 							// Plain text between tags, including the match as it is not a valid start or end tag.
 
 							currentNode.appendChild(
-								document.createTextNode(xml.substring(lastIndex, markupRegexp.lastIndex))
+								document.createTextNode(
+									Entities.decodeHTML(xml.substring(lastIndex, markupRegexp.lastIndex))
+								)
 							);
 						}
 
@@ -205,7 +211,7 @@ export default class XMLParser {
 
 										const name = attributeMatch[1] || attributeMatch[5] || attributeMatch[9] || '';
 										const rawValue = attributeMatch[3] || attributeMatch[7] || '';
-										const value = rawValue ? decode(rawValue) : '';
+										const value = rawValue ? Entities.decodeHTMLAttribute(rawValue) : '';
 										const namespaceURI =
 											(<IElement>currentNode).tagName === 'SVG' && name === 'xmlns' ? value : null;
 
@@ -271,7 +277,9 @@ export default class XMLParser {
 
 							// Plain text elements such as <script> and <style> should only contain text.
 							currentNode.appendChild(
-								document.createTextNode(xml.substring(startTagIndex, match.index))
+								document.createTextNode(
+									Entities.decodeHTML(xml.substring(startTagIndex, match.index))
+								)
 							);
 
 							stack.pop();
@@ -289,7 +297,9 @@ export default class XMLParser {
 			if (lastIndex !== xml.length) {
 				// Plain text after tags.
 
-				currentNode.appendChild(document.createTextNode(xml.substring(lastIndex)));
+				currentNode.appendChild(
+					document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex)))
+				);
 			}
 		}
 

package/src/xml-serializer/XMLSerializer.ts

@@ -2,26 +2,48 @@ import Element from '../nodes/element/Element';
 import Node from '../nodes/node/Node';
 import VoidElements from '../config/VoidElements';
 import DocumentType from '../nodes/document-type/DocumentType';
-import { escape } from 'he';
 import INode from '../nodes/node/INode';
 import IElement from '../nodes/element/IElement';
 import IHTMLTemplateElement from '../nodes/html-template-element/IHTMLTemplateElement';
 import NodeTypeEnum from '../nodes/node/NodeTypeEnum';
 import IProcessingInstruction from '../nodes/processing-instruction/IProcessingInstruction';
+import * as Entities from 'entities';
 
 /**
  * Utility for converting an element to string.
  */
 export default class XMLSerializer {
+	public _options = {
+		includeShadowRoots: false,
+		escapeEntities: true
+	};
+
+	/**
+	 * Constructor.
+	 *
+	 * @param [options] Options.
+	 * @param [options.includeShadowRoots] Include shadow roots.
+	 * @param [options.escapeEntities] Escape text.
+	 */
+	constructor(options?: { includeShadowRoots?: boolean; escapeEntities?: boolean }) {
+		if (options) {
+			if (options.includeShadowRoots !== undefined) {
+				this._options.includeShadowRoots = options.includeShadowRoots;
+			}
+
+			if (options.escapeEntities !== undefined) {
+				this._options.escapeEntities = options.escapeEntities;
+			}
+		}
+	}
+
 	/**
 	 * Renders an element as HTML.
 	 *
 	 * @param root Root element.
-	 * @param [options] Options.
-	 * @param [options.includeShadowRoots] Set to "true" to include shadow roots.
 	 * @returns Result.
 	 */
-	public serializeToString(root: INode, options?: { includeShadowRoots?: boolean }): string {
+	public serializeToString(root: INode): string {
 		switch (root.nodeType) {
 			case NodeTypeEnum.elementNode:
 				const element = <Element>root;
@@ -38,14 +60,14 @@ export default class XMLSerializer {
 				let innerHTML = '';
 
 				for (const node of childNodes) {
-					innerHTML += this.serializeToString(node, options);
+					innerHTML += this.serializeToString(node);
 				}
 
-				if (options?.includeShadowRoots && element.shadowRoot) {
+				if (this._options.includeShadowRoots && element.shadowRoot) {
 					innerHTML += `<template shadowrootmode="${element.shadowRoot.mode}">`;
 
 					for (const node of element.shadowRoot.childNodes) {
-						innerHTML += this.serializeToString(node, options);
+						innerHTML += this.serializeToString(node);
 					}
 
 					innerHTML += '</template>';
@@ -56,7 +78,7 @@ export default class XMLSerializer {
 			case Node.DOCUMENT_NODE:
 				let html = '';
 				for (const node of root.childNodes) {
-					html += this.serializeToString(node, options);
+					html += this.serializeToString(node);
 				}
 				return html;
 			case NodeTypeEnum.commentNode:
@@ -65,7 +87,9 @@ export default class XMLSerializer {
 				// TODO: Add support for processing instructions.
 				return `<!--?${(<IProcessingInstruction>root).target} ${root.textContent}?-->`;
 			case NodeTypeEnum.textNode:
-				return root.textContent;
+				return this._options.escapeEntities
+					? Entities.escapeText(root.textContent)
+					: root.textContent;
 			case NodeTypeEnum.documentTypeNode:
 				const doctype = <DocumentType>root;
 				const identifier = doctype.publicId ? ' PUBLIC' : doctype.systemId ? ' SYSTEM' : '';
@@ -87,12 +111,15 @@ export default class XMLSerializer {
 		let attributeString = '';
 
 		if (!(<Element>element)._attributes.is && (<Element>element)._isValue) {
-			attributeString += ' is="' + escape((<Element>element)._isValue) + '"';
+			attributeString += ' is="' + (<Element>element)._isValue + '"';
 		}
 
 		for (const attribute of Object.values((<Element>element)._attributes)) {
 			if (attribute.value !== null) {
-				attributeString += ' ' + attribute.name + '="' + escape(attribute.value) + '"';
+				const escapedValue = this._options.escapeEntities
+					? Entities.escapeText(attribute.value)
+					: attribute.value;
+				attributeString += ' ' + attribute.name + '="' + escapedValue + '"';
 			}
 		}
 		return attributeString;