happy-dom 14.12.3 → 15.0.0

package/src/window/CrossOriginBrowserWindow.ts

@@ -3,6 +3,7 @@ import BrowserWindow from './BrowserWindow.js';
 import DOMException from '../exception/DOMException.js';
 import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
 import Location from '../location/Location.js';
+import * as PropertySymbol from '../PropertySymbol.js';
 
 /**
  * Browser window with limited access due to CORS restrictions in iframes.
@@ -11,11 +12,15 @@ export default class CrossOriginBrowserWindow
 	extends EventTarget
 	implements CrossOriginBrowserWindow
 {
-	public readonly self = this;
 	public readonly window = this;
-	public readonly parent: BrowserWindow | CrossOriginBrowserWindow;
-	public readonly top: BrowserWindow | CrossOriginBrowserWindow;
 	public readonly location: Location;
+
+	// Internal properties
+	public [PropertySymbol.self]: BrowserWindow | CrossOriginBrowserWindow = this;
+	public declare [PropertySymbol.top]: BrowserWindow | CrossOriginBrowserWindow;
+	public declare [PropertySymbol.parent]: BrowserWindow | CrossOriginBrowserWindow;
+
+	// Private properties
 	#targetWindow: BrowserWindow;
 
 	/**
@@ -27,8 +32,9 @@ export default class CrossOriginBrowserWindow
 	constructor(target: BrowserWindow, parent?: BrowserWindow) {
 		super();
 
-		this.parent = parent ?? this;
-		this.top = parent ?? this;
+		this[PropertySymbol.parent] = parent ?? this;
+		this[PropertySymbol.top] = parent ?? this;
+
 		this.location = <Location>new Proxy(
 			{},
 			{
@@ -49,6 +55,51 @@ export default class CrossOriginBrowserWindow
 		this.#targetWindow = target;
 	}
 
+	/**
+	 * Returns self.
+	 *
+	 * @returns Self.
+	 */
+	public get self(): BrowserWindow | CrossOriginBrowserWindow {
+		return this[PropertySymbol.self];
+	}
+
+	/**
+	 * Returns self.
+	 *
+	 * @param self Self.
+	 */
+	public set self(self: BrowserWindow | CrossOriginBrowserWindow | null) {
+		this[PropertySymbol.self] = self;
+	}
+
+	/**
+	 * Returns top.
+	 *
+	 * @returns Top.
+	 */
+	public get top(): BrowserWindow | CrossOriginBrowserWindow {
+		return this[PropertySymbol.top];
+	}
+
+	/**
+	 * Returns parent.
+	 *
+	 * @returns Parent.
+	 */
+	public get parent(): BrowserWindow | CrossOriginBrowserWindow {
+		return this[PropertySymbol.parent];
+	}
+
+	/**
+	 * Returns parent.
+	 *
+	 * @param parent Parent.
+	 */
+	public set parent(parent: BrowserWindow | null) {
+		this[PropertySymbol.parent] = parent;
+	}
+
 	/**
 	 * Returns the opener.
 	 *

package/src/xml-parser/XMLParser.ts

@@ -81,6 +81,7 @@ export default class XMLParser {
 		const stackTagNames: string[] = [];
 		const markupRegexp = new RegExp(MARKUP_REGEXP, 'gm');
 		const { evaluateScripts = false } = options || {};
+		let newNode: Node | null = null;
 		let currentNode: Node | null = root;
 		let match: RegExpExecArray;
 		let readState: MarkupReadStateEnum = MarkupReadStateEnum.startOrEndTag;
@@ -98,9 +99,9 @@ export default class XMLParser {
 							(match[1] || match[2] || match[3] || match[4] || match[5] !== undefined || match[6])
 						) {
 							// Plain text between tags.
-
-							currentNode.appendChild(
-								document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex, match.index)))
+							currentNode[PropertySymbol.appendChild](
+								document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex, match.index))),
+								true
 							);
 						}
 
@@ -108,34 +109,6 @@ export default class XMLParser {
 							// Start tag.
 							const tagName = match[1].toUpperCase();
 							const localName = tagName === 'SVG' ? 'svg' : match[1];
-							const config = HTMLElementConfig[localName];
-
-							// Some elements are not allowed to be nested (e.g. "<a><a></a></a>" is not allowed.).
-							// Therefore we need to auto-close the tag, so that it become valid (e.g. "<a></a><a></a>").
-							if (
-								config?.contentModel ===
-									HTMLElementConfigContentModelEnum.noFirstLevelSelfDescendants &&
-								stackTagNames[stackTagNames.length - 1] === tagName
-							) {
-								stack.pop();
-								stackTagNames.pop();
-								currentNode = stack[stack.length - 1] || root;
-							} else if (
-								config?.contentModel === HTMLElementConfigContentModelEnum.noSelfDescendants &&
-								stackTagNames.includes(tagName)
-							) {
-								while (currentNode !== root) {
-									if ((<Element>currentNode)[PropertySymbol.tagName].toUpperCase() === tagName) {
-										stack.pop();
-										stackTagNames.pop();
-										currentNode = stack[stack.length - 1] || root;
-										break;
-									}
-									stack.pop();
-									stackTagNames.pop();
-									currentNode = stack[stack.length - 1] || root;
-								}
-							}
 
 							// NamespaceURI is inherited from the parent element.
 							// NamespaceURI should be SVG for SVGSVGElement.
@@ -143,12 +116,10 @@ export default class XMLParser {
 								tagName === 'SVG'
 									? NamespaceURI.svg
 									: (<Element>currentNode)[PropertySymbol.namespaceURI] || NamespaceURI.html;
-							const newElement = document.createElementNS(namespaceURI, localName);
 
-							currentNode.appendChild(newElement);
-							currentNode = newElement;
-							stack.push(currentNode);
-							stackTagNames.push(tagName);
+							// Create a new element.
+							newNode = document.createElementNS(namespaceURI, localName);
+
 							readState = MarkupReadStateEnum.insideStartTag;
 							startTagIndex = markupRegexp.lastIndex;
 						} else if (match[2]) {
@@ -180,14 +151,18 @@ export default class XMLParser {
 								comment = '?' + match[6];
 							}
 
-							currentNode.appendChild(document.createComment(Entities.decodeHTML(comment)));
+							currentNode[PropertySymbol.appendChild](
+								document.createComment(Entities.decodeHTML(comment)),
+								true
+							);
 						} else if (match[5] !== undefined) {
 							// Exclamation mark comment.
 							// Document type node or comment.
 							const exclamationComment = Entities.decodeHTML(match[5]);
-							currentNode.appendChild(
+							currentNode[PropertySymbol.appendChild](
 								this.getDocumentTypeNode(document, exclamationComment) ||
-									document.createComment(exclamationComment)
+									document.createComment(exclamationComment),
+								true
 							);
 						} else if (match[6]) {
 							// Processing instruction (not supported by HTML).
@@ -195,10 +170,11 @@ export default class XMLParser {
 						} else {
 							// Plain text between tags, including the match as it is not a valid start or end tag.
 
-							currentNode.appendChild(
+							currentNode[PropertySymbol.appendChild](
 								document.createTextNode(
 									Entities.decodeHTML(xml.substring(lastIndex, markupRegexp.lastIndex))
-								)
+								),
+								true
 							);
 						}
 
@@ -223,7 +199,6 @@ export default class XMLParser {
 										attributeMatch[9]
 									) {
 										// Valid attribute name and value.
-
 										const name =
 											attributeMatch[1] ||
 											attributeMatch[3] ||
@@ -234,14 +209,23 @@ export default class XMLParser {
 											attributeMatch[2] || attributeMatch[4] || attributeMatch[7] || '';
 										const value = rawValue ? Entities.decodeHTMLAttribute(rawValue) : '';
 
-										// In XML and SVG namespaces, the attribute "xmlns" should be set to the "http://www.w3.org/2000/xmlns/" namespace.
-										const namespaceURI =
-											(<Element>currentNode)[PropertySymbol.namespaceURI] === NamespaceURI.svg &&
-											name === 'xmlns'
-												? NamespaceURI.xmlns
-												: null;
-
-										(<Element>currentNode).setAttributeNS(namespaceURI, name, value);
+										if ((<Element>newNode)[PropertySymbol.namespaceURI] === NamespaceURI.svg) {
+											// In XML and SVG namespaces, the attribute "xmlns" should be set to the "http://www.w3.org/2000/xmlns/" namespace.
+											const attributeItem = document.createAttributeNS(
+												name === 'xmlns' ? NamespaceURI.xmlns : null,
+												name
+											);
+											attributeItem[PropertySymbol.value] = value;
+											(<Element>newNode)[PropertySymbol.attributes][PropertySymbol.setNamedItem](
+												attributeItem
+											);
+										} else {
+											const attributeItem = document.createAttribute(name);
+											attributeItem[PropertySymbol.value] = value;
+											(<Element>newNode)[PropertySymbol.attributes][PropertySymbol.setNamedItem](
+												attributeItem
+											);
+										}
 
 										startTagIndex += attributeMatch[0].length;
 									} else if (
@@ -250,7 +234,6 @@ export default class XMLParser {
 											(attributeMatch[6] && !attributeMatch[8]))
 									) {
 										// End attribute apostrophe is missing (e.g. "attr='value" or 'attr="value').
-
 										hasAttributeStringEnded = false;
 										break;
 									}
@@ -260,7 +243,42 @@ export default class XMLParser {
 							// We need to check if the attribute string is read completely.
 							// The attribute string can potentially contain "/>" or ">".
 							if (hasAttributeStringEnded) {
-								const config = HTMLElementConfig[(<Element>currentNode)[PropertySymbol.localName]];
+								const config = HTMLElementConfig[(<Element>newNode)[PropertySymbol.localName]];
+								const tagName = (<Element>newNode)[PropertySymbol.tagName];
+
+								// Some elements are not allowed to be nested (e.g. "<a><a></a></a>" is not allowed.).
+								// Therefore we need to auto-close the tag, so that it become valid (e.g. "<a></a><a></a>").
+								if (
+									config?.contentModel ===
+										HTMLElementConfigContentModelEnum.noFirstLevelSelfDescendants &&
+									stackTagNames[stackTagNames.length - 1] === tagName
+								) {
+									stack.pop();
+									stackTagNames.pop();
+									currentNode = stack[stack.length - 1] || root;
+								} else if (
+									config?.contentModel === HTMLElementConfigContentModelEnum.noSelfDescendants &&
+									stackTagNames.includes(tagName)
+								) {
+									while (currentNode !== root) {
+										if ((<Element>currentNode)[PropertySymbol.tagName].toUpperCase() === tagName) {
+											stack.pop();
+											stackTagNames.pop();
+											currentNode = stack[stack.length - 1] || root;
+											break;
+										}
+										stack.pop();
+										stackTagNames.pop();
+										currentNode = stack[stack.length - 1] || root;
+									}
+								}
+
+								// Appends the new node to its parent and sets is as current node.
+								currentNode[PropertySymbol.appendChild](newNode, true);
+								currentNode = newNode;
+								stack.push(currentNode);
+								stackTagNames.push(tagName);
+								newNode = null;
 
 								// Checks if the tag is a self closing tag (ends with "/>") or void element.
 								// When it is a self closing tag or void element it should be closed immediately.
@@ -305,10 +323,11 @@ export default class XMLParser {
 							}
 
 							// Plain text elements such as <script> and <style> should only contain text.
-							currentNode.appendChild(
+							currentNode[PropertySymbol.appendChild](
 								document.createTextNode(
 									Entities.decodeHTML(xml.substring(startTagIndex, match.index))
-								)
+								),
+								true
 							);
 
 							stack.pop();
@@ -323,11 +342,18 @@ export default class XMLParser {
 				lastIndex = markupRegexp.lastIndex;
 			}
 
+			// We expected the "newNode" to be null if the start tag was closed correctly.
+			// We should append the last node to the current node to correct it.
+			if (newNode && currentNode) {
+				currentNode[PropertySymbol.appendChild](newNode, true);
+			}
+
 			if (lastIndex !== xml.length) {
 				// Plain text after tags.
 
-				currentNode.appendChild(
-					document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex)))
+				currentNode[PropertySymbol.appendChild](
+					document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex))),
+					true
 				);
 			}
 		}

package/src/xml-serializer/XMLSerializer.ts

@@ -15,30 +15,16 @@ import HTMLElementConfigContentModelEnum from '../config/HTMLElementConfigConten
  * Utility for converting an element to string.
  */
 export default class XMLSerializer {
-	private options = {
-		includeShadowRoots: false,
-		escapeEntities: true
+	public [PropertySymbol.options]: {
+		serializableShadowRoots: boolean;
+		shadowRoots: ShadowRoot[] | null;
+		allShadowRoots: boolean;
+	} = {
+		serializableShadowRoots: false,
+		shadowRoots: null,
+		allShadowRoots: false
 	};
 
-	/**
-	 * 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.
 	 *
@@ -46,6 +32,8 @@ export default class XMLSerializer {
 	 * @returns Result.
 	 */
 	public serializeToString(root: Node): string {
+		const options = this[PropertySymbol.options];
+
 		switch (root[PropertySymbol.nodeType]) {
 			case NodeTypeEnum.elementNode:
 				const element = <Element>root;
@@ -58,20 +46,26 @@ export default class XMLSerializer {
 
 				const childNodes =
 					localName === 'template'
-						? (<DocumentFragment>(<HTMLTemplateElement>root).content)[PropertySymbol.childNodes]
-						: (<DocumentFragment>root)[PropertySymbol.childNodes];
+						? (<DocumentFragment>(<HTMLTemplateElement>root).content)[PropertySymbol.nodeArray]
+						: (<DocumentFragment>root)[PropertySymbol.nodeArray];
 				let innerHTML = '';
 
 				for (const node of childNodes) {
 					innerHTML += this.serializeToString(node);
 				}
 
-				// TODO: Should we include closed shadow roots?
-				// We are currently only including open shadow roots.
-				if (this.options.includeShadowRoots && element.shadowRoot) {
-					innerHTML += `<template shadowrootmode="${element.shadowRoot[PropertySymbol.mode]}">`;
-
-					for (const node of (<ShadowRoot>element.shadowRoot)[PropertySymbol.childNodes]) {
+				// TODO: Should we include closed shadow roots? We are currently only including open shadow roots.
+				if (
+					element.shadowRoot &&
+					(options.allShadowRoots ||
+						(options.serializableShadowRoots && element.shadowRoot[PropertySymbol.serializable]) ||
+						options.shadowRoots?.includes(element.shadowRoot))
+				) {
+					innerHTML += `<template shadowrootmode="${element.shadowRoot[PropertySymbol.mode]}"${
+						element.shadowRoot[PropertySymbol.serializable] ? ' shadowrootserializable=""' : ''
+					}>`;
+
+					for (const node of (<ShadowRoot>element.shadowRoot)[PropertySymbol.nodeArray]) {
 						innerHTML += this.serializeToString(node);
 					}
 
@@ -82,7 +76,7 @@ export default class XMLSerializer {
 			case Node.DOCUMENT_FRAGMENT_NODE:
 			case Node.DOCUMENT_NODE:
 				let html = '';
-				for (const node of (<Node>root)[PropertySymbol.childNodes]) {
+				for (const node of (<Node>root)[PropertySymbol.nodeArray]) {
 					html += this.serializeToString(node);
 				}
 				return html;
@@ -92,9 +86,7 @@ export default class XMLSerializer {
 				// TODO: Add support for processing instructions.
 				return `<!--?${(<ProcessingInstruction>root).target} ${root.textContent}?-->`;
 			case NodeTypeEnum.textNode:
-				return this.options.escapeEntities
-					? Entities.escapeText(root.textContent)
-					: root.textContent;
+				return Entities.escapeText(root.textContent);
 			case NodeTypeEnum.documentTypeNode:
 				const doctype = <DocumentType>root;
 				const identifier = doctype.publicId ? ' PUBLIC' : doctype.systemId ? ' SYSTEM' : '';
@@ -122,14 +114,11 @@ export default class XMLSerializer {
 			attributeString += ' is="' + (<Element>element)[PropertySymbol.isValue] + '"';
 		}
 
-		for (let i = 0, max = (<Element>element)[PropertySymbol.attributes].length; i < max; i++) {
-			const attribute = (<Element>element)[PropertySymbol.attributes][i];
-			if (attribute[PropertySymbol.value] !== null) {
-				const escapedValue = this.options.escapeEntities
-					? Entities.escapeText(attribute[PropertySymbol.value])
-					: attribute[PropertySymbol.value];
-				attributeString += ' ' + attribute[PropertySymbol.name] + '="' + escapedValue + '"';
-			}
+		for (const attribute of (<Element>element)[PropertySymbol.attributes][
+			PropertySymbol.namedItems
+		].values()) {
+			const escapedValue = Entities.escapeAttribute(attribute[PropertySymbol.value]);
+			attributeString += ' ' + attribute[PropertySymbol.name] + '="' + escapedValue + '"';
 		}
 
 		return attributeString;

package/tsconfig.json

@@ -2,7 +2,7 @@
 	"compilerOptions": {
 		"outDir": "lib",
 		"rootDir": "src",
-		"target": "ES2020",
+		"target": "ES2022",
 		"declaration": true,
 		"declarationMap": true,
 		"module": "Node16",
@@ -21,7 +21,7 @@
 		"composite": false,
 		"incremental": false,
         "lib": [
-            "es2020"
+            "ES2022"
         ],
 		"types": [
 			"node"

package/vitest.config.ts

@@ -5,6 +5,7 @@ export default defineConfig({
 		environment: 'node',
 		include: ['./test/**/*.test.ts'],
 		setupFiles: ['./test/setup.ts'],
-		testTimeout: 500
+		testTimeout: 500,
+		restoreMocks: true
 	}
 });