buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/validity-state/ValidityState.ts

@@ -0,0 +1,234 @@
+import type HTMLButtonElement from '../nodes/html-button-element/HTMLButtonElement.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type HTMLFormElement from '../nodes/html-form-element/HTMLFormElement.js';
+import type HTMLInputElement from '../nodes/html-input-element/HTMLInputElement.js';
+import type HTMLSelectElement from '../nodes/html-select-element/HTMLSelectElement.js';
+import type HTMLTextAreaElement from '../nodes/html-text-area-element/HTMLTextAreaElement.js';
+import type ShadowRoot from '../nodes/shadow-root/ShadowRoot.js';
+import type HTMLObjectElement from '../nodes/html-object-element/HTMLObjectElement.js';
+import type HTMLOutputElement from '../nodes/html-output-element/HTMLOutputElement.js';
+
+const EMAIL_REGEXP =
+	/^([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22))*\x40([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d))*$/;
+const URL_REGEXP =
+	/^(?:(?:https?|HTTPS?|ftp|FTP):\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-zA-Z\u00a1-\uffff0-9]-*)*[a-zA-Z\u00a1-\uffff0-9]+)(?:\.(?:[a-zA-Z\u00a1-\uffff0-9]-*)*[a-zA-Z\u00a1-\uffff0-9]+)*)(?::\d{2,5})?(?:[\/?#]\S*)?$/;
+
+/**
+ * Input validity state.
+ *
+ * Based on:
+ * https://github.com/cferdinandi/validate/blob/master/src/js/_validityState.polyfill.js
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/ValidityState
+ */
+export default class ValidityState {
+	private element:
+		| HTMLInputElement
+		| HTMLTextAreaElement
+		| HTMLSelectElement
+		| HTMLButtonElement
+		| HTMLObjectElement
+		| HTMLOutputElement;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param element Input element.
+	 */
+	constructor(
+		element:
+			| HTMLInputElement
+			| HTMLTextAreaElement
+			| HTMLSelectElement
+			| HTMLButtonElement
+			| HTMLObjectElement
+			| HTMLOutputElement
+	) {
+		this.element = element;
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get badInput(): boolean {
+		return (
+			this.element[PropertySymbol.localName] === 'input' &&
+			(this.element.type === 'number' || this.element.type === 'range') &&
+			(<HTMLInputElement>this.element).value.length > 0 &&
+			!/^[-+]?(?:\d+|\d*[.,]\d+)$/.test((<HTMLInputElement>this.element).value)
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get customError(): boolean {
+		return this.element[PropertySymbol.validationMessage].length > 0;
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get patternMismatch(): boolean {
+		return (
+			this.element[PropertySymbol.localName] === 'input' &&
+			this.element.hasAttribute('pattern') &&
+			(<HTMLInputElement>this.element).value.length > 0 &&
+			(<HTMLInputElement>this.element).value.replace(
+				new RegExp(this.element.getAttribute('pattern')!),
+				''
+			).length > 0
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get rangeOverflow(): boolean {
+		return (
+			this.element[PropertySymbol.localName] === 'input' &&
+			this.element.hasAttribute('max') &&
+			(this.element.type === 'number' || this.element.type === 'range') &&
+			(<HTMLInputElement>this.element).value.length > 0 &&
+			Number((<HTMLInputElement>this.element).value) > Number(this.element.getAttribute('max'))
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get rangeUnderflow(): boolean {
+		return (
+			this.element[PropertySymbol.localName] === 'input' &&
+			this.element.hasAttribute('min') &&
+			(this.element.type === 'number' || this.element.type === 'range') &&
+			(<HTMLInputElement>this.element).value.length > 0 &&
+			Number((<HTMLInputElement>this.element).value) < Number(this.element.getAttribute('min'))
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get stepMismatch(): boolean {
+		return (
+			this.element[PropertySymbol.localName] === 'input' &&
+			(this.element.type === 'number' || this.element.type === 'range') &&
+			((this.element.hasAttribute('step') &&
+				this.element.getAttribute('step') !== 'any' &&
+				Number((<HTMLInputElement>this.element).value) %
+					Number(this.element.getAttribute('step')) !==
+					0) ||
+				(!this.element.hasAttribute('step') &&
+					Number((<HTMLInputElement>this.element).value) % 1 !== 0))
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get tooLong(): boolean {
+		return (
+			(this.element[PropertySymbol.localName] === 'input' ||
+				this.element[PropertySymbol.localName] === 'textarea') &&
+			(<HTMLInputElement>this.element).maxLength > 0 &&
+			(<HTMLInputElement>this.element).value.length > (<HTMLInputElement>this.element).maxLength
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get tooShort(): boolean {
+		return (
+			(this.element[PropertySymbol.localName] === 'input' ||
+				this.element[PropertySymbol.localName] === 'textarea') &&
+			(<HTMLInputElement>this.element).minLength > 0 &&
+			(<HTMLInputElement>this.element).value.length > 0 &&
+			(<HTMLInputElement>this.element).value.length < (<HTMLInputElement>this.element).minLength
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get typeMismatch(): boolean {
+		return (
+			this.element[PropertySymbol.localName] === 'input' &&
+			(<HTMLInputElement>this.element).value.length > 0 &&
+			((this.element.type === 'email' &&
+				!EMAIL_REGEXP.test((<HTMLInputElement>this.element).value)) ||
+				(this.element.type === 'url' && !URL_REGEXP.test((<HTMLInputElement>this.element).value)))
+		);
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get valueMissing(): boolean {
+		if (
+			!(<HTMLInputElement>this.element).required ||
+			this.element[PropertySymbol.localName] === 'object' ||
+			this.element[PropertySymbol.localName] === 'output'
+		) {
+			return false;
+		}
+		if (this.element[PropertySymbol.localName] === 'input') {
+			if (this.element.type === 'checkbox') {
+				return !(<HTMLInputElement>this.element).checked;
+			} else if (this.element.type === 'radio') {
+				if ((<HTMLInputElement>this.element).checked) {
+					return false;
+				}
+				if (!this.element.name) {
+					return true;
+				}
+				const root =
+					<HTMLFormElement>this.element[PropertySymbol.formNode] ||
+					<ShadowRoot>this.element.getRootNode();
+				return !root || !root.querySelector(`input[name="${this.element.name}"]:checked`);
+			}
+		}
+		return (<HTMLInputElement>this.element).value.length === 0;
+	}
+
+	/**
+	 * Returns validity.
+	 *
+	 * @returns "true" if valid.
+	 */
+	public get valid(): boolean {
+		return (
+			!this.badInput &&
+			!this.customError &&
+			!this.patternMismatch &&
+			!this.rangeOverflow &&
+			!this.rangeUnderflow &&
+			!this.stepMismatch &&
+			!this.tooLong &&
+			!this.tooShort &&
+			!this.typeMismatch &&
+			!this.valueMissing
+		);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/version.ts

@@ -0,0 +1 @@
+export default { version: '0.0.0' };

package/vendor/happy-dom/packages/happy-dom/src/web-socket/WebSocket.ts

@@ -0,0 +1,408 @@
+import CookieStringUtility from '../cookie/urilities/CookieStringUtility.js';
+import EventTarget from '../event/EventTarget.js';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import WindowBrowserContext from '../window/WindowBrowserContext.js';
+import WebSocketReadyStateEnum from './WebSocketReadyStateEnum.js';
+import Blob from '../file/Blob.js';
+import WS from '../../../../../../lib/happy-dom/websocket-adapter.js';
+
+// https://tools.ietf.org/html/rfc7230#section-3.2.6
+const SECURE_PROTOCOL_REGEXP = /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/;
+
+/**
+ * Represents a WebSocket.
+ *
+ * Based on:
+ * https://github.com/jsdom/jsdom/blob/main/lib/jsdom/living/websockets/WebSocket-impl.js
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+ */
+export default class WebSocket extends EventTarget {
+	public static readonly CONNECTING: number = WebSocketReadyStateEnum.connecting;
+	public static readonly OPEN: number = WebSocketReadyStateEnum.open;
+	public static readonly CLOSING: number = WebSocketReadyStateEnum.closing;
+	public static readonly CLOSED: number = WebSocketReadyStateEnum.closed;
+
+	#readyState: WebSocketReadyStateEnum = WebSocketReadyStateEnum.closed;
+	#extensions: string = '';
+	#binaryType: 'blob' | 'arraybuffer' = 'blob';
+	#error: Error | null = null;
+	#url: URL;
+
+	public [PropertySymbol.webSocket]: WS | null = null;
+
+	/**
+	 *
+	 * @param url
+	 * @param protocols
+	 */
+	constructor(url: string, protocols?: string | string[]) {
+		super();
+
+		const window = this[PropertySymbol.window];
+
+		let parsedURL: URL;
+		try {
+			parsedURL = new URL(url);
+		} catch {
+			throw new window.DOMException(
+				`The URL '${url}' is invalid.`,
+				DOMExceptionNameEnum.syntaxError
+			);
+		}
+
+		if (parsedURL.protocol !== 'ws:' && parsedURL.protocol !== 'wss:') {
+			throw new window.DOMException(
+				`The URL's protocol must be either 'ws' or 'wss'. '${parsedURL.protocol}' is not allowed.`,
+				DOMExceptionNameEnum.syntaxError
+			);
+		}
+
+		// Note: WebSocket URLs can have paths (e.g., wss://example.com/chat/room1)
+		// The fragment (hash) should be removed per the spec, but paths are valid.
+		if (parsedURL.hash) {
+			// Remove fragment from URL as per WebSocket spec
+			parsedURL.hash = '';
+		}
+
+		const protocolSet = new Set<string>();
+		const protocolList: string[] =
+			protocols !== undefined ? (Array.isArray(protocols) ? protocols : [protocols]) : [];
+
+		for (const protocol of protocolList) {
+			if (!this.#validateSecureProtocol(protocol)) {
+				throw new window.DOMException(
+					`The subprotocol '${protocol}' is invalid.`,
+					DOMExceptionNameEnum.syntaxError
+				);
+			}
+
+			if (protocolSet.has(protocol)) {
+				throw new window.DOMException(
+					`The subprotocol '${protocol}' is duplicated.`,
+					DOMExceptionNameEnum.syntaxError
+				);
+			}
+
+			protocolSet.add(protocol);
+		}
+
+		this.#url = parsedURL;
+
+		this.#connect(parsedURL, protocolList);
+	}
+
+	/**
+	 * Returns the ready state.
+	 *
+	 * @returns The ready state.
+	 */
+	public get readyState(): number {
+		return this.#readyState;
+	}
+
+	/**
+	 * Returns the extensions.
+	 *
+	 * @returns The extensions.
+	 */
+	public get extensions(): string {
+		return this.#extensions;
+	}
+
+	/**
+	 * Returns the binary type.
+	 *
+	 * @returns The binary type.
+	 */
+	public get binaryType(): 'blob' | 'arraybuffer' {
+		return this.#binaryType;
+	}
+
+	/**
+	 * Sets the binary type.
+	 *
+	 * @param value The binary type.
+	 */
+	public set binaryType(value: 'blob' | 'arraybuffer') {
+		if (value !== 'blob' && value !== 'arraybuffer') {
+			return;
+		}
+		this.#binaryType = value;
+	}
+
+	/**
+	 * Returns protocol.
+	 */
+	public get protocol(): string {
+		return this[PropertySymbol.webSocket]?.protocol || '';
+	}
+
+	/**
+	 * Returns the URL.
+	 *
+	 * @returns The URL.
+	 */
+	public get url(): string {
+		return this.#url.href;
+	}
+
+	/**
+	 * Closes the WebSocket.
+	 *
+	 * @param [code] Code.
+	 * @param [reason] Reason.
+	 */
+	public close(code?: number, reason?: string | Buffer<ArrayBufferLike>): void {
+		const window = this[PropertySymbol.window];
+
+		if (code !== undefined && code !== 1000 && !(code >= 3000 && code <= 4999)) {
+			throw new window.DOMException(
+				`The code must be either 1000, or between 3000 and 4999. ${code} is neither.`,
+				DOMExceptionNameEnum.invalidAccessError
+			);
+		}
+		if (reason !== undefined && Buffer.byteLength(reason, 'utf8') > 123) {
+			throw new window.DOMException(
+				`The message must not be greater than 123 bytes.`,
+				DOMExceptionNameEnum.syntaxError
+			);
+		}
+
+		this.#close(code, reason ? Buffer.from(<string>reason) : undefined);
+	}
+
+	/**
+	 * Sends data through the WebSocket.
+	 *
+	 * @param data Data.
+	 */
+	public send(data: ArrayBuffer | ArrayBufferView | Blob | Buffer | string): void {
+		const window = this[PropertySymbol.window];
+
+		if (this.#readyState === WebSocketReadyStateEnum.connecting) {
+			throw new window.DOMException(
+				'Still in CONNECTING state.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		if (this.#readyState !== WebSocketReadyStateEnum.open) {
+			return;
+		}
+
+		if (typeof data === 'string') {
+			this[PropertySymbol.webSocket]?.send(data, { binary: false });
+			return;
+		}
+
+		let buffer: Buffer;
+
+		if (data instanceof ArrayBuffer) {
+			buffer = Buffer.from(new Uint8Array(data));
+		} else if (data instanceof Blob) {
+			buffer = data[PropertySymbol.buffer];
+		} else if (data instanceof Buffer) {
+			buffer = data;
+		} else if (ArrayBuffer.isView(data)) {
+			buffer = Buffer.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+		} else {
+			buffer = Buffer.from(String(data));
+		}
+
+		this[PropertySymbol.webSocket]?.send(buffer, { binary: true });
+	}
+
+	/**
+	 * Destroys the WebSocket.
+	 */
+	public override [PropertySymbol.destroy](): void {
+		super[PropertySymbol.destroy]();
+		this.#close(1001);
+	}
+
+	/**
+	 * Connects the WebSocket.
+	 *
+	 * @param url URL.
+	 * @param protocols Protocols.
+	 */
+	#connect(url: URL, protocols: string[]): void {
+		const window = this[PropertySymbol.window];
+		const browserContext = new WindowBrowserContext(window).getBrowserContext();
+
+		if (!browserContext) {
+			return;
+		}
+
+		const originURL = new URL(window.location.href);
+		const cookies = browserContext.cookieContainer.getCookies(originURL, false);
+
+		this.#readyState = WebSocketReadyStateEnum.connecting;
+
+		this[PropertySymbol.webSocket] = new WS(url, protocols, {
+			headers: {
+				'user-agent': window.navigator.userAgent,
+				cookie: CookieStringUtility.cookiesToString(cookies),
+				origin: originURL.origin
+			},
+			rejectUnauthorized: !browserContext.browser.settings.fetch.disableStrictSSL
+		});
+		this[PropertySymbol.webSocket].once('open', () => {
+			this.#onConnectionEstablished();
+		});
+		this[PropertySymbol.webSocket].on('message', this.#onMessageReceived.bind(this));
+		this[PropertySymbol.webSocket].once(
+			'close',
+			(code: number, reason: Buffer<ArrayBufferLike>) => {
+				this.#onConnectionClosed(code, reason);
+			}
+		);
+		this[PropertySymbol.webSocket].once('upgrade', ({ headers }) => {
+			if (headers['set-cookie'] !== undefined) {
+				const cookieStrings = Array.isArray(headers['set-cookie'])
+					? headers['set-cookie']
+					: [headers['set-cookie']];
+				for (const cookieString of cookieStrings) {
+					const cookie = CookieStringUtility.stringToCookie(originURL, cookieString);
+					if (cookie) {
+						browserContext.cookieContainer.addCookies([cookie]);
+					}
+				}
+			}
+		});
+		this[PropertySymbol.webSocket].once('error', (error: Error) => {
+			// We only need to store the error for debugging purposes and to know that it wasn't a clean close.
+			// The 'close' event will be emitted afterwards.
+			this.#error = error;
+		});
+		window[PropertySymbol.openWebSockets].push(this);
+	}
+
+	/**
+	 * Closes the WebSocket connection.
+	 *
+	 * @param code Code.
+	 * @param reason Reason.
+	 */
+	#close(code?: number, reason?: string | Buffer<ArrayBufferLike>): void {
+		if (this.readyState === WebSocketReadyStateEnum.connecting) {
+			if (this[PropertySymbol.webSocket]) {
+				this[PropertySymbol.webSocket].terminate();
+			} else {
+				this.#readyState = WebSocketReadyStateEnum.closing;
+			}
+		} else if (this[PropertySymbol.webSocket] && this.readyState === WebSocketReadyStateEnum.open) {
+			this[PropertySymbol.webSocket].close(code, reason);
+		}
+		this[PropertySymbol.webSocket] = null;
+	}
+
+	/**
+	 * Called when the connection has been established.
+	 *
+	 * @see https://html.spec.whatwg.org/multipage/web-sockets.html#feedback-from-the-protocol
+	 */
+	#onConnectionEstablished(): void {
+		if (this[PropertySymbol.webSocket]?.extensions) {
+			this.#extensions = Object.keys(this[PropertySymbol.webSocket]!.extensions).join(', ');
+		}
+		this.#readyState = WebSocketReadyStateEnum.open;
+		this.dispatchEvent(new this[PropertySymbol.window].Event('open'));
+	}
+
+	/**
+	 * Called when the connection has been closed.
+	 *
+	 * @param code Code.
+	 * @param reason Reason.
+	 */
+	#onConnectionClosed(code: number, reason: Buffer<ArrayBufferLike>): void {
+		const window = this[PropertySymbol.window];
+		const index = window[PropertySymbol.openWebSockets].indexOf(this);
+
+		if (index !== -1) {
+			window[PropertySymbol.openWebSockets].splice(index, 1);
+		}
+
+		this.#readyState = WebSocketReadyStateEnum.closed;
+
+		this.dispatchEvent(
+			new this[PropertySymbol.window].CloseEvent('close', {
+				wasClean: this.#error === null,
+				code,
+				reason: reason.toString()
+			})
+		);
+	}
+
+	/**
+	 * Called when a message has been received.
+	 *
+	 * @param data Data.
+	 * @param isBinary "true" if the data is binary.
+	 */
+	#onMessageReceived(data: any, isBinary: boolean): void {
+		if (this.#readyState !== WebSocketReadyStateEnum.open) {
+			return;
+		}
+
+		const window = this[PropertySymbol.window];
+		let dataForEvent;
+
+		if (isBinary) {
+			switch (this.binaryType) {
+				case 'arraybuffer':
+					if (data instanceof window.ArrayBuffer) {
+						dataForEvent = data;
+					} else if (Array.isArray(data)) {
+						dataForEvent = this.#convertToArrayBuffer(Buffer.concat(data));
+					} else {
+						dataForEvent = this.#convertToArrayBuffer(data);
+					}
+					break;
+				case 'blob':
+				default:
+					if (!Array.isArray(data)) {
+						data = [data];
+					}
+					dataForEvent = new window.Blob(data);
+					break;
+			}
+		} else {
+			dataForEvent = String(data);
+		}
+
+		this.dispatchEvent(
+			new window.MessageEvent('message', {
+				data: dataForEvent,
+				origin: this.#url.origin
+			})
+		);
+	}
+
+	/**
+	 * Converts a Node.js Buffer to an ArrayBuffer.
+	 *
+	 * @param buffer Node.js Buffer.
+	 * @returns ArrayBuffer.
+	 */
+	#convertToArrayBuffer(buffer: Buffer): ArrayBuffer {
+		const window = this[PropertySymbol.window];
+		const arrayBuffer = new window.ArrayBuffer(buffer.byteLength);
+		const view = new Uint8Array(arrayBuffer);
+		view.set(buffer);
+		return arrayBuffer;
+	}
+
+	/**
+	 * See Sec-WebSocket-Protocol-Client, which is for the syntax of an entire header value. This function checks if a single header conforms to the rules.
+	 *
+	 * @see https://tools.ietf.org/html/rfc6455#section-4.3
+	 * @param protocol
+	 */
+	#validateSecureProtocol(protocol: string): boolean {
+		return SECURE_PROTOCOL_REGEXP.test(protocol);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/web-socket/WebSocketReadyStateEnum.ts

@@ -0,0 +1,8 @@
+enum WebSocketReadyStateEnum {
+	connecting = 0,
+	open = 1,
+	closing = 2,
+	closed = 3
+}
+
+export default WebSocketReadyStateEnum;