happy-dom 17.1.1 → 17.1.3

package/src/fetch/AbortSignal.ts

@@ -14,9 +14,9 @@ export default class AbortSignal extends EventTarget {
 	protected declare static [PropertySymbol.window]: BrowserWindow;
 	protected declare [PropertySymbol.window]: BrowserWindow;
 
-	// Public properties
-	public readonly aborted: boolean = false;
-	public readonly reason: Error | null = null;
+	// Internal properties
+	public [PropertySymbol.aborted]: boolean = false;
+	public [PropertySymbol.reason]: any = undefined;
 
 	// Events
 	public onabort: ((this: AbortSignal, event: Event) => void) | null = null;
@@ -28,9 +28,7 @@ export default class AbortSignal extends EventTarget {
 		super();
 
 		if (!this[PropertySymbol.window]) {
-			throw new TypeError(
-				`Failed to construct '${this.constructor.name}': '${this.constructor.name}' was constructed outside a Window context.`
-			);
+			throw new TypeError(`Failed to construct 'AbortSignal': Illegal constructor`);
 		}
 	}
 
@@ -41,22 +39,59 @@ export default class AbortSignal extends EventTarget {
 		return 'AbortSignal';
 	}
 
+	/**
+	 * Returns true if the signal has been aborted.
+	 *
+	 * @returns True if the signal has been aborted.
+	 */
+	public get aborted(): boolean {
+		return this[PropertySymbol.aborted];
+	}
+
+	/**
+	 * Setter for aborted. Value will be ignored as the property is read-only.
+	 *
+	 * @param _value Aborted.
+	 */
+	public set aborted(_value: boolean) {
+		// Do nothing
+	}
+
+	/**
+	 * Returns the reason the signal was aborted.
+	 *
+	 * @returns Reason.
+	 */
+	public get reason(): any {
+		return this[PropertySymbol.reason];
+	}
+
+	/**
+	 * Setter for reason. Value will be ignored as the property is read-only.
+	 *
+	 * @param _value Reason.
+	 */
+	public set reason(_value: any) {
+		// Do nothing
+	}
+
 	/**
 	 * Aborts the signal.
 	 *
 	 * @param [reason] Reason.
 	 */
-	public [PropertySymbol.abort](reason?: Error): void {
+	public [PropertySymbol.abort](reason?: any): void {
 		if (this.aborted) {
 			return;
 		}
-		(<Error>this.reason) =
-			reason ||
-			new this[PropertySymbol.window].DOMException(
-				'signal is aborted without reason',
-				DOMExceptionNameEnum.abortError
-			);
-		(<boolean>this.aborted) = true;
+		this[PropertySymbol.reason] =
+			reason !== undefined
+				? reason
+				: new this[PropertySymbol.window].DOMException(
+						'signal is aborted without reason',
+						DOMExceptionNameEnum.abortError
+					);
+		this[PropertySymbol.aborted] = true;
 		this.dispatchEvent(new Event('abort'));
 	}
 
@@ -75,15 +110,16 @@ export default class AbortSignal extends EventTarget {
 	 * @param [reason] Reason.
 	 * @returns AbortSignal instance.
 	 */
-	public static abort(reason?: Error): AbortSignal {
+	public static abort(reason?: any): AbortSignal {
 		const signal = new this();
-		(<Error>signal.reason) =
-			reason ||
-			new this[PropertySymbol.window].DOMException(
-				'signal is aborted without reason',
-				DOMExceptionNameEnum.abortError
-			);
-		(<boolean>signal.aborted) = true;
+		signal[PropertySymbol.reason] =
+			reason !== undefined
+				? reason
+				: new this[PropertySymbol.window].DOMException(
+						'signal is aborted without reason',
+						DOMExceptionNameEnum.abortError
+					);
+		signal[PropertySymbol.aborted] = true;
 		return signal;
 	}
 
@@ -118,8 +154,8 @@ export default class AbortSignal extends EventTarget {
 	 */
 	public static any(signals: AbortSignal[]): AbortSignal {
 		for (const signal of signals) {
-			if (signal.aborted) {
-				return this.abort(signal.reason);
+			if (signal[PropertySymbol.aborted]) {
+				return this.abort(signal[PropertySymbol.reason]);
 			}
 		}
 
@@ -135,7 +171,7 @@ export default class AbortSignal extends EventTarget {
 		for (const signal of signals) {
 			const handler = (): void => {
 				stopListening();
-				anySignal[PropertySymbol.abort](signal.reason);
+				anySignal[PropertySymbol.abort](signal[PropertySymbol.reason]);
 			};
 			handlers.set(signal, handler);
 			signal.addEventListener('abort', handler);

package/src/fetch/Fetch.ts

@@ -134,9 +134,12 @@ export default class Fetch {
 
 		FetchRequestValidationUtility.validateSchema(this.request);
 
-		if (this.request.signal.aborted) {
-			throw new this.#window.DOMException(
-				'The operation was aborted.',
+		if (this.request.signal[PropertySymbol.aborted]) {
+			if (this.request.signal[PropertySymbol.reason] !== undefined) {
+				throw this.request.signal[PropertySymbol.reason];
+			}
+			throw new this[PropertySymbol.window].DOMException(
+				'signal is aborted without reason',
 				DOMExceptionNameEnum.abortError
 			);
 		}
@@ -947,8 +950,8 @@ export default class Fetch {
 					headers.delete('cookie2');
 				}
 
-				if (this.request.signal.aborted) {
-					this.abort();
+				if (this.request.signal[PropertySymbol.aborted]) {
+					this.abort(this.request.signal[PropertySymbol.reason]);
 					return true;
 				}
 
@@ -1006,7 +1009,7 @@ export default class Fetch {
 	 *
 	 * @param reason Reason.
 	 */
-	private abort(reason?: Error): void {
+	private abort(reason?: any): void {
 		const error = new this.#window.DOMException(
 			'The operation was aborted.' + (reason ? ' ' + reason.toString() : ''),
 			DOMExceptionNameEnum.abortError
@@ -1034,7 +1037,7 @@ export default class Fetch {
 		}
 
 		if (this.reject) {
-			this.reject(error);
+			this.reject(reason !== undefined ? reason : error);
 		}
 	}
 }

package/src/fetch/SyncFetch.ts

@@ -113,9 +113,12 @@ export default class SyncFetch {
 
 		FetchRequestValidationUtility.validateSchema(this.request);
 
-		if (this.request.signal.aborted) {
-			throw new this.#window.DOMException(
-				'The operation was aborted.',
+		if (this.request.signal[PropertySymbol.aborted]) {
+			if (this.request.signal[PropertySymbol.reason] !== undefined) {
+				throw this.request.signal[PropertySymbol.reason];
+			}
+			throw new this[PropertySymbol.window].DOMException(
+				'signal is aborted without reason',
 				DOMExceptionNameEnum.abortError
 			);
 		}

package/src/html-serializer/HTMLSerializer.ts

@@ -143,18 +143,18 @@ export default class HTMLSerializer {
 	private getAttributes(element: Element): string {
 		let attributeString = '';
 
-		const namedItems = (<Element>element)[PropertySymbol.attributes][PropertySymbol.namedItems];
+		const attributes = (<Element>element)[PropertySymbol.attributes][PropertySymbol.items];
 
-		if (!namedItems.has('is') && element[PropertySymbol.isValue]) {
+		if (!attributes.has(':is') && element[PropertySymbol.isValue]) {
 			attributeString +=
 				' is="' + XMLEncodeUtility.encodeHTMLAttributeValue(element[PropertySymbol.isValue]) + '"';
 		}
 
-		for (const attributes of namedItems.values()) {
+		for (const attribute of attributes.values()) {
 			const escapedValue = XMLEncodeUtility.encodeHTMLAttributeValue(
-				attributes[0][PropertySymbol.value]
+				attribute[PropertySymbol.value]
 			);
-			attributeString += ' ' + attributes[0][PropertySymbol.name] + '="' + escapedValue + '"';
+			attributeString += ' ' + attribute[PropertySymbol.name] + '="' + escapedValue + '"';
 		}
 
 		return attributeString;

package/src/nodes/document/Document.ts

@@ -50,6 +50,7 @@ import SVGElementConfig from '../../config/SVGElementConfig.js';
 import StringUtility from '../../utilities/StringUtility.js';
 import HTMLParser from '../../html-parser/HTMLParser.js';
 import PreloadEntry from '../../fetch/preload/PreloadEntry.js';
+import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
 
 const PROCESSING_INSTRUCTION_TARGET_REGEXP = /^[a-z][a-z0-9-]+$/;
 
@@ -1222,7 +1223,17 @@ export default class Document extends Node {
 	 * @returns Attribute.
 	 */
 	public createAttribute(qualifiedName: string): Attr {
-		return this.createAttributeNS(null, StringUtility.asciiLowerCase(qualifiedName));
+		// We should use the NodeFactory and not the class constructor, so that owner document will be this document
+		const attribute = NodeFactory.createNode(this, this[PropertySymbol.window].Attr);
+
+		const name = StringUtility.asciiLowerCase(qualifiedName);
+		const parts = name.split(':');
+
+		attribute[PropertySymbol.name] = name;
+		attribute[PropertySymbol.localName] = parts[1] ?? name;
+		attribute[PropertySymbol.prefix] = parts[1] ? parts[0] : null;
+
+		return attribute;
 	}
 
 	/**
@@ -1237,11 +1248,21 @@ export default class Document extends Node {
 		const attribute = NodeFactory.createNode(this, this[PropertySymbol.window].Attr);
 
 		const parts = qualifiedName.split(':');
+
 		attribute[PropertySymbol.namespaceURI] = namespaceURI;
 		attribute[PropertySymbol.name] = qualifiedName;
 		attribute[PropertySymbol.localName] = parts[1] ?? qualifiedName;
 		attribute[PropertySymbol.prefix] = parts[1] ? parts[0] : null;
 
+		if (!namespaceURI && attribute[PropertySymbol.prefix]) {
+			throw new this[PropertySymbol.window].DOMException(
+				`Failed to execute 'createAttributeNS' on 'Document': The namespace URI provided ('${
+					namespaceURI || ''
+				}') is not valid for the qualified name provided ('${qualifiedName}').`,
+				DOMExceptionNameEnum.namespaceError
+			);
+		}
+
 		return attribute;
 	}
 

package/src/nodes/element/Element.ts

@@ -33,6 +33,7 @@ import HTMLSerializer from '../../html-serializer/HTMLSerializer.js';
 import HTMLParser from '../../html-parser/HTMLParser.js';
 import IScrollToOptions from '../../window/IScrollToOptions.js';
 import { AttributeUtility } from '../../utilities/AttributeUtility.js';
+import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
 
 type InsertAdjacentPosition = 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend';
 
@@ -545,9 +546,17 @@ export default class Element
 			clone[PropertySymbol.shadowRoot][PropertySymbol.host] = clone;
 		}
 
-		for (const item of this[PropertySymbol.attributes][PropertySymbol.namespaceItems].values()) {
-			clone[PropertySymbol.attributes].setNamedItem(item.cloneNode());
-		}
+		clone[PropertySymbol.attributes][PropertySymbol.itemsByNamespaceURI] = new Map(
+			this[PropertySymbol.attributes][PropertySymbol.itemsByNamespaceURI]
+		);
+
+		clone[PropertySymbol.attributes][PropertySymbol.itemsByName] = new Map(
+			this[PropertySymbol.attributes][PropertySymbol.itemsByName]
+		);
+
+		clone[PropertySymbol.attributes][PropertySymbol.items] = new Map(
+			this[PropertySymbol.attributes][PropertySymbol.items]
+		);
 
 		return <Element>clone;
 	}
@@ -704,6 +713,12 @@ export default class Element
 	 */
 	public setAttributeNS(namespaceURI: string, name: string, value: string): void {
 		const attribute = this[PropertySymbol.ownerDocument].createAttributeNS(namespaceURI, name);
+		if (!namespaceURI && attribute[PropertySymbol.prefix]) {
+			throw new this[PropertySymbol.window].DOMException(
+				`Failed to execute 'setAttributeNS' on 'Element': '' is an invalid namespace for attributes.`,
+				DOMExceptionNameEnum.namespaceError
+			);
+		}
 		attribute[PropertySymbol.value] = String(value);
 		this[PropertySymbol.attributes].setNamedItemNS(attribute);
 	}
@@ -715,7 +730,7 @@ export default class Element
 	 */
 	public getAttributeNames(): string[] {
 		const names = [];
-		for (const item of this[PropertySymbol.attributes][PropertySymbol.namespaceItems].values()) {
+		for (const item of this[PropertySymbol.attributes][PropertySymbol.items].values()) {
 			names.push(item[PropertySymbol.name]);
 		}
 		return names;
@@ -799,7 +814,7 @@ export default class Element
 	 * @returns "true" if the element has attributes.
 	 */
 	public hasAttributes(): boolean {
-		return this[PropertySymbol.attributes][PropertySymbol.namespaceItems].size > 0;
+		return this[PropertySymbol.attributes][PropertySymbol.items].size > 0;
 	}
 
 	/**

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;