buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/nodes/parent-node/ParentNodeUtility.ts

@@ -0,0 +1,334 @@
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type DocumentFragment from '../document-fragment/DocumentFragment.js';
+import type Document from '../document/Document.js';
+import type Element from '../element/Element.js';
+import Node from '../node/Node.js';
+import NamespaceURI from '../../config/NamespaceURI.js';
+import HTMLCollection from '../element/HTMLCollection.js';
+import QuerySelector from '../../query-selector/QuerySelector.js';
+import type ICachedResult from '../node/ICachedResult.js';
+
+/**
+ * Parent node utility.
+ */
+export default class ParentNodeUtility {
+	/**
+	 * Inserts a set of Node objects or DOMString objects after the last child of the ParentNode. DOMString objects are inserted as equivalent Text nodes.
+	 *
+	 * @param parentNode Parent node.
+	 * @param nodes List of Node or DOMString.
+	 */
+	public static append(parentNode: Element | Document | DocumentFragment, ...nodes: any[]): void {
+		for (const node of nodes) {
+			if (node instanceof Node) {
+				parentNode.appendChild(node);
+			} else {
+				parentNode.appendChild(
+					parentNode[PropertySymbol.ownerDocument].createTextNode(String(node))
+				);
+			}
+		}
+	}
+
+	/**
+	 * Inserts a set of Node objects or DOMString objects before the first child of the ParentNode. DOMString objects are inserted as equivalent Text nodes.
+	 *
+	 * @param parentNode Parent node.
+	 * @param nodes List of Node or DOMString.
+	 */
+	public static prepend(
+		parentNode: Element | Document | DocumentFragment,
+		...nodes: (string | Node)[]
+	): void {
+		const firstChild = parentNode.firstChild;
+		for (const node of nodes) {
+			if (node instanceof Node) {
+				parentNode.insertBefore(node, firstChild);
+			} else {
+				parentNode.insertBefore(
+					parentNode[PropertySymbol.ownerDocument].createTextNode(String(node)),
+					firstChild
+				);
+			}
+		}
+	}
+
+	/**
+	 * Replaces the existing children of a ParentNode with a specified new set of children.
+	 *
+	 * @param parentNode Parent node.
+	 * @param nodes List of Node or DOMString.
+	 */
+	public static replaceChildren(
+		parentNode: Element | Document | DocumentFragment,
+		...nodes: (string | Node)[]
+	): void {
+		const childNodes = (<DocumentFragment>parentNode)[PropertySymbol.nodeArray];
+
+		while (childNodes.length) {
+			parentNode.removeChild(childNodes[0]);
+		}
+
+		this.append(parentNode, ...nodes);
+	}
+
+	/**
+	 * Returns an elements by class name.
+	 *
+	 * @param parentNode Parent node.
+	 * @param className Tag name.
+	 * @returns Matching element.
+	 */
+	public static getElementsByClassName(
+		parentNode: Element | DocumentFragment | Document,
+		className: string
+	): HTMLCollection<Element> {
+		return new HTMLCollection(
+			PropertySymbol.illegalConstructor,
+			() =>
+				QuerySelector.querySelectorAll(parentNode, `.${className.replace(/\s+/gm, '.')}`)[
+					PropertySymbol.items
+				]
+		);
+	}
+
+	/**
+	 * Returns an elements by tag name.
+	 *
+	 * @param parentNode Parent node.
+	 * @param tagName Tag name.
+	 * @returns Matching element.
+	 */
+	public static getElementsByTagName<T extends Element = Element>(
+		parentNode: Element | DocumentFragment | Document,
+		tagName: string
+	): HTMLCollection<T> {
+		const upperTagName = tagName.toUpperCase();
+		const includeAll = tagName === '*';
+
+		const find = (
+			parent: Element | DocumentFragment | Document,
+			cachedResult: ICachedResult
+		): T[] => {
+			const elements: T[] = [];
+
+			for (const element of (<DocumentFragment>parent)[PropertySymbol.elementArray]) {
+				if (includeAll || element[PropertySymbol.tagName]!.toUpperCase() === upperTagName) {
+					elements.push(<T>element);
+				}
+
+				element[PropertySymbol.affectsCache].push(cachedResult);
+
+				for (const foundElement of find(<Element>element, cachedResult)) {
+					elements.push(foundElement);
+				}
+			}
+
+			return elements;
+		};
+
+		const query = (): T[] => {
+			const cache = parentNode[PropertySymbol.cache].elementsByTagName;
+			const cachedItems = cache.get(tagName);
+
+			if (cachedItems?.result) {
+				const items = cachedItems.result.deref();
+				if (items) {
+					return <T[]>items;
+				}
+			}
+
+			const cachedResult: ICachedResult = { result: null };
+			const items = find(parentNode, cachedResult);
+
+			cachedResult.result = new WeakRef(items);
+			cache.set(tagName, cachedResult);
+
+			return items;
+		};
+
+		return new HTMLCollection<T>(PropertySymbol.illegalConstructor, query);
+	}
+
+	/**
+	 * Returns an elements by tag name and namespace.
+	 *
+	 * @param parentNode Parent node.
+	 * @param namespaceURI Namespace URI.
+	 * @param tagName Tag name.
+	 * @returns Matching element.
+	 */
+	public static getElementsByTagNameNS(
+		parentNode: Element | DocumentFragment | Document,
+		namespaceURI: string,
+		tagName: string
+	): HTMLCollection<Element> {
+		// When the namespace is HTML, the tag name is case-insensitive.
+		const formattedTagName =
+			namespaceURI === NamespaceURI.html &&
+			parentNode[PropertySymbol.ownerDocument][PropertySymbol.contentType] === 'text/html'
+				? tagName.toUpperCase()
+				: tagName;
+		const includeAll = tagName === '*';
+
+		const find = (
+			parent: Element | DocumentFragment | Document,
+			cachedResult: ICachedResult
+		): Element[] => {
+			const elements: Element[] = [];
+
+			for (const element of (<DocumentFragment>parent)[PropertySymbol.elementArray]) {
+				if (
+					(includeAll || element[PropertySymbol.tagName] === formattedTagName) &&
+					element[PropertySymbol.namespaceURI] === namespaceURI
+				) {
+					elements.push(<Element>element);
+				}
+
+				element[PropertySymbol.affectsCache].push(cachedResult);
+
+				for (const foundElement of find(<Element>element, cachedResult)) {
+					elements.push(foundElement);
+				}
+			}
+
+			return elements;
+		};
+
+		const query = (): Element[] => {
+			const cache = parentNode[PropertySymbol.cache].elementsByTagNameNS;
+			const cachedItems = cache.get(tagName);
+
+			if (cachedItems?.result) {
+				const items = cachedItems.result.deref();
+				if (items) {
+					return items;
+				}
+			}
+
+			const cachedResult: ICachedResult = { result: null };
+			const items = find(parentNode, cachedResult);
+
+			cachedResult.result = new WeakRef(items);
+			cache.set(tagName, cachedResult);
+
+			return items;
+		};
+
+		return new HTMLCollection(PropertySymbol.illegalConstructor, query);
+	}
+
+	/**
+	 * Returns the first element matching a tag name.
+	 * This is not part of the browser standard and is only used internally (used in Document).
+	 *
+	 * @param parentNode Parent node.
+	 * @param tagName Tag name.
+	 * @returns Matching element.
+	 */
+	public static getElementByTagName(
+		parentNode: Element | DocumentFragment | Document,
+		tagName: string
+	): Element | null {
+		const upperTagName = tagName.toUpperCase();
+
+		const find = (
+			parent: Element | DocumentFragment | Document,
+			cachedResult: ICachedResult
+		): Element | null => {
+			for (const element of (<DocumentFragment>parent)[PropertySymbol.elementArray]) {
+				element[PropertySymbol.affectsCache].push(cachedResult);
+
+				if (element[PropertySymbol.tagName] === upperTagName) {
+					return <Element>element;
+				}
+
+				const foundElement = find(<Element>element, cachedResult);
+				if (foundElement) {
+					return foundElement;
+				}
+			}
+
+			return null;
+		};
+
+		const cache = parentNode[PropertySymbol.cache].elementByTagName;
+		const cachedItem = cache.get(tagName);
+
+		if (cachedItem?.result) {
+			const item = cachedItem.result.deref();
+			if (item) {
+				return item;
+			}
+		}
+
+		const cachedResult: ICachedResult = { result: null };
+		const item = find(parentNode, cachedResult);
+
+		cachedResult.result = item ? new WeakRef(item) : { deref: () => null };
+		cache.set(tagName, cachedResult);
+
+		return item;
+	}
+
+	/**
+	 * Returns an element by ID.
+	 *
+	 * @param parentNode Parent node.
+	 * @param id ID.
+	 * @returns Matching element.
+	 */
+	public static getElementById(
+		parentNode: Element | DocumentFragment | Document,
+		id: string
+	): Element | null {
+		id = String(id);
+
+		if (parentNode[PropertySymbol.nodeType] === Node.DOCUMENT_NODE) {
+			const entry = (<Document>parentNode)[PropertySymbol.elementIdMap].get(id);
+			if (entry && entry.elements.length > 0) {
+				return entry.elements[0];
+			}
+			return null;
+		}
+
+		const find = (
+			parent: Element | DocumentFragment | Document,
+			cachedResult: ICachedResult
+		): Element | null => {
+			for (const element of (<DocumentFragment>parent)[PropertySymbol.elementArray]) {
+				element[PropertySymbol.affectsCache].push(cachedResult);
+
+				if (element.getAttribute('id') === id) {
+					return <Element>element;
+				}
+
+				const foundElement = find(<Element>element, cachedResult);
+
+				if (foundElement) {
+					return foundElement;
+				}
+			}
+
+			return null;
+		};
+
+		const cache = parentNode[PropertySymbol.cache].elementById;
+		const cachedItem = cache.get(id);
+
+		if (cachedItem?.result) {
+			const item = cachedItem.result.deref();
+			if (item) {
+				return item;
+			}
+		}
+
+		const cachedResult: ICachedResult = { result: null };
+		const item = find(parentNode, cachedResult);
+
+		cachedResult.result = item ? new WeakRef(item) : { deref: () => null };
+		cache.set(id, cachedResult);
+
+		return item;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/processing-instruction/ProcessingInstruction.ts

@@ -0,0 +1,22 @@
+import CharacterData from '../character-data/CharacterData.js';
+import NodeTypeEnum from '../node/NodeTypeEnum.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+
+/**
+ * Processing instruction node interface.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/ProcessingInstruction.
+ */
+export default class ProcessingInstruction extends CharacterData {
+	public [PropertySymbol.nodeType] = NodeTypeEnum.processingInstructionNode;
+	public [PropertySymbol.target]: string = '';
+
+	/**
+	 * Returns target.
+	 *
+	 * @returns Target.
+	 */
+	public get target(): string {
+		return this[PropertySymbol.target];
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/shadow-root/ShadowRoot.ts

@@ -0,0 +1,290 @@
+import DocumentFragment from '../document-fragment/DocumentFragment.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type Element from '../element/Element.js';
+import type CSSStyleSheet from '../../css/CSSStyleSheet.js';
+import type HTMLElement from '../../nodes/html-element/HTMLElement.js';
+import type Event from '../../event/Event.js';
+import type SVGElement from '../svg-element/SVGElement.js';
+import type Document from '../document/Document.js';
+import HTMLSerializer from '../../html-serializer/HTMLSerializer.js';
+import HTMLParser from '../../html-parser/HTMLParser.js';
+
+/**
+ * ShadowRoot.
+ */
+export default class ShadowRoot extends DocumentFragment {
+	// Public properties
+	public declare cloneNode: (deep?: boolean) => ShadowRoot;
+
+	// Internal properties
+	public [PropertySymbol.adoptedStyleSheets]: CSSStyleSheet[] = [];
+	public [PropertySymbol.mode] = 'open';
+	public [PropertySymbol.host]: Element | null = null;
+	public [PropertySymbol.clonable]: boolean = false;
+	public [PropertySymbol.delegatesFocus]: boolean = false;
+	public [PropertySymbol.serializable]: boolean = false;
+	public [PropertySymbol.slotAssignment]: 'named' | 'manual' = 'named';
+	public [PropertySymbol.propertyEventListeners]: Map<string, ((event: Event) => void) | null> =
+		new Map();
+
+	// Events
+
+	/* eslint-disable jsdoc/require-jsdoc */
+
+	public get onslotchange(): ((event: Event) => void) | null {
+		return this[PropertySymbol.propertyEventListeners].get('onslotchange') ?? null;
+	}
+
+	public set onslotchange(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('onslotchange', value);
+	}
+
+	/* eslint-enable jsdoc/require-jsdoc */
+
+	/**
+	 * Returns mode.
+	 *
+	 * @returns Mode.
+	 */
+	public get mode(): string {
+		return this[PropertySymbol.mode];
+	}
+
+	/**
+	 * Returns host.
+	 *
+	 * @returns Host.
+	 */
+	public get host(): Element | null {
+		return this[PropertySymbol.host];
+	}
+
+	/**
+	 * Returns clonable.
+	 *
+	 * @returns Clonable.
+	 */
+	public get clonable(): boolean {
+		return this[PropertySymbol.clonable];
+	}
+
+	/**
+	 * Returns delegates focus.
+	 *
+	 * @returns Delegates focus.
+	 */
+	public get delegatesFocus(): boolean {
+		// TODO: Implement delegates focus
+		return this[PropertySymbol.delegatesFocus];
+	}
+
+	/**
+	 * Returns serializable.
+	 *
+	 * @returns Serializable.
+	 */
+	public get serializable(): boolean {
+		return this[PropertySymbol.serializable];
+	}
+
+	/**
+	 * Returns slot assignment.
+	 *
+	 * @returns Slot assignment.
+	 */
+	public get slotAssignment(): 'named' | 'manual' {
+		return this[PropertySymbol.slotAssignment];
+	}
+
+	/**
+	 * The element that's currently in full screen mode for this shadow tree.
+	 *
+	 * @returns Fullscreen element.
+	 */
+	public get fullscreenElement(): Element | null {
+		// TODO: Implement fullscreen element
+		return null;
+	}
+
+	/**
+	 * Returns the Element within the shadow tree that is currently being presented in picture-in-picture mode.
+	 *
+	 * @returns Picture-in-picture element.
+	 */
+	public get pictureInPictureElement(): Element | null {
+		// TODO: Implement picture-in-picture element
+		return null;
+	}
+
+	/**
+	 * Returns the Element set as the target for mouse events while the pointer is locked. null if lock is pending, pointer is unlocked, or if the target is in another tree.
+	 *
+	 * @returns Pointer lock element.
+	 */
+	public get pointerLockElement(): Element | null {
+		// TODO: Implement pointer lock element
+		return null;
+	}
+
+	/**
+	 * Returns inner HTML.
+	 *
+	 * @returns HTML.
+	 */
+	public get innerHTML(): string {
+		const serializer = new HTMLSerializer();
+		let html = '';
+		for (const node of this[PropertySymbol.nodeArray]) {
+			html += serializer.serializeToString(node);
+		}
+		return html;
+	}
+
+	/**
+	 * Sets inner HTML.
+	 *
+	 * @param html HTML.
+	 */
+	public set innerHTML(html: string) {
+		const childNodes = this[PropertySymbol.nodeArray];
+
+		while (childNodes.length) {
+			this.removeChild(childNodes[0]);
+		}
+
+		new HTMLParser(this[PropertySymbol.window]).parse(html, this);
+	}
+
+	/**
+	 * Returns adopted style sheets.
+	 *
+	 * @returns Adopted style sheets.
+	 */
+	public get adoptedStyleSheets(): CSSStyleSheet[] {
+		const window = this[PropertySymbol.window];
+		return new Proxy(this[PropertySymbol.adoptedStyleSheets], {
+			set(target, property, value, receiver) {
+				if (typeof property === 'string' && String(Number(property)) === property) {
+					if (!(value instanceof window.CSSStyleSheet)) {
+						throw new window.TypeError(`Failed to convert value to 'CSSStyleSheet'.`);
+					}
+				}
+				return Reflect.set(target, property, value, receiver);
+			},
+			get(target, property, receiver) {
+				if (typeof property === 'string' && String(Number(property)) === property) {
+					return Reflect.get(target, property, receiver);
+				}
+				if (property === 'push' || property === 'unshift') {
+					return (...args: any[]) => {
+						for (const arg of args) {
+							if (!(arg instanceof window.CSSStyleSheet)) {
+								throw new window.TypeError(`Failed to convert value to 'CSSStyleSheet'.`);
+							}
+						}
+						return Array.prototype[property].apply(target, args);
+					};
+				}
+				return Reflect.get(target, property, receiver);
+			}
+		});
+	}
+
+	/**
+	 * Sets adopted style sheets.
+	 *
+	 * @param value Adopted style sheets.
+	 */
+	public set adoptedStyleSheets(value: CSSStyleSheet[]) {
+		if (!Array.isArray(value)) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to set the 'adoptedStyleSheets' property on 'ShadowRoot': The provided value cannot be converted to a sequence.`
+			);
+		}
+		for (const sheet of value) {
+			if (!(sheet instanceof this[PropertySymbol.window].CSSStyleSheet)) {
+				throw new this[PropertySymbol.window].TypeError(
+					`Failed to set the 'adoptedStyleSheets' property on 'ShadowRoot': Failed to convert value to 'CSSStyleSheet'.`
+				);
+			}
+		}
+		this[PropertySymbol.adoptedStyleSheets] = value;
+		this[PropertySymbol.ownerDocument][PropertySymbol.clearComputedStyleCache]();
+	}
+
+	/**
+	 * Returns active element.
+	 *
+	 * @returns Active element.
+	 */
+	public get activeElement(): HTMLElement | SVGElement | null {
+		let activeElement: HTMLElement | SVGElement | null =
+			this[PropertySymbol.ownerDocument][PropertySymbol.activeElement];
+
+		let rootNode: ShadowRoot | Document = <ShadowRoot | Document>activeElement?.getRootNode();
+
+		if (!rootNode || rootNode === this[PropertySymbol.ownerDocument]) {
+			return null;
+		}
+
+		if (rootNode === this) {
+			return activeElement;
+		}
+
+		while (rootNode && rootNode !== this) {
+			activeElement = <HTMLElement | SVGElement>(<ShadowRoot>rootNode).host;
+			rootNode = <ShadowRoot | Document>activeElement.getRootNode();
+		}
+
+		return activeElement;
+	}
+
+	/**
+	 * Returns an array of all Animation objects currently in effect, whose target elements are descendants of the shadow tree.
+	 *
+	 * @returns Array of animations.
+	 */
+	public getAnimations(): object[] {
+		// TODO: Implement getAnimations()
+		return [];
+	}
+
+	/**
+	 * Parses a string of HTML into a document fragment, without sanitization, which then replaces the shadowroot's original subtree. The HTML string may include declarative shadow roots, which would be parsed as template elements the HTML was set using ShadowRoot.innerHTML.
+	 *
+	 * @param html HTML.
+	 */
+	public setHTMLUnsafe(html: string): void {
+		// TODO: Implement support for declarative shadow roots
+
+		const childNodes = this[PropertySymbol.nodeArray];
+
+		while (childNodes.length) {
+			this.removeChild(childNodes[0]);
+		}
+
+		new HTMLParser(this[PropertySymbol.window]).parse(html, this);
+	}
+
+	/**
+	 * Converts to string.
+	 *
+	 * @returns String.
+	 */
+	public toString(): string {
+		return this.innerHTML;
+	}
+
+	/**
+	 * @override
+	 */
+	public override [PropertySymbol.cloneNode](deep = false): ShadowRoot {
+		const clone = <ShadowRoot>super[PropertySymbol.cloneNode](deep);
+		clone[PropertySymbol.mode] = this[PropertySymbol.mode];
+		clone[PropertySymbol.clonable] = this[PropertySymbol.clonable];
+		clone[PropertySymbol.delegatesFocus] = this[PropertySymbol.delegatesFocus];
+		clone[PropertySymbol.serializable] = this[PropertySymbol.serializable];
+		clone[PropertySymbol.slotAssignment] = this[PropertySymbol.slotAssignment];
+		return clone;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/svg-animate-element/SVGAnimateElement.ts

@@ -0,0 +1,8 @@
+import SVGAnimationElement from '../svg-animation-element/SVGAnimationElement.js';
+
+/**
+ * SVG Animate Element.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateElement
+ */
+export default class SVGAnimateElement extends SVGAnimationElement {}

package/vendor/happy-dom/packages/happy-dom/src/nodes/svg-animate-motion-element/SVGAnimateMotionElement.ts

@@ -0,0 +1,8 @@
+import SVGAnimationElement from '../svg-animation-element/SVGAnimationElement.js';
+
+/**
+ * SVG Animate Element Motion.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateMotionElement
+ */
+export default class SVGAnimateMotionElement extends SVGAnimationElement {}

package/vendor/happy-dom/packages/happy-dom/src/nodes/svg-animate-transform-element/SVGAnimateTransformElement.ts

@@ -0,0 +1,8 @@
+import SVGAnimationElement from '../svg-animation-element/SVGAnimationElement.js';
+
+/**
+ * SVG Animate Element Transform.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/SVGAnimateTransformElement
+ */
+export default class SVGAnimateTransformElement extends SVGAnimationElement {}