buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/nodes/element/ElementEventAttributeUtility.ts

@@ -0,0 +1,96 @@
+import BrowserErrorCaptureEnum from '../../browser/enums/BrowserErrorCaptureEnum.js';
+import WindowBrowserContext from '../../window/WindowBrowserContext.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type Event from '../../event/Event.js';
+import type Element from './Element.js';
+
+/**
+ * ECMAScript module compiler.
+ */
+export default class ElementEventAttributeUtility {
+	/**
+	 * Evaluates code in attribute and returns event listener.
+	 *
+	 * @param element
+	 * @param property Property.
+	 * @returns Result.
+	 */
+	public static getEventListener(
+		element: Element,
+		property: string
+	): ((event: Event) => void) | null {
+		const cached = element[PropertySymbol.propertyEventListeners].get(property);
+		if (cached) {
+			return cached;
+		}
+
+		const window = element[PropertySymbol.ownerDocument][PropertySymbol.defaultView];
+
+		if (!window) {
+			return null;
+		}
+
+		const browserSettings = new WindowBrowserContext(window).getSettings();
+
+		if (!browserSettings || !browserSettings.enableJavaScriptEvaluation) {
+			return null;
+		}
+
+		const code = element.getAttribute(property);
+
+		if (!code) {
+			return null;
+		}
+
+		let newCode = `(function anonymous($happy_dom, event) {`;
+
+		if (
+			browserSettings &&
+			!browserSettings.disableErrorCapturing &&
+			browserSettings.errorCapture === BrowserErrorCaptureEnum.tryAndCatch
+		) {
+			newCode += 'try {\n';
+		}
+
+		newCode += code;
+
+		if (
+			browserSettings &&
+			!browserSettings.disableErrorCapturing &&
+			browserSettings.errorCapture === BrowserErrorCaptureEnum.tryAndCatch
+		) {
+			newCode += '} catch(e) { $happy_dom.dispatchError(e); }';
+		}
+
+		newCode += '})';
+
+		let listener: ((event: Event) => void) | null = null;
+
+		try {
+			listener = window[PropertySymbol.evaluateScript](newCode, {
+				filename: window.location.href
+			}).bind(element, {
+				dispatchError: window[PropertySymbol.dispatchError].bind(window)
+			});
+		} catch (e) {
+			const error = new window.SyntaxError(
+				`Failed to read the '${property}' property from '${element.constructor.name}': ${(<Error>e).message}`
+			);
+			if (
+				browserSettings.disableErrorCapturing ||
+				browserSettings.errorCapture !== BrowserErrorCaptureEnum.tryAndCatch
+			) {
+				throw error;
+			} else {
+				window[PropertySymbol.dispatchError](error);
+				return null;
+			}
+		}
+
+		if (listener) {
+			element[PropertySymbol.propertyEventListeners].set(property, listener);
+		}
+
+		return listener;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/element/HTMLCollection.ts

@@ -0,0 +1,228 @@
+import ClassMethodBinder from '../../utilities/ClassMethodBinder.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type Element from './Element.js';
+
+/**
+ * HTMLCollection.
+ *
+ * We are extending Array here to improve performance.
+ * However, we should not expose Array methods to the outside.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection
+ */
+export default class HTMLCollection<T extends Element, NamedItem = T> {
+	[index: number]: T;
+	protected [PropertySymbol.query]: () => T[];
+
+	/**
+	 * Constructor.
+	 *
+	 * @param illegalConstructorSymbol Illegal constructor symbol.
+	 * @param query Query function.
+	 */
+	constructor(illegalConstructorSymbol: symbol, query: () => T[]) {
+		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+			throw new TypeError('Illegal constructor');
+		}
+
+		this[PropertySymbol.query] = query;
+
+		const methodBinder = new ClassMethodBinder(
+			this,
+			this.constructor !== HTMLCollection ? [this.constructor, HTMLCollection] : [HTMLCollection]
+		);
+
+		return new Proxy(this, {
+			get: (target, property) => {
+				if (property === 'length') {
+					return query().length;
+				}
+				if (property in target || typeof property === 'symbol') {
+					methodBinder.bind(property);
+					return (<any>target)[property];
+				}
+				const index = Number(property);
+				if (!isNaN(index)) {
+					return query()[index];
+				}
+				return target.namedItem(<string>property) || undefined;
+			},
+			set(target, property, newValue): boolean {
+				methodBinder.bind(property);
+				if (typeof property === 'symbol') {
+					(<any>target)[property] = newValue;
+					return true;
+				}
+				const index = Number(property);
+				if (isNaN(index)) {
+					(<any>target)[property] = newValue;
+				}
+				return true;
+			},
+			deleteProperty(target, property): boolean {
+				if (typeof property === 'symbol') {
+					delete (<any>target)[property];
+					return true;
+				}
+				const index = Number(property);
+				if (isNaN(index)) {
+					delete (<any>target)[property];
+				}
+				return true;
+			},
+			ownKeys(): string[] {
+				const keys: string[] = [];
+				const items = query();
+				for (let i = 0; i < items.length; i++) {
+					const item = items[i];
+					const name = item.getAttribute('id') || item.getAttribute('name');
+					keys.push(String(i));
+
+					if (name) {
+						keys.push(name);
+					}
+				}
+				return keys;
+			},
+			has(target, property): boolean {
+				if (property in target) {
+					return true;
+				}
+
+				const items = query();
+				const index = Number(property);
+
+				if (!isNaN(index) && index >= 0 && index < items.length) {
+					return true;
+				}
+
+				property = String(property);
+
+				for (let i = 0; i < items.length; i++) {
+					const item = items[i];
+					const name = item.getAttribute('id') || item.getAttribute('name');
+
+					if (name && name === property) {
+						return true;
+					}
+				}
+
+				return false;
+			},
+			defineProperty(target, property, descriptor): boolean {
+				methodBinder.preventBinding(property);
+
+				if (property in target) {
+					Object.defineProperty(target, property, descriptor);
+					return true;
+				}
+
+				return false;
+			},
+			getOwnPropertyDescriptor(target, property): PropertyDescriptor | undefined {
+				if (property in target || typeof property === 'symbol') {
+					return;
+				}
+
+				const items = query();
+				const index = Number(property);
+
+				if (!isNaN(index) && index >= 0 && index < items.length) {
+					return {
+						value: items[index],
+						writable: false,
+						enumerable: true,
+						configurable: true
+					};
+				}
+
+				for (let i = 0; i < items.length; i++) {
+					const item = items[i];
+					const name = item.getAttribute('id') || item.getAttribute('name');
+
+					if (name && name === property) {
+						return {
+							value: item,
+							writable: false,
+							enumerable: true,
+							configurable: true
+						};
+					}
+				}
+			}
+		});
+	}
+
+	/**
+	 * Returns length.
+	 *
+	 * @returns Length.
+	 */
+	public get length(): number {
+		return this[PropertySymbol.query]().length;
+	}
+
+	/**
+	 * Returns `Symbol.toStringTag`.
+	 *
+	 * @returns `Symbol.toStringTag`.
+	 */
+	public get [Symbol.toStringTag](): string {
+		return this.constructor.name;
+	}
+
+	/**
+	 * Returns `[object HTMLCollection]`.
+	 *
+	 * @returns `[object HTMLCollection]`.
+	 */
+	public toLocaleString(): string {
+		return `[object ${this.constructor.name}]`;
+	}
+
+	/**
+	 * Returns `[object HTMLCollection]`.
+	 *
+	 * @returns `[object HTMLCollection]`.
+	 */
+	public toString(): string {
+		return `[object ${this.constructor.name}]`;
+	}
+
+	/**
+	 * Returns item by index.
+	 *
+	 * @param index Index.
+	 */
+	public item(index: number): T | null {
+		const items = this[PropertySymbol.query]();
+		return index >= 0 && items[index] ? items[index] : null;
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all values of the key/value pairs contained in this object.
+	 *
+	 * @returns Iterator.
+	 */
+	public [Symbol.iterator](): ArrayIterator<T> {
+		const items = this[PropertySymbol.query]();
+		return items[Symbol.iterator]();
+	}
+
+	/**
+	 * Returns named item.
+	 *
+	 * @param name Name.
+	 * @returns Node.
+	 */
+	public namedItem(name: string): NamedItem | null {
+		const items = this[PropertySymbol.query]();
+		name = String(name);
+		for (const item of items) {
+			if (item.getAttribute('id') === name || item.getAttribute('name') === name) {
+				return <NamedItem>(<unknown>item);
+			}
+		}
+		return null;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/element/NamedNodeMap.ts

@@ -0,0 +1,274 @@
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type Attr from '../attr/Attr.js';
+import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
+import type Element from './Element.js';
+import NamespaceURI from '../../config/NamespaceURI.js';
+import StringUtility from '../../utilities/StringUtility.js';
+
+/**
+ * Named Node Map.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap
+ */
+export default class NamedNodeMap {
+	[index: number]: Attr;
+
+	// Items by attribute namespaceURI
+	public [PropertySymbol.itemsByNamespaceURI]: 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;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param ownerElement Owner element.
+	 */
+	constructor(ownerElement: Element) {
+		this[PropertySymbol.ownerElement] = ownerElement;
+	}
+
+	/**
+	 * Returns length.
+	 *
+	 * @returns Length.
+	 */
+	public get length(): number {
+		return this[PropertySymbol.items].size;
+	}
+
+	/**
+	 * Returns string.
+	 *
+	 * @returns string.
+	 */
+	public get [Symbol.toStringTag](): string {
+		return 'NamedNodeMap';
+	}
+
+	/**
+	 * Returns string.
+	 *
+	 * @returns string.
+	 */
+	public toString(): string {
+		return '[object NamedNodeMap]';
+	}
+
+	/**
+	 * Iterator.
+	 *
+	 * @returns Iterator.
+	 */
+	public [Symbol.iterator](): ArrayIterator<Attr> {
+		return this[PropertySymbol.items].values();
+	}
+
+	/**
+	 * Returns item by index.
+	 *
+	 * @param index Index.
+	 */
+	public item(index: number): Attr | null {
+		const items = Array.from(this[PropertySymbol.items].values());
+		return index >= 0 && items[index] ? items[index] : null;
+	}
+
+	/**
+	 * Returns named item.
+	 *
+	 * @param name Name.
+	 * @returns Item.
+	 */
+	public getNamedItem(name: string): Attr | null {
+		name = String(name);
+		if (
+			this[PropertySymbol.ownerElement][PropertySymbol.namespaceURI] === NamespaceURI.html &&
+			this[PropertySymbol.ownerElement][PropertySymbol.ownerDocument][
+				PropertySymbol.contentType
+			] === 'text/html'
+		) {
+			return this[PropertySymbol.itemsByName].get(StringUtility.asciiLowerCase(name))?.[0] || null;
+		}
+		return this[PropertySymbol.itemsByName].get(name)?.[0] || null;
+	}
+
+	/**
+	 * Returns item by name and namespace.
+	 *
+	 * @param namespace Namespace.
+	 * @param localName Local name of the attribute.
+	 * @returns Item.
+	 */
+	public getNamedItemNS(namespace: string | null, localName: string): Attr | 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 null;
+	}
+
+	/**
+	 * Sets named item.
+	 *
+	 * @param item Item.
+	 * @returns Replaced item.
+	 */
+	public setNamedItem(item: Attr): Attr | null {
+		return this[PropertySymbol.setNamedItem](item);
+	}
+
+	/**
+	 * Adds a new namespaced item.
+	 *
+	 * @alias setNamedItem()
+	 * @param item Item.
+	 * @returns Replaced item.
+	 */
+	public setNamedItemNS(item: Attr): Attr | null {
+		return this[PropertySymbol.setNamedItem](item);
+	}
+
+	/**
+	 * Removes an item.
+	 *
+	 * @throws DOMException
+	 * @param name Name of item.
+	 * @returns Removed item.
+	 */
+	public removeNamedItem(name: string): Attr {
+		const item = this.getNamedItem(name);
+
+		if (!item) {
+			throw new this[PropertySymbol.ownerElement][PropertySymbol.window].DOMException(
+				`Failed to execute 'removeNamedItem' on 'NamedNodeMap': No item with name '${name}' was found.`,
+				DOMExceptionNameEnum.notFoundError
+			);
+		}
+
+		this[PropertySymbol.removeNamedItem](item);
+
+		return item;
+	}
+
+	/**
+	 * Removes a namespaced item.
+	 *
+	 * @param namespace Namespace.
+	 * @param localName Local name of the item.
+	 * @returns Removed item.
+	 */
+	public removeNamedItemNS(namespace: string | null, localName: string): Attr | null {
+		const item = this.getNamedItemNS(namespace, localName);
+
+		if (!item) {
+			throw new this[PropertySymbol.ownerElement][PropertySymbol.window].DOMException(
+				`Failed to execute 'removeNamedItemNS' on 'NamedNodeMap': No item with name '${localName}' in namespace '${namespace}' was found.`,
+				DOMExceptionNameEnum.notFoundError
+			);
+		}
+
+		this[PropertySymbol.removeNamedItem](item);
+
+		return item;
+	}
+
+	/**
+	 * Sets named item.
+	 *
+	 * @param item Item.
+	 * @param [ignoreListeners] Ignore listeners.
+	 * @returns Replaced item.
+	 */
+	public [PropertySymbol.setNamedItem](item: Attr, ignoreListeners = false): Attr | null {
+		if (
+			item[PropertySymbol.ownerElement] !== null &&
+			item[PropertySymbol.ownerElement] !== this[PropertySymbol.ownerElement]
+		) {
+			throw new this[PropertySymbol.ownerElement][PropertySymbol.window].DOMException(
+				'The attribute is in use.',
+				DOMExceptionNameEnum.inUseAttributeError
+			);
+		}
+
+		item[PropertySymbol.ownerElement] = this[PropertySymbol.ownerElement];
+
+		const replacedItem =
+			this.getNamedItemNS(item[PropertySymbol.namespaceURI], item[PropertySymbol.localName]!) ||
+			null;
+		const itemsByName = this[PropertySymbol.itemsByName].get(item[PropertySymbol.name]!);
+
+		if (replacedItem === item) {
+			return item;
+		}
+
+		this[PropertySymbol.itemsByNamespaceURI].set(
+			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.localName]}`,
+			item
+		);
+		this[PropertySymbol.items].set(
+			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.name]}`,
+			item
+		);
+
+		if (!itemsByName?.length) {
+			this[PropertySymbol.itemsByName].set(item[PropertySymbol.name]!, [item]);
+		} else {
+			const index = itemsByName.indexOf(replacedItem!);
+			if (index !== -1) {
+				itemsByName.splice(index, 1);
+			}
+			itemsByName.push(item);
+		}
+
+		if (!ignoreListeners) {
+			this[PropertySymbol.ownerElement][PropertySymbol.onSetAttribute](item, replacedItem);
+		}
+
+		return replacedItem;
+	}
+
+	/**
+	 * Removes named item.
+	 *
+	 * @param item Item.
+	 * @param ignoreListeners
+	 */
+	public [PropertySymbol.removeNamedItem](item: Attr, ignoreListeners = false): void {
+		item[PropertySymbol.ownerElement] = null;
+
+		this[PropertySymbol.itemsByNamespaceURI].delete(
+			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.localName]}`
+		);
+		this[PropertySymbol.items].delete(
+			`${item[PropertySymbol.namespaceURI] || ''}:${item[PropertySymbol.name]}`
+		);
+
+		const itemsByName = this[PropertySymbol.itemsByName].get(item[PropertySymbol.name]!);
+
+		if (itemsByName?.length) {
+			const index = itemsByName.indexOf(item);
+			if (index !== -1) {
+				itemsByName.splice(index, 1);
+			}
+			if (!itemsByName.length) {
+				this[PropertySymbol.itemsByName].delete(item[PropertySymbol.name]!);
+			}
+		}
+
+		if (!ignoreListeners) {
+			this[PropertySymbol.ownerElement][PropertySymbol.onRemoveAttribute](item);
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/element/NamedNodeMapProxyFactory.ts

@@ -0,0 +1,127 @@
+/* eslint-disable filenames/match-exported */
+
+import ClassMethodBinder from '../../utilities/ClassMethodBinder.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import NamedNodeMap from './NamedNodeMap.js';
+
+/**
+ * Named Node Map.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap
+ */
+export default class NamedNodeMapProxyFactory {
+	/**
+	 * Constructor.
+	 *
+	 * @param namedNodeMap
+	 */
+	public static createProxy(namedNodeMap: NamedNodeMap): NamedNodeMap {
+		const methodBinder = new ClassMethodBinder(this, [NamedNodeMap]);
+
+		return new Proxy<NamedNodeMap>(namedNodeMap, {
+			get: (target, property) => {
+				if (property === 'length') {
+					return namedNodeMap[PropertySymbol.items].size;
+				}
+				if (property in target || typeof property === 'symbol') {
+					methodBinder.bind(property);
+					return (<any>target)[property];
+				}
+				const index = Number(property);
+				if (!isNaN(index)) {
+					return target.item(index);
+				}
+				return target.getNamedItem(<string>property) || undefined;
+			},
+			set(target, property, newValue): boolean {
+				methodBinder.bind(property);
+				if (typeof property === 'symbol') {
+					(<any>target)[property] = newValue;
+					return true;
+				}
+				const index = Number(property);
+				if (isNaN(index)) {
+					(<any>target)[property] = newValue;
+				}
+				return true;
+			},
+			deleteProperty(target, property): boolean {
+				if (typeof property === 'symbol') {
+					delete (<any>target)[property];
+					return true;
+				}
+				const index = Number(property);
+				if (isNaN(index)) {
+					delete (<any>target)[property];
+				}
+				return true;
+			},
+			ownKeys(): string[] {
+				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;
+			},
+			has(target, property): boolean {
+				if (typeof property === 'symbol') {
+					return false;
+				}
+
+				if (property in target || namedNodeMap[PropertySymbol.items].has(property)) {
+					return true;
+				}
+
+				const index = Number(property);
+
+				if (!isNaN(index) && index >= 0 && index < namedNodeMap[PropertySymbol.items].size) {
+					return true;
+				}
+
+				return false;
+			},
+			defineProperty(target, property, descriptor): boolean {
+				methodBinder.preventBinding(property);
+
+				if (property in target) {
+					Object.defineProperty(target, property, descriptor);
+					return true;
+				}
+
+				return false;
+			},
+			getOwnPropertyDescriptor(target, property): PropertyDescriptor | undefined {
+				if (property in target || typeof property === 'symbol') {
+					return;
+				}
+
+				const index = Number(property);
+				if (!isNaN(index)) {
+					if (index >= 0) {
+						const itemByIndex = target.item(index);
+						if (itemByIndex) {
+							return {
+								value: itemByIndex,
+								writable: false,
+								enumerable: true,
+								configurable: true
+							};
+						}
+					}
+					return;
+				}
+
+				const items = namedNodeMap[PropertySymbol.items].get(<string>property);
+
+				if (items) {
+					return {
+						value: items,
+						writable: false,
+						enumerable: true,
+						configurable: true
+					};
+				}
+			}
+		});
+	}
+}