buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/browser/detached-browser/DetachedBrowser.ts

@@ -0,0 +1,129 @@
+import type IBrowserSettings from '../types/IBrowserSettings.js';
+import DetachedBrowserContext from './DetachedBrowserContext.js';
+import type IOptionalBrowserSettings from '../types/IOptionalBrowserSettings.js';
+import BrowserSettingsFactory from '../BrowserSettingsFactory.js';
+import type DetachedBrowserPage from './DetachedBrowserPage.js';
+import type IBrowser from '../types/IBrowser.js';
+import type IBrowserFrame from '../types/IBrowserFrame.js';
+import type IConsole from '../../console/IConsole.js';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import BrowserErrorCaptureEnum from '../enums/BrowserErrorCaptureEnum.js';
+import BrowserExceptionObserver from '../utilities/BrowserExceptionObserver.js';
+import type BrowserContext from '../BrowserContext.js';
+
+/**
+ * Detached browser used when constructing a Window instance without a browser.
+ */
+export default class DetachedBrowser implements IBrowser {
+	public readonly contexts: DetachedBrowserContext[];
+	public readonly settings: IBrowserSettings;
+	public readonly console: IConsole | null;
+	public readonly windowClass: new (
+		browserFrame: IBrowserFrame,
+		options?: { url?: string; width?: number; height?: number }
+	) => BrowserWindow;
+	public [PropertySymbol.exceptionObserver]: BrowserExceptionObserver | null = null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param windowClass Window class.
+	 * @param [options] Options.
+	 * @param [options.settings] Browser settings.
+	 * @param [options.console] Console.
+	 */
+	constructor(
+		windowClass: new (
+			browserFrame: IBrowserFrame,
+			options?: { url?: string; width?: number; height?: number }
+		) => BrowserWindow,
+		options?: { settings?: IOptionalBrowserSettings; console?: IConsole }
+	) {
+		this.windowClass = windowClass;
+		this.console = options?.console || null;
+		this.settings = BrowserSettingsFactory.createSettings(options?.settings);
+		if (this.settings.errorCapture === BrowserErrorCaptureEnum.processLevel) {
+			this[PropertySymbol.exceptionObserver] = new BrowserExceptionObserver();
+		}
+		this.contexts = [];
+		this.contexts.push(new DetachedBrowserContext(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(): DetachedBrowserContext {
+		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> {
+		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.
+	 */
+	public newIncognitoContext(): DetachedBrowserContext {
+		throw new Error('Not possible to create a new context on a detached browser.');
+	}
+
+	/**
+	 * Creates a new page.
+	 *
+	 * @returns Page.
+	 */
+	public newPage(): DetachedBrowserPage {
+		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/detached-browser/DetachedBrowserContext.ts

@@ -0,0 +1,103 @@
+import type DetachedBrowser from './DetachedBrowser.js';
+import DetachedBrowserPage from './DetachedBrowserPage.js';
+import type IBrowserContext from '../types/IBrowserContext.js';
+import type ICookieContainer from '../../cookie/ICookieContainer.js';
+import CookieContainer from '../../cookie/CookieContainer.js';
+import ResponseCache from '../../fetch/cache/response/ResponseCache.js';
+import type IResponseCache from '../../fetch/cache/response/IResponseCache.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';
+
+/**
+ * Detached browser context used when constructing a Window instance without a browser.
+ */
+export default class DetachedBrowserContext implements IBrowserContext {
+	public readonly pages: DetachedBrowserPage[];
+	public readonly browser: DetachedBrowser;
+	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 Browser.
+	 */
+	constructor(browser: DetachedBrowser) {
+		this.browser = browser;
+		this.pages = [];
+		this.pages.push(new DetachedBrowserPage(this));
+	}
+
+	/**
+	 * 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);
+		}
+
+		(<DetachedBrowserPage[]>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.
+	 *
+	 * @param [opener] Opener.
+	 * @returns Page.
+	 */
+	public newPage(): DetachedBrowserPage {
+		const page = new DetachedBrowserPage(this);
+		this.pages.push(page);
+		return page;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/browser/detached-browser/DetachedBrowserFrame.ts

@@ -0,0 +1,250 @@
+import type DetachedBrowserPage from './DetachedBrowserPage.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import AsyncTaskManager from '../../async-task-manager/AsyncTaskManager.js';
+import type IBrowserFrame from '../types/IBrowserFrame.js';
+import type Response from '../../fetch/Response.js';
+import type IGoToOptions from '../types/IGoToOptions.js';
+import type { Script } from 'vm';
+import BrowserFrameURL from '../utilities/BrowserFrameURL.js';
+import BrowserFrameScriptEvaluator from '../utilities/BrowserFrameScriptEvaluator.js';
+import BrowserFrameNavigator from '../utilities/BrowserFrameNavigator.js';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+import type IReloadOptions from '../types/IReloadOptions.js';
+import type Document from '../../nodes/document/Document.js';
+import type CrossOriginBrowserWindow from '../../window/CrossOriginBrowserWindow.js';
+import HistoryItemList from '../../history/HistoryItemList.js';
+
+/**
+ * Browser frame used when constructing a Window instance without a browser.
+ */
+export default class DetachedBrowserFrame implements IBrowserFrame {
+	// When constructing a detached Window instance, it needs to inject the window into the frame.
+	public declare window: BrowserWindow;
+
+	public readonly childFrames: DetachedBrowserFrame[] = [];
+	public readonly parentFrame: DetachedBrowserFrame | null = null;
+	public readonly page: DetachedBrowserPage;
+	public readonly closed: boolean = false;
+	public [PropertySymbol.asyncTaskManager]: AsyncTaskManager = new AsyncTaskManager(this);
+	public [PropertySymbol.listeners]: { navigation: Array<() => void> } = { navigation: [] };
+	public [PropertySymbol.openerFrame]: IBrowserFrame | null = null;
+	public [PropertySymbol.openerWindow]: BrowserWindow | CrossOriginBrowserWindow | null = null;
+	public [PropertySymbol.popup] = false;
+	public [PropertySymbol.history] = new HistoryItemList();
+
+	/**
+	 * Constructor.
+	 *
+	 * @param page Page.
+	 * @param [window] Window.
+	 */
+	constructor(page: DetachedBrowserPage) {
+		this.page = page;
+
+		if (page.context.browser.contexts[0]?.pages[0]?.mainFrame) {
+			this.window = new this.page.context.browser.windowClass(this);
+
+			// Attach process level error capturing.
+			if (page.context.browser[PropertySymbol.exceptionObserver]) {
+				page.context.browser[PropertySymbol.exceptionObserver].observe(this.window);
+			}
+		}
+	}
+
+	/**
+	 * Returns the content.
+	 *
+	 * @returns Content.
+	 */
+	public get content(): string {
+		if (!this.window) {
+			throw new Error('The frame has been destroyed, the "window" property is not set.');
+		}
+		return this.window.document.documentElement.outerHTML;
+	}
+
+	/**
+	 * Sets the content.
+	 *
+	 * @param content Content.
+	 */
+	public set content(content) {
+		if (!this.window) {
+			throw new Error('The frame has been destroyed, the "window" property is not set.');
+		}
+		this.window.document[PropertySymbol.isFirstWrite] = true;
+		this.window.document[PropertySymbol.isFirstWriteAfterOpen] = false;
+		this.window.document.open();
+		this.window.document.write(content);
+	}
+
+	/**
+	 * Returns the URL.
+	 *
+	 * @returns URL.
+	 */
+	public get url(): string {
+		if (!this.window) {
+			throw new Error('The frame has been destroyed, the "window" property is not set.');
+		}
+		return this.window.location.href;
+	}
+
+	/**
+	 * Sets the content.
+	 *
+	 * @param url URL.
+	 */
+	public set url(url) {
+		if (!this.window) {
+			throw new Error('The frame has been destroyed, the "window" property is not set.');
+		}
+		this.window[PropertySymbol.location][PropertySymbol.setURL](
+			this,
+			BrowserFrameURL.getRelativeURL(this, url).href
+		);
+	}
+
+	/**
+	 * Returns document.
+	 *
+	 * @returns Document.
+	 */
+	public get document(): Document {
+		return this.window?.document ?? null;
+	}
+
+	/**
+	 * Returns a promise that is resolved when all resources has been loaded, fetch has completed, and all async tasks such as timers are complete.
+	 */
+	public async waitUntilComplete(): Promise<void> {
+		await Promise.all([
+			this[PropertySymbol.asyncTaskManager].waitUntilComplete(),
+			...this.childFrames.map((frame) => frame.waitUntilComplete())
+		]);
+	}
+
+	/**
+	 * Returns a promise that is resolved when the frame has navigated and the response HTML has been written to the document.
+	 */
+	public waitForNavigation(): Promise<void> {
+		return new Promise((resolve) => this[PropertySymbol.listeners].navigation.push(resolve));
+	}
+
+	/**
+	 * Aborts all ongoing operations.
+	 */
+	public abort(): Promise<void> {
+		if (!this.childFrames.length) {
+			return this[PropertySymbol.asyncTaskManager].abort();
+		}
+		return new Promise((resolve, reject) => {
+			// Using Promise instead of async/await to prevent microtask
+			Promise.all(
+				this.childFrames
+					.map((frame) => frame.abort())
+					.concat([this[PropertySymbol.asyncTaskManager].abort()])
+			)
+				.then(() => resolve())
+				.catch(reject);
+		});
+	}
+
+	/**
+	 * Evaluates code or a VM Script in the page's context.
+	 *
+	 * @param script Script.
+	 * @returns Result.
+	 */
+	public evaluate(script: string | Script): any {
+		return BrowserFrameScriptEvaluator.evaluate(this, script);
+	}
+
+	/**
+	 * Evaluates a module in the page's context.
+	 *
+	 * @param options Options.
+	 * @param options.url URL.
+	 * @param options.type Module type.
+	 * @param options.code Code.
+	 * @returns Module exports.
+	 */
+	public evaluateModule(options: {
+		url?: string;
+		type?: 'esm' | 'css' | 'json';
+		code?: string;
+	}): Promise<Record<string, any>> {
+		return BrowserFrameScriptEvaluator.evaluateModule(this, options);
+	}
+
+	/**
+	 * Go to a page.
+	 *
+	 * @param url URL.
+	 * @param [options] Options.
+	 * @returns Response.
+	 */
+	public goto(url: string, options?: IGoToOptions): Promise<Response | null> {
+		return BrowserFrameNavigator.navigate({
+			windowClass: this.page.context.browser.windowClass,
+			frame: this,
+			url: url,
+			goToOptions: options
+		});
+	}
+
+	/**
+	 * Navigates back in history.
+	 *
+	 * @param [options] Options.
+	 */
+	public goBack(options?: IGoToOptions): Promise<Response | null> {
+		return BrowserFrameNavigator.navigateBack({
+			windowClass: this.page.context.browser.windowClass,
+			frame: this,
+			goToOptions: options
+		});
+	}
+
+	/**
+	 * Navigates forward in history.
+	 *
+	 * @param [options] Options.
+	 */
+	public goForward(options?: IGoToOptions): Promise<Response | null> {
+		return BrowserFrameNavigator.navigateForward({
+			windowClass: this.page.context.browser.windowClass,
+			frame: this,
+			goToOptions: options
+		});
+	}
+
+	/**
+	 * Navigates a delta in history.
+	 *
+	 * @param steps Steps.
+	 * @param [options] Options.
+	 */
+	public goSteps(steps?: number, options?: IGoToOptions): Promise<Response | null> {
+		return BrowserFrameNavigator.navigateSteps({
+			windowClass: this.page.context.browser.windowClass,
+			frame: this,
+			steps: steps,
+			goToOptions: options
+		});
+	}
+
+	/**
+	 * Reloads the current frame.
+	 *
+	 * @param [options] Options.
+	 * @returns Response.
+	 */
+	public reload(options?: IReloadOptions): Promise<Response | null> {
+		return BrowserFrameNavigator.reload({
+			windowClass: this.page.context.browser.windowClass,
+			frame: this,
+			goToOptions: options
+		});
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/browser/detached-browser/DetachedBrowserPage.ts

@@ -0,0 +1,218 @@
+import VirtualConsolePrinter from '../../console/VirtualConsolePrinter.js';
+import type IConsole from '../../console/IConsole.js';
+import DetachedBrowserFrame from './DetachedBrowserFrame.js';
+import type DetachedBrowserContext from './DetachedBrowserContext.js';
+import VirtualConsole from '../../console/VirtualConsole.js';
+import type IBrowserPage from '../types/IBrowserPage.js';
+import type { Script } from 'vm';
+import type IGoToOptions from '../types/IGoToOptions.js';
+import type Response from '../../fetch/Response.js';
+import BrowserPageUtility from '../utilities/BrowserPageUtility.js';
+import type IReloadOptions from '../types/IReloadOptions.js';
+import type IOptionalBrowserPageViewport from '../types/IOptionalBrowserPageViewport.js';
+import type IBrowserPageViewport from '../types/IBrowserPageViewport.js';
+import Event from '../../event/Event.js';
+
+/**
+ * Detached browser page used when constructing a Window instance without a browser.
+ */
+export default class DetachedBrowserPage implements IBrowserPage {
+	public readonly virtualConsolePrinter = new VirtualConsolePrinter();
+	public readonly mainFrame: DetachedBrowserFrame;
+	public readonly context: DetachedBrowserContext;
+	public readonly console: IConsole;
+	public readonly viewport: IBrowserPageViewport;
+	public readonly closed: boolean = false;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param context Browser context.
+	 */
+	constructor(context: DetachedBrowserContext) {
+		this.context = context;
+		this.console = context.browser.console ?? new VirtualConsole(this.virtualConsolePrinter);
+		this.mainFrame = new DetachedBrowserFrame(this);
+		this.viewport = {
+			width: context.browser.settings.viewport.width,
+			height: context.browser.settings.viewport.height,
+			devicePixelRatio: context.browser.settings.viewport.devicePixelRatio
+		};
+	}
+
+	/**
+	 * Returns frames.
+	 */
+	public get frames(): DetachedBrowserFrame[] {
+		return <DetachedBrowserFrame[]>BrowserPageUtility.getFrames(this);
+	}
+
+	/**
+	 * Returns the viewport.
+	 */
+	public get content(): string {
+		return this.mainFrame.content;
+	}
+
+	/**
+	 * Sets the content.
+	 *
+	 * @param content Content.
+	 */
+	public set content(content) {
+		this.mainFrame.content = content;
+	}
+
+	/**
+	 * Returns the URL.
+	 *
+	 * @returns URL.
+	 */
+	public get url(): string {
+		return this.mainFrame.url;
+	}
+
+	/**
+	 * Sets the content.
+	 *
+	 * @param url URL.
+	 */
+	public set url(url) {
+		this.mainFrame.url = url;
+	}
+
+	/**
+	 * Aborts all ongoing operations and destroys the page.
+	 */
+	public close(): Promise<void> {
+		// Using Promise instead of async/await to prevent microtask
+		return new Promise((resolve, reject) => {
+			const context = this.context;
+			BrowserPageUtility.closePage(this)
+				.then(() => {
+					// As we are in a detached page, a context or browser should not exist without a page as there are no references to them.
+					if (context.pages[0] === this) {
+						context.browser.close().then(resolve).catch(reject);
+					} else {
+						resolve();
+					}
+				})
+				.catch(reject);
+		});
+	}
+
+	/**
+	 * Returns a promise that is resolved when all resources has been loaded, fetch has completed, and all async tasks such as timers are complete.
+	 */
+	public waitUntilComplete(): Promise<void> {
+		return this.mainFrame.waitUntilComplete();
+	}
+
+	/**
+	 * Returns a promise that is resolved when the page has navigated and the response HTML has been written to the document.
+	 */
+	public waitForNavigation(): Promise<void> {
+		return this.mainFrame.waitForNavigation();
+	}
+
+	/**
+	 * Aborts all ongoing operations.
+	 */
+	public abort(): Promise<void> {
+		return this.mainFrame.abort();
+	}
+
+	/**
+	 * Evaluates code or a VM Script in the page's context.
+	 *
+	 * @param script Script.
+	 * @returns Result.
+	 */
+	public evaluate(script: string | Script): any {
+		return this.mainFrame.evaluate(script);
+	}
+
+	/**
+	 * Evaluates a module in the page's context.
+	 *
+	 * @param options Options.
+	 * @param options.url URL.
+	 * @param options.type Module type.
+	 * @param options.code Code.
+	 * @returns Module exports.
+	 */
+	public evaluateModule(options: {
+		url?: string;
+		type?: 'esm' | 'css' | 'json';
+		code?: string;
+	}): Promise<Record<string, any>> {
+		return this.mainFrame.evaluateModule(options);
+	}
+
+	/**
+	 * Sets the viewport.
+	 *
+	 * @param viewport Viewport.
+	 */
+	public setViewport(viewport: IOptionalBrowserPageViewport): void {
+		const previousViewport = Object.assign({}, this.viewport);
+		Object.assign(this.viewport, viewport);
+		if (
+			previousViewport.width !== this.viewport.width ||
+			previousViewport.height !== this.viewport.height ||
+			previousViewport.devicePixelRatio !== this.viewport.devicePixelRatio
+		) {
+			this.mainFrame.window.dispatchEvent(new Event('resize'));
+		}
+	}
+
+	/**
+	 * Go to a page.
+	 *
+	 * @param url URL.
+	 * @param [options] Options.
+	 * @returns Response.
+	 */
+	public goto(url: string, options?: IGoToOptions): Promise<Response | null> {
+		return this.mainFrame.goto(url, options);
+	}
+
+	/**
+	 * Navigates back in history.
+	 *
+	 * @param [options] Options.
+	 */
+	public goBack(options?: IGoToOptions): Promise<Response | null> {
+		return this.mainFrame.goBack(options);
+	}
+
+	/**
+	 * Navigates forward in history.
+	 *
+	 * @param [options] Options.
+	 */
+	public goForward(options?: IGoToOptions): Promise<Response | null> {
+		return this.mainFrame.goForward(options);
+	}
+
+	/**
+	 * Navigates a delta in history.
+	 *
+	 * @param delta Delta.
+	 * @param steps
+	 * @param [options] Options.
+	 */
+	public goSteps(steps?: number, options?: IGoToOptions): Promise<Response | null> {
+		return this.mainFrame.goSteps(steps, options);
+	}
+
+	/**
+	 * Reloads the current page.
+	 *
+	 * @param [options] Options.
+	 * @returns Response.
+	 */
+	public reload(options?: IReloadOptions): Promise<Response | null> {
+		return this.mainFrame.reload(options);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/browser/enums/BrowserErrorCaptureEnum.ts

@@ -0,0 +1,10 @@
+enum BrowserErrorCaptureEnum {
+	/** Happy DOM use try and catch when evaluating code, but will not be able to catch all errors and Promise rejections. This will decrease performance as using try and catch makes the execution significally slower. This is the default setting. */
+	tryAndCatch = 'tryAndCatch',
+	/** Happy DOM will add an event listener to the Node.js process to catch all errors and Promise rejections. This will not work in Jest and Vitest as it conflicts with their error listeners. */
+	processLevel = 'processLevel',
+	/** Error capturing is disabled. Errors and Promise rejections will be thrown. */
+	disabled = 'disabled'
+}
+
+export default BrowserErrorCaptureEnum;