buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/mutation-observer/MutationObserver.ts

@@ -0,0 +1,175 @@
+import * as PropertySymbol from '../PropertySymbol.js';
+import type Node from '../nodes/node/Node.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type IMutationObserverInit from './IMutationObserverInit.js';
+import MutationObserverListener from './MutationObserverListener.js';
+import type MutationRecord from './MutationRecord.js';
+
+/**
+ * The MutationObserver interface provides the ability to watch for changes being made to the DOM tree.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+ */
+export default class MutationObserver {
+	// Injected by WindowContextClassExtender
+	protected declare [PropertySymbol.window]: BrowserWindow;
+	#callback: (records: MutationRecord[], observer: MutationObserver) => void;
+	#listeners: MutationObserverListener[] = [];
+	#destroyed: boolean = false;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param callback Callback.
+	 */
+	constructor(callback: (records: MutationRecord[], observer: MutationObserver) => void) {
+		if (!this[PropertySymbol.window]) {
+			throw new TypeError(
+				`Failed to construct '${this.constructor.name}': '${this.constructor.name}' was constructed outside a Window context.`
+			);
+		}
+
+		this.#callback = callback;
+	}
+
+	/**
+	 * Starts observing.
+	 *
+	 * @param target Target.
+	 * @param options Options.
+	 */
+	public observe(target: Node, options: IMutationObserverInit): void {
+		if (this.#destroyed) {
+			return;
+		}
+
+		if (!target) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'observe' on 'MutationObserver': The first parameter "target" should be of type "Node".`
+			);
+		}
+
+		if (options && (options.attributeFilter || options.attributeOldValue)) {
+			if (options.attributes === undefined) {
+				options = Object.assign({}, options, {
+					attributes: true,
+					attributeFilter: options.attributeFilter,
+					attributeOldValue: options.attributeOldValue
+				});
+			}
+
+			if (!options.attributes && options.attributeOldValue) {
+				throw new this[PropertySymbol.window].TypeError(
+					`Failed to execute 'observe' on 'MutationObserver': The options object may only set 'attributeOldValue' to true when 'attributes' is true or not present.`
+				);
+			}
+
+			if (!options.attributes && options.attributeFilter) {
+				throw new this[PropertySymbol.window].TypeError(
+					`Failed to execute 'observe' on 'MutationObserver': The options object may only set 'attributeFilter' when 'attributes' is true or not present.`
+				);
+			}
+		}
+
+		if (options && options.characterDataOldValue) {
+			if (options.characterData === undefined) {
+				options = Object.assign({}, options, {
+					characterData: true,
+					characterDataOldValue: options.characterDataOldValue
+				});
+			}
+
+			if (!options.characterData && options.characterDataOldValue) {
+				throw new this[PropertySymbol.window].TypeError(
+					`Failed to execute 'observe' on 'MutationObserver': The options object may only set 'characterDataOldValue' to true when 'characterData' is true or not present.`
+				);
+			}
+		}
+
+		if (!options || (!options.childList && !options.attributes && !options.characterData)) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'observe' on 'MutationObserver': The options object must set at least one of 'attributes', 'characterData', or 'childList' to true.`
+			);
+		}
+
+		// Makes sure that attribute names are lower case.
+		// TODO: Is this correct?
+		options = Object.assign({}, options, {
+			attributeFilter: options.attributeFilter
+				? options.attributeFilter.map((name) => name.toLowerCase())
+				: null
+		});
+
+		/**
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver/observe#reusing_mutationobservers
+		 */
+		for (const listener of this.#listeners) {
+			if (listener.target === target) {
+				listener.options = options;
+				return;
+			}
+		}
+
+		const listener = new MutationObserverListener({
+			window: this[PropertySymbol.window],
+			options,
+			callback: this.#callback.bind(this),
+			observer: this,
+			target
+		});
+
+		this.#listeners.push(listener);
+
+		// Stores all observers on the window object, so that they can be disconnected when the window is closed.
+		if (!this[PropertySymbol.window][PropertySymbol.mutationObservers].includes(this)) {
+			this[PropertySymbol.window][PropertySymbol.mutationObservers].push(this);
+		}
+
+		// Starts observing target node.
+		(<Node>target)[PropertySymbol.observeMutations](listener.mutationListener);
+	}
+
+	/**
+	 * Disconnects.
+	 */
+	public disconnect(): void {
+		if (this.#listeners.length === 0) {
+			return;
+		}
+
+		for (const listener of this.#listeners) {
+			(<Node>listener.target)[PropertySymbol.unobserveMutations](listener.mutationListener);
+			listener.destroy();
+		}
+
+		this.#listeners = [];
+
+		const mutationObservers = this[PropertySymbol.window][PropertySymbol.mutationObservers];
+		const index = mutationObservers.indexOf(this);
+
+		if (index !== -1) {
+			mutationObservers.splice(index, 1);
+		}
+	}
+
+	/**
+	 * Returns a list of all matching DOM changes that have been detected but not yet processed by the observer's callback function, leaving the mutation queue empty.
+	 *
+	 * @returns Records.
+	 */
+	public takeRecords(): MutationRecord[] {
+		let records: MutationRecord[] = [];
+		for (const listener of this.#listeners) {
+			records = records.concat(listener.takeRecords());
+		}
+		return records;
+	}
+
+	/**
+	 *
+	 */
+	public [PropertySymbol.destroy](): void {
+		this.#destroyed = true;
+		this.disconnect();
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/mutation-observer/MutationObserverListener.ts

@@ -0,0 +1,115 @@
+import type IMutationObserverInit from './IMutationObserverInit.js';
+import type MutationObserver from './MutationObserver.js';
+import type MutationRecord from './MutationRecord.js';
+import type Node from '../nodes/node/Node.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type IMutationListener from './IMutationListener.js';
+
+/**
+ * Mutation Observer Listener.
+ */
+export default class MutationObserverListener {
+	public target: Node;
+	public options: IMutationObserverInit;
+	public mutationListener: IMutationListener;
+	#window: BrowserWindow;
+	#observer: MutationObserver;
+	#callback: (record: MutationRecord[], observer: MutationObserver) => void;
+	#records: MutationRecord[] = [];
+	#destroyed = false;
+	#microtaskQueued = false;
+	#listenerCallback: (record: MutationRecord) => void;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param init Options.
+	 * @param init.window Window.
+	 * @param init.options Options.
+	 * @param init.target Target.
+	 * @param init.observer Observer.
+	 * @param init.callback Callback.
+	 */
+	constructor(init: {
+		window: BrowserWindow;
+		options: IMutationObserverInit;
+		target: Node;
+		observer: MutationObserver;
+		callback: (record: MutationRecord[], observer: MutationObserver) => void;
+	}) {
+		this.options = init.options;
+		this.target = init.target;
+		this.#listenerCallback = (record: MutationRecord) => this.report(record);
+		this.mutationListener = {
+			options: init.options,
+			callback: new WeakRef(this.#listenerCallback)
+		};
+		this.#window = init.window;
+		this.#observer = init.observer;
+		this.#callback = init.callback;
+	}
+
+	/**
+	 * Reports mutations.
+	 *
+	 * @param record Record.
+	 */
+	public report(record: MutationRecord): void {
+		if (this.#destroyed) {
+			return;
+		}
+
+		this.#records.push(record);
+
+		if (this.#microtaskQueued) {
+			return;
+		}
+
+		this.#window.queueMicrotask(() => {
+			if (this.#destroyed) {
+				return;
+			}
+
+			this.#microtaskQueued = false;
+
+			const records = this.#records;
+
+			if (records?.length > 0) {
+				this.#records = [];
+				this.#callback(records, this.#observer);
+			}
+		});
+
+		this.#microtaskQueued = true;
+	}
+
+	/**
+	 * Destroys the listener.
+	 */
+	public takeRecords(): MutationRecord[] {
+		if (this.#destroyed) {
+			return [];
+		}
+		const records = this.#records;
+		this.#records = [];
+		return records;
+	}
+
+	/**
+	 * Destroys the listener.
+	 */
+	public destroy(): void {
+		if (this.#destroyed) {
+			return;
+		}
+		this.#destroyed = true;
+		this.options = null!;
+		this.target = null!;
+		this.#listenerCallback = null!;
+		this.mutationListener = null!;
+		this.#window = null!;
+		this.#observer = null!;
+		this.#callback = null!;
+		this.#records = null!;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/mutation-observer/MutationRecord.ts

@@ -0,0 +1,55 @@
+import type Node from '../nodes/node/Node.js';
+import type MutationTypeEnum from './MutationTypeEnum.js';
+
+/**
+ * MutationRecord is a model for a mutation.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord
+ */
+export default class MutationRecord {
+	public type: string;
+	public target: Node;
+	public addedNodes: Node[];
+	public removedNodes: Node[];
+	public previousSibling: Node | null;
+	public nextSibling: Node | null;
+	public attributeName: string | null;
+	public attributeNamespace: string | null;
+	public oldValue: string | null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param init Options to initialize the mutation record.
+	 * @param init.type Type.
+	 * @param init.target Target node.
+	 * @param init.addedNodes Nodes added.
+	 * @param init.removedNodes Nodes removed.
+	 * @param init.previousSibling Previous sibling node.
+	 * @param init.nextSibling Next sibling node.
+	 * @param init.attributeName Name of the attribute.
+	 * @param init.attributeNamespace Namespace of the attribute.
+	 * @param init.oldValue Previous value of the attribute.
+	 */
+	constructor(init: {
+		type: MutationTypeEnum;
+		target: Node;
+		addedNodes?: Node[];
+		removedNodes?: Node[];
+		previousSibling?: Node | null;
+		nextSibling?: Node | null;
+		attributeName?: string | null;
+		attributeNamespace?: string | null;
+		oldValue?: string | null;
+	}) {
+		this.type = init.type;
+		this.target = init.target;
+		this.addedNodes = init.addedNodes || [];
+		this.removedNodes = init.removedNodes || [];
+		this.previousSibling = init.previousSibling || null;
+		this.nextSibling = init.nextSibling || null;
+		this.attributeName = init.attributeName || null;
+		this.attributeNamespace = init.attributeNamespace || null;
+		this.oldValue = init.oldValue || null;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/mutation-observer/MutationTypeEnum.ts

@@ -0,0 +1,7 @@
+enum MutationTypeEnum {
+	attributes = 'attributes',
+	characterData = 'characterData',
+	childList = 'childList'
+}
+
+export default MutationTypeEnum;

package/vendor/happy-dom/packages/happy-dom/src/navigator/MimeType.ts

@@ -0,0 +1,35 @@
+import type Plugin from './Plugin.js';
+
+/**
+ * MimeType.
+ */
+export default class MimeType {
+	public readonly description: string;
+	public readonly enabledPlugin: Plugin;
+	public readonly suffixes: string;
+	public readonly type: string;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param description
+	 * @param enabledPlugin
+	 * @param suffixes
+	 * @param type
+	 */
+	constructor(description: string, enabledPlugin: Plugin, suffixes: string, type: string) {
+		this.description = description;
+		this.enabledPlugin = enabledPlugin;
+		this.suffixes = suffixes;
+		this.type = type;
+	}
+
+	/**
+	 * Returns the object as a string.
+	 *
+	 * @returns String.
+	 */
+	public toString(): string {
+		return '[object MimeType]';
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/navigator/MimeTypeArray.ts

@@ -0,0 +1,48 @@
+import type MimeType from './MimeType.js';
+
+/**
+ * MimeTypeArray.
+ *
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/MimeTypeArray.
+ */
+export default class MimeTypeArray {
+	[n: number]: MimeType;
+	public readonly length: number;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param mimeTypes
+	 */
+	constructor(mimeTypes: MimeType[]) {
+		for (let i = 0, max = mimeTypes.length; i < max; i++) {
+			this[i] = mimeTypes[i];
+			(<any>this)[mimeTypes[i].type] = mimeTypes[i];
+		}
+		this.length = mimeTypes.length;
+	}
+
+	/**
+	 * @param index
+	 */
+	public item(index: number): MimeType {
+		return this[index] || null;
+	}
+
+	/**
+	 * @param name
+	 */
+	public namedItem(name: string): MimeType {
+		return (<any>this)[name] || null;
+	}
+
+	/**
+	 * Returns the object as a string.
+	 *
+	 * @returns String.
+	 */
+	public toString(): string {
+		return '[object MimeTypeArray]';
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/navigator/Navigator.ts

@@ -0,0 +1,247 @@
+import MimeTypeArray from './MimeTypeArray.js';
+import PluginArray from './PluginArray.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import Permissions from '../permissions/Permissions.js';
+import Clipboard from '../clipboard/Clipboard.js';
+import WindowBrowserContext from '../window/WindowBrowserContext.js';
+import type Blob from '../file/Blob.js';
+import type FormData from '../form-data/FormData.js';
+
+/**
+ * Browser Navigator API.
+ *
+ * Mocked information is taken from FireFox.
+ *
+ * Reference:
+ * https://html.spec.whatwg.org/multipage/system-state.html#dom-navigator.
+ */
+export default class Navigator {
+	#window: BrowserWindow;
+	#clipboard: Clipboard;
+	#permissions: Permissions;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param window Owner window.
+	 */
+	constructor(window: BrowserWindow) {
+		if (!window) {
+			throw new TypeError('Invalid constructor');
+		}
+
+		this.#window = window;
+		this.#clipboard = new Clipboard(window);
+		this.#permissions = new Permissions(window);
+	}
+
+	/**
+	 * False if setting a cookie will be ignored and true otherwise.
+	 */
+	public get cookieEnabled(): boolean {
+		return true;
+	}
+
+	/**
+	 * TODO: Not implemented.
+	 */
+	public get credentials(): any {
+		return null;
+	}
+
+	/**
+	 * TODO: Not implemented.
+	 */
+	public get geolocation(): any {
+		return null;
+	}
+
+	/**
+	 * String representing the preferred language of the user, usually the language of the browser UI.
+	 */
+	public get language(): string {
+		return 'en-US';
+	}
+
+	/**
+	 * Array of string representing the user's preferred languages.
+	 */
+	public get languages(): string[] {
+		return ['en-US', 'en'];
+	}
+
+	/**
+	 * TODO: Not implemented.
+	 */
+	public get locks(): any {
+		return null;
+	}
+
+	/**
+	 * Maximum number of simultaneous touch contact points are supported by the current device.
+	 */
+	public get maxTouchPoints(): number {
+		return new WindowBrowserContext(this.#window).getSettings()?.navigator.maxTouchPoints || 0;
+	}
+
+	/**
+	 * Number of logical processors available to run threads on the user's computer.
+	 */
+	public get hardwareConcurrency(): number {
+		return 8;
+	}
+
+	/**
+	 * Browser app code name.
+	 */
+	public get appCodeName(): string {
+		return 'Mozilla';
+	}
+
+	/**
+	 * Browser app name.
+	 */
+	public get appName(): string {
+		return 'Netscape';
+	}
+
+	/**
+	 * Browser app version.
+	 */
+	public get appVersion(): string {
+		const userAgent = this.userAgent;
+		const index = userAgent.indexOf('/');
+		return index > -1 ? userAgent.substring(index + 1) : '';
+	}
+
+	/**
+	 * Browser platform.
+	 */
+	public get platform(): string {
+		const userAgent = this.userAgent;
+		const indexStart = userAgent.indexOf('(');
+		const indexEnd = userAgent.indexOf(')');
+		return indexStart > -1 && indexEnd > -1 ? userAgent.substring(indexStart + 1, indexEnd) : '';
+	}
+
+	/**
+	 * Browser product.
+	 */
+	public get product(): string {
+		return 'Gecko';
+	}
+
+	/**
+	 * Browser product sub.
+	 */
+	public get productSub(): string {
+		return '20100101';
+	}
+
+	/**
+	 * Browser vendor.
+	 */
+	public get vendor(): string {
+		return '';
+	}
+
+	/**
+	 * Browser vendor sub.
+	 */
+	public get vendorSub(): string {
+		return '';
+	}
+
+	/**
+	 * Browser user agent.
+	 *
+	 * "appCodeName/appVersion number (Platform; Security; OS-or-CPU; Localization; rv: revision-version-number) product/productSub Application-Name Application-Name-version".
+	 */
+	public get userAgent(): string {
+		return new WindowBrowserContext(this.#window).getSettings()?.navigator.userAgent || '';
+	}
+
+	/**
+	 * Boolean value indicating whether the browser is working online.
+	 */
+	public get onLine(): boolean {
+		return true;
+	}
+
+	/**
+	 * Returns a Permissions object that can be used to query and update permission status of APIs covered by the Permissions API.
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/permissions
+	 * @returns Permissions.
+	 */
+	public get permissions(): Permissions {
+		return this.#permissions;
+	}
+
+	/**
+	 * Returns a Clipboard object providing access to the contents of the system clipboard.
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/clipboard
+	 * @returns Clipboard.
+	 */
+	public get clipboard(): Clipboard {
+		return this.#clipboard;
+	}
+
+	/**
+	 * Boolean Indicates whether the user agent is controlled by automation.
+	 */
+	public get webdriver(): boolean {
+		return true;
+	}
+
+	/**
+	 * The user's Do Not Track setting, which indicates whether the user is requesting web sites and advertisers to not track them.
+	 *
+	 * The value of the property reflects that of the DNT HTTP header, i.e. Values of "1", "0", or "unspecified".
+	 */
+	public get doNotTrack(): string {
+		return 'unspecified';
+	}
+
+	/**
+	 * Browser mime-types.
+	 */
+	public get mimeTypes(): MimeTypeArray {
+		return new MimeTypeArray([]);
+	}
+
+	/**
+	 * Browser plugins.
+	 */
+	public get plugins(): PluginArray {
+		return new PluginArray([]);
+	}
+
+	/**
+	 * Sends an HTTP POST request containing a small amount of data to a web server.
+	 *
+	 * @param url URL.
+	 * @param data Data.
+	 * @returns "true" if the user agent successfully queued the data for transfer. Otherwise, it returns "false".
+	 */
+	public sendBeacon(
+		url: string,
+		data: string | Blob | ArrayBuffer | ArrayBufferView | FormData
+	): boolean {
+		this.#window.fetch(url, {
+			method: 'POST',
+			body: data
+		});
+		return true;
+	}
+
+	/**
+	 * Returns the object as a string.
+	 *
+	 * @returns String.
+	 */
+	public toString(): string {
+		return '[object Navigator]';
+	}
+}