buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/fetch/certificate/FetchHTTPSCertificate.ts

@@ -0,0 +1,52 @@
+// SSL certificate generated for Happy DOM to be able to perform HTTPS requests
+export default {
+	cert: `-----BEGIN CERTIFICATE-----
+MIIDYzCCAkugAwIBAgIUJRKB/H66hpet1VfUlm0CiXqePA4wDQYJKoZIhvcNAQEL
+BQAwQTELMAkGA1UEBhMCU0UxDjAMBgNVBAgMBVNrYW5lMQ4wDAYDVQQHDAVNYWxt
+bzESMBAGA1UECgwJSGFwcHkgRE9NMB4XDTIyMTAxMTIyMDM0OVoXDTMyMTAwODIy
+MDM0OVowQTELMAkGA1UEBhMCU0UxDjAMBgNVBAgMBVNrYW5lMQ4wDAYDVQQHDAVN
+YWxtbzESMBAGA1UECgwJSGFwcHkgRE9NMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAqerQSQEg/SxVxRiwlItithr5e5EMZo1nsqt/xOxagbmpW3IEmt0j
+bpbH7iEF4DDEo7KAOwUCOwVWeFxRoag8lG2ax48wrgjlCna45XDn0Xeg1ARajL04
+gs46HZ0VrzIloVGfln0zgt/Vum5BNqs9Oc5fQoBmoP3cAn3dn4ZVcP0AKthtcyPl
+q2DuNRN0PV0D2RtMSiAy9l1Ko6N5x+sAeClDyOL+sTDLngZBVeZyOKt9Id15S8Zt
+XtA6VMgHnnF3jChn7pag77rsd/y5iANAVNZYqRl+Eg7xaDcsvbgH46UBOrBcB39Q
+tTh5Mtjoxep5e3ZDFG+kQ1HUE+iz5O5n0wIDAQABo1MwUTAdBgNVHQ4EFgQU69s9
+YSobG/m2SN4L/7zTaF7iDbwwHwYDVR0jBBgwFoAU69s9YSobG/m2SN4L/7zTaF7i
+DbwwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAi/WUXx2oal8L
+YnPlIuKfh49n/K18wXSYG//oFYwxfVxqpYH8hUiXVm/GUcXCxS++hUkaKLqXmH9q
+MKJiCrZr3vS+2nsBKopkICu/TLdROl0sAI9lByfnEbfSAzjxe1IWJdK8NdY0y5m5
+9pEr/URVIAp/CxrneyASb4q0Jg5To3FR7vYc+2X6wZn0MundKMg6Dp9/A37jiF3l
+Tt/EJp299YZcsUzh+LnRuggRjnoOVu1aLcLFlaUiwZfy9m8mLG6B/mdW/qNzNMh9
+Oqvg1zfGdpz/4D/2UUUBn6pq1vbsoAaF3OesoA3mfDcegDf/H9woJlpT0Wql+e68
+Y3FblSokcA==
+-----END CERTIFICATE-----`,
+	key: `-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCp6tBJASD9LFXF
+GLCUi2K2Gvl7kQxmjWeyq3/E7FqBualbcgSa3SNulsfuIQXgMMSjsoA7BQI7BVZ4
+XFGhqDyUbZrHjzCuCOUKdrjlcOfRd6DUBFqMvTiCzjodnRWvMiWhUZ+WfTOC39W6
+bkE2qz05zl9CgGag/dwCfd2fhlVw/QAq2G1zI+WrYO41E3Q9XQPZG0xKIDL2XUqj
+o3nH6wB4KUPI4v6xMMueBkFV5nI4q30h3XlLxm1e0DpUyAeecXeMKGfulqDvuux3
+/LmIA0BU1lipGX4SDvFoNyy9uAfjpQE6sFwHf1C1OHky2OjF6nl7dkMUb6RDUdQT
+6LPk7mfTAgMBAAECggEAKkwTkTjAt4UjzK56tl+EMQTB+ep/hb/JgoaChci4Nva6
+m9LkJpDJ0yuhlTuPNOGu8XjrxsVWas7HWarRf0Zb3i7yip6wZYI9Ub+AA015x4DZ
+/i0fRU2NFbK0cM67qSL4jxG8gj+kZP3HPGNZxHwX/53JxMolwgmvjMc8NgvAlSFd
+NnV9h4xtbhUh1NGS5zmP3iU2rwnE8JrIEzwy6axLom7nekAgkdcbAr0UoBs8gcgH
+aYNhU4Gz3tGcZZ0IXAfT/bJIH1Ko8AGv4pssWc3BXcmmNdm/+kzvHIxEIV7Qegmo
+XG1ZyZCyD/0b4/3e8ySDBEDqwR+HeyTW2isWG2agAQKBgQDp44aTwr3dkIXY30xv
+FPfUOipg/B49dWnffYJ9MWc1FT9ijNPAngWSk0EIiEQIazICcUBI4Yji6/KeyqLJ
+GdLpDi1CkKqtyh73mjELinYp3EUQgEa77aQogGa2+nMOVfu+O5CtloUrv/A18jX3
++VEyaEASK0fWmnSI0OdlxQHIAQKBgQC5+xOls2F3MlKASvWRLlnW1wHqlDTtVoYg
+5Nh8syZH4Ci2UH8tON3A5/7SWNM0t1cgV6Cw4zW8Z2spgIT/W0iYYrQ4hHL1xdCu
++CxL1km4Gy8Uwpsd+KdFahFqF/XTmLzW0HXLxWSK0fTwmdV0SFrKF3MXfTCU2AeZ
+jJoMFb6P0wKBgQC3Odw6s0vkYAzLGhuZxfZkVvDOK5RRF0NKpttr0iEFL9EJFkPo
+2KKK8jr3QTDy229BBJGUxsJi6u6VwS8HlehpVQbV59kd7oKV/EBBx0XMg1fDlopT
+PNbmN7i/zbIG4AsoOyebJZjL7kBzMn1e9vzKHWtcEHXlw/hZGja8vjooAQKBgAeg
+xK2HLfg1mCyq5meN/yFQsENu0LzrT5UJzddPgcJw7zqLEqxIKNBAs7Ls8by3yFsL
+PQwERa/0jfCl1M6kb9XQNpQa2pw6ANUsWKTDpUJn2wZ+9N3F1RaDwzMWyH5lRVmK
+M0qoTfdjpSg5Jwgd75taWt4bxGJWeflSSv8z5R0BAoGAWL8c527AbeBvx2tOYKkD
+2TFranvANNcoMrbeviZSkkGvMNDP3p8b6juJwXOIeWNr8q4vFgCzLmq6d1/9gYm2
+3XJwwyD0LKlqzkBrrKU47qrnmMosUrIRlrAzd3HbShOptxc6Iz2apSaUDKGKXkaw
+gl5OpEjeliU7Mus0BVS858g=
+-----END PRIVATE KEY-----`
+};

package/vendor/happy-dom/packages/happy-dom/src/fetch/data-uri/DataURIParser.ts

@@ -0,0 +1,66 @@
+/**
+ * Data URI parser.
+ *
+ * Based on:
+ * https://github.com/TooTallNate/node-data-uri-to-buffer/blob/main/src/index.ts (MIT)
+ */
+export default class DataURIParser {
+	/**
+	 * Returns a Buffer instance from the given data URI `uri`.
+	 *
+	 * @param uri Data URI.
+	 * @returns Buffer.
+	 */
+	public static parse(uri: string): {
+		type: string;
+		charset: string;
+		buffer: Buffer;
+	} {
+		if (!/^data:/i.test(uri)) {
+			throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
+		}
+
+		// Strip newlines
+		uri = uri.replace(/\r?\n/g, '');
+
+		// Split the URI up into the "metadata" and the "data" portions
+		const firstComma = uri.indexOf(',');
+		if (firstComma === -1 || firstComma <= 4) {
+			throw new TypeError('malformed data: URI');
+		}
+
+		// Remove the "data:" scheme and parse the metadata
+		const meta = uri.substring(5, firstComma).split(';');
+		let charset = '';
+		let base64 = false;
+		let type = meta[0] || 'text/plain';
+
+		for (let i = 1; i < meta.length; i++) {
+			if (meta[i] === 'base64') {
+				base64 = true;
+			} else if (meta[i]) {
+				type += `;${meta[i]}`;
+				if (meta[i].indexOf('charset=') === 0) {
+					charset = meta[i].substring(8);
+				}
+			}
+		}
+
+		// Defaults to US-ASCII only if type is not provided
+		if (!meta[0] && !charset.length) {
+			type += ';charset=US-ASCII';
+			charset = 'US-ASCII';
+		}
+
+		// Get the encoded data portion and decode URI-encoded chars
+		const encoding = base64 ? 'base64' : 'ascii';
+		const data = unescape(uri.substring(firstComma + 1));
+		const buffer = Buffer.from(data, encoding);
+
+		return {
+			type,
+			charset,
+			buffer
+		};
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/multipart/MultipartFormDataParser.ts

@@ -0,0 +1,174 @@
+import type FormData from '../../form-data/FormData.js';
+import { ReadableStream } from 'stream/web';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import MultipartReader from './MultipartReader.js';
+import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
+import { Buffer } from 'buffer';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+import { ReadableStreamWrapper } from '../ReadableStreamWrapper.js';
+
+/**
+ * Multipart form data factory.
+ *
+ * Based on:
+ * https://github.com/node-fetch/node-fetch/blob/main/src/utils/multipart-parser.js (MIT)
+ */
+export default class MultipartFormDataParser {
+	/**
+	 * Returns form data.
+	 *
+	 * @param window Window.
+	 * @param response Response object containing a body stream.
+	 * @param response.body Body stream.
+	 * @param requestOrResponse
+	 * @param requestOrResponse.body
+	 * @param contentType Content type header value.
+	 * @returns Form data.
+	 */
+	public static async streamToFormData(
+		window: BrowserWindow,
+		requestOrResponse: {
+			body: ReadableStream<Uint8Array> | null;
+			[PropertySymbol.error]: Error | null;
+			[PropertySymbol.aborted]: boolean;
+		},
+		contentType: string
+	): Promise<{ formData: FormData; buffer: Buffer }> {
+		if (!/multipart/i.test(contentType)) {
+			throw new window.DOMException(
+				`Failed to build FormData object: The "content-type" header isn't of type "multipart/form-data".`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const body = requestOrResponse.body;
+
+		if (!body) {
+			throw new window.DOMException(
+				'Failed to build FormData object: The response body is null.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const match = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+
+		if (!match) {
+			throw new window.DOMException(
+				`Failed to build FormData object: The "content-type" header doesn't contain any multipart boundary.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const bodyReader = body.getReader();
+		const reader = new MultipartReader(window, match[1] || match[2]);
+		const chunks: any[] = [];
+		let buffer: Buffer;
+		const bytes = 0;
+
+		let readResult = await bodyReader.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
+				);
+			}
+			reader.write(readResult.value);
+			readResult = await bodyReader.read();
+		}
+
+		try {
+			buffer =
+				typeof chunks[0] === 'string' ? Buffer.from(chunks.join('')) : Buffer.concat(chunks, bytes);
+		} catch (error) {
+			throw new window.DOMException(
+				`Could not create Buffer from response body. Error: ${(<Error>error).message}.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		return {
+			formData: reader.end(),
+			buffer
+		};
+	}
+
+	/**
+	 * Converts a FormData object to a ReadableStream.
+	 *
+	 * @param formData FormData.
+	 * @returns Stream and type.
+	 */
+	public static formDataToStream(formData: FormData): {
+		contentType: string;
+		contentLength: number;
+		buffer: Buffer;
+		stream: ReadableStreamWrapper;
+	} {
+		const boundary = '----HappyDOMFormDataBoundary' + Math.random().toString(36);
+		const chunks: Buffer[] = [];
+		const prefix = `--${boundary}\r\nContent-Disposition: form-data; name="`;
+
+		for (const [name, value] of formData) {
+			if (typeof value === 'string') {
+				chunks.push(
+					Buffer.from(
+						`${prefix}${this.escapeName(name)}"\r\n\r\n${value.replace(
+							/\r(?!\n)|(?<!\r)\n/g,
+							'\r\n'
+						)}\r\n`
+					)
+				);
+			} else {
+				chunks.push(
+					Buffer.from(
+						`${prefix}${this.escapeName(name)}"; filename="${this.escapeName(
+							value.name,
+							true
+						)}"\r\nContent-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`
+					)
+				);
+				chunks.push(value[PropertySymbol.buffer]);
+				chunks.push(Buffer.from('\r\n'));
+			}
+		}
+
+		// add end boundary
+		chunks.push(Buffer.from(`--${boundary}--\r\n`));
+
+		const buffer = Buffer.concat(chunks);
+
+		return {
+			contentType: `multipart/form-data; boundary=${boundary}`,
+			contentLength: buffer.length,
+			buffer,
+			stream: new ReadableStreamWrapper(
+				() =>
+					new ReadableStream({
+						start(controller) {
+							controller.enqueue(buffer);
+							controller.close();
+						}
+					})
+			)
+		};
+	}
+
+	/**
+	 * Escapes a form data entry name.
+	 *
+	 * @param name Name.
+	 * @param filename Whether it is a filename.
+	 * @returns Escaped name.
+	 */
+	private static escapeName(name: string, filename = false): string {
+		return (filename ? name : name.replace(/\r?\n|\r/g, '\r\n'))
+			.replace(/\n/g, '%0A')
+			.replace(/\r/g, '%0D')
+			.replace(/"/g, '%22');
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/multipart/MultipartReader.ts

@@ -0,0 +1,216 @@
+import File from '../../file/File.js';
+import type FormData from '../../form-data/FormData.js';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+
+enum MultipartParserStateEnum {
+	boundary = 0,
+	headerStart = 2,
+	header = 3,
+	data = 5
+}
+
+const CHARACTER_CODE = {
+	lf: 10,
+	cr: 13
+};
+
+/**
+ * Multipart reader.
+ *
+ * Based on:
+ * https://github.com/node-fetch/node-fetch/blob/main/src/utils/multipart-parser.js (MIT)
+ */
+export default class MultipartReader {
+	private formData: FormData;
+	private boundary: Uint8Array;
+	private boundaryIndex = 0;
+	private state = MultipartParserStateEnum.boundary;
+	private data: {
+		contentDisposition: { [key: string]: string } | null;
+		value: number[];
+		contentType: string | null;
+		header: string;
+	} = {
+		contentDisposition: null,
+		value: [],
+		contentType: null,
+		header: ''
+	};
+
+	/**
+	 * Constructor.
+	 *
+	 * @param window Window.
+	 * @param formData Form data.
+	 * @param boundary Boundary.
+	 */
+	constructor(window: BrowserWindow, boundary: string) {
+		const boundaryHeader = `--${boundary}`;
+		this.boundary = new Uint8Array(boundaryHeader.length);
+		this.formData = new window.FormData();
+
+		for (let i = 0, max = boundaryHeader.length; i < max; i++) {
+			this.boundary[i] = boundaryHeader.charCodeAt(i);
+		}
+	}
+
+	/**
+	 * Appends data.
+	 *
+	 * @param data Data.
+	 */
+	public write(data: Uint8Array): void {
+		let char: number;
+		let nextChar: number;
+
+		for (let i = 0, max = data.length; i < max; i++) {
+			char = data[i];
+			nextChar = data[i + 1];
+
+			switch (this.state) {
+				case MultipartParserStateEnum.boundary:
+					if (char === this.boundary[this.boundaryIndex]) {
+						this.boundaryIndex++;
+					} else {
+						this.boundaryIndex = 0;
+					}
+
+					if (this.boundaryIndex === this.boundary.length) {
+						this.state = MultipartParserStateEnum.headerStart;
+						this.boundaryIndex = 0;
+					}
+
+					break;
+
+				case MultipartParserStateEnum.headerStart:
+					if (nextChar !== CHARACTER_CODE.cr && nextChar !== CHARACTER_CODE.lf) {
+						this.data.header = '';
+						this.state =
+							data[i - 2] === CHARACTER_CODE.lf
+								? MultipartParserStateEnum.data
+								: MultipartParserStateEnum.header;
+					}
+
+					break;
+
+				case MultipartParserStateEnum.header:
+					if (char === CHARACTER_CODE.cr) {
+						if (this.data.header) {
+							const headerParts = this.data.header.split(':');
+							if (headerParts.length > 1) {
+								const headerName = headerParts[0].toLowerCase();
+								const headerValue = headerParts[1].trim();
+
+								switch (headerName) {
+									case 'content-disposition':
+										this.data.contentDisposition = this.getContentDisposition(headerValue);
+										break;
+									case 'content-type':
+										this.data.contentType = headerValue;
+										break;
+								}
+							}
+						}
+
+						this.state = MultipartParserStateEnum.headerStart;
+					} else {
+						this.data.header += String.fromCharCode(char);
+					}
+
+					break;
+
+				case MultipartParserStateEnum.data:
+					if (char === this.boundary[this.boundaryIndex]) {
+						this.boundaryIndex++;
+					} else {
+						this.boundaryIndex = 0;
+					}
+
+					if (this.boundaryIndex === this.boundary.length) {
+						this.state = MultipartParserStateEnum.headerStart;
+
+						if (this.data.value.length) {
+							this.appendFormData(
+								this.data.contentDisposition!.name,
+								Buffer.from(this.data.value.slice(0, -(this.boundary.length + 1))),
+								this.data.contentDisposition!.filename,
+								this.data.contentType!
+							);
+
+							this.data.value = [];
+							this.data.contentDisposition = null;
+							this.data.contentType = null;
+						}
+
+						this.boundaryIndex = 0;
+					} else {
+						this.data.value.push(char);
+					}
+
+					break;
+			}
+		}
+	}
+
+	/**
+	 * Ends the stream.
+	 *
+	 * @returns Form data.
+	 */
+	public end(): FormData {
+		// If we are missing an end boundary, but we have data, we should append it.
+		if (this.data.contentDisposition && this.data.value.length) {
+			this.appendFormData(
+				this.data.contentDisposition.name,
+				Buffer.from(this.data.value.slice(0, -2)),
+				this.data.contentDisposition.filename,
+				this.data.contentType!
+			);
+		}
+
+		return this.formData;
+	}
+
+	/**
+	 * Appends data.
+	 *
+	 * @param key Key.
+	 * @param value value.
+	 * @param filename Filename.
+	 * @param type Type.
+	 */
+	private appendFormData(key: string, value: Buffer, filename?: string, type?: string): void {
+		if (!value.length) {
+			return;
+		}
+
+		if (filename) {
+			this.formData.append(
+				key,
+				new File([value], filename, {
+					type
+				})
+			);
+		} else {
+			this.formData.append(key, value.toString());
+		}
+	}
+
+	/**
+	 * Returns content disposition.
+	 *
+	 * @param headerValue Header value.
+	 * @returns Content disposition.
+	 */
+	private getContentDisposition(headerValue: string): { [key: string]: string } {
+		const regex = /([a-z]+) *= *"([^"]+)"/g;
+		const contentDisposition: { [key: string]: string } = {};
+		let match: RegExpExecArray | null;
+
+		while ((match = regex.exec(headerValue))) {
+			contentDisposition[match[1]] = match[2];
+		}
+
+		return contentDisposition;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/preload/PreloadEntry.ts

@@ -0,0 +1,50 @@
+import type Response from '../Response.js';
+
+/**
+ * Preload entry.
+ *
+ * @see https://html.spec.whatwg.org/multipage/links.html#preload-entry
+ */
+export default class PreloadEntry {
+	public integrityMetadata: string | null = null;
+	public response: Response | null = null;
+	public error: Error | null = null;
+	#callback: {
+		resolve: (response: Response) => void;
+		reject: (error: Error) => void;
+	} | null = null;
+
+	/**
+	 * On response available.
+	 *
+	 * @returns Response.
+	 */
+	public onResponseAvailable(): Promise<Response> {
+		return new Promise((resolve, reject) => {
+			this.#callback = { resolve, reject };
+		});
+	}
+
+	/**
+	 * Response available.
+	 *
+	 * @param error
+	 * @param response
+	 */
+	public responseAvailable(error: Error | null, response: Response | null): void {
+		this.response = response;
+		this.error = error;
+
+		if (!this.#callback) {
+			return;
+		}
+
+		if (error) {
+			this.#callback.reject(error);
+		} else if (!response) {
+			this.#callback.reject(new Error('Response is null'));
+		} else {
+			this.#callback.resolve(response);
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/preload/PreloadUtility.ts

@@ -0,0 +1,33 @@
+import type { TRequestCredentials } from '../types/TRequestCredentials.js';
+import type { TRequestMode } from '../types/TRequestMode.js';
+
+/**
+ * Utility for preloading resources.
+ *
+ * @see https://html.spec.whatwg.org/multipage/links.html#link-type-preload
+ */
+export default class PreloadUtility {
+	/**
+	 * Returns a key for a preload entry.
+	 *
+	 * @param options Options.
+	 * @param options.url URL.
+	 * @param options.destination Destination.
+	 * @param options.mode Mode.
+	 * @param options.credentialsMode Credentials mode.
+	 * @returns Key.
+	 */
+	public static getKey(options: {
+		url: string;
+		destination: string;
+		mode: TRequestMode;
+		credentialsMode: TRequestCredentials;
+	}): string {
+		return JSON.stringify({
+			url: options.url,
+			destination: options.destination,
+			mode: options.mode,
+			credentialsMode: options.credentialsMode
+		});
+	}
+}

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

@@ -0,0 +1,60 @@
+import type Request from '../Request.js';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+import type Response from '../Response.js';
+import type ISyncResponse from './ISyncResponse.js';
+
+export default interface IFetchInterceptor {
+	/**
+	 * Hook dispatched before making an async request.
+	 * It can be used for modifying the request, providing a response without making a request or for logging.
+	 *
+	 * @param context Contains the request and the window from where the request was made.
+	 *
+	 * @returns Promise that can resolve to a response to be used instead of sending out the response.
+	 */
+	beforeAsyncRequest?: (context: {
+		request: Request;
+		window: BrowserWindow;
+	}) => Promise<Response | void>;
+
+	/**
+	 * Hook dispatched before making an sync request.
+	 * It can be used for modifying the request, providing a response without making a request or for logging.
+	 *
+	 * @param context Contains the request and the window from where the request was made.
+	 *
+	 * @returns Promise that can resolve to a response to be used instead of sending out the response.
+	 */
+	beforeSyncRequest?: (context: {
+		request: Request;
+		window: BrowserWindow;
+	}) => ISyncResponse | void;
+
+	/**
+	 * Hook dispatched after receiving an async response.
+	 * It can be used for modifying or replacing the response and logging.
+	 *
+	 * @param context Contains the request, response and the window from where the request was made.
+	 *
+	 * @returns Promise that can resolve to a response to be used instead of sending out the response.
+	 */
+	afterAsyncResponse?: (context: {
+		request: Request;
+		response: Response;
+		window: BrowserWindow;
+	}) => Promise<Response | void>;
+
+	/**
+	 * Hook dispatched after receiving a sync response.
+	 * It can be used for modifying or replacing the response and logging
+	 *
+	 * @param context Contains the request, response and the window from where the request was made.
+	 *
+	 * @returns Promise that can resolve to a response to be used instead of sending out the response.
+	 */
+	afterSyncResponse?: (context: {
+		request: Request;
+		response: ISyncResponse;
+		window: BrowserWindow;
+	}) => ISyncResponse | void;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Fetch request header.
+ */
+export default interface IFetchRequestHeaders {
+	url?: string | RegExp | null;
+	headers: {
+		[key: string]: string;
+	};
+}

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

@@ -0,0 +1,23 @@
+import type AbortSignal from '../AbortSignal.js';
+import type URL from '../../url/URL.js';
+import type { TRequestBody } from './TRequestBody.js';
+import type { THeadersInit } from './THeadersInit.js';
+import type { TRequestMode } from './TRequestMode.js';
+import type { TRequestCredentials } from './TRequestCredentials.js';
+import type { TRequestReferrerPolicy } from './TRequestReferrerPolicy.js';
+import type { TRequestRedirect } from './TRequestRedirect.js';
+
+/**
+ * Fetch request init.
+ */
+export default interface IRequestInit {
+	body?: TRequestBody;
+	headers?: THeadersInit;
+	method?: string;
+	mode?: TRequestMode;
+	redirect?: TRequestRedirect;
+	signal?: AbortSignal | null;
+	referrer?: '' | 'no-referrer' | 'client' | string | URL;
+	credentials?: TRequestCredentials;
+	referrerPolicy?: TRequestReferrerPolicy;
+}

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

@@ -0,0 +1,4 @@
+export default interface IResourceFetchResponse {
+	content: string;
+	virtualServerFile: string | null;
+}