happy-dom 17.1.2 → 17.1.3

package/src/nodes/element/NamedNodeMap.ts

@@ -14,11 +14,14 @@ import StringUtility from '../../utilities/StringUtility.js';
 export default class NamedNodeMap {
 	[index: number]: Attr;
 
-	// All items with the namespaceURI as prefix
-	public [PropertySymbol.namespaceItems]: Map<string, Attr> = new Map();
+	// Items by attribute namespaceURI
+	public [PropertySymbol.itemsByNamespaceURI]: Map<string, Attr> = new Map();
 
-	// Items without namespaceURI as prefix, where the HTML namespace is the default namespace
-	public [PropertySymbol.namedItems]: Map<string, Attr[]> = new Map();
+	// Items by attribute name
+	public [PropertySymbol.itemsByName]: Map<string, Attr[]> = new Map();
+
+	// All items
+	public [PropertySymbol.items]: Map<string, Attr> = new Map();
 
 	public declare [PropertySymbol.ownerElement]: Element;
 
@@ -37,7 +40,7 @@ export default class NamedNodeMap {
 	 * @returns Length.
 	 */
 	public get length(): number {
-		return this[PropertySymbol.namespaceItems].size;
+		return this[PropertySymbol.items].size;
 	}
 
 	/**
@@ -64,7 +67,7 @@ export default class NamedNodeMap {
 	 * @returns Iterator.
 	 */
 	public [Symbol.iterator](): IterableIterator<Attr> {
-		return this[PropertySymbol.namespaceItems].values();
+		return this[PropertySymbol.items].values();
 	}
 
 	/**
@@ -73,7 +76,7 @@ export default class NamedNodeMap {
 	 * @param index Index.
 	 */
 	public item(index: number): Attr | null {
-		const items = Array.from(this[PropertySymbol.namespaceItems].values());
+		const items = Array.from(this[PropertySymbol.items].values());
 		return index >= 0 && items[index] ? items[index] : null;
 	}
 
@@ -91,9 +94,9 @@ export default class NamedNodeMap {
 				PropertySymbol.contentType
 			] === 'text/html'
 		) {
-			return this[PropertySymbol.namedItems].get(StringUtility.asciiLowerCase(name))?.[0] || null;
+			return this[PropertySymbol.itemsByName].get(StringUtility.asciiLowerCase(name))?.[0] || null;
 		}
-		return this[PropertySymbol.namedItems].get(name)?.[0] || null;
+		return this[PropertySymbol.itemsByName].get(name)?.[0] || null;
 	}
 
 	/**
@@ -104,11 +107,17 @@ export default class NamedNodeMap {
 	 * @returns Item.
 	 */
 	public getNamedItemNS(namespace: string, localName: string): Attr | null {
-		if (namespace === '') {
-			namespace = null;
+		const item = this[PropertySymbol.itemsByNamespaceURI].get(`${namespace || ''}:${localName}`);
+
+		// It seems like an item cant have a prefix without a namespaceURI
+		// E.g. element.setAttribute('ns1:key', 'value1');
+		// expect(element.attributes.getNamedItemNS(null, 'key')).toBeNull();
+
+		if (item && (!item[PropertySymbol.prefix] || item[PropertySymbol.namespaceURI])) {
+			return item;
 		}
 
-		return this[PropertySymbol.namespaceItems].get(`${namespace || ''}:${localName}`) || null;
+		return null;
 	}
 
 	/**
@@ -199,26 +208,29 @@ export default class NamedNodeMap {
 		const replacedItem =
 			this.getNamedItemNS(item[PropertySymbol.namespaceURI], item[PropertySymbol.localName]) ||
 			null;
-
-		const namedItems = this[PropertySymbol.namedItems].get(item[PropertySymbol.name]);
+		const itemsByName = this[PropertySymbol.itemsByName].get(item[PropertySymbol.name]);
 
 		if (replacedItem === item) {
 			return item;
 		}
 
-		this[PropertySymbol.namespaceItems].set(
+		this[PropertySymbol.itemsByNamespaceURI].set(
 			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.localName]}`,
 			item
 		);
+		this[PropertySymbol.items].set(
+			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.name]}`,
+			item
+		);
 
-		if (!namedItems?.length) {
-			this[PropertySymbol.namedItems].set(item[PropertySymbol.name], [item]);
+		if (!itemsByName?.length) {
+			this[PropertySymbol.itemsByName].set(item[PropertySymbol.name], [item]);
 		} else {
-			const index = namedItems.indexOf(replacedItem);
+			const index = itemsByName.indexOf(replacedItem);
 			if (index !== -1) {
-				namedItems.splice(index, 1);
+				itemsByName.splice(index, 1);
 			}
-			namedItems.push(item);
+			itemsByName.push(item);
 		}
 
 		if (!ignoreListeners) {
@@ -237,19 +249,22 @@ export default class NamedNodeMap {
 	public [PropertySymbol.removeNamedItem](item: Attr, ignoreListeners = false): void {
 		item[PropertySymbol.ownerElement] = null;
 
-		this[PropertySymbol.namespaceItems].delete(
+		this[PropertySymbol.itemsByNamespaceURI].delete(
 			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.localName]}`
 		);
+		this[PropertySymbol.items].delete(
+			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.name]}`
+		);
 
-		const namedItems = this[PropertySymbol.namedItems].get(item[PropertySymbol.name]);
+		const itemsByName = this[PropertySymbol.itemsByName].get(item[PropertySymbol.name]);
 
-		if (namedItems?.length) {
-			const index = namedItems.indexOf(item);
+		if (itemsByName?.length) {
+			const index = itemsByName.indexOf(item);
 			if (index !== -1) {
-				namedItems.splice(index, 1);
+				itemsByName.splice(index, 1);
 			}
-			if (!namedItems.length) {
-				this[PropertySymbol.namedItems].delete(item[PropertySymbol.name]);
+			if (!itemsByName.length) {
+				this[PropertySymbol.itemsByName].delete(item[PropertySymbol.name]);
 			}
 		}
 

package/src/nodes/element/NamedNodeMapProxyFactory.ts

@@ -21,7 +21,7 @@ export default class NamedNodeMapProxyFactory {
 		return new Proxy<NamedNodeMap>(namedNodeMap, {
 			get: (target, property) => {
 				if (property === 'length') {
-					return namedNodeMap[PropertySymbol.namedItems].size;
+					return namedNodeMap[PropertySymbol.items].size;
 				}
 				if (property in target || typeof property === 'symbol') {
 					methodBinder.bind(property);
@@ -29,7 +29,7 @@ export default class NamedNodeMapProxyFactory {
 				}
 				const index = Number(property);
 				if (!isNaN(index)) {
-					return Array.from(namedNodeMap[PropertySymbol.namedItems].values())[index]?.[0];
+					return target.item(index);
 				}
 				return target.getNamedItem(<string>property) || undefined;
 			},
@@ -57,8 +57,8 @@ export default class NamedNodeMapProxyFactory {
 				return true;
 			},
 			ownKeys(): string[] {
-				const keys = Array.from(namedNodeMap[PropertySymbol.namedItems].keys());
-				for (let i = 0, max = namedNodeMap[PropertySymbol.namedItems].size; i < max; i++) {
+				const keys = Array.from(namedNodeMap[PropertySymbol.items].keys());
+				for (let i = 0, max = namedNodeMap[PropertySymbol.items].size; i < max; i++) {
 					keys.push(String(i));
 				}
 				return keys;
@@ -68,13 +68,13 @@ export default class NamedNodeMapProxyFactory {
 					return false;
 				}
 
-				if (property in target || namedNodeMap[PropertySymbol.namedItems].has(property)) {
+				if (property in target || namedNodeMap[PropertySymbol.items].has(property)) {
 					return true;
 				}
 
 				const index = Number(property);
 
-				if (!isNaN(index) && index >= 0 && index < namedNodeMap[PropertySymbol.namedItems].size) {
+				if (!isNaN(index) && index >= 0 && index < namedNodeMap[PropertySymbol.items].size) {
 					return true;
 				}
 
@@ -96,21 +96,26 @@ export default class NamedNodeMapProxyFactory {
 				}
 
 				const index = Number(property);
-
-				if (!isNaN(index) && index >= 0 && index < namedNodeMap[PropertySymbol.namedItems].size) {
-					return {
-						value: Array.from(namedNodeMap[PropertySymbol.namedItems].values())[index][0],
-						writable: false,
-						enumerable: true,
-						configurable: true
-					};
+				if (!isNaN(index)) {
+					if (index >= 0) {
+						const itemByIndex = target.item(index);
+						if (itemByIndex) {
+							return {
+								value: itemByIndex,
+								writable: false,
+								enumerable: true,
+								configurable: true
+							};
+						}
+					}
+					return;
 				}
 
-				const namedItems = namedNodeMap[PropertySymbol.namedItems].get(<string>property);
+				const items = namedNodeMap[PropertySymbol.items].get(<string>property);
 
-				if (namedItems) {
+				if (items) {
 					return {
-						value: namedItems[0],
+						value: items,
 						writable: false,
 						enumerable: true,
 						configurable: true

package/src/nodes/html-element/HTMLElement.ts

@@ -649,14 +649,14 @@ export default class HTMLElement extends Element {
 		newElement[PropertySymbol.isValue] = this[PropertySymbol.isValue];
 		newElement[PropertySymbol.cache] = this[PropertySymbol.cache];
 		newElement[PropertySymbol.affectsCache] = this[PropertySymbol.affectsCache];
-		newElement[PropertySymbol.attributes][PropertySymbol.namedItems] =
-			this[PropertySymbol.attributes][PropertySymbol.namedItems];
-		newElement[PropertySymbol.attributes][PropertySymbol.namespaceItems] =
-			this[PropertySymbol.attributes][PropertySymbol.namespaceItems];
-
-		for (const attr of newElement[PropertySymbol.attributes][
-			PropertySymbol.namespaceItems
-		].values()) {
+		newElement[PropertySymbol.attributes][PropertySymbol.itemsByNamespaceURI] =
+			this[PropertySymbol.attributes][PropertySymbol.itemsByNamespaceURI];
+		newElement[PropertySymbol.attributes][PropertySymbol.itemsByName] =
+			this[PropertySymbol.attributes][PropertySymbol.itemsByName];
+		newElement[PropertySymbol.attributes][PropertySymbol.items] =
+			this[PropertySymbol.attributes][PropertySymbol.items];
+
+		for (const attr of newElement[PropertySymbol.attributes][PropertySymbol.items].values()) {
 			attr[PropertySymbol.ownerElement] = newElement;
 		}
 
@@ -677,8 +677,9 @@ export default class HTMLElement extends Element {
 		this[PropertySymbol.isValue] = null;
 		this[PropertySymbol.cache] = newCache;
 		this[PropertySymbol.affectsCache] = [];
-		this[PropertySymbol.attributes][PropertySymbol.namedItems] = new Map();
-		this[PropertySymbol.attributes][PropertySymbol.namespaceItems] = new Map();
+		this[PropertySymbol.attributes][PropertySymbol.itemsByNamespaceURI] = new Map();
+		this[PropertySymbol.attributes][PropertySymbol.itemsByName] = new Map();
+		this[PropertySymbol.attributes][PropertySymbol.items] = new Map();
 
 		for (const node of newElement[PropertySymbol.nodeArray]) {
 			node[PropertySymbol.parentNode] = newElement;

package/src/nodes/node/Node.ts

@@ -1102,13 +1102,13 @@ export default class Node extends EventTarget {
 				/**
 				 * 5.2.1. For each attr in node2’s attribute list:
 				 */
-				for (const attributes of Array.from(
-					(<Element>node2)[PropertySymbol.attributes][PropertySymbol.namedItems].values()
-				)) {
+				for (const attribute of (<Element>node2)[PropertySymbol.attributes][
+					PropertySymbol.items
+				].values()) {
 					/**
 					 * 5.2.1.1. If attr equals attr1, then return the result of adding DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and DOCUMENT_POSITION_PRECEDING.
 					 */
-					if (NodeUtility.isEqualNode(attributes[0], attr1)) {
+					if (NodeUtility.isEqualNode(attribute, attr1)) {
 						return (
 							Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | Node.DOCUMENT_POSITION_PRECEDING
 						);
@@ -1117,7 +1117,7 @@ export default class Node extends EventTarget {
 					/**
 					 * 5.2.1.2. If attr equals attr2, then return the result of adding DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and DOCUMENT_POSITION_FOLLOWING.
 					 */
-					if (NodeUtility.isEqualNode(attributes[0], attr2)) {
+					if (NodeUtility.isEqualNode(attribute, attr2)) {
 						return (
 							Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | Node.DOCUMENT_POSITION_FOLLOWING
 						);

package/src/nodes/node/NodeUtility.ts

@@ -200,19 +200,18 @@ export default class NodeUtility {
 	 */
 	public static attributeListsEqual(elementA: Element, elementB: Element): boolean {
 		const attributesA = Array.from(
-			elementA[PropertySymbol.attributes][PropertySymbol.namedItems].values()
+			elementA[PropertySymbol.attributes][PropertySymbol.items].values()
 		);
 		const attributesB = Array.from(
-			elementB[PropertySymbol.attributes][PropertySymbol.namedItems].values()
+			elementB[PropertySymbol.attributes][PropertySymbol.items].values()
 		);
 		for (const attributeA of attributesA) {
 			let found = false;
 			for (const attributeB of attributesB) {
 				if (
-					attributeA[0][PropertySymbol.namespaceURI] ===
-						attributeB[0][PropertySymbol.namespaceURI] &&
-					attributeA[0].localName === attributeB[0].localName &&
-					attributeA[0][PropertySymbol.value] === attributeB[0][PropertySymbol.value]
+					attributeA[PropertySymbol.namespaceURI] === attributeB[PropertySymbol.namespaceURI] &&
+					attributeA.localName === attributeB.localName &&
+					attributeA[PropertySymbol.value] === attributeB[PropertySymbol.value]
 				) {
 					found = true;
 					break;
@@ -258,8 +257,8 @@ export default class NodeUtility {
 					elementA[PropertySymbol.namespaceURI] !== elementB[PropertySymbol.namespaceURI] ||
 					elementA[PropertySymbol.prefix] !== elementB[PropertySymbol.prefix] ||
 					elementA[PropertySymbol.localName] !== elementB[PropertySymbol.localName] ||
-					elementA[PropertySymbol.attributes][PropertySymbol.namespaceItems].size !==
-						elementB[PropertySymbol.attributes][PropertySymbol.namespaceItems].size
+					elementA[PropertySymbol.attributes][PropertySymbol.items].size !==
+						elementB[PropertySymbol.attributes][PropertySymbol.items].size
 				) {
 					return false;
 				}

package/src/xml-parser/XMLParser.ts

@@ -533,8 +533,8 @@ export default class XMLParser {
 								);
 								this.nextElement[PropertySymbol.attributes] = attributes;
 								attributes[PropertySymbol.ownerElement] = this.nextElement;
-								for (const attr of attributes[PropertySymbol.namespaceItems].values()) {
-									attr[PropertySymbol.ownerElement] = this.nextElement;
+								for (const item of attributes[PropertySymbol.items].values()) {
+									item[PropertySymbol.ownerElement] = this.nextElement;
 								}
 							} else {
 								this.nextElement[PropertySymbol.namespaceURI] = value;

package/src/xml-serializer/XMLSerializer.ts

@@ -140,17 +140,15 @@ export default class XMLSerializer {
 		inheritedNamespacePrefixes: Map<string, string> | null
 	): Map<string, string> | null {
 		const namespacePrefixes = new Map<string, string>(inheritedNamespacePrefixes);
-		const namedItems = (<Element>element)[PropertySymbol.attributes][PropertySymbol.namedItems];
 
-		for (const attributes of namedItems.values()) {
+		for (const attribute of (<Element>element)[PropertySymbol.attributes][
+			PropertySymbol.items
+		].values()) {
 			if (
-				attributes[0][PropertySymbol.namespaceURI] === NamespaceURI.xmlns &&
-				attributes[0][PropertySymbol.prefix]
+				attribute[PropertySymbol.namespaceURI] === NamespaceURI.xmlns &&
+				attribute[PropertySymbol.prefix]
 			) {
-				namespacePrefixes.set(
-					attributes[0][PropertySymbol.value],
-					attributes[0][PropertySymbol.localName]
-				);
+				namespacePrefixes.set(attribute[PropertySymbol.value], attribute[PropertySymbol.localName]);
 			}
 		}
 
@@ -216,12 +214,11 @@ export default class XMLSerializer {
 		let attributeString = '';
 		let namespaceString = '';
 
-		const namedItems = (<Element>element)[PropertySymbol.attributes][PropertySymbol.namedItems];
 		const handledNamespaces = new Set();
 
-		for (const attributes of namedItems.values()) {
-			const attribute = attributes[0];
-
+		for (const attribute of (<Element>element)[PropertySymbol.attributes][
+			PropertySymbol.items
+		].values()) {
 			// Namespace attributes should be in the beginning of the string.
 			if (attribute[PropertySymbol.namespaceURI] === NamespaceURI.xmlns) {
 				if (