happy-dom 12.10.3 → 13.0.0

package/src/fetch/cache/response/ICachableRequest.ts

@@ -0,0 +1,7 @@
+import IHeaders from '../../types/IHeaders.js';
+
+export default interface ICachableRequest {
+	url: string;
+	method: string;
+	headers: IHeaders;
+}

package/src/fetch/cache/response/ICachableResponse.ts

@@ -0,0 +1,10 @@
+import IHeaders from '../../types/IHeaders.js';
+
+export default interface ICachableResponse {
+	status: number;
+	statusText: string;
+	url: string;
+	headers: IHeaders;
+	body: Buffer | null;
+	waitingForBody: boolean;
+}

package/src/fetch/cache/response/ICachedResponse.ts

@@ -0,0 +1,36 @@
+import CachedResponseStateEnum from './CachedResponseStateEnum.js';
+import IHeaders from '../../types/IHeaders.js';
+
+export default interface ICachedResponse {
+	/** Response. */
+	response: {
+		status: number;
+		statusText: string;
+		url: string;
+		headers: IHeaders;
+		// We need to wait for the body to be populated if set to "true".
+		waitingForBody: boolean;
+		body: Buffer | null;
+	};
+	/** Request. */
+	request: {
+		headers: IHeaders;
+		method: string;
+	};
+	/** Cache update time in milliseconds. */
+	cacheUpdateTime: number;
+	/** Last modified time in milliseconds. */
+	lastModified: number | null;
+	/** Vary headers. */
+	vary: { [header: string]: string };
+	/** Expire time in milliseconds. */
+	expires: number | null;
+	/** ETag */
+	etag: string | null;
+	/** Must revalidate using "If-Modified-Since" request when expired. Not supported yet. */
+	mustRevalidate: boolean;
+	/** Stale while revalidate using "If-Modified-Since" request when expired */
+	staleWhileRevalidate: boolean;
+	/** Used when "mustRevalidate" or "staleWhileRevalidate" is true. */
+	state: CachedResponseStateEnum;
+}

package/src/fetch/cache/response/IResponseCache.ts

@@ -0,0 +1,34 @@
+import ICachedResponse from './ICachedResponse.js';
+import ICachableRequest from './ICachableRequest.js';
+import ICachableResponse from './ICachableResponse.js';
+
+/**
+ * Fetch response cache.
+ */
+export default interface IResponseCache {
+	/**
+	 * Returns cached response.
+	 *
+	 * @param request Request.
+	 * @returns Cached response.
+	 */
+	get(request: ICachableRequest): ICachedResponse | null;
+
+	/**
+	 * Adds a cached response.
+	 *
+	 * @param request Request.
+	 * @param response Response.
+	 * @returns Cached response.
+	 */
+	add(request: ICachableRequest, response: ICachableResponse): ICachedResponse | null;
+
+	/**
+	 * Clears the cache.
+	 *
+	 * @param [options] Options.
+	 * @param [options.url] URL.
+	 * @param [options.toTime] Time in MS.
+	 */
+	clear(options?: { url?: string; toTime?: number }): void;
+}

package/src/fetch/cache/response/ResponseCache.ts

@@ -0,0 +1,221 @@
+import IResponseCache from './IResponseCache.js';
+import ICachedResponse from './ICachedResponse.js';
+import CachedResponseStateEnum from './CachedResponseStateEnum.js';
+import ICachableRequest from './ICachableRequest.js';
+import ICachableResponse from './ICachableResponse.js';
+import Headers from '../../Headers.js';
+
+const UPDATE_RESPONSE_HEADERS = ['Cache-Control', 'Last-Modified', 'Vary', 'ETag'];
+
+/**
+ * Fetch response cache.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching
+ * @see https://www.mnot.net/cache_docs/
+ */
+export default class ResponseCache implements IResponseCache {
+	#entries: { [url: string]: ICachedResponse[] } = {};
+
+	/**
+	 * Returns cached response.
+	 *
+	 * @param request Request.
+	 * @returns Cached response.
+	 */
+	public get(request: ICachableRequest): ICachedResponse | null {
+		if (request.headers.get('Cache-Control')?.includes('no-cache')) {
+			return null;
+		}
+
+		const url = request.url;
+
+		if (this.#entries[url]) {
+			for (let i = 0, max = this.#entries[url].length; i < max; i++) {
+				const entry = this.#entries[url][i];
+				let isMatch = entry.request.method === request.method;
+				if (isMatch) {
+					for (const header of Object.keys(entry.vary)) {
+						const requestHeader = request.headers.get(header);
+						if (requestHeader !== null && entry.vary[header] !== requestHeader) {
+							isMatch = false;
+							break;
+						}
+					}
+				}
+				if (isMatch) {
+					if (entry.expires && entry.expires < Date.now()) {
+						if (entry.lastModified) {
+							entry.state = CachedResponseStateEnum.stale;
+						} else if (!entry.etag) {
+							this.#entries[url].splice(i, 1);
+							return null;
+						}
+					}
+					return entry;
+				}
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Adds a cache entity.
+	 *
+	 * @param request Request.
+	 * @param response Response.
+	 * @returns Cached response.
+	 */
+	public add(request: ICachableRequest, response: ICachableResponse): ICachedResponse {
+		// We should only cache GET and HEAD requests.
+		if (
+			(request.method !== 'GET' && request.method !== 'HEAD') ||
+			request.headers.get('Cache-Control')?.includes('no-cache')
+		) {
+			return null;
+		}
+
+		const url = request.url;
+		let cachedResponse = this.get(request);
+
+		if (response.status === 304) {
+			if (!cachedResponse) {
+				throw new Error('ResponseCache: Cached response not found.');
+			}
+
+			for (const name of UPDATE_RESPONSE_HEADERS) {
+				if (response.headers.has(name)) {
+					cachedResponse.response.headers.set(name, response.headers.get(name));
+				}
+			}
+
+			cachedResponse.cacheUpdateTime = Date.now();
+			cachedResponse.state = CachedResponseStateEnum.fresh;
+		} else {
+			if (cachedResponse) {
+				const index = this.#entries[url].indexOf(cachedResponse);
+				if (index !== -1) {
+					this.#entries[url].splice(index, 1);
+				}
+			}
+
+			cachedResponse = {
+				response: {
+					status: response.status,
+					statusText: response.statusText,
+					url: response.url,
+					headers: new Headers(response.headers),
+					// We need to wait for the body to be consumed and then populated if set to true (e.g. by using Response.text()).
+					waitingForBody: response.waitingForBody,
+					body: response.body ?? null
+				},
+				request: {
+					headers: request.headers,
+					method: request.method
+				},
+				vary: {},
+				expires: null,
+				etag: null,
+				cacheUpdateTime: Date.now(),
+				lastModified: null,
+				mustRevalidate: false,
+				staleWhileRevalidate: false,
+				state: CachedResponseStateEnum.fresh
+			};
+
+			this.#entries[url] = this.#entries[url] || [];
+			this.#entries[url].push(cachedResponse);
+		}
+
+		if (response.headers.has('Cache-Control')) {
+			const age = response.headers.get('Age');
+
+			for (const part of response.headers.get('Cache-Control').split(',')) {
+				const [key, value] = part.trim().split('=');
+				switch (key) {
+					case 'max-age':
+						cachedResponse.expires =
+							Date.now() + parseInt(value) * 1000 - (age ? parseInt(age) * 1000 : 0);
+						break;
+					case 'no-cache':
+					case 'no-store':
+						const index = this.#entries[url].indexOf(cachedResponse);
+						if (index !== -1) {
+							this.#entries[url].splice(index, 1);
+						}
+						return null;
+					case 'must-revalidate':
+						cachedResponse.mustRevalidate = true;
+						break;
+					case 'stale-while-revalidate':
+						cachedResponse.staleWhileRevalidate = true;
+						break;
+				}
+			}
+		}
+
+		if (response.headers.has('Last-Modified')) {
+			cachedResponse.lastModified = Date.parse(response.headers.get('Last-Modified'));
+		}
+
+		if (response.headers.has('Vary')) {
+			for (const header of response.headers.get('Vary').split(',')) {
+				const name = header.trim();
+				const value = request.headers.get(name);
+				if (value) {
+					cachedResponse.vary[name] = value;
+				}
+			}
+		}
+
+		if (response.headers.has('ETag')) {
+			cachedResponse.etag = response.headers.get('ETag');
+		}
+
+		if (!cachedResponse.expires) {
+			const expires = response.headers.get('Expires');
+			if (expires) {
+				cachedResponse.expires = Date.parse(expires);
+			}
+		}
+
+		// Cache is invalid if it has expired and doesn't have an ETag.
+		if (!cachedResponse.etag && (!cachedResponse.expires || cachedResponse.expires < Date.now())) {
+			const index = this.#entries[url].indexOf(cachedResponse);
+			if (index !== -1) {
+				this.#entries[url].splice(index, 1);
+			}
+			return null;
+		}
+
+		return cachedResponse;
+	}
+
+	/**
+	 * Clears the cache.
+	 *
+	 * @param [options] Options.
+	 * @param [options.url] URL.
+	 * @param [options.toTime] Removes all entries that are older than this time. Time in MS.
+	 */
+	public clear(options?: { url?: string; toTime?: number }): void {
+		if (options) {
+			if (options.toTime) {
+				for (const key of options.url ? [options.url] : Object.keys(this.#entries)) {
+					if (this.#entries[key]) {
+						for (let i = 0, max = this.#entries[key].length; i < max; i++) {
+							if (this.#entries[key][i].cacheUpdateTime < options.toTime) {
+								this.#entries[key].splice(i, 1);
+								i--;
+								max--;
+							}
+						}
+					}
+				}
+			} else if (options.url) {
+				delete this.#entries[options.url];
+			}
+		} else {
+			this.#entries = {};
+		}
+	}
+}

package/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/src/fetch/multipart/MultipartFormDataParser.ts

@@ -1,4 +1,5 @@
 import FormData from '../../form-data/FormData.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
 import Stream from 'stream';
 import MultipartReader from './MultipartReader.js';
 import DOMException from '../../exception/DOMException.js';
@@ -21,7 +22,7 @@ export default class MultipartFormDataParser {
 	public static async streamToFormData(
 		body: Stream.Readable,
 		contentType: string
-	): Promise<FormData> {
+	): Promise<{ formData: FormData; buffer: Buffer }> {
 		if (!/multipart/i.test(contentType)) {
 			throw new DOMException(
 				`Failed to build FormData object: The "content-type" header isn't of type "multipart/form-data".`,
@@ -39,12 +40,50 @@ export default class MultipartFormDataParser {
 		}
 
 		const reader = new MultipartReader(match[1] || match[2]);
+		const chunks = [];
+		let buffer: Buffer;
+		let bytes = 0;
 
-		for await (const chunk of body) {
-			reader.write(chunk);
+		try {
+			for await (const chunk of body) {
+				reader.write(chunk);
+				bytes += chunk.length;
+				chunks.push(chunk);
+			}
+		} catch (error) {
+			if (error instanceof DOMException) {
+				throw error;
+			}
+			throw new DOMException(
+				`Failed to read response body. Error: ${error.message}.`,
+				DOMExceptionNameEnum.encodingError
+			);
+		}
+
+		if (
+			(<Stream.Readable>body).readableEnded === false ||
+			(<Stream.Readable>body)['_readableState']?.ended === false
+		) {
+			throw new DOMException(
+				`Premature close of server response.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		try {
+			buffer =
+				typeof chunks[0] === 'string' ? Buffer.from(chunks.join('')) : Buffer.concat(chunks, bytes);
+		} catch (error) {
+			throw new DOMException(
+				`Could not create Buffer from response body. Error: ${error.message}.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
 		}
 
-		return reader.end();
+		return {
+			formData: reader.end(),
+			buffer
+		};
 	}
 
 	/**
@@ -82,7 +121,7 @@ export default class MultipartFormDataParser {
 						)}"\r\nContent-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`
 					)
 				);
-				chunks.push(value._buffer);
+				chunks.push(value[PropertySymbol.buffer]);
 				chunks.push(Buffer.from('\r\n'));
 			}
 		}

package/src/fetch/types/ISyncResponse.ts

@@ -0,0 +1,16 @@
+import IHeaders from './IHeaders.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: IHeaders;
+	body: Buffer;
+}

package/src/fetch/utilities/FetchBodyUtility.ts

@@ -1,4 +1,5 @@
 import MultipartFormDataParser from '../multipart/MultipartFormDataParser.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
 import Stream from 'stream';
 import { URLSearchParams } from 'url';
 import FormData from '../../form-data/FormData.js';
@@ -7,7 +8,6 @@ import DOMException from '../../exception/DOMException.js';
 import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
 import IRequestBody from '../types/IRequestBody.js';
 import IResponseBody from '../types/IResponseBody.js';
-import Request from '../Request.js';
 
 /**
  * Fetch body utility.
@@ -39,7 +39,7 @@ export default class FetchBodyUtility {
 				contentLength: buffer.length
 			};
 		} else if (body instanceof Blob) {
-			const buffer = (<Blob>body)._buffer;
+			const buffer = (<Blob>body)[PropertySymbol.buffer];
 			return {
 				buffer,
 				stream: Stream.Readable.from(buffer),
@@ -90,13 +90,21 @@ export default class FetchBodyUtility {
 	}
 
 	/**
-	 * Clones a request body stream.
+	 * Clones a request or body body stream.
 	 *
-	 * @param request Request.
-	 * @returns Stream.
+	 * It is actually not cloning the stream.
+	 * It creates a pass through stream and pipes the original stream to it.
+	 *
+	 * @param requestOrResponse Request or Response.
+	 * @param requestOrResponse.body
+	 * @param requestOrResponse.bodyUsed
+	 * @returns New stream.
 	 */
-	public static cloneRequestBodyStream(request: Request): Stream.Readable {
-		if (request.bodyUsed) {
+	public static cloneBodyStream(requestOrResponse: {
+		body: Stream.Readable;
+		bodyUsed: boolean;
+	}): Stream.Readable {
+		if (requestOrResponse.bodyUsed) {
 			throw new DOMException(
 				`Failed to clone body stream of request: Request body is already used.`,
 				DOMExceptionNameEnum.invalidStateError
@@ -106,11 +114,11 @@ export default class FetchBodyUtility {
 		const p1 = new Stream.PassThrough();
 		const p2 = new Stream.PassThrough();
 
-		request.body.pipe(p1);
-		request.body.pipe(p2);
+		requestOrResponse.body.pipe(p1);
+		requestOrResponse.body.pipe(p2);
 
-		// Sets the body of the cloned request to the first pass through stream.
-		(<Stream.Readable>request.body) = p1;
+		// Sets the body of the cloned request/response to the first pass through stream.
+		(<Stream.Readable>requestOrResponse.body) = p1;
 
 		// Returns the clone.
 		return p2;

package/src/fetch/utilities/FetchCORSUtility.ts

@@ -1,3 +1,5 @@
+import { URL } from 'url';
+
 /**
  * Fetch CORS utility.
  */
@@ -8,7 +10,14 @@ export default class FetchCORSUtility {
 	 * @param originURL Origin URL.
 	 * @param targetURL Target URL.
 	 */
-	public static isCORS(originURL, targetURL): boolean {
+	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.hostname !== targetURL.hostname &&
 				!originURL.hostname.endsWith(targetURL.hostname)) ||

package/src/fetch/utilities/FetchRequestHeaderUtility.ts

@@ -1,5 +1,11 @@
+import IBrowserFrame from '../../browser/types/IBrowserFrame.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
+import IBrowserWindow from '../../window/IBrowserWindow.js';
+import CookieStringUtility from '../../cookie/urilities/CookieStringUtility.js';
 import Headers from '../Headers.js';
+import Request from '../Request.js';
 import IHeaders from '../types/IHeaders.js';
+import FetchCORSUtility from './FetchCORSUtility.js';
 
 const FORBIDDEN_HEADER_NAMES = [
 	'accept-charset',
@@ -8,6 +14,7 @@ const FORBIDDEN_HEADER_NAMES = [
 	'access-control-request-method',
 	'connection',
 	'content-length',
+	'content-transfer-encoding',
 	'cookie',
 	'cookie2',
 	'date',
@@ -34,14 +41,99 @@ export default class FetchRequestHeaderUtility {
 	 * @param headers Headers.
 	 */
 	public static removeForbiddenHeaders(headers: IHeaders): void {
-		for (const key of Object.keys((<Headers>headers)._entries)) {
+		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)._entries[key];
+				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.
+	 * @returns Headers.
+	 */
+	public static getRequestHeaders(options: {
+		browserFrame: IBrowserFrame;
+		window: IBrowserWindow;
+		request: Request;
+	}): { [key: string]: string } {
+		const headers = new Headers(options.request.headers);
+		const isCORS = FetchCORSUtility.isCORS(
+			options.window.location,
+			options.request[PropertySymbol.url]
+		);
+
+		// TODO: Maybe we need to add support for OPTIONS request with 'Access-Control-Allow-*' headers?
+		if (
+			options.request.credentials === 'omit' ||
+			(options.request.credentials === 'same-origin' && isCORS)
+		) {
+			headers.delete('authorization');
+			headers.delete('www-authenticate');
+		}
+
+		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.window.location,
+				false
+			);
+			if (cookies.length > 0) {
+				headers.set('Cookie', CookieStringUtility.cookiesToString(cookies));
+			}
+		}
+
+		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]);
+		}
+
+		// We need to convert the headers to Node request headers.
+		const httpRequestHeaders = {};
+
+		for (const header of Object.values(headers[PropertySymbol.entries])) {
+			httpRequestHeaders[header.name] = header.value;
+		}
+
+		return httpRequestHeaders;
+	}
 }