buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/IResponseInit.ts

@@ -0,0 +1,10 @@
+import type { THeadersInit } from './THeadersInit.js';
+
+/**
+ * Response init.
+ */
+export default interface IResponseInit {
+	headers?: THeadersInit | undefined;
+	status?: number | undefined;
+	statusText?: string | undefined;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/ISyncResponse.ts

@@ -0,0 +1,18 @@
+import type { PropertySymbol } from '../../index.js';
+import type Headers from '../Headers.js';
+
+/**
+ * Fetch response.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/Response
+ */
+export default interface ISyncResponse {
+	status: number;
+	statusText: string;
+	ok: boolean;
+	url: string;
+	redirected: boolean;
+	headers: Headers;
+	body: Buffer | null;
+	[PropertySymbol.virtualServerFile]?: string | null;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/IVirtualServer.ts

@@ -0,0 +1,7 @@
+/**
+ * Virtual server used for simulating a server that reads from the file system.
+ */
+export default interface IVirtualServer {
+	url: string | RegExp;
+	directory: string;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/THeadersInit.ts

@@ -0,0 +1,3 @@
+import type Headers from '../Headers.js';
+
+export type THeadersInit = string[][] | { [key: string]: string } | Headers;

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/TRequestBody.ts

@@ -0,0 +1,14 @@
+import type { URLSearchParams } from 'url';
+import type FormData from '../../form-data/FormData.js';
+import type Blob from '../../file/Blob.js';
+import type { ReadableStream } from 'stream/web';
+
+export type TRequestBody =
+	| ArrayBuffer
+	| ArrayBufferView
+	| ReadableStream
+	| string
+	| URLSearchParams
+	| Blob
+	| FormData
+	| null;

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/TRequestCredentials.ts

@@ -0,0 +1 @@
+export type TRequestCredentials = 'omit' | 'same-origin' | 'include';

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/TRequestInfo.ts

@@ -0,0 +1,4 @@
+import type URL from '../../url/URL.js';
+import type Request from '../Request.js';
+
+export type TRequestInfo = Request | string | URL;

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/TRequestMode.ts

@@ -0,0 +1 @@
+export type TRequestMode = 'same-origin' | 'cors' | 'no-cors' | 'navigate' | 'websocket';

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/TRequestRedirect.ts

@@ -0,0 +1 @@
+export type TRequestRedirect = 'follow' | 'error' | 'manual';

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/TRequestReferrerPolicy.ts

@@ -0,0 +1,10 @@
+export type TRequestReferrerPolicy =
+	| ''
+	| 'no-referrer'
+	| 'no-referrer-when-downgrade'
+	| 'same-origin'
+	| 'origin'
+	| 'strict-origin'
+	| 'origin-when-cross-origin'
+	| 'strict-origin-when-cross-origin'
+	| 'unsafe-url';

package/vendor/happy-dom/packages/happy-dom/src/fetch/types/TResponseBody.ts

@@ -0,0 +1,14 @@
+import type { ReadableStream } from 'stream/web';
+import type { URLSearchParams } from 'url';
+import type FormData from '../../form-data/FormData.js';
+import type Blob from '../../file/Blob.js';
+
+export type TResponseBody =
+	| ArrayBuffer
+	| ArrayBufferView
+	| ReadableStream
+	| string
+	| URLSearchParams
+	| Blob
+	| FormData
+	| null;

package/vendor/happy-dom/packages/happy-dom/src/fetch/utilities/FetchBodyUtility.ts

@@ -0,0 +1,284 @@
+import MultipartFormDataParser from '../multipart/MultipartFormDataParser.js';
+import { ReadableStream } from 'stream/web';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import { URLSearchParams } from 'url';
+import FormData from '../../form-data/FormData.js';
+import Blob from '../../file/Blob.js';
+import DOMException from '../../exception/DOMException.js';
+import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
+import type { TRequestBody } from '../types/TRequestBody.js';
+import type { TResponseBody } from '../types/TResponseBody.js';
+import { Buffer } from 'buffer';
+import Stream from 'stream';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+import { ReadableStreamWrapper } from '../ReadableStreamWrapper.js';
+
+/**
+ * Fetch body utility.
+ */
+export default class FetchBodyUtility {
+	/**
+	 * Parses body and returns stream and type.
+	 *
+	 * Based on:
+	 * https://github.com/node-fetch/node-fetch/blob/main/src/body.js (MIT)
+	 *
+	 * @param body Body.
+	 * @returns Stream and type.
+	 */
+	public static getBodyStream(body: TRequestBody | TResponseBody): {
+		contentType: string | null;
+		contentLength: number | null;
+		stream: ReadableStreamWrapper | null;
+		buffer: Buffer | null;
+	} {
+		if (body === null || body === undefined) {
+			return { stream: null, buffer: null, contentType: null, contentLength: null };
+		} else if (body instanceof URLSearchParams) {
+			const buffer = Buffer.from(body.toString());
+			return {
+				buffer,
+				stream: this.getReadableStream(buffer),
+				contentType: 'application/x-www-form-urlencoded;charset=UTF-8',
+				contentLength: buffer.length
+			};
+		} else if (body instanceof Blob) {
+			const buffer = (<Blob>body)[PropertySymbol.buffer];
+			return {
+				buffer,
+				stream: this.getReadableStream(buffer),
+				contentType: body.type,
+				contentLength: body.size
+			};
+		} else if (Buffer.isBuffer(body)) {
+			return {
+				buffer: body,
+				stream: this.getReadableStream(body),
+				contentType: null,
+				contentLength: body.length
+			};
+		} else if (body instanceof ArrayBuffer) {
+			const buffer = Buffer.from(body);
+			return {
+				buffer,
+				stream: this.getReadableStream(buffer),
+				contentType: null,
+				contentLength: body.byteLength
+			};
+		} else if (ArrayBuffer.isView(body)) {
+			const buffer = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+			return {
+				buffer,
+				stream: this.getReadableStream(buffer),
+				contentType: null,
+				contentLength: body.byteLength
+			};
+		} else if (body instanceof ReadableStream) {
+			return {
+				buffer: null,
+				stream: new ReadableStreamWrapper(() => body),
+				contentType: null,
+				contentLength: null
+			};
+		} else if (body instanceof FormData) {
+			return MultipartFormDataParser.formDataToStream(body);
+		}
+
+		const buffer = Buffer.from(String(body));
+		return {
+			buffer,
+			stream: this.getReadableStream(buffer),
+			contentType: 'text/plain;charset=UTF-8',
+			contentLength: buffer.length
+		};
+	}
+
+	/**
+	 * Clones a request or body body stream.
+	 *
+	 * It is actually not cloning the stream.
+	 * It creates a pass through stream and pipes the original stream to it.
+	 *
+	 * @param window Window.
+	 * @param requestOrResponse Request or Response.
+	 * @param requestOrResponse.body Body.
+	 * @param requestOrResponse.bodyUsed Body used.
+	 * @returns New stream.
+	 */
+	public static cloneBodyStream(
+		window: BrowserWindow,
+		requestOrResponse: {
+			[PropertySymbol.buffer]?: Buffer | null;
+			[PropertySymbol.body]?: ReadableStreamWrapper | null;
+			body: ReadableStream | null;
+			bodyUsed: boolean;
+		}
+	): ReadableStream | null {
+		if (requestOrResponse.bodyUsed) {
+			throw new window.DOMException(
+				`Failed to clone body stream of request: Request body is already used.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		if (requestOrResponse.body === null || requestOrResponse.body === undefined) {
+			return null;
+		}
+
+		// If a buffer is set, use it to create a new stream.
+		if (requestOrResponse[PropertySymbol.buffer]) {
+			return this.getReadableStream(requestOrResponse[PropertySymbol.buffer]).readableStream;
+		}
+
+		// Pipe underlying node stream if it exists.
+		if ((<any>requestOrResponse.body)[PropertySymbol.nodeStream]) {
+			const stream1 = new Stream.PassThrough();
+			const stream2 = new Stream.PassThrough();
+			(<any>requestOrResponse.body)[PropertySymbol.nodeStream].pipe(stream1);
+			(<any>requestOrResponse.body)[PropertySymbol.nodeStream].pipe(stream2);
+			// Sets the body of the cloned request/response to the first pass through stream.
+			// Sets the body of the original request/response
+			requestOrResponse[PropertySymbol.body] = new ReadableStreamWrapper(() =>
+				this.nodeToWebStream(stream1)
+			);
+			// Returns the clone.
+			return this.nodeToWebStream(stream2);
+		}
+
+		// Uses the tee() method to clone the ReadableStream
+		// This requires the stream to be consumed in parallel which is not the case for the fetch API
+		const [stream1, stream2] = requestOrResponse.body.tee();
+
+		// Sets the body of the original request/response
+		requestOrResponse[PropertySymbol.body] = new ReadableStreamWrapper(() => stream1);
+
+		// Returns the other stream as the clone
+		return stream2;
+	}
+
+	/**
+	 * Consume and convert an entire Body to a Buffer.
+	 *
+	 * Based on:
+	 * https://github.com/node-fetch/node-fetch/blob/main/src/body.js (MIT)
+	 *
+	 * @see https://fetch.spec.whatwg.org/#concept-body-consume-body
+	 * @param window Window.
+	 * @param requestOrResponse
+	 * @param requestOrResponse.body
+	 * @param body Body stream.
+	 * @returns Promise.
+	 */
+	public static async consumeBodyStream(
+		window: BrowserWindow,
+		requestOrResponse: {
+			body: ReadableStream | null;
+			[PropertySymbol.aborted]: boolean;
+			[PropertySymbol.error]: Error | null;
+		}
+	): Promise<Buffer> {
+		const body = requestOrResponse.body;
+
+		if (body === null || !(body instanceof ReadableStream)) {
+			return Buffer.alloc(0);
+		}
+
+		if (requestOrResponse[PropertySymbol.error]) {
+			throw requestOrResponse[PropertySymbol.error];
+		}
+
+		const reader = body.getReader();
+		const chunks = [];
+		let bytes = 0;
+
+		try {
+			let readResult = await reader.read();
+			while (!readResult.done) {
+				if (requestOrResponse[PropertySymbol.error]) {
+					throw requestOrResponse[PropertySymbol.error];
+				}
+				if (requestOrResponse[PropertySymbol.aborted]) {
+					throw new window.DOMException(
+						'Failed to read response body: The stream was aborted.',
+						DOMExceptionNameEnum.abortError
+					);
+				}
+				const chunk = readResult.value;
+				bytes += chunk.length;
+				chunks.push(chunk);
+				readResult = await reader.read();
+			}
+		} catch (error) {
+			if (error instanceof DOMException) {
+				throw error;
+			}
+			throw new window.DOMException(
+				`Failed to read response body. Error: ${(<Error>error).message}.`,
+				DOMExceptionNameEnum.encodingError
+			);
+		}
+
+		try {
+			if (typeof chunks[0] === 'string') {
+				return Buffer.from(chunks.join(''));
+			}
+
+			return Buffer.concat(chunks, bytes);
+		} catch (error) {
+			throw new window.DOMException(
+				`Could not create Buffer from response body. Error: ${(<Error>error).message}.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+	}
+
+	/**
+	 * Wraps a Node.js stream into a browser-compatible ReadableStream.
+	 *
+	 * Enables the use of Node.js streams where browser ReadableStreams are required.
+	 * Handles 'data', 'end', and 'error' events from the Node.js stream.
+	 *
+	 * @param nodeStream The Node.js stream to be converted.
+	 * @returns ReadableStream
+	 */
+	public static nodeToWebStream(nodeStream: Stream): ReadableStream {
+		const readableStream = new ReadableStream({
+			start(controller) {
+				nodeStream.on('data', (chunk) => {
+					controller.enqueue(chunk);
+				});
+
+				nodeStream.on('end', () => {
+					controller.close();
+				});
+
+				nodeStream.on('error', (err) => {
+					controller.error(err);
+				});
+			}
+		});
+		(<any>readableStream)[PropertySymbol.nodeStream] = nodeStream;
+		return readableStream;
+	}
+
+	/**
+	 * Wraps a given value in a browser ReadableStream.
+	 *
+	 * This method creates a ReadableStream and immediately enqueues and closes it
+	 * with the provided value, useful for stream API compatibility.
+	 *
+	 * @param value The value to be wrapped in a ReadableStream.
+	 * @returns ReadableStream
+	 */
+	private static getReadableStream(value: any): ReadableStreamWrapper {
+		return new ReadableStreamWrapper(
+			() =>
+				new ReadableStream({
+					start(controller) {
+						controller.enqueue(value);
+						controller.close();
+					}
+				})
+		);
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/utilities/FetchCORSUtility.ts

@@ -0,0 +1,23 @@
+import { URL } from 'url';
+
+/**
+ * Fetch CORS utility.
+ */
+export default class FetchCORSUtility {
+	/**
+	 * Validates request headers.
+	 *
+	 * @param originURL Origin URL.
+	 * @param targetURL Target URL.
+	 */
+	public static isCORS(originURL: URL | string, targetURL: URL | string): boolean {
+		originURL = typeof originURL === 'string' ? new URL(<string>originURL) : <URL>originURL;
+		targetURL = typeof targetURL === 'string' ? new URL(<string>targetURL) : <URL>targetURL;
+
+		if (targetURL.protocol === 'about:' || targetURL.protocol === 'javascript:') {
+			return false;
+		}
+
+		return originURL.origin !== targetURL.origin;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/utilities/FetchRequestHeaderUtility.ts

@@ -0,0 +1,141 @@
+import type IBrowserFrame from '../../browser/types/IBrowserFrame.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+import CookieStringUtility from '../../cookie/urilities/CookieStringUtility.js';
+import type Headers from '../Headers.js';
+import type Request from '../Request.js';
+import FetchCORSUtility from './FetchCORSUtility.js';
+import { URL } from 'url';
+
+const FORBIDDEN_HEADER_NAMES = [
+	'accept-charset',
+	'accept-encoding',
+	'access-control-request-headers',
+	'access-control-request-method',
+	'connection',
+	'content-length',
+	'content-transfer-encoding',
+	'cookie',
+	'cookie2',
+	'date',
+	'dnt',
+	'expect',
+	'host',
+	'keep-alive',
+	'origin',
+	'referer',
+	'te',
+	'trailer',
+	'transfer-encoding',
+	'upgrade',
+	'via'
+];
+
+/**
+ * Fetch request header utility.
+ */
+export default class FetchRequestHeaderUtility {
+	/**
+	 * Validates request headers.
+	 *
+	 * @param headers Headers.
+	 */
+	public static removeForbiddenHeaders(headers: Headers): void {
+		for (const key of Object.keys((<Headers>headers)[PropertySymbol.entries])) {
+			if (
+				FORBIDDEN_HEADER_NAMES.includes(key) ||
+				key.startsWith('proxy-') ||
+				key.startsWith('sec-')
+			) {
+				delete (<Headers>headers)[PropertySymbol.entries][key];
+			}
+		}
+	}
+
+	/**
+	 * Returns "true" if the header is forbidden.
+	 *
+	 * @param name Header name.
+	 * @returns "true" if the header is forbidden.
+	 */
+	public static isHeaderForbidden(name: string): boolean {
+		return FORBIDDEN_HEADER_NAMES.includes(name.toLowerCase());
+	}
+
+	/**
+	 * Returns request headers.
+	 *
+	 * @param options Options.
+	 * @param options.browserFrame Browser frame.
+	 * @param options.window Window.
+	 * @param options.request Request.
+	 * @param [options.baseHeaders] Any base headers (may be overwritten by browser/window headers).
+	 * @returns Headers.
+	 */
+	public static getRequestHeaders(options: {
+		browserFrame: IBrowserFrame;
+		window: BrowserWindow;
+		request: Request;
+		baseHeaders?: Headers | null;
+	}): { [key: string]: string } {
+		const headers = new options.window.Headers(options.baseHeaders);
+		options.request.headers.forEach((value, key) => {
+			headers.set(key, value);
+		});
+
+		const originURL = new URL(options.window.location.href);
+		const isCORS = FetchCORSUtility.isCORS(originURL, options.request[PropertySymbol.url]);
+
+		headers.set('Accept-Encoding', 'gzip, deflate, br');
+		headers.set('Connection', 'close');
+
+		if (!headers.has('User-Agent')) {
+			headers.set('User-Agent', options.window.navigator.userAgent);
+		}
+
+		if (options.request[PropertySymbol.referrer] instanceof URL) {
+			headers.set('Referer', options.request[PropertySymbol.referrer].href);
+		}
+
+		if (
+			options.request.credentials === 'include' ||
+			(options.request.credentials === 'same-origin' && !isCORS)
+		) {
+			const cookies = options.browserFrame.page.context.cookieContainer.getCookies(
+				options.request[PropertySymbol.url],
+				false
+			);
+			if (cookies.length > 0) {
+				headers.set('Cookie', CookieStringUtility.cookiesToString(cookies));
+			}
+		} else {
+			headers.delete('Cookie');
+			headers.delete('Cookie2');
+		}
+
+		if (!headers.has('Accept')) {
+			headers.set('Accept', '*/*');
+		}
+
+		if (!headers.has('Content-Length') && options.request[PropertySymbol.contentLength] !== null) {
+			headers.set('Content-Length', String(options.request[PropertySymbol.contentLength]));
+		}
+
+		if (!headers.has('Content-Type') && options.request[PropertySymbol.contentType]) {
+			headers.set('Content-Type', options.request[PropertySymbol.contentType]);
+		}
+
+		if (isCORS) {
+			headers.set('Origin', originURL.origin);
+		}
+
+		// We need to convert the headers to Node request headers.
+		const httpRequestHeaders: { [name: string]: string } = {};
+
+		for (const header of Object.values(headers[PropertySymbol.entries])) {
+			httpRequestHeaders[header.name] = header.value.join(', ');
+		}
+
+		return httpRequestHeaders;
+	}
+}