buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/dom/dom-matrix/IDOMMatrixCompatibleObject.ts

@@ -0,0 +1,24 @@
+export default interface IDOMMatrixCompatibleObject {
+	a?: number;
+	b?: number;
+	c?: number;
+	d?: number;
+	e?: number;
+	f?: number;
+	m11?: number;
+	m12?: number;
+	m13?: number;
+	m14?: number;
+	m21?: number;
+	m22?: number;
+	m23?: number;
+	m24?: number;
+	m31?: number;
+	m32?: number;
+	m33?: number;
+	m34?: number;
+	m41?: number;
+	m42?: number;
+	m43?: number;
+	m44?: number;
+}

package/vendor/happy-dom/packages/happy-dom/src/dom/dom-matrix/IDOMMatrixJSON.ts

@@ -0,0 +1,26 @@
+export default interface IDOMMatrixJSON {
+	a: number;
+	b: number;
+	c: number;
+	d: number;
+	e: number;
+	f: number;
+	m11: number;
+	m12: number;
+	m13: number;
+	m14: number;
+	m21: number;
+	m22: number;
+	m23: number;
+	m24: number;
+	m31: number;
+	m32: number;
+	m33: number;
+	m34: number;
+	m41: number;
+	m42: number;
+	m43: number;
+	m44: number;
+	is2D: boolean;
+	isIdentity: boolean;
+}

package/vendor/happy-dom/packages/happy-dom/src/dom/dom-matrix/TDOMMatrix2DArray.ts

@@ -0,0 +1,3 @@
+/** An array of 6 numbers representing a 2D matrix. */
+
+export type TDOMMatrix2DArray = [number, number, number, number, number, number];

package/vendor/happy-dom/packages/happy-dom/src/dom/dom-matrix/TDOMMatrix3DArray.ts

@@ -0,0 +1,20 @@
+/** An array of 16 numbers representing a 3D matrix. */
+
+export type TDOMMatrix3DArray = [
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number,
+	number
+];

package/vendor/happy-dom/packages/happy-dom/src/dom/dom-matrix/TDOMMatrixInit.ts

@@ -0,0 +1,8 @@
+import type IDOMMatrixCompatibleObject from './IDOMMatrixCompatibleObject.js';
+
+export type TDOMMatrixInit =
+	| string
+	| any[]
+	| IDOMMatrixCompatibleObject
+	| Float32Array
+	| Float64Array;

package/vendor/happy-dom/packages/happy-dom/src/dom-implementation/DOMImplementation.ts

@@ -0,0 +1,81 @@
+import DocumentType from '../nodes/document-type/DocumentType.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type Document from '../nodes/document/Document.js';
+import NodeFactory from '../nodes/NodeFactory.js';
+
+/**
+ * The DOMImplementation interface represents an object providing methods which are not dependent on any particular document. Such an object is returned by the.
+ */
+export default class DOMImplementation {
+	#document: Document;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param document Document.
+	 */
+	constructor(document: Document) {
+		this.#document = document;
+	}
+
+	/**
+	 * Creates and returns an XML Document.
+	 *
+	 * TODO: Not fully implemented.
+	 *
+	 * @param _namespaceURI Namespace URI.
+	 * @param qualifiedName Qualified name.
+	 * @param [_docType] Document type.
+	 */
+	public createDocument(
+		_namespaceURI: string | null,
+		qualifiedName: string | null,
+		_docType?: string | null
+	): Document {
+		if (arguments.length < 2) {
+			throw new this.#document[PropertySymbol.window].TypeError(
+				`Failed to execute 'createDocument' on 'DOMImplementation': 2 arguments required, but only ${arguments.length} present.`
+			);
+		}
+
+		// The spec declares "qualifiedName" as "[LegacyNullToEmptyString] DOMString",
+		// so "null" is coerced to an empty string instead of being rejected.
+		qualifiedName = qualifiedName === null ? '' : String(qualifiedName);
+
+		switch (qualifiedName.split(':').pop()) {
+			case 'svg':
+			case 'xml':
+				return new this.#document[PropertySymbol.window].XMLDocument();
+			default:
+				return new this.#document[PropertySymbol.window].HTMLDocument();
+		}
+	}
+
+	/**
+	 * Creates and returns an HTML Document.
+	 */
+	public createHTMLDocument(): Document {
+		return new this.#document[PropertySymbol.window].HTMLDocument();
+	}
+
+	/**
+	 * Creates and returns an HTML Document.
+	 *
+	 * @param qualifiedName Qualified name.
+	 * @param publicId Public ID.
+	 * @param systemId System ID.
+	 */
+	public createDocumentType(
+		qualifiedName: string,
+		publicId: string,
+		systemId: string
+	): DocumentType {
+		const documentType = NodeFactory.createNode<DocumentType>(this.#document, DocumentType);
+
+		documentType[PropertySymbol.name] = qualifiedName;
+		documentType[PropertySymbol.publicId] = publicId;
+		documentType[PropertySymbol.systemId] = systemId;
+
+		return documentType;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/dom-parser/DOMParser.ts

@@ -0,0 +1,47 @@
+import type Document from '../nodes/document/Document.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import XMLParser from '../xml-parser/XMLParser.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import HTMLParser from '../html-parser/HTMLParser.js';
+
+/**
+ * DOM parser.
+ *
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/DOMParser.
+ */
+export default class DOMParser {
+	// Injected by WindowContextClassExtender
+	protected declare [PropertySymbol.window]: BrowserWindow;
+
+	/**
+	 * Parses HTML and returns a root element.
+	 *
+	 * @param string HTML data.
+	 * @param mimeType Mime type.
+	 * @returns Root element.
+	 */
+	public parseFromString(string: string, mimeType: string): Document {
+		if (!mimeType) {
+			throw new this[PropertySymbol.window].DOMException(
+				'Second parameter "mimeType" is mandatory.'
+			);
+		}
+
+		const window = this[PropertySymbol.window];
+
+		switch (mimeType) {
+			case 'text/html':
+				const newDocument = new window.HTMLDocument();
+				newDocument[PropertySymbol.defaultView] = window;
+				return <Document>new HTMLParser(this[PropertySymbol.window]).parse(string, newDocument);
+			case 'image/svg+xml':
+			case 'text/xml':
+			case 'application/xml':
+			case 'application/xhtml+xml':
+				return <Document>new XMLParser(this[PropertySymbol.window]).parse(string);
+			default:
+				throw new window.DOMException(`Unknown mime type "${mimeType}".`);
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/event/DataTransfer.ts

@@ -0,0 +1,128 @@
+import type File from '../file/File.js';
+import DataTransferItem from './DataTransferItem.js';
+import DataTransferItemList from './DataTransferItemList.js';
+
+/**
+ * DataTransfer.
+ *
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer
+ */
+export default class DataTransfer {
+	public dropEffect: 'none' | 'copy' | 'link' | 'move' = 'none';
+	public effectAllowed:
+		| 'none'
+		| 'copy'
+		| 'copyLink'
+		| 'copyMove'
+		| 'link'
+		| 'linkMove'
+		| 'move'
+		| 'all'
+		| 'uninitialized' = 'none';
+	public readonly items: DataTransferItemList = new DataTransferItemList();
+
+	/**
+	 * Returns files.
+	 *
+	 * @returns Files.
+	 */
+	public get files(): File[] {
+		const files: File[] = [];
+		for (const item of this.items) {
+			if (item.kind === 'file') {
+				const file = item.getAsFile();
+				if (file) {
+					files.push(file);
+				}
+			}
+		}
+		return files;
+	}
+
+	/**
+	 * Returns types.
+	 *
+	 * @returns Types.
+	 */
+	public get types(): string[] {
+		return this.items.map((item) => item.type);
+	}
+
+	/**
+	 * Clears the data.
+	 */
+	public clearData(): void {
+		this.items.clear();
+	}
+
+	/**
+	 * Sets the data.
+	 *
+	 * @param format Format.
+	 * @param data Data.
+	 */
+	public setData(format: string, data: string): void {
+		for (let i = 0, max = this.items.length; i < max; i++) {
+			if (this.items[i].type === format) {
+				this.items[i] = new DataTransferItem(data, format);
+				return;
+			}
+		}
+		this.items.add(data, format);
+	}
+
+	/**
+	 * Gets the data.
+	 *
+	 * @param format Format.
+	 * @returns Data.
+	 */
+	public getData(format: string): string {
+		// Normalize format according to the spec
+		// https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransfer-getdata
+		const normalizedFormat = this.#normalizeFormat(format);
+
+		for (let i = 0, max = this.items.length; i < max; i++) {
+			const itemFormat = this.#normalizeFormat(this.items[i].type);
+			if (itemFormat === normalizedFormat) {
+				let data = '';
+				this.items[i].getAsString((s) => (data = s));
+				return data;
+			}
+		}
+		return '';
+	}
+
+	/**
+	 * Normalizes the format according to the HTML spec.
+	 *
+	 * @param format Format to normalize.
+	 * @returns Normalized format.
+	 */
+	#normalizeFormat(format: string): string {
+		// Convert to lowercase as per spec
+		const lowercaseFormat = format.toLowerCase();
+
+		// "text" is a shorthand for "text/plain"
+		if (lowercaseFormat === 'text') {
+			return 'text/plain';
+		}
+
+		// "url" is a shorthand for "text/uri-list"
+		if (lowercaseFormat === 'url') {
+			return 'text/uri-list';
+		}
+
+		return lowercaseFormat;
+	}
+
+	/**
+	 * Sets drag image.
+	 *
+	 * TODO: Implement.
+	 */
+	public setDragImage(): void {
+		throw new Error('Not implemented.');
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/event/DataTransferItem.ts

@@ -0,0 +1,47 @@
+import type File from '../file/File.js';
+
+/**
+ * Data transfer item.
+ *
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem.
+ */
+export default class DataTransferItem {
+	public readonly kind: 'string' | 'file';
+	public readonly type: string;
+	#item: string | File | null = null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param item Item.
+	 * @param type Type.
+	 */
+	constructor(item: string | File, type = '') {
+		this.kind = typeof item === 'string' ? 'string' : 'file';
+		this.type = this.kind === 'string' ? type : (<File>item).type;
+		this.#item = item;
+	}
+
+	/**
+	 * Returns file.
+	 */
+	public getAsFile(): File | null {
+		if (this.kind === 'string') {
+			return null;
+		}
+		return <File>this.#item;
+	}
+
+	/**
+	 * Returns string.
+	 *
+	 * @param callback Callback.
+	 */
+	public getAsString(callback: (text: string) => void): void {
+		if (this.kind === 'file') {
+			callback('');
+		}
+		callback(<string>this.#item);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/event/DataTransferItemList.ts

@@ -0,0 +1,44 @@
+import File from '../file/File.js';
+import DataTransferItem from './DataTransferItem.js';
+
+/**
+ *
+ */
+export default class DataTransferItemList extends Array<DataTransferItem> {
+	/**
+	 * Adds an item.
+	 *
+	 * @param item Item.
+	 * @param type Type.
+	 */
+	public add(item: File | string, type?: string): void {
+		if (item instanceof File) {
+			this.push(new DataTransferItem(item));
+			return;
+		}
+		if (!type) {
+			throw new TypeError(
+				`Failed to execute 'add' on 'DataTransferItemList': parameter 1 is not of type 'File'.`
+			);
+		}
+		this.push(new DataTransferItem(item, type));
+	}
+
+	/**
+	 * Removes an item.
+	 *
+	 * @param index Index.
+	 */
+	public remove(index: number): void {
+		this.splice(index, 1);
+	}
+
+	/**
+	 * Clears list.
+	 */
+	public clear(): void {
+		while (this.length) {
+			this.pop();
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/event/Event.ts

@@ -0,0 +1,222 @@
+import type IEventInit from './IEventInit.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type Node from '../nodes/node/Node.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type ShadowRoot from '../nodes/shadow-root/ShadowRoot.js';
+import type EventTarget from './EventTarget.js';
+import NodeTypeEnum from '../nodes/node/NodeTypeEnum.js';
+import EventPhaseEnum from './EventPhaseEnum.js';
+import type Document from '../nodes/document/Document.js';
+
+/**
+ * Event.
+ */
+export default class Event {
+	public static NONE = EventPhaseEnum.none;
+	public static CAPTURING_PHASE = EventPhaseEnum.capturing;
+	public static AT_TARGET = EventPhaseEnum.atTarget;
+	public static BUBBLING_PHASE = EventPhaseEnum.bubbling;
+
+	public NONE = Event.NONE;
+	public CAPTURING_PHASE = Event.CAPTURING_PHASE;
+	public AT_TARGET = Event.AT_TARGET;
+	public BUBBLING_PHASE = Event.BUBBLING_PHASE;
+
+	public [PropertySymbol.composed] = false;
+	public [PropertySymbol.bubbles] = false;
+	public [PropertySymbol.cancelable] = false;
+	public [PropertySymbol.defaultPrevented] = false;
+	public [PropertySymbol.eventPhase] = EventPhaseEnum.none;
+	public [PropertySymbol.timeStamp] = performance.now();
+	public [PropertySymbol.type]: string;
+
+	public [PropertySymbol.dispatching] = false;
+	public [PropertySymbol.immediatePropagationStopped] = false;
+	public [PropertySymbol.propagationStopped] = false;
+	public [PropertySymbol.target]: EventTarget | null = null;
+	public [PropertySymbol.currentTarget]: EventTarget | null = null;
+	public [PropertySymbol.isInPassiveEventListener] = false;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param type Event type.
+	 * @param [eventInit] Event init.
+	 */
+	constructor(type: string, eventInit: IEventInit | null = null) {
+		this[PropertySymbol.type] = type;
+		this[PropertySymbol.bubbles] = eventInit?.bubbles ?? false;
+		this[PropertySymbol.cancelable] = eventInit?.cancelable ?? false;
+		this[PropertySymbol.composed] = eventInit?.composed ?? false;
+	}
+
+	/**
+	 * Returns composed.
+	 *
+	 * @returns Composed.
+	 */
+	public get composed(): boolean {
+		return this[PropertySymbol.composed];
+	}
+
+	/**
+	 * Returns bubbles.
+	 *
+	 * @returns Bubbles.
+	 */
+	public get bubbles(): boolean {
+		return this[PropertySymbol.bubbles];
+	}
+
+	/**
+	 * Returns cancelable.
+	 *
+	 * @returns Cancelable.
+	 */
+	public get cancelable(): boolean {
+		return this[PropertySymbol.cancelable];
+	}
+
+	/**
+	 * Returns defaultPrevented.
+	 *
+	 * @returns Default prevented.
+	 */
+	public get defaultPrevented(): boolean {
+		return this[PropertySymbol.defaultPrevented];
+	}
+
+	/**
+	 * Returns eventPhase.
+	 *
+	 * @returns Event phase.
+	 */
+	public get eventPhase(): EventPhaseEnum {
+		return this[PropertySymbol.eventPhase];
+	}
+
+	/**
+	 * Returns timeStamp.
+	 *
+	 * @returns Time stamp.
+	 */
+	public get timeStamp(): number {
+		return this[PropertySymbol.timeStamp];
+	}
+
+	/**
+	 * Returns type.
+	 *
+	 * @returns Type.
+	 */
+	public get type(): string {
+		return this[PropertySymbol.type];
+	}
+
+	/**
+	 * Returns target.
+	 *
+	 * @returns Target.
+	 */
+	public get target(): EventTarget {
+		return this[PropertySymbol.target]!;
+	}
+
+	/**
+	 * Returns target.
+	 *
+	 * @returns Target.
+	 */
+	public get currentTarget(): EventTarget {
+		return this[PropertySymbol.currentTarget]!;
+	}
+
+	/**
+	 * Returns "true" if propagation has been stopped.
+	 *
+	 * @returns "true" if propagation has been stopped.
+	 */
+	public get cancelBubble(): boolean {
+		return this[PropertySymbol.propagationStopped];
+	}
+
+	/**
+	 * Returns composed path.
+	 *
+	 * @returns Composed path.
+	 */
+	public composedPath(): EventTarget[] {
+		if (!this[PropertySymbol.target]) {
+			return [];
+		}
+
+		const composedPath = [];
+		let eventTarget: Node | ShadowRoot | BrowserWindow | null = <Node | ShadowRoot>(
+			this[PropertySymbol.target]
+		);
+
+		while (eventTarget) {
+			composedPath.push(eventTarget);
+
+			if ((<Node>(<unknown>eventTarget)).parentNode) {
+				eventTarget = (<Node>(<unknown>eventTarget)).parentNode!;
+			} else if (
+				this[PropertySymbol.composed] &&
+				(<Node>eventTarget)[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode &&
+				(<ShadowRoot>eventTarget).host
+			) {
+				eventTarget = (<ShadowRoot>eventTarget).host;
+			} else if (
+				(<Node>eventTarget)[PropertySymbol.nodeType] === NodeTypeEnum.documentNode &&
+				// The "load" event is a special case. It should not bubble up to the window.
+				this[PropertySymbol.type] !== 'load'
+			) {
+				eventTarget = (<Document>(<unknown>eventTarget))[PropertySymbol.window];
+			} else {
+				break;
+			}
+		}
+
+		return composedPath;
+	}
+
+	/**
+	 * Init event.
+	 *
+	 * @deprecated
+	 * @param type Type.
+	 * @param [bubbles=false] "true" if it bubbles.
+	 * @param [cancelable=false] "true" if it cancelable.
+	 */
+	public initEvent(type: string, bubbles = false, cancelable = false): void {
+		this[PropertySymbol.type] = type;
+		this[PropertySymbol.bubbles] = bubbles;
+		this[PropertySymbol.cancelable] = cancelable;
+		this[PropertySymbol.propagationStopped] = false;
+		this[PropertySymbol.immediatePropagationStopped] = false;
+		this[PropertySymbol.defaultPrevented] = false;
+	}
+
+	/**
+	 * Prevents default.
+	 */
+	public preventDefault(): void {
+		if (!this[PropertySymbol.isInPassiveEventListener] && this.cancelable) {
+			this[PropertySymbol.defaultPrevented] = true;
+		}
+	}
+
+	/**
+	 * Stops immediate propagation.
+	 */
+	public stopImmediatePropagation(): void {
+		this[PropertySymbol.immediatePropagationStopped] = true;
+	}
+
+	/**
+	 * Stops propagation.
+	 */
+	public stopPropagation(): void {
+		this[PropertySymbol.propagationStopped] = true;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/event/EventPhaseEnum.ts

@@ -0,0 +1,7 @@
+enum EventPhaseEnum {
+	none = 0,
+	capturing = 1,
+	atTarget = 2,
+	bubbling = 3
+}
+export default EventPhaseEnum;