buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-canvas-element/HTMLCanvasElement.ts

@@ -0,0 +1,304 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import Blob from '../../file/Blob.js';
+import OffscreenCanvas from '../../canvas/OffscreenCanvas.js';
+import type Event from '../../event/Event.js';
+import type MediaStream from '../html-media-element/MediaStream.js';
+import ElementEventAttributeUtility from '../element/ElementEventAttributeUtility.js';
+import type ICanvasAdapter from '../../canvas/ICanvasAdapter.js';
+import WindowBrowserContext from '../../window/WindowBrowserContext.js';
+import type ICanvas from '../../canvas/ICanvasShape.js';
+import type ICanvasRenderingContext2D from '../../canvas/ICanvasRenderingContext2D.js';
+import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
+
+const DEVICE_ID = 'S3F/aBCdEfGHIjKlMnOpQRStUvWxYz1234567890+1AbC2DEf2GHi3jK34le+ab12C3+1aBCdEf==';
+
+enum CanvasModeEnum {
+	none = 'none',
+	context = 'context',
+	offscreen = 'offscreen'
+}
+
+/**
+ * HTMLCanvasElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement
+ */
+export default class HTMLCanvasElement extends HTMLElement implements ICanvas {
+	// Private properties
+	#mode: CanvasModeEnum = CanvasModeEnum.none;
+	#offscreenCanvas: OffscreenCanvas | null = null;
+
+	// Events
+
+	/* eslint-disable jsdoc/require-jsdoc */
+
+	public get oncontextlost(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'oncontextlost');
+	}
+
+	public set oncontextlost(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('oncontextlost', value);
+	}
+
+	public get oncontextrestored(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'oncontextrestored');
+	}
+
+	public set oncontextrestored(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('oncontextrestored', value);
+	}
+
+	public get onwebglcontextcreationerror(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'onwebglcontextcreationerror');
+	}
+
+	public set onwebglcontextcreationerror(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('onwebglcontextcreationerror', value);
+	}
+
+	public get onwebglcontextlost(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'onwebglcontextlost');
+	}
+
+	public set onwebglcontextlost(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('onwebglcontextlost', value);
+	}
+
+	public get onwebglcontextrestored(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'onwebglcontextrestored');
+	}
+
+	public set onwebglcontextrestored(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('onwebglcontextrestored', value);
+	}
+
+	/* eslint-enable jsdoc/require-jsdoc */
+
+	/**
+	 * Returns width.
+	 *
+	 * @returns Width.
+	 */
+	public get width(): number {
+		const width = this.getAttribute('width');
+		if (width === null) {
+			return 300;
+		}
+		const parsed = parseInt(width, 10);
+		return isNaN(parsed) ? 300 : parsed;
+	}
+
+	/**
+	 * Sets width.
+	 *
+	 * @param width Width.
+	 */
+	public set width(width: number) {
+		this.setAttribute('width', String(width));
+	}
+
+	/**
+	 * Returns height.
+	 *
+	 * @returns Height.
+	 */
+	public get height(): number {
+		const height = this.getAttribute('height');
+		if (height === null) {
+			return 150;
+		}
+		const parsed = parseInt(height, 10);
+		return isNaN(parsed) ? 150 : parsed;
+	}
+
+	/**
+	 * Sets height.
+	 *
+	 * @param height Height.
+	 */
+	public set height(height: number) {
+		this.setAttribute('height', String(height));
+	}
+
+	/**
+	 * Returns capture stream.
+	 *
+	 * @param [frameRate] Frame rate.
+	 * @returns Capture stream.
+	 */
+	public captureStream(frameRate?: number): MediaStream {
+		const stream = new this[PropertySymbol.window].MediaStream();
+		const track = new this[PropertySymbol.window].CanvasCaptureMediaStreamTrack(
+			PropertySymbol.illegalConstructor,
+			this
+		);
+
+		track[PropertySymbol.kind] = 'video';
+		track[PropertySymbol.capabilities].deviceId = DEVICE_ID;
+		track[PropertySymbol.capabilities].aspectRatio.max = this.width;
+		track[PropertySymbol.capabilities].height.max = this.height;
+		track[PropertySymbol.capabilities].width.max = this.width;
+		track[PropertySymbol.settings].deviceId = DEVICE_ID;
+
+		if (frameRate !== undefined) {
+			track[PropertySymbol.capabilities].frameRate.max = frameRate;
+			track[PropertySymbol.settings].frameRate = frameRate;
+		}
+
+		stream.addTrack(track);
+
+		return stream;
+	}
+
+	/**
+	 * Returns context.
+	 *
+	 * @param contextType Context type.
+	 * @param [contextAttributes] Context attributes.
+	 * @returns Context.
+	 */
+	public getContext(
+		contextType: '2d' | 'webgl' | 'webgl2' | 'webgpu' | 'bitmaprenderer',
+		contextAttributes?: { [key: string]: any }
+	): ICanvasRenderingContext2D | null {
+		if (this.#mode === CanvasModeEnum.offscreen) {
+			throw new this[PropertySymbol.window].DOMException(
+				`Failed to execute 'getContext' on 'HTMLCanvasElement': Cannot get context from a canvas that has transferred its control to offscreen.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+		this.#mode = CanvasModeEnum.context;
+		const browserFrame = new WindowBrowserContext(this[PropertySymbol.window]).getBrowserFrame();
+		if (!browserFrame) {
+			throw new this[PropertySymbol.window].Error(
+				`Failed to execute 'getContext' on 'HTMLCanvasElement': Browser frame is not available. This happens when the browser is closing.`
+			);
+		}
+		const settings = new WindowBrowserContext(this[PropertySymbol.window]).getSettings();
+		const adapter = settings?.canvasAdapter;
+		if (!adapter) {
+			return null;
+		}
+		return adapter.getContext(
+			{
+				browserFrame,
+				window: this[PropertySymbol.window],
+				canvas: this
+			},
+			contextType,
+			contextAttributes
+		);
+	}
+
+	/**
+	 * Returns to data URL.
+	 *
+	 * @param [type] Type.
+	 * @param [quality] Quality.
+	 * @returns Data URL.
+	 */
+	public toDataURL(type?: string, quality?: number): string {
+		const browserFrame = new WindowBrowserContext(this[PropertySymbol.window]).getBrowserFrame();
+		if (!browserFrame) {
+			throw new this[PropertySymbol.window].Error(
+				`Failed to execute 'toDataURL' on 'HTMLCanvasElement': Browser frame is not available. This happens when the browser is closing.`
+			);
+		}
+		const settings = new WindowBrowserContext(this[PropertySymbol.window]).getSettings();
+		const adapter = settings?.canvasAdapter;
+		if (!adapter) {
+			return `data:${type || 'image/png'};base64,${Buffer.from([]).toString('base64')}`;
+		}
+		if (this.#offscreenCanvas) {
+			return (<ICanvasAdapter>adapter).toDataURL(
+				{
+					browserFrame,
+					window: this[PropertySymbol.window],
+					canvas: this.#offscreenCanvas
+				},
+				type,
+				quality
+			);
+		}
+		return (<ICanvasAdapter>adapter).toDataURL(
+			{
+				browserFrame,
+				window: this[PropertySymbol.window],
+				canvas: this
+			},
+			type,
+			quality
+		);
+	}
+
+	/**
+	 * Returns to blob.
+	 *
+	 * @param callback Callback.
+	 * @param [type] Type.
+	 * @param [quality] Quality.
+	 */
+	public toBlob(callback: (blob: Blob | null) => void, type?: string, quality?: any): void {
+		const browserFrame = new WindowBrowserContext(this[PropertySymbol.window]).getBrowserFrame();
+		if (!browserFrame) {
+			throw new this[PropertySymbol.window].Error(
+				`Failed to execute 'toBlob' on 'HTMLCanvasElement': Browser frame is not available. This happens when the browser is closing.`
+			);
+		}
+		const settings = new WindowBrowserContext(this[PropertySymbol.window]).getSettings();
+		const adapter = settings?.canvasAdapter;
+		if (!adapter) {
+			this[PropertySymbol.window].requestAnimationFrame(() =>
+				callback(new Blob([], { type: type || 'image/png' }))
+			);
+			return;
+		}
+		if (this.#offscreenCanvas) {
+			(<ICanvasAdapter>adapter).toBlob(
+				{
+					browserFrame,
+					window: this[PropertySymbol.window],
+					canvas: this.#offscreenCanvas
+				},
+				callback,
+				type,
+				quality
+			);
+			return;
+		}
+		(<ICanvasAdapter>adapter).toBlob(
+			{
+				browserFrame,
+				window: this[PropertySymbol.window],
+				canvas: this
+			},
+			callback,
+			type,
+			quality
+		);
+	}
+
+	/**
+	 * Transfers control to offscreen.
+	 *
+	 * @returns Offscreen canvas.
+	 */
+	public transferControlToOffscreen(): OffscreenCanvas {
+		if (this.#mode === CanvasModeEnum.context) {
+			throw new this[PropertySymbol.window].DOMException(
+				`Failed to execute 'transferControlToOffscreen' on 'HTMLCanvasElement': Cannot transfer control from a canvas that has a rendering context.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+		if (this.#mode === CanvasModeEnum.offscreen) {
+			throw new this[PropertySymbol.window].DOMException(
+				`Failed to execute 'transferControlToOffscreen' on 'HTMLCanvasElement': Cannot transfer control from a canvas for more than one time.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+		this.#mode = CanvasModeEnum.offscreen;
+		this.#offscreenCanvas = new OffscreenCanvas(this.width, this.height);
+		return this.#offscreenCanvas;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-d-list-element/HTMLDListElement.ts

@@ -0,0 +1,7 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+/**
+ * HTMLDListElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLDListElement
+ */
+export default class HTMLDListElement extends HTMLElement {}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-data-element/HTMLDataElement.ts

@@ -0,0 +1,25 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+/**
+ * HTMLDataElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLDataElement
+ */
+export default class HTMLDataElement extends HTMLElement {
+	/**
+	 * Returns value.
+	 *
+	 * @returns Value.
+	 */
+	public get value(): string {
+		return this.getAttribute('value') || '';
+	}
+
+	/**
+	 * Sets value.
+	 *
+	 * @param value Value.
+	 */
+	public set value(value: string) {
+		this.setAttribute('value', value);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-data-list-element/HTMLDataListElement.ts

@@ -0,0 +1,28 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type HTMLCollection from '../element/HTMLCollection.js';
+import type HTMLOptionElement from '../html-option-element/HTMLOptionElement.js';
+import ParentNodeUtility from '../parent-node/ParentNodeUtility.js';
+
+/**
+ * HTMLDataListElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLDataListElement
+ */
+export default class HTMLDataListElement extends HTMLElement {
+	public [PropertySymbol.options]: HTMLCollection<HTMLOptionElement> | null = null;
+
+	/**
+	 * Returns options.
+	 *
+	 * @returns Options.
+	 */
+	public get options(): HTMLCollection<HTMLOptionElement> {
+		if (!this[PropertySymbol.options]) {
+			this[PropertySymbol.options] = <HTMLCollection<HTMLOptionElement>>(
+				ParentNodeUtility.getElementsByTagName(this, 'OPTION')
+			);
+		}
+		return this[PropertySymbol.options];
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-details-element/HTMLDetailsElement.ts

@@ -0,0 +1,112 @@
+import Event from '../../event/Event.js';
+import HTMLElement from '../html-element/HTMLElement.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type Attr from '../attr/Attr.js';
+import EventPhaseEnum from '../../event/EventPhaseEnum.js';
+import MouseEvent from '../../event/events/MouseEvent.js';
+import ElementEventAttributeUtility from '../element/ElementEventAttributeUtility.js';
+import type Element from '../element/Element.js';
+
+/**
+ * HTMLDetailsElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLDetailsElement
+ */
+export default class HTMLDetailsElement extends HTMLElement {
+	// Events
+
+	/* eslint-disable jsdoc/require-jsdoc */
+
+	public get ontoggle(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'ontoggle');
+	}
+
+	public set ontoggle(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('ontoggle', value);
+	}
+
+	/* eslint-enable jsdoc/require-jsdoc */
+
+	/**
+	 * Returns the open attribute.
+	 */
+	public get open(): boolean {
+		return this.getAttribute('open') !== null;
+	}
+
+	/**
+	 * Sets the open attribute.
+	 *
+	 * @param open New value.
+	 */
+	public set open(open: boolean) {
+		if (open) {
+			this.setAttribute('open', '');
+		} else {
+			this.removeAttribute('open');
+		}
+	}
+
+	/**
+	 * @override
+	 */
+	public override [PropertySymbol.onSetAttribute](
+		attribute: Attr,
+		replacedAttribute: Attr | null
+	): void {
+		super[PropertySymbol.onSetAttribute](attribute, replacedAttribute);
+		if (attribute[PropertySymbol.name] === 'open') {
+			if (attribute[PropertySymbol.value] !== replacedAttribute?.[PropertySymbol.value]) {
+				this.dispatchEvent(new Event('toggle'));
+			}
+		}
+	}
+
+	/**
+	 * @override
+	 */
+	public override [PropertySymbol.onRemoveAttribute](removedAttribute: Attr): void {
+		super[PropertySymbol.onRemoveAttribute](removedAttribute);
+		if (removedAttribute && removedAttribute[PropertySymbol.name] === 'open') {
+			this.dispatchEvent(new Event('toggle'));
+		}
+	}
+
+	/**
+	 * @override
+	 */
+	public override dispatchEvent(event: Event): boolean {
+		const returnValue = super.dispatchEvent(event);
+
+		if (
+			!event[PropertySymbol.defaultPrevented] &&
+			event.type === 'click' &&
+			event.eventPhase === EventPhaseEnum.bubbling &&
+			event instanceof MouseEvent
+		) {
+			const target = <Element | null>event[PropertySymbol.target];
+
+			if (target) {
+				if (
+					target[PropertySymbol.localName] === 'summary' &&
+					target[PropertySymbol.parentNode] === this
+				) {
+					this.open = !this.open;
+				} else {
+					let summaryElement: Element | null = target;
+					for (const element of this[PropertySymbol.elementArray]) {
+						if (element[PropertySymbol.localName] === 'summary') {
+							summaryElement = element;
+							break;
+						}
+					}
+					if (summaryElement && summaryElement.contains(target)) {
+						this.open = !this.open;
+					}
+				}
+			}
+		}
+
+		return returnValue;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-dialog-element/HTMLDialogElement.ts

@@ -0,0 +1,104 @@
+import Event from '../../event/Event.js';
+import HTMLElement from '../html-element/HTMLElement.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import ElementEventAttributeUtility from '../element/ElementEventAttributeUtility.js';
+
+/**
+ * HTML Dialog Element.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLDialogElement
+ */
+export default class HTMLDialogElement extends HTMLElement {
+	// Internal properties
+	public [PropertySymbol.returnValue] = '';
+
+	// Events
+
+	/* eslint-disable jsdoc/require-jsdoc */
+
+	public get oncancel(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'oncancel');
+	}
+
+	public set oncancel(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('oncancel', value);
+	}
+
+	public get onclose(): ((event: Event) => void) | null {
+		return ElementEventAttributeUtility.getEventListener(this, 'onclose');
+	}
+
+	public set onclose(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('onclose', value);
+	}
+
+	/* eslint-enable jsdoc/require-jsdoc */
+
+	/**
+	 * Returns return value.
+	 *
+	 * @returns Return value.
+	 */
+	public get returnValue(): string {
+		return this[PropertySymbol.returnValue];
+	}
+
+	/**
+	 * Sets return value.
+	 *
+	 * @param value Return value.
+	 */
+	public set returnValue(value: string) {
+		this[PropertySymbol.returnValue] = String(value);
+	}
+
+	/**
+	 * Sets the "open" attribute.
+	 *
+	 * @param open Open.
+	 */
+	public set open(open: boolean) {
+		if (open) {
+			this.setAttribute('open', '');
+		} else {
+			this.removeAttribute('open');
+		}
+	}
+
+	/**
+	 * Returns open.
+	 *
+	 * @returns Open.
+	 */
+	public get open(): boolean {
+		return this.getAttribute('open') !== null;
+	}
+
+	/**
+	 * Closes the dialog.
+	 *
+	 * @param [returnValue] ReturnValue.
+	 */
+	public close(returnValue?: string): void {
+		const wasOpen = this.open;
+		this.removeAttribute('open');
+		this.returnValue = returnValue !== undefined ? String(returnValue) : '';
+		if (wasOpen) {
+			this.dispatchEvent(new Event('close'));
+		}
+	}
+
+	/**
+	 * Shows the modal.
+	 */
+	public showModal(): void {
+		this.setAttribute('open', '');
+	}
+
+	/**
+	 * Shows the dialog.
+	 */
+	public show(): void {
+		this.setAttribute('open', '');
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-div-element/HTMLDivElement.ts

@@ -0,0 +1,7 @@
+import HTMLElement from '../html-element/HTMLElement.js';
+/**
+ * HTMLDivElement
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLDivElement
+ */
+export default class HTMLDivElement extends HTMLElement {}

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-document/HTMLDocument.ts

@@ -0,0 +1,82 @@
+import Document from '../document/Document.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type Node from '../node/Node.js';
+import NodeTypeEnum from '../node/NodeTypeEnum.js';
+
+/**
+ * Document.
+ */
+export default class HTMLDocument extends Document {
+	/**
+	 * Constructor.
+	 */
+	constructor() {
+		super();
+
+		// Default document elements
+		const documentElement = this.createElement('html');
+		const bodyElement = this.createElement('body');
+		const headElement = this.createElement('head');
+
+		this.appendChild(documentElement);
+
+		documentElement.appendChild(headElement);
+		documentElement.appendChild(bodyElement);
+	}
+
+	/**
+	 * @override
+	 */
+	public override [PropertySymbol.appendChild](node: Node, disableValidations = false): Node {
+		if (node[PropertySymbol.nodeType] === NodeTypeEnum.textNode) {
+			throw new this[PropertySymbol.window].Error(
+				`Failed to execute 'appendChild' on 'Node': Nodes of type '#text' may not be inserted inside nodes of type '#document'.`
+			);
+		}
+
+		if (node[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode) {
+			return node;
+		}
+
+		if (
+			node[PropertySymbol.nodeType] === NodeTypeEnum.elementNode &&
+			this[PropertySymbol.elementArray].length !== 0
+		) {
+			throw new this[PropertySymbol.window].Error(
+				`Failed to execute 'appendChild' on 'Node': Only one element on document allowed.`
+			);
+		}
+
+		return super[PropertySymbol.appendChild](node, disableValidations);
+	}
+
+	/**
+	 * @override
+	 */
+	public override [PropertySymbol.insertBefore](
+		newNode: Node,
+		referenceNode: Node | null,
+		disableValidations = false
+	): Node {
+		if (newNode[PropertySymbol.nodeType] === NodeTypeEnum.textNode) {
+			throw new this[PropertySymbol.window].Error(
+				`Failed to execute 'insertBefore' on 'Node': Nodes of type '#text' may not be inserted inside nodes of type '#document'.`
+			);
+		}
+
+		if (newNode[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode) {
+			return newNode;
+		}
+
+		if (
+			newNode[PropertySymbol.nodeType] === NodeTypeEnum.elementNode &&
+			this[PropertySymbol.elementArray].length !== 0
+		) {
+			throw new this[PropertySymbol.window].Error(
+				`Failed to execute 'insertBefore' on 'Node': Only one element on document allowed.`
+			);
+		}
+
+		return super[PropertySymbol.insertBefore](newNode, referenceNode, disableValidations);
+	}
+}