buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/async-task-manager/AsyncTaskManager.ts

@@ -0,0 +1,340 @@
+import type IBrowserFrame from '../browser/types/IBrowserFrame.js';
+import AsyncTaskManagerDebugError from './AsyncTaskManagerDebugError.js';
+
+// We need to set this as a global constant, so that using fake timers in Jest and Vitest won't override this on the global object.
+const TIMER = {
+	setTimeout: globalThis.setTimeout.bind(globalThis),
+	clearTimeout: globalThis.clearTimeout.bind(globalThis),
+	clearImmediate: globalThis.clearImmediate.bind(globalThis)
+};
+
+/**
+ * Handles async tasks.
+ */
+export default class AsyncTaskManager {
+	private static taskID = 0;
+	private runningTasks: { [k: string]: (destroy: boolean) => void } = {};
+	private runningTaskCount = 0;
+	private runningTimers: NodeJS.Timeout[] = [];
+	private runningImmediates: NodeJS.Immediate[] = [];
+	private debugTrace: Map<number | NodeJS.Timeout | NodeJS.Immediate, string> = new Map();
+	private waitUntilCompleteTimer: NodeJS.Timeout | null = null;
+	private waitUntilCompleteResolvers: Array<{
+		resolve: () => void;
+		reject: (error: Error) => void;
+	}> = [];
+	private destroyed = false;
+	#debugTimeout: NodeJS.Timeout | null = null;
+	#browserFrame: IBrowserFrame;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param browserFrame Browser frame.
+	 */
+	constructor(browserFrame: IBrowserFrame) {
+		this.#browserFrame = browserFrame;
+	}
+
+	/**
+	 * Returns a promise that is resolved when async tasks are complete.
+	 *
+	 * @returns Promise.
+	 */
+	public waitUntilComplete(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			this.waitUntilCompleteResolvers.push({ resolve, reject });
+			this.resolveWhenComplete();
+		});
+	}
+
+	/**
+	 * Aborts all tasks.
+	 */
+	public abort(): Promise<void> {
+		if (this.destroyed) {
+			return new Promise((resolve, reject) => {
+				this.waitUntilCompleteResolvers.push({ resolve, reject });
+				this.resolveWhenComplete();
+			});
+		}
+		return this.abortAll(false);
+	}
+
+	/**
+	 * Destroys the manager.
+	 */
+	public destroy(): Promise<void> {
+		if (this.destroyed) {
+			return new Promise((resolve, reject) => {
+				this.waitUntilCompleteResolvers.push({ resolve, reject });
+				this.resolveWhenComplete();
+			});
+		}
+		return this.abortAll(true);
+	}
+
+	/**
+	 * Starts a timer.
+	 *
+	 * @param timerID Timer ID.
+	 */
+	public startTimer(timerID: NodeJS.Timeout): void {
+		if (this.destroyed) {
+			TIMER.clearTimeout(timerID);
+			return;
+		}
+		if (this.waitUntilCompleteTimer) {
+			TIMER.clearTimeout(this.waitUntilCompleteTimer);
+			this.waitUntilCompleteTimer = null;
+		}
+		this.runningTimers.push(timerID);
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.set(timerID, new AsyncTaskManagerDebugError().stack!);
+		}
+	}
+
+	/**
+	 * Ends a timer.
+	 *
+	 * @param timerID Timer ID.
+	 */
+	public endTimer(timerID: NodeJS.Timeout): void {
+		if (this.destroyed) {
+			TIMER.clearTimeout(timerID);
+			return;
+		}
+		const index = this.runningTimers.indexOf(timerID);
+		if (index !== -1) {
+			this.runningTimers.splice(index, 1);
+			this.resolveWhenComplete();
+		}
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.delete(timerID);
+		}
+	}
+
+	/**
+	 * Starts an immediate.
+	 *
+	 * @param immediateID Immediate ID.
+	 */
+	public startImmediate(immediateID: NodeJS.Immediate): void {
+		if (this.destroyed) {
+			TIMER.clearImmediate(immediateID);
+			return;
+		}
+		if (this.waitUntilCompleteTimer) {
+			TIMER.clearTimeout(this.waitUntilCompleteTimer);
+			this.waitUntilCompleteTimer = null;
+		}
+		this.runningImmediates.push(immediateID);
+		if (this.#browserFrame.page?.context?.browser?.settings?.debug?.traceWaitUntilComplete > 0) {
+			this.debugTrace.set(immediateID, new AsyncTaskManagerDebugError().stack!);
+		}
+	}
+
+	/**
+	 * Ends an immediate.
+	 *
+	 * @param immediateID Immediate ID.
+	 */
+	public endImmediate(immediateID: NodeJS.Immediate): void {
+		if (this.destroyed) {
+			TIMER.clearImmediate(immediateID);
+			return;
+		}
+		const index = this.runningImmediates.indexOf(immediateID);
+		if (index !== -1) {
+			this.runningImmediates.splice(index, 1);
+			this.resolveWhenComplete();
+		}
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.delete(immediateID);
+		}
+	}
+
+	/**
+	 * Starts an async task.
+	 *
+	 * @param abortHandler Abort handler.
+	 * @returns Task ID.
+	 */
+	public startTask(abortHandler?: (destroy?: boolean) => void): number {
+		if (this.destroyed) {
+			if (abortHandler) {
+				abortHandler(this.destroyed);
+			}
+			throw new this.#browserFrame.window.Error(
+				`Failed to execute 'startTask()' on 'AsyncTaskManager': The asynchronous task manager has been destroyed. This error can be thrown if scripts continue to run while a browser frame is closed.`
+			);
+		}
+		if (this.waitUntilCompleteTimer) {
+			TIMER.clearTimeout(this.waitUntilCompleteTimer);
+			this.waitUntilCompleteTimer = null;
+		}
+		const taskID = this.newTaskID();
+		this.runningTasks[taskID] = abortHandler ? abortHandler : () => {};
+		this.runningTaskCount++;
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.set(taskID, new AsyncTaskManagerDebugError().stack!);
+		}
+		return taskID;
+	}
+
+	/**
+	 * Ends an async task.
+	 *
+	 * @param taskID Task ID.
+	 */
+	public endTask(taskID: number): void {
+		if (this.destroyed) {
+			return;
+		}
+		if (this.runningTasks[taskID]) {
+			delete this.runningTasks[taskID];
+			this.runningTaskCount--;
+			this.resolveWhenComplete();
+		}
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.delete(taskID);
+		}
+	}
+
+	/**
+	 * Returns the amount of running tasks.
+	 *
+	 * @returns Count.
+	 */
+	public getTaskCount(): number {
+		return this.runningTaskCount;
+	}
+
+	/**
+	 * Returns a new task ID.
+	 *
+	 * @returns Task ID.
+	 */
+	private newTaskID(): number {
+		(<typeof AsyncTaskManager>this.constructor).taskID++;
+		return (<typeof AsyncTaskManager>this.constructor).taskID;
+	}
+
+	/**
+	 * Resolves when complete.
+	 */
+	private resolveWhenComplete(): void {
+		this.applyDebugging();
+
+		if (this.runningTaskCount || this.runningTimers.length || this.runningImmediates.length) {
+			return;
+		}
+
+		if (this.waitUntilCompleteTimer) {
+			TIMER.clearTimeout(this.waitUntilCompleteTimer);
+			this.waitUntilCompleteTimer = null;
+		}
+
+		// It is not possible to detect when all microtasks are complete (such as process.nextTick() or promises).
+		// To cater for this we use setTimeout() which has the lowest priority and will be executed last.
+		// @see https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick
+		this.waitUntilCompleteTimer = TIMER.setTimeout(() => {
+			this.waitUntilCompleteTimer = null;
+			if (!this.runningTaskCount && !this.runningTimers.length && !this.runningImmediates.length) {
+				if (this.#debugTimeout) {
+					TIMER.clearTimeout(this.#debugTimeout);
+				}
+				const resolvers = this.waitUntilCompleteResolvers;
+				this.waitUntilCompleteResolvers = [];
+				for (const resolver of resolvers) {
+					resolver.resolve();
+				}
+				this.destroyed = false;
+			} else {
+				this.applyDebugging();
+			}
+		}, 1);
+	}
+
+	/**
+	 * Applies debugging.
+	 */
+	private applyDebugging(): void {
+		const debug = this.#browserFrame.page.context.browser.settings.debug;
+		if (!debug?.traceWaitUntilComplete || debug.traceWaitUntilComplete < 1) {
+			return;
+		}
+		if (this.#debugTimeout) {
+			return;
+		}
+		this.#debugTimeout = TIMER.setTimeout(() => {
+			this.#debugTimeout = null;
+
+			let errorMessage = `The maximum time was reached for "waitUntilComplete()".\n\n${
+				this.debugTrace.size
+			} task${
+				this.debugTrace.size === 1 ? '' : 's'
+			} did not end in time.\n\nThe following traces were recorded:\n\n`;
+
+			let number = 1;
+			for (const [key, value] of this.debugTrace.entries()) {
+				const type = typeof key === 'number' ? 'Task' : 'Timer';
+				errorMessage += `${type} #${number}\n‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾${value
+					.replace(/AsyncTaskManagerDebugError:{0,1}/, '')
+					.replace(/\s+at /gm, '\n> ')}\n\n`;
+				number++;
+			}
+
+			const error = new Error(errorMessage);
+
+			for (const resolver of this.waitUntilCompleteResolvers) {
+				resolver.reject(error);
+			}
+
+			this.abortAll(true);
+		}, debug.traceWaitUntilComplete);
+	}
+
+	/**
+	 * Aborts all tasks.
+	 *
+	 * @param destroy Destroy.
+	 */
+	private abortAll(destroy: boolean): Promise<void> {
+		const runningTimers = this.runningTimers;
+		const runningImmediates = this.runningImmediates;
+		const runningTasks = this.runningTasks;
+
+		if (destroy) {
+			this.destroyed = true;
+		}
+		this.runningTasks = {};
+		this.runningTaskCount = 0;
+		this.runningImmediates = [];
+		this.runningTimers = [];
+		this.debugTrace = new Map();
+
+		if (this.waitUntilCompleteTimer) {
+			TIMER.clearTimeout(this.waitUntilCompleteTimer);
+			this.waitUntilCompleteTimer = null;
+		}
+
+		for (const immediate of runningImmediates) {
+			TIMER.clearImmediate(immediate);
+		}
+
+		for (const timer of runningTimers) {
+			TIMER.clearTimeout(timer);
+		}
+
+		for (const key of Object.keys(runningTasks)) {
+			runningTasks[key](destroy);
+		}
+
+		// We need to wait for microtasks to complete before resolving.
+		return new Promise((resolve, reject) => {
+			this.waitUntilCompleteResolvers.push({ resolve, reject });
+			this.resolveWhenComplete();
+		});
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/async-task-manager/AsyncTaskManagerDebugError.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown for retrieving the stack trace during debugging.
+ */
+export default class AsyncTaskManagerDebugError extends Error {
+	/**
+	 * Constructor.
+	 *
+	 * @param message Message.
+	 */
+	constructor(message?: string) {
+		super(message);
+		this.name = 'AsyncTaskManagerDebugError';
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/base64/Base64.ts

@@ -0,0 +1,97 @@
+import DOMException from '../exception/DOMException.js';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
+
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+
+/**
+ * Base64 encoding and decoding.
+ */
+export default class Base64 {
+	/**
+	 * Creates a Base64-encoded ASCII string from a binary string (i.e., a string in which each character in the string is treated as a byte of binary data).
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/btoa
+	 * @param data Binay data.
+	 * @returns Base64-encoded string.
+	 */
+	public static btoa(data: unknown): string {
+		const str = (<string>data).toString();
+		if (/[^\u0000-\u00ff]/.test(str)) {
+			throw new DOMException(
+				"Failed to execute 'btoa' on 'Window': The string to be encoded contains characters outside of the Latin1 range.",
+				DOMExceptionNameEnum.invalidCharacterError
+			);
+		}
+
+		let t = '';
+		let p = -6;
+		let a = 0;
+		let i = 0;
+		let v = 0;
+		let c;
+		while (i < str.length || p > -6) {
+			if (p < 0) {
+				if (i < str.length) {
+					c = str.charCodeAt(i++);
+					v += 8;
+				} else {
+					c = 0;
+				}
+				a = ((a & 255) << 8) | (c & 255);
+				p += 8;
+			}
+			t += BASE64_CHARS.charAt(v > 0 ? (a >> p) & 63 : 64);
+			p -= 6;
+			v -= 6;
+		}
+		return t;
+	}
+
+	/**
+	 * Decodes a string of data which has been encoded using Base64 encoding.
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/atob
+	 * @see https://infra.spec.whatwg.org/#forgiving-base64-encode.
+	 * @see Https://html.spec.whatwg.org/multipage/webappapis.html#btoa.
+	 * @param data Binay string.
+	 * @returns An ASCII string containing decoded data from encodedData.
+	 */
+	public static atob(data: unknown): string {
+		const str = (<string>data).toString();
+
+		if (/[^\u0000-\u00ff]/.test(str)) {
+			throw new DOMException(
+				"Failed to execute 'atob' on 'Window': The string to be decoded contains characters outside of the Latin1 range.",
+				DOMExceptionNameEnum.invalidCharacterError
+			);
+		}
+
+		if (/[^A-Za-z\d+/=]/.test(str) || str.length % 4 == 1) {
+			throw new DOMException(
+				"Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.",
+				DOMExceptionNameEnum.invalidCharacterError
+			);
+		}
+
+		let t = '';
+		let p = -8;
+		let a = 0;
+		let c;
+		let d;
+		for (let i = 0; i < str.length; i++) {
+			if ((c = BASE64_CHARS.indexOf(str.charAt(i))) < 0) {
+				continue;
+			}
+			a = (a << 6) | (c & 63);
+			if ((p += 6) >= 0) {
+				d = (a >> p) & 255;
+				if (c !== 64) {
+					t += String.fromCharCode(d);
+				}
+				a &= 63;
+				p -= 8;
+			}
+		}
+		return t;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/browser/Browser.ts

@@ -0,0 +1,123 @@
+import type IBrowserSettings from './types/IBrowserSettings.js';
+import BrowserContext from './BrowserContext.js';
+import type IOptionalBrowserSettings from './types/IOptionalBrowserSettings.js';
+import BrowserSettingsFactory from './BrowserSettingsFactory.js';
+import type BrowserPage from './BrowserPage.js';
+import type IBrowser from './types/IBrowser.js';
+import type IConsole from '../console/IConsole.js';
+import BrowserExceptionObserver from './utilities/BrowserExceptionObserver.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import BrowserErrorCaptureEnum from './enums/BrowserErrorCaptureEnum.js';
+
+/**
+ * Browser.
+ */
+export default class Browser implements IBrowser {
+	public readonly contexts: BrowserContext[];
+	public readonly settings: IBrowserSettings;
+	public readonly console: IConsole | null;
+	public [PropertySymbol.exceptionObserver]: BrowserExceptionObserver | null = null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param [options] Options.
+	 * @param [options.settings] Browser settings.
+	 * @param [options.console] Console.
+	 */
+	constructor(options?: { settings?: IOptionalBrowserSettings; console?: IConsole }) {
+		this.console = options?.console || null;
+		this.settings = BrowserSettingsFactory.createSettings(options?.settings);
+		if (this.settings.errorCapture === BrowserErrorCaptureEnum.processLevel) {
+			this[PropertySymbol.exceptionObserver] = new BrowserExceptionObserver();
+		}
+		this.contexts = [new BrowserContext(this)];
+	}
+
+	/**
+	 * Returns true if the browser is closed.
+	 *
+	 * @returns True if the browser is closed.
+	 */
+	public get closed(): boolean {
+		return this.contexts.length === 0;
+	}
+
+	/**
+	 * Returns the default context.
+	 *
+	 * @returns Default context.
+	 */
+	public get defaultContext(): BrowserContext {
+		if (this.contexts.length === 0) {
+			throw new Error('No default context. The browser has been closed.');
+		}
+		return this.contexts[0];
+	}
+
+	/**
+	 * Aborts all ongoing operations and destroys the browser.
+	 */
+	public async close(): Promise<void> {
+		if (this.contexts.length === 0) {
+			return;
+		}
+		const contexts = this.contexts;
+		(<BrowserContext[]>this.contexts) = [];
+		await Promise.all(contexts.map((context) => context.close()));
+	}
+
+	/**
+	 * Returns a promise that is resolved when all resources has been loaded, fetch has completed, and all async tasks such as timers are complete.
+	 *
+	 * @returns Promise.
+	 */
+	public async waitUntilComplete(): Promise<void> {
+		if (this.contexts.length === 0) {
+			throw new Error('No default context. The browser has been closed.');
+		}
+		await Promise.all(this.contexts.map((page) => page.waitUntilComplete()));
+	}
+
+	/**
+	 * Aborts all ongoing operations.
+	 */
+	public abort(): Promise<void> {
+		// Using Promise instead of async/await to prevent microtask
+		return new Promise((resolve, reject) => {
+			if (!this.contexts.length) {
+				resolve();
+				return;
+			}
+			Promise.all(this.contexts.slice().map((context) => context.abort()))
+				.then(() => resolve())
+				.catch((error) => reject(error));
+		});
+	}
+
+	/**
+	 * Creates a new incognito context.
+	 *
+	 * @returns Context.
+	 */
+	public newIncognitoContext(): BrowserContext {
+		if (this.contexts.length === 0) {
+			throw new Error('No default context. The browser has been closed.');
+		}
+		const context = new BrowserContext(this);
+		this.contexts.push(context);
+		return context;
+	}
+
+	/**
+	 * Creates a new page.
+	 *
+	 * @returns Page.
+	 */
+	public newPage(): BrowserPage {
+		if (this.contexts.length === 0) {
+			throw new Error('No default context. The browser has been closed.');
+		}
+		return this.contexts[0].newPage();
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/browser/BrowserContext.ts

@@ -0,0 +1,100 @@
+import CookieContainer from '../cookie/CookieContainer.js';
+import type ICookieContainer from '../cookie/ICookieContainer.js';
+import type IResponseCache from '../fetch/cache/response/IResponseCache.js';
+import ResponseCache from '../fetch/cache/response/ResponseCache.js';
+import type Browser from './Browser.js';
+import BrowserPage from './BrowserPage.js';
+import type IBrowserContext from './types/IBrowserContext.js';
+import type IPreflightResponseCache from '../fetch/cache/preflight/IPreflightResponseCache.js';
+import PreflightResponseCache from '../fetch/cache/preflight/PreflightResponseCache.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type IECMAScriptModuleCachedResult from '../module/types/IECMAScriptModuleCachedResult.js';
+
+/**
+ * Browser context.
+ */
+export default class BrowserContext implements IBrowserContext {
+	public readonly pages: BrowserPage[] = [];
+	public readonly browser: Browser;
+	public readonly cookieContainer: ICookieContainer = new CookieContainer();
+	public readonly responseCache: IResponseCache = new ResponseCache();
+	public readonly preflightResponseCache: IPreflightResponseCache = new PreflightResponseCache();
+	public readonly closed: boolean = false;
+	public readonly [PropertySymbol.moduleCache]: Map<string, IECMAScriptModuleCachedResult> =
+		new Map();
+
+	/**
+	 * Constructor.
+	 *
+	 * @param browser
+	 */
+	constructor(browser: Browser) {
+		this.browser = browser;
+	}
+
+	/**
+	 * Aborts all ongoing operations and destroys the context.
+	 */
+	public async close(): Promise<void> {
+		if (this.closed) {
+			return;
+		}
+
+		if (this.browser.contexts[0] === this) {
+			throw new Error(
+				'Cannot close the default context. Use `browser.close()` to close the browser instead.'
+			);
+		}
+
+		(<boolean>this.closed) = true;
+
+		await Promise.all(this.pages.slice().map((page) => page.close()));
+
+		const browser = this.browser;
+		const index = browser.contexts.indexOf(this);
+
+		if (index !== -1) {
+			browser.contexts.splice(index, 1);
+		}
+
+		(<BrowserPage[]>this.pages) = [];
+		this.cookieContainer.clearCookies();
+		this.responseCache.clear();
+		this.preflightResponseCache.clear();
+	}
+
+	/**
+	 * Returns a promise that is resolved when all resources has been loaded, fetch has completed, and all async tasks such as timers are complete.
+	 *
+	 * @returns Promise.
+	 */
+	public async waitUntilComplete(): Promise<void> {
+		await Promise.all(this.pages.map((page) => page.waitUntilComplete()));
+	}
+
+	/**
+	 * Aborts all ongoing operations.
+	 */
+	public abort(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			if (!this.pages.length) {
+				resolve();
+				return;
+			}
+			Promise.all(this.pages.slice().map((page) => page.abort()))
+				.then(() => resolve())
+				.catch((error) => reject(error));
+		});
+	}
+
+	/**
+	 * Creates a new page.
+	 *
+	 * @returns Page.
+	 */
+	public newPage(): BrowserPage {
+		const page = new BrowserPage(this);
+		this.pages.push(page);
+		return page;
+	}
+}