buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/window/WindowBrowserContext.ts

@@ -0,0 +1,117 @@
+import type AsyncTaskManager from '../async-task-manager/AsyncTaskManager.js';
+import type IBrowser from '../browser/types/IBrowser.js';
+import type IBrowserContext from '../browser/types/IBrowserContext.js';
+import type IBrowserFrame from '../browser/types/IBrowserFrame.js';
+import type IBrowserPage from '../browser/types/IBrowserPage.js';
+import type IBrowserSettings from '../browser/types/IBrowserSettings.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type BrowserWindow from './BrowserWindow.js';
+
+/**
+ * API for accessing the Browser in a Window context without exposing the Browser as accessible properties.
+ *
+ * The Browser should never be exposed to scripts, as the scripts could then manipulate it, which would lead to security issues.
+ */
+export default class WindowBrowserContext {
+	private static [PropertySymbol.browserFrames]: Map<number, IBrowserFrame> = new Map();
+	private static [PropertySymbol.windowInternalId] = 0;
+	#window: BrowserWindow;
+
+	/**
+	 * Browser window.
+	 *
+	 * @param window Window.
+	 */
+	constructor(window: BrowserWindow) {
+		this.#window = window;
+	}
+
+	/**
+	 * Returns the browser settings of the window.
+	 *
+	 * @returns Browser settings.
+	 */
+	public getSettings(): IBrowserSettings | null {
+		return this.getBrowserFrame()?.page.context.browser.settings || null;
+	}
+
+	/**
+	 * Returns the browser.
+	 *
+	 * @returns Browser.
+	 */
+	public getBrowser(): IBrowser | null {
+		return this.getBrowserFrame()?.page.context.browser || null;
+	}
+
+	/**
+	 * Returns the browser page.
+	 *
+	 * @returns Browser page.
+	 */
+	public getBrowserPage(): IBrowserPage | null {
+		return this.getBrowserFrame()?.page || null;
+	}
+
+	/**
+	 * Returns the browser context.
+	 *
+	 * @returns Browser context.
+	 */
+	public getBrowserContext(): IBrowserContext | null {
+		return this.getBrowserFrame()?.page.context || null;
+	}
+
+	/**
+	 * Returns the browser frame of the window.
+	 *
+	 * @returns Browser frame.
+	 */
+	public getBrowserFrame(): IBrowserFrame | null {
+		if (!this.#window) {
+			return null;
+		}
+		return (
+			(<typeof WindowBrowserContext>this.constructor)[PropertySymbol.browserFrames].get(
+				this.#window[PropertySymbol.internalId]
+			) || null
+		);
+	}
+
+	/**
+	 * Returns the async task manager of the window.
+	 *
+	 * @returns Async task manager.
+	 */
+	public getAsyncTaskManager(): AsyncTaskManager | null {
+		return this.getBrowserFrame()?.[PropertySymbol.asyncTaskManager] || null;
+	}
+
+	/**
+	 * Assigns the window to a browser frame.
+	 *
+	 * @param window Window.
+	 * @param browserFrame Browser frame.
+	 */
+	public static setWindowBrowserFrameRelation(
+		window: BrowserWindow,
+		browserFrame: IBrowserFrame
+	): void {
+		const browserFrames = this[PropertySymbol.browserFrames];
+		if (window[PropertySymbol.internalId] === -1) {
+			window[PropertySymbol.internalId] = this[PropertySymbol.windowInternalId];
+			this[PropertySymbol.windowInternalId]++;
+		}
+		browserFrames.set(window[PropertySymbol.internalId], browserFrame);
+	}
+
+	/**
+	 * Assigns the window to a browser frame.
+	 *
+	 * @param window Window.
+	 * @param browserFrame Browser frame.
+	 */
+	public static removeWindowBrowserFrameRelation(window: BrowserWindow): void {
+		this[PropertySymbol.browserFrames].delete(window[PropertySymbol.internalId]);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/window/WindowContextClassExtender.ts

@@ -0,0 +1,288 @@
+import type BrowserWindow from './BrowserWindow.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+
+import DocumentImplementation from '../nodes/document/Document.js';
+import HTMLDocumentImplementation from '../nodes/html-document/HTMLDocument.js';
+import XMLDocumentImplementation from '../nodes/xml-document/XMLDocument.js';
+import DocumentFragmentImplementation from '../nodes/document-fragment/DocumentFragment.js';
+import TextImplementation from '../nodes/text/Text.js';
+import CommentImplementation from '../nodes/comment/Comment.js';
+import ImageImplementation from '../nodes/html-image-element/Image.js';
+import AudioImplementation from '../nodes/html-audio-element/Audio.js';
+import MutationObserverImplementation from '../mutation-observer/MutationObserver.js';
+import MessagePortImplementation from '../event/MessagePort.js';
+import CSSStyleSheetImplementation from '../css/CSSStyleSheet.js';
+import DOMExceptionImplementation from '../exception/DOMException.js';
+import HeadersImplementation from '../fetch/Headers.js';
+import RequestImplementation from '../fetch/Request.js';
+import ResponseImplementation from '../fetch/Response.js';
+import EventTargetImplementation from '../event/EventTarget.js';
+import XMLHttpRequestUploadImplementation from '../xml-http-request/XMLHttpRequestUpload.js';
+import XMLHttpRequestEventTargetImplementation from '../xml-http-request/XMLHttpRequestEventTarget.js';
+import AbortControllerImplementation from '../fetch/AbortController.js';
+import AbortSignalImplementation from '../fetch/AbortSignal.js';
+import FormDataImplementation from '../form-data/FormData.js';
+import PermissionStatusImplementation from '../permissions/PermissionStatus.js';
+import XMLHttpRequestImplementation from '../xml-http-request/XMLHttpRequest.js';
+import DOMParserImplementation from '../dom-parser/DOMParser.js';
+import RangeImplementation from '../range/Range.js';
+import VTTCueImplementation from '../nodes/html-media-element/VTTCue.js';
+import TextTrackImplementation from '../nodes/html-media-element/TextTrack.js';
+import TextTrackListImplementation from '../nodes/html-media-element/TextTrackList.js';
+import TextTrackCueImplementation from '../nodes/html-media-element/TextTrackCue.js';
+import RemotePlaybackImplementation from '../nodes/html-media-element/RemotePlayback.js';
+import FileReaderImplementation from '../file/FileReader.js';
+import MediaStreamImplementation from '../nodes/html-media-element/MediaStream.js';
+import MediaStreamTrackImplementation from '../nodes/html-media-element/MediaStreamTrack.js';
+import CanvasCaptureMediaStreamTrackImplementation from '../nodes/html-canvas-element/CanvasCaptureMediaStreamTrack.js';
+import URLImplementation from '../url/URL.js';
+import WebSocketImplementation from '../web-socket/WebSocket.js';
+import ImageDataImplementation from '../canvas/ImageData.js';
+import OffscreenCanvasImplementation from '../canvas/OffscreenCanvas.js';
+import DOMMatrixReadOnlyImplementation from '../dom/dom-matrix/DOMMatrixReadOnly.js';
+import DOMMatrixImplementation from '../dom/dom-matrix/DOMMatrix.js';
+import DOMPointReadOnlyImplementation from '../dom/DOMPointReadOnly.js';
+import DOMPointImplementation from '../dom/DOMPoint.js';
+import AnimationImplementation from '../animation/Animation.js';
+import KeyframeEffectImplementation from '../animation/KeyframeEffect.js';
+
+/**
+ * Extends classes with a "window" property, so that they internally can access it's Window context.
+ *
+ * By using WindowBrowserContext, the classes can get access to their Browser context, for accessing settings or navigating the browser.
+ */
+export default class WindowContextClassExtender {
+	/**
+	 * Extends classes with a "window" property.
+	 *
+	 * @param window Window.
+	 */
+	public static extendClasses(window: BrowserWindow): void {
+		/* eslint-disable jsdoc/require-jsdoc */
+
+		// Document
+		class Document extends DocumentImplementation {}
+		Document.prototype[PropertySymbol.window] = window;
+		(<typeof Document>window.Document) = Document;
+
+		// HTMLDocument
+		class HTMLDocument extends HTMLDocumentImplementation {}
+		HTMLDocument.prototype[PropertySymbol.window] = window;
+		(<typeof HTMLDocument>window.HTMLDocument) = HTMLDocument;
+
+		// XMLDocument
+		class XMLDocument extends XMLDocumentImplementation {}
+		XMLDocument.prototype[PropertySymbol.window] = window;
+		(<typeof XMLDocument>window.XMLDocument) = XMLDocument;
+
+		// DocumentFragment
+		class DocumentFragment extends DocumentFragmentImplementation {}
+		DocumentFragment.prototype[PropertySymbol.window] = window;
+		(<typeof DocumentFragment>window.DocumentFragment) = DocumentFragment;
+
+		// Text
+		class Text extends TextImplementation {}
+		Text.prototype[PropertySymbol.window] = window;
+		(<typeof Text>window.Text) = Text;
+
+		// Comment
+		class Comment extends CommentImplementation {}
+		Comment.prototype[PropertySymbol.window] = window;
+		(<typeof Comment>window.Comment) = Comment;
+
+		// Image
+		class Image extends ImageImplementation {}
+		Image.prototype[PropertySymbol.window] = window;
+		(<typeof Image>window.Image) = Image;
+
+		// Audio
+		class Audio extends AudioImplementation {}
+		Audio.prototype[PropertySymbol.window] = window;
+		(<typeof Audio>window.Audio) = Audio;
+
+		// MutationObserver
+		class MutationObserver extends MutationObserverImplementation {}
+		MutationObserver.prototype[PropertySymbol.window] = window;
+		(<typeof MutationObserver>window.MutationObserver) = MutationObserver;
+
+		// MessagePort
+		class MessagePort extends MessagePortImplementation {}
+		MessagePort.prototype[PropertySymbol.window] = window;
+		(<typeof MessagePort>window.MessagePort) = MessagePort;
+
+		// CSSStyleSheet
+		class CSSStyleSheet extends CSSStyleSheetImplementation {}
+		CSSStyleSheet.prototype[PropertySymbol.window] = window;
+		(<typeof CSSStyleSheet>window.CSSStyleSheet) = CSSStyleSheet;
+
+		// DOMException
+		class DOMException extends DOMExceptionImplementation {}
+		(<typeof DOMException>window.DOMException) = DOMException;
+
+		// Headers
+		class Headers extends HeadersImplementation {}
+		Headers.prototype[PropertySymbol.window] = window;
+		(<typeof Headers>window.Headers) = Headers;
+
+		// Request
+		class Request extends RequestImplementation {}
+		Request.prototype[PropertySymbol.window] = window;
+		(<typeof Request>window.Request) = Request;
+
+		// Response
+		class Response extends ResponseImplementation {}
+		Response.prototype[PropertySymbol.window] = window;
+		Response[PropertySymbol.window] = window;
+		(<typeof Response>window.Response) = Response;
+
+		// XMLHttpRequestEventTarget
+		class EventTarget extends EventTargetImplementation {}
+		EventTarget.prototype[PropertySymbol.window] = window;
+		(<typeof EventTarget>window.EventTarget) = EventTarget;
+
+		// XMLHttpRequestUpload
+		class XMLHttpRequestUpload extends XMLHttpRequestUploadImplementation {}
+		XMLHttpRequestUpload.prototype[PropertySymbol.window] = window;
+		(<typeof XMLHttpRequestUpload>window.XMLHttpRequestUpload) = XMLHttpRequestUpload;
+
+		// XMLHttpRequestEventTarget
+		class XMLHttpRequestEventTarget extends XMLHttpRequestEventTargetImplementation {}
+		XMLHttpRequestEventTarget.prototype[PropertySymbol.window] = window;
+		(<typeof XMLHttpRequestEventTarget>window.XMLHttpRequestEventTarget) =
+			XMLHttpRequestEventTarget;
+
+		// AbortController
+		class AbortController extends AbortControllerImplementation {}
+		AbortController.prototype[PropertySymbol.window] = window;
+		(<typeof AbortController>window.AbortController) = AbortController;
+
+		// AbortSignal
+		class AbortSignal extends AbortSignalImplementation {}
+		AbortSignal.prototype[PropertySymbol.window] = window;
+		AbortSignal[PropertySymbol.window] = window;
+		(<typeof AbortSignal>window.AbortSignal) = AbortSignal;
+
+		// FormData
+		class FormData extends FormDataImplementation {}
+		FormData.prototype[PropertySymbol.window] = window;
+		(<typeof FormData>window.FormData) = FormData;
+
+		// PermissionStatus
+		class PermissionStatus extends PermissionStatusImplementation {}
+		PermissionStatus.prototype[PropertySymbol.window] = window;
+		(<typeof PermissionStatus>window.PermissionStatus) = PermissionStatus;
+
+		// XMLHttpRequest
+		class XMLHttpRequest extends XMLHttpRequestImplementation {}
+		XMLHttpRequest.prototype[PropertySymbol.window] = window;
+		(<typeof XMLHttpRequest>window.XMLHttpRequest) = XMLHttpRequest;
+
+		// DOMParser
+		class DOMParser extends DOMParserImplementation {}
+		DOMParser.prototype[PropertySymbol.window] = window;
+		(<typeof DOMParser>window.DOMParser) = DOMParser;
+
+		// Range
+		class Range extends RangeImplementation {}
+		Range.prototype[PropertySymbol.window] = window;
+		(<typeof Range>window.Range) = Range;
+
+		// VTTCue
+		class VTTCue extends VTTCueImplementation {}
+		VTTCue.prototype[PropertySymbol.window] = window;
+		(<typeof VTTCue>window.VTTCue) = VTTCue;
+
+		// TextTrack
+		class TextTrack extends TextTrackImplementation {}
+		TextTrack.prototype[PropertySymbol.window] = window;
+		(<typeof TextTrack>window.TextTrack) = TextTrack;
+
+		// TextTrackList
+		class TextTrackList extends TextTrackListImplementation {}
+		TextTrackList.prototype[PropertySymbol.window] = window;
+		(<typeof TextTrackList>window.TextTrackList) = TextTrackList;
+
+		// TextTrackCue
+		class TextTrackCue extends TextTrackCueImplementation {}
+		TextTrackCue.prototype[PropertySymbol.window] = window;
+		(<typeof TextTrackCue>window.TextTrackCue) = TextTrackCue;
+
+		// RemotePlayback
+		class RemotePlayback extends RemotePlaybackImplementation {}
+		RemotePlayback.prototype[PropertySymbol.window] = window;
+		(<typeof RemotePlayback>window.RemotePlayback) = RemotePlayback;
+
+		// FileReader
+		class FileReader extends FileReaderImplementation {}
+		FileReader.prototype[PropertySymbol.window] = window;
+		(<typeof FileReader>window.FileReader) = FileReader;
+
+		// MediaStream
+		class MediaStream extends MediaStreamImplementation {}
+		MediaStream.prototype[PropertySymbol.window] = window;
+		(<typeof MediaStream>window.MediaStream) = MediaStream;
+
+		// MediaStreamTrack
+		class MediaStreamTrack extends MediaStreamTrackImplementation {}
+		MediaStreamTrack.prototype[PropertySymbol.window] = window;
+		(<typeof MediaStreamTrack>window.MediaStreamTrack) = MediaStreamTrack;
+
+		// MediaStreamTrack
+		class CanvasCaptureMediaStreamTrack extends CanvasCaptureMediaStreamTrackImplementation {}
+		CanvasCaptureMediaStreamTrack.prototype[PropertySymbol.window] = window;
+		(<typeof CanvasCaptureMediaStreamTrack>window.CanvasCaptureMediaStreamTrack) =
+			CanvasCaptureMediaStreamTrack;
+
+		// URL
+		class URL extends URLImplementation {}
+		URL.prototype[PropertySymbol.window] = window;
+		(<typeof URL>window.URL) = URL;
+
+		// WebSocket
+		class WebSocket extends WebSocketImplementation {}
+		WebSocket.prototype[PropertySymbol.window] = window;
+		(<typeof WebSocket>window.WebSocket) = WebSocket;
+
+		// ImageData
+		class ImageData extends ImageDataImplementation {}
+		ImageData.prototype[PropertySymbol.window] = window;
+		(<typeof ImageData>window.ImageData) = ImageData;
+
+		// OffscreenCanvas
+		class OffscreenCanvas extends OffscreenCanvasImplementation {}
+		OffscreenCanvas.prototype[PropertySymbol.window] = window;
+		(<typeof OffscreenCanvas>window.OffscreenCanvas) = OffscreenCanvas;
+
+		// DOMMatrixReadOnly
+		class DOMMatrixReadOnly extends DOMMatrixReadOnlyImplementation {}
+		DOMMatrixReadOnly.prototype[PropertySymbol.window] = window;
+		(<typeof DOMMatrixReadOnly>window.DOMMatrixReadOnly) = DOMMatrixReadOnly;
+
+		// DOMMatrix
+		class DOMMatrix extends DOMMatrixImplementation {}
+		DOMMatrix.prototype[PropertySymbol.window] = window;
+		(<typeof DOMMatrix>window.DOMMatrix) = DOMMatrix;
+
+		// DOMPointReadOnly
+		class DOMPointReadOnly extends DOMPointReadOnlyImplementation {}
+		DOMPointReadOnly.prototype[PropertySymbol.window] = window;
+		(<typeof DOMPointReadOnly>window.DOMPointReadOnly) = DOMPointReadOnly;
+
+		// DOMPoint
+		class DOMPoint extends DOMPointImplementation {}
+		DOMPoint.prototype[PropertySymbol.window] = window;
+		(<typeof DOMPoint>window.DOMPoint) = DOMPoint;
+
+		// Animation
+		class Animation extends AnimationImplementation {}
+		Animation.prototype[PropertySymbol.window] = window;
+		(<typeof Animation>window.Animation) = Animation;
+
+		// KeyframeEffect
+		class KeyframeEffect extends KeyframeEffectImplementation {}
+		KeyframeEffect.prototype[PropertySymbol.window] = window;
+		(<typeof KeyframeEffect>window.KeyframeEffect) = KeyframeEffect;
+
+		/* eslint-enable jsdoc/require-jsdoc */
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/window/WindowPageOpenUtility.ts

@@ -0,0 +1,200 @@
+import type BrowserWindow from './BrowserWindow.js';
+import CrossOriginBrowserWindow from './CrossOriginBrowserWindow.js';
+import type IBrowserFrame from '../browser/types/IBrowserFrame.js';
+import FetchCORSUtility from '../fetch/utilities/FetchCORSUtility.js';
+import BrowserFrameURL from '../browser/utilities/BrowserFrameURL.js';
+import { URL } from 'url';
+import * as PropertySymbol from '../PropertySymbol.js';
+
+/**
+ * Window page open handler.
+ */
+export default class WindowPageOpenUtility {
+	/**
+	 * Opens a page.
+	 *
+	 * @param browserFrame Browser frame.
+	 * @param [options] Options.
+	 * @param [options.url] URL.
+	 * @param [options.target] Target.
+	 * @param [options.features] Window features.
+	 */
+	public static openPage(
+		browserFrame: IBrowserFrame,
+		options?: {
+			url?: string;
+			target?: string;
+			features?: string;
+		}
+	): BrowserWindow | CrossOriginBrowserWindow | null {
+		const features = this.getWindowFeatures(options?.features || '');
+		const target = options?.target !== undefined ? String(options.target) : null;
+		const originURL = new URL(browserFrame.window.location.href);
+		const targetURL = BrowserFrameURL.getRelativeURL(browserFrame, options?.url);
+		const oldWindow = browserFrame.window;
+		let targetFrame: IBrowserFrame;
+
+		if (browserFrame.window !== oldWindow) {
+			return null;
+		}
+
+		switch (target) {
+			case '_self':
+				targetFrame = browserFrame;
+				break;
+			case '_top':
+				targetFrame = browserFrame.page.mainFrame;
+				break;
+			case '_parent':
+				targetFrame = browserFrame.parentFrame ?? browserFrame;
+				break;
+			case '_blank':
+			default:
+				const newPage = browserFrame.page.context.newPage();
+				targetFrame = newPage.mainFrame;
+				targetFrame[PropertySymbol.openerFrame] = browserFrame;
+				break;
+		}
+
+		targetFrame
+			.goto(targetURL.href, {
+				referrer: features.noreferrer ? undefined : browserFrame.window.location.origin,
+				referrerPolicy: features.noreferrer ? 'no-referrer' : undefined
+			})
+			.catch((error) => {
+				targetFrame.page.console.error(error);
+			});
+
+		if (targetURL.protocol === 'javascript:') {
+			return targetFrame.window;
+		}
+
+		// When using a detached Window instance directly and not via the Browser API we will not navigate and the window for the frame will not have changed.
+		if (targetFrame === browserFrame && browserFrame.window === oldWindow) {
+			return null;
+		}
+
+		if (features.popup && target !== '_self' && target !== '_top' && target !== '_parent') {
+			targetFrame[PropertySymbol.popup] = true;
+
+			if (features?.width || features?.height) {
+				targetFrame.page.setViewport({
+					width: features?.width,
+					height: features?.height
+				});
+			}
+
+			if (features?.left) {
+				(<number>targetFrame.window.screenLeft) = features.left;
+				(<number>targetFrame.window.screenX) = features.left;
+			}
+
+			if (features?.top) {
+				(<number>targetFrame.window.screenTop) = features.top;
+				(<number>targetFrame.window.screenY) = features.top;
+			}
+		}
+
+		if (
+			target &&
+			target !== '_self' &&
+			target !== '_top' &&
+			target !== '_parent' &&
+			target !== '_blank'
+		) {
+			(<string>targetFrame.window.name) = target;
+		}
+
+		const isCORS = FetchCORSUtility.isCORS(originURL, targetFrame.url);
+
+		if (
+			!features.noopener &&
+			!features.noreferrer &&
+			browserFrame.window &&
+			targetFrame[PropertySymbol.openerFrame] &&
+			targetFrame.window !== browserFrame.window
+		) {
+			targetFrame[PropertySymbol.openerWindow] = isCORS
+				? new CrossOriginBrowserWindow(browserFrame.window)
+				: browserFrame.window;
+		}
+
+		if (features.noopener || features.noreferrer) {
+			return null;
+		}
+
+		if (isCORS) {
+			return new CrossOriginBrowserWindow(targetFrame.window, browserFrame.window);
+		}
+
+		return targetFrame.window;
+	}
+
+	/**
+	 * Returns window features.
+	 *
+	 * @param features Window features string.
+	 * @returns Window features.
+	 */
+	private static getWindowFeatures(features: string): {
+		popup: boolean;
+		width: number;
+		height: number;
+		left: number;
+		top: number;
+		noopener: boolean;
+		noreferrer: boolean;
+	} {
+		const parts = features.split(',');
+		const result: {
+			popup: boolean;
+			width: number;
+			height: number;
+			left: number;
+			top: number;
+			noopener: boolean;
+			noreferrer: boolean;
+		} = {
+			popup: false,
+			width: 0,
+			height: 0,
+			left: 0,
+			top: 0,
+			noopener: false,
+			noreferrer: false
+		};
+
+		for (const part of parts) {
+			const [key, value] = part.split('=');
+			switch (key) {
+				case 'popup':
+					result.popup = !value || value === 'yes' || value === '1' || value === 'true';
+					break;
+				case 'width':
+				case 'innerWidth':
+					result.width = parseInt(value, 10);
+					break;
+				case 'height':
+				case 'innerHeight':
+					result.height = parseInt(value, 10);
+					break;
+				case 'left':
+				case 'screenX':
+					result.left = parseInt(value, 10);
+					break;
+				case 'top':
+				case 'screenY':
+					result.top = parseInt(value, 10);
+					break;
+				case 'noopener':
+					result.noopener = true;
+					break;
+				case 'noreferrer':
+					result.noreferrer = true;
+					break;
+			}
+		}
+
+		return result;
+	}
+}