buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/preflight/ICacheablePreflightRequest.ts

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

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/preflight/ICacheablePreflightResponse.ts

@@ -0,0 +1,7 @@
+import type Headers from '../../Headers.js';
+
+export default interface ICacheablePreflightResponse {
+	status: number;
+	url: string;
+	headers: Headers;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/preflight/ICachedPreflightResponse.ts

@@ -0,0 +1,5 @@
+export default interface ICachedPreflightResponse {
+	allowOrigin: string;
+	allowMethods: string[];
+	expires: number;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/preflight/IPreflightResponseCache.ts

@@ -0,0 +1,33 @@
+import type ICachedPreflightResponse from './ICachedPreflightResponse.js';
+import type ICacheablePreflightRequest from './ICacheablePreflightRequest.js';
+import type ICacheablePreflightResponse from './ICacheablePreflightResponse.js';
+
+/**
+ * Fetch response cache.
+ */
+export default interface IPreflightResponseCache {
+	/**
+	 * Returns cached response.
+	 *
+	 * @param request Request.
+	 * @returns Cached response.
+	 */
+	get(request: ICacheablePreflightRequest): ICachedPreflightResponse | null;
+
+	/**
+	 * Adds a cached response.
+	 *
+	 * @param request Request.
+	 * @param response Response.
+	 * @returns Cached response.
+	 */
+	add(
+		request: ICacheablePreflightRequest,
+		response: ICacheablePreflightResponse
+	): ICachedPreflightResponse | null;
+
+	/**
+	 * Clears the cache.
+	 */
+	clear(): void;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/preflight/PreflightResponseCache.ts

@@ -0,0 +1,94 @@
+import type IPreflightResponseCache from './IPreflightResponseCache.js';
+import type ICacheablePreflightRequest from './ICacheablePreflightRequest.js';
+import type ICachedPreflightResponse from './ICachedPreflightResponse.js';
+import type ICacheablePreflightResponse from './ICacheablePreflightResponse.js';
+
+/**
+ * Fetch preflight response cache.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request
+ */
+export default class PreflightResponseCache implements IPreflightResponseCache {
+	#entries: Map<string, ICachedPreflightResponse> = new Map();
+
+	/**
+	 * Returns cached response.
+	 *
+	 * @param request Request.
+	 * @returns Cached response.
+	 */
+	public get(request: ICacheablePreflightRequest): ICachedPreflightResponse | null {
+		const cachedResponse = this.#entries.get(request.url);
+
+		if (cachedResponse) {
+			if (cachedResponse.expires < Date.now()) {
+				this.#entries.delete(request.url);
+				return null;
+			}
+			return cachedResponse;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Adds a cache entity.
+	 *
+	 * @param request Request.
+	 * @param response Response.
+	 * @returns Cached response.
+	 */
+	public add(
+		request: ICacheablePreflightRequest,
+		response: ICacheablePreflightResponse
+	): ICachedPreflightResponse | null {
+		this.#entries.delete(request.url);
+
+		if (request.headers.get('Cache-Control')?.includes('no-cache')) {
+			return null;
+		}
+
+		if (response.status < 200 || response.status >= 300) {
+			return null;
+		}
+
+		const maxAge = response.headers.get('Access-Control-Max-Age');
+		const allowOrigin = response.headers.get('Access-Control-Allow-Origin');
+
+		if (!maxAge || !allowOrigin) {
+			return null;
+		}
+
+		const allowMethods: string[] = [];
+
+		if (response.headers.has('Access-Control-Allow-Methods')) {
+			const allowMethodsHeader = response.headers.get('Access-Control-Allow-Methods');
+			if (allowMethodsHeader !== '*') {
+				for (const method of response.headers.get('Access-Control-Allow-Methods')!.split(',')) {
+					allowMethods.push(method.trim().toUpperCase());
+				}
+			}
+		}
+
+		const cachedResponse: ICachedPreflightResponse = {
+			allowOrigin,
+			allowMethods,
+			expires: Date.now() + parseInt(maxAge) * 1000
+		};
+
+		if (isNaN(cachedResponse.expires) || cachedResponse.expires < Date.now()) {
+			return null;
+		}
+
+		this.#entries.set(request.url, cachedResponse);
+
+		return cachedResponse;
+	}
+
+	/**
+	 * Clears the cache.
+	 */
+	public clear(): void {
+		this.#entries.clear();
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/CachedResponseStateEnum.ts

@@ -0,0 +1,5 @@
+enum CachedResponseStateEnum {
+	fresh = 'fresh',
+	stale = 'stale'
+}
+export default CachedResponseStateEnum;

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/ICacheableRequest.ts

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

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/ICacheableResponse.ts

@@ -0,0 +1,11 @@
+import type Headers from '../../Headers.js';
+
+export default interface ICacheableResponse {
+	status: number;
+	statusText: string;
+	url: string;
+	headers: Headers;
+	body: Buffer | null;
+	waitingForBody: boolean;
+	virtual?: boolean;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/ICachedResponse.ts

@@ -0,0 +1,40 @@
+import type CachedResponseStateEnum from './CachedResponseStateEnum.js';
+import type Headers from '../../Headers.js';
+import type * as PropertySymbol from '../../../PropertySymbol.js';
+
+export default interface ICachedResponse {
+	/** Response. */
+	response: {
+		status: number;
+		statusText: string;
+		url: string;
+		headers: Headers;
+		// We need to wait for the body to be populated if set to "true".
+		waitingForBody: boolean;
+		body: Buffer | null;
+		[PropertySymbol.virtualServerFile]?: string | null;
+	};
+	/** Request. */
+	request: {
+		headers: Headers;
+		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;
+	/** Virtual server response */
+	virtual: boolean;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/IResponseCache.ts

@@ -0,0 +1,37 @@
+import type ICachedResponse from './ICachedResponse.js';
+import type ICacheableRequest from './ICacheableRequest.js';
+import type ICacheableResponse from './ICacheableResponse.js';
+import type IResponseCacheFileSystem from './IResponseCacheFileSystem.js';
+
+/**
+ * Fetch response cache.
+ */
+export default interface IResponseCache {
+	fileSystem: IResponseCacheFileSystem;
+
+	/**
+	 * Returns cached response.
+	 *
+	 * @param request Request.
+	 * @returns Cached response.
+	 */
+	get(request: ICacheableRequest): ICachedResponse | null;
+
+	/**
+	 * Adds a cached response.
+	 *
+	 * @param request Request.
+	 * @param response Response.
+	 * @returns Cached response.
+	 */
+	add(request: ICacheableRequest, response: ICacheableResponse): 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/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/IResponseCacheFileSystem.ts

@@ -0,0 +1,18 @@
+/**
+ * Fetch response cache file system implementation.
+ */
+export default interface IResponseCacheFileSystem {
+	/**
+	 * Loads the cache from file system.
+	 *
+	 * @param directory Directory to load from.
+	 */
+	load(directory: string): Promise<void>;
+
+	/**
+	 * Saves the cache to file system.
+	 *
+	 * @param directory Directory to store to.
+	 */
+	save(directory: string): Promise<void>;
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/ResponseCache.ts

@@ -0,0 +1,248 @@
+import type IResponseCache from './IResponseCache.js';
+import type ICachedResponse from './ICachedResponse.js';
+import CachedResponseStateEnum from './CachedResponseStateEnum.js';
+import type ICacheableRequest from './ICacheableRequest.js';
+import type ICacheableResponse from './ICacheableResponse.js';
+import Headers from '../../Headers.js';
+import ResponseCacheFileSystem from './ResponseCacheFileSystem.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 {
+	public fileSystem: ResponseCacheFileSystem;
+	#entries: Map<string, ICachedResponse[]> = new Map();
+
+	/**
+	 * Constructor.
+	 */
+	constructor() {
+		this.fileSystem = new ResponseCacheFileSystem(this.#entries);
+	}
+
+	/**
+	 * Returns cached response.
+	 *
+	 * @param request Request.
+	 * @returns Cached response.
+	 */
+	public get(request: ICacheableRequest): ICachedResponse | null {
+		if (request.headers.get('Cache-Control')?.includes('no-cache')) {
+			return null;
+		}
+
+		const url = request.url;
+		const entries = this.#entries.get(url);
+
+		if (entries) {
+			for (let i = 0, max = entries.length; i < max; i++) {
+				const entry = entries[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) {
+							entries.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: ICacheableRequest, response: ICacheableResponse): ICachedResponse | null {
+		// 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 entries = this.#entries.get(url);
+				if (entries) {
+					const index = entries.indexOf(cachedResponse);
+					if (index !== -1) {
+						entries.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,
+				virtual: response.virtual ?? false
+			};
+
+			let entries = this.#entries.get(url);
+
+			if (!entries) {
+				entries = [];
+				this.#entries.set(url, entries);
+			}
+
+			entries.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() + parseFloat(value) * 1000 - (age ? parseFloat(age) * 1000 : 0);
+						break;
+					case 'no-cache':
+					case 'no-store':
+						const entries = this.#entries.get(url);
+						if (entries) {
+							const index = entries.indexOf(cachedResponse);
+							if (index !== -1) {
+								entries.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 entries = this.#entries.get(url);
+			if (entries) {
+				const index = entries.indexOf(cachedResponse);
+				if (index !== -1) {
+					entries.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] : this.#entries.keys()) {
+					const entry = this.#entries.get(key);
+					if (entry) {
+						for (let i = 0, max = entry.length; i < max; i++) {
+							if (entry[i].cacheUpdateTime < options.toTime) {
+								entry.splice(i, 1);
+								i--;
+								max--;
+							}
+						}
+					}
+				}
+			} else if (options.url) {
+				this.#entries.delete(options.url);
+			}
+		} else {
+			this.#entries.clear();
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/fetch/cache/response/ResponseCacheFileSystem.ts

@@ -0,0 +1,175 @@
+import type ICachedResponse from './ICachedResponse.js';
+import Headers from '../../Headers.js';
+import FS from 'fs';
+import Path from 'path';
+import Crypto from 'crypto';
+import type IResponseCacheFileSystem from './IResponseCacheFileSystem.js';
+
+/**
+ * Fetch response cache file system implementation.
+ */
+export default class ResponseCacheFileSystem implements IResponseCacheFileSystem {
+	#createdDirectories: Set<string> = new Set();
+	#hashes: Set<string> = new Set();
+	#entries: Map<string, ICachedResponse[]>;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param entries Map of URL to cached responses.
+	 */
+	constructor(entries: Map<string, ICachedResponse[]>) {
+		this.#entries = entries;
+	}
+
+	/**
+	 * Loads cache from file system.
+	 *
+	 * @param directory Directory to load from.
+	 */
+	public async load(directory: string): Promise<void> {
+		if (!directory) {
+			throw new Error(
+				"Failed to execute 'load' on 'ResponseCacheFileSystem': Directory is not specified."
+			);
+		}
+
+		const absoluteDirectory = Path.resolve(directory);
+		let files: string[] = [];
+
+		try {
+			files = await FS.promises.readdir(absoluteDirectory);
+		} catch (error) {
+			// Ignore if the directory does not exist
+			return;
+		}
+
+		const promises = [];
+		const entries = this.#entries;
+
+		for (const file of files) {
+			if (file.endsWith('.json')) {
+				promises.push(
+					FS.promises
+						.readFile(Path.join(absoluteDirectory, file), 'utf8')
+						.then((content) => {
+							const cachedResponse = <ICachedResponse>JSON.parse(content);
+							if (cachedResponse.response && cachedResponse.request && !cachedResponse.virtual) {
+								cachedResponse.response.headers = new Headers(cachedResponse.response.headers);
+								cachedResponse.request.headers = new Headers(cachedResponse.request.headers);
+
+								return FS.promises
+									.readFile(Path.join(absoluteDirectory, file.split('.')[0] + '.data'))
+									.then((body) => {
+										cachedResponse.response.body = body;
+										let entry = entries.get(cachedResponse.response.url);
+										if (!entry) {
+											entry = [];
+											entries.set(cachedResponse.response.url, entry);
+										}
+										entry.push(cachedResponse);
+									})
+									.catch(() => {
+										let entry = entries.get(cachedResponse.response.url);
+										if (!entry) {
+											entry = [];
+											entries.set(cachedResponse.response.url, entry);
+										}
+										entry.push(cachedResponse);
+									});
+							}
+						})
+						.catch(() => {})
+				);
+			}
+		}
+
+		await Promise.all(promises);
+	}
+
+	/**
+	 * Saves the cache to file system.
+	 *
+	 * @param directory Directory to store to.
+	 */
+	public async save(directory: string): Promise<void> {
+		if (!directory) {
+			throw new Error(
+				"Failed to execute 'store' on 'ResponseCacheFileSystem': Directory is not specified."
+			);
+		}
+
+		if (!this.#entries.size) {
+			return;
+		}
+
+		const absoluteDirectory = Path.resolve(directory);
+		const isDirectoryCreated = this.#createdDirectories.has(absoluteDirectory);
+
+		if (!isDirectoryCreated) {
+			this.#createdDirectories.add(absoluteDirectory);
+			try {
+				await FS.promises.mkdir(absoluteDirectory, {
+					recursive: true
+				});
+			} catch (error) {
+				// Ignore if the directory already exists
+			}
+		}
+
+		const entries = this.#entries;
+		const promises = [];
+
+		for (const entry of entries.values()) {
+			for (const cachedResponse of entry) {
+				if (!cachedResponse.virtual) {
+					const responseHeaders: { [k: string]: string } = {};
+					const requestHeaders: { [k: string]: string } = {};
+
+					for (const [key, value] of cachedResponse.response.headers.entries()) {
+						responseHeaders[key] = value;
+					}
+
+					for (const [key, value] of cachedResponse.request.headers.entries()) {
+						requestHeaders[key] = value;
+					}
+
+					const cacheableEntry = {
+						...cachedResponse,
+						response: {
+							...cachedResponse.response,
+							headers: responseHeaders,
+							body: null
+						},
+						request: {
+							...cachedResponse.request,
+							headers: requestHeaders
+						}
+					};
+
+					const json = JSON.stringify(cacheableEntry, null, 3);
+					const hash = Crypto.createHash('md5').update(json).digest('hex');
+
+					if (!this.#hashes.has(hash)) {
+						this.#hashes.add(hash);
+
+						promises.push(
+							FS.promises.writeFile(Path.join(absoluteDirectory, `${hash}.json`), json)
+						);
+
+						if (cachedResponse.response.body) {
+							promises.push(
+								FS.promises.writeFile(
+									Path.join(absoluteDirectory, `${hash}.data`),
+									cachedResponse.response.body
+								)
+							);
+						}
+					}
+				}
+			}
+		}
+
+		await Promise.all(promises);
+	}
+}