buninu-browser 0.0.2

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/ServerRendererServer.ts

@@ -0,0 +1,332 @@
+import Http2 from 'http2';
+import type IOptionalServerRendererConfiguration from './types/IOptionalServerRendererConfiguration.js';
+import type IServerRendererConfiguration from './types/IServerRendererConfiguration.js';
+import ServerRendererConfigurationFactory from './utilities/ServerRendererConfigurationFactory.js';
+import ServerRenderer from './ServerRenderer.js';
+import FetchHTTPSCertificate from 'happy-dom/lib/fetch/certificate/FetchHTTPSCertificate.js';
+import ZLib from 'node:zlib';
+import Stream from 'node:stream/promises';
+import OS from 'node:os';
+import type IServerRendererResult from './types/IServerRendererResult.js';
+// eslint-disable-next-line import/no-named-as-default
+import Chalk from 'chalk';
+import ServerRendererLogLevelEnum from './enums/ServerRendererLogLevelEnum.js';
+import PackageVersion from './utilities/PackageVersion.js';
+
+/**
+ * Server renderer proxy HTTP2 server.
+ */
+export default class ServerRendererServer {
+	#configuration: IServerRendererConfiguration;
+	#serverRenderer: ServerRenderer;
+	#server: Http2.Http2Server | null = null;
+	#cache: Map<
+		string,
+		{
+			timestamp: number;
+			result: IServerRendererResult;
+		}
+	> = new Map();
+	#cacheQueue: Map<
+		string,
+		Array<{ resolve: (result: IServerRendererResult) => void; reject: (error: Error) => void }>
+	> = new Map();
+
+	/**
+	 * Constructor.
+	 *
+	 * @param configuration Configuration.
+	 */
+	constructor(configuration?: IOptionalServerRendererConfiguration) {
+		this.#configuration = ServerRendererConfigurationFactory.createConfiguration(configuration);
+		this.#serverRenderer = new ServerRenderer(this.#configuration);
+	}
+
+	/**
+	 * Starts the server.
+	 */
+	public async start(): Promise<void> {
+		let url: URL;
+		try {
+			url = new URL(this.#configuration.server.serverURL);
+		} catch (error) {
+			throw new Error('Failed to start server. The setting "server.serverURL" is not a valid URL.');
+		}
+
+		if (!this.#configuration.server.targetOrigin) {
+			throw new Error('Failed to start server. The setting "server.targetOrigin" is not set.');
+		}
+
+		let targetOrigin: URL;
+		try {
+			targetOrigin = new URL(this.#configuration.server.targetOrigin);
+		} catch (error) {
+			throw new Error(
+				'Failed to start server. The setting "server.targetOrigin" is not a valid URL.'
+			);
+		}
+
+		switch (url.protocol) {
+			case 'http:':
+				this.#server = Http2.createServer(
+					(request: Http2.Http2ServerRequest, response: Http2.Http2ServerResponse) =>
+						this.#onIncomingRequest(request, response)
+				);
+				break;
+			case 'https:':
+				this.#server = Http2.createSecureServer(
+					{
+						key: FetchHTTPSCertificate.key,
+						cert: FetchHTTPSCertificate.cert
+					},
+					(request: Http2.Http2ServerRequest, response: Http2.Http2ServerResponse) =>
+						this.#onIncomingRequest(request, response)
+				);
+				break;
+			default:
+				throw new Error(
+					`Unsupported protocol "${url.protocol}". Only "http:" and "https:" are supported.`
+				);
+		}
+
+		this.#server.listen(url.port ? Number(url.port) : url.protocol === 'https:' ? 443 : 80);
+
+		// eslint-disable-next-line no-console
+		console.log(Chalk.green(`\nHappy DOM Proxy Server ${await PackageVersion.getVersion()}\n`));
+
+		// eslint-disable-next-line no-console
+		console.log(
+			`  ${Chalk.green('➜')}  ${Chalk.bold('Local:')}   ${Chalk.cyan(
+				`${url.protocol}//localhost:${url.port}/`
+			)}\n  ${Chalk.green('➜')}  ${Chalk.bold('Network:')} ${Chalk.cyan(
+				`${url.protocol}//${this.#getNetworkIP()}:${url.port}/`
+			)}\n  ${Chalk.green('➜')}  ${Chalk.bold('Target:')}  ${Chalk.cyan(
+				`${targetOrigin.protocol}//${targetOrigin.host}/`
+			)}\n\n  ${Chalk.green('➜')}  ${Chalk.bold('URL:')}     ${Chalk.cyan(
+				`${url.protocol}//localhost:${url.port}${url.pathname}${url.search}${url.hash}`
+			)}\n`
+		);
+	}
+
+	/**
+	 * Stops the server.
+	 */
+	public async stop(): Promise<void> {
+		if (this.#server) {
+			this.#server.close();
+		}
+		if (this.#serverRenderer) {
+			await this.#serverRenderer.close();
+		}
+	}
+
+	/**
+	 * Triggered on incoming request.
+	 *
+	 * @param request Request.
+	 * @param response Response.
+	 * @returns Promise.
+	 */
+	async #onIncomingRequest(
+		request: Http2.Http2ServerRequest,
+		response: Http2.Http2ServerResponse
+	): Promise<void> {
+		const url = new URL(request.url, this.#configuration.server.targetOrigin!);
+		const headers: { [name: string]: string } = {};
+
+		for (const name of Object.keys(request.headers)) {
+			if (name[0] !== ':' && name.toLowerCase() !== 'transfer-encoding') {
+				headers[name] = Array.isArray(request.headers[name])
+					? request.headers[name].join(', ')
+					: request.headers[name]!;
+			}
+		}
+
+		const fetchResponse = await fetch(url.href, { headers });
+		const isCacheEnabled =
+			!this.#configuration.server.disableCache && this.#configuration.server.cacheTime > 0;
+		const isCacheQueueEnabled = isCacheEnabled && !this.#configuration.server.disableCacheQueue;
+		const cacheKey = this.#getCacheKey(url, headers, fetchResponse.status);
+		let result: IServerRendererResult | null = null;
+
+		response.statusCode = fetchResponse.status;
+
+		// HTML files should be served from the server renderer.
+		if (
+			fetchResponse.headers.get('content-type')?.startsWith('text/html') &&
+			fetchResponse.status === 200
+		) {
+			if (isCacheEnabled) {
+				const cached = this.#cache.get(cacheKey);
+				if (cached) {
+					if (Date.now() - cached.timestamp < this.#configuration.server.cacheTime) {
+						if (this.#configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+							// eslint-disable-next-line no-console
+							console.log(Chalk.bold(`• Using cached response for ${url.href}`));
+						}
+
+						result = cached.result;
+					} else {
+						this.#cache.delete(cacheKey);
+					}
+				}
+			}
+
+			if (!result && isCacheQueueEnabled) {
+				const cacheQueue = this.#cacheQueue.get(cacheKey);
+				if (cacheQueue) {
+					if (this.#configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+						// eslint-disable-next-line no-console
+						console.log(Chalk.bold(`• Waiting for ongoing rendering of ${url.href}`));
+					}
+
+					result = await new Promise((resolve, reject) => {
+						cacheQueue.push({ resolve, reject });
+					});
+
+					if (this.#configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+						// eslint-disable-next-line no-console
+						console.log(Chalk.bold(`• Using cached response for ${url.href}`));
+					}
+				} else {
+					this.#cacheQueue.set(cacheKey, []);
+				}
+			}
+
+			if (!result) {
+				result = (
+					await this.#serverRenderer.render([{ url: url.href, headers }], { keepAlive: true })
+				)[0];
+			}
+
+			if (isCacheQueueEnabled) {
+				const cacheQueue = this.#cacheQueue.get(cacheKey);
+
+				if (cacheQueue) {
+					this.#cacheQueue.delete(cacheKey);
+					for (const { resolve } of cacheQueue) {
+						resolve(result);
+					}
+				}
+			}
+
+			for (const key of Object.keys(result.headers!)) {
+				const lowerKey = key.toLowerCase();
+				if (
+					lowerKey !== 'transfer-encoding' &&
+					lowerKey !== 'content-length' &&
+					lowerKey !== 'content-encoding'
+				) {
+					response.setHeader(key, result.headers![key]);
+				}
+			}
+
+			response.statusCode = result.error ? 500 : result.status!;
+
+			if (result.error) {
+				if (this.#configuration.logLevel >= ServerRendererLogLevelEnum.error) {
+					// eslint-disable-next-line no-console
+					console.log(Chalk.red(`\n✖ Failed to render ${url.href}:\n${result.error}\n`));
+				}
+				response.setHeader('Content-Type', 'text/html; charset=utf-8');
+				response.end(
+					`<h1>Internal Server Error</h1><br><p>${result.error.replace(/\n/gm, '<br>')}</p>`
+				);
+				return;
+			}
+
+			if (isCacheEnabled) {
+				this.#cache.set(cacheKey, {
+					timestamp: Date.now(),
+					result
+				});
+			}
+
+			response.setHeader('Content-Encoding', 'gzip');
+			response.setHeader('Content-Type', 'text/html; charset=utf-8');
+
+			try {
+				await Stream.pipeline(result.content!, ZLib.createGzip(), response);
+			} catch (error) {
+				if (this.#configuration.logLevel >= ServerRendererLogLevelEnum.error) {
+					// eslint-disable-next-line no-console
+					console.log(Chalk.red(`\n✖ Failed to send response: ${error}\n`));
+				}
+				response.statusCode = 500;
+				response.setHeader('Content-Type', 'text/plain; charset=utf-8');
+				response.write('Internal Server Error');
+			}
+
+			response.end();
+
+			return;
+		}
+
+		for (const [key, value] of fetchResponse.headers.entries()) {
+			if (key.toLowerCase() !== 'transfer-encoding') {
+				response.setHeader(key, value);
+			}
+		}
+
+		response.statusCode = fetchResponse.status;
+
+		if (fetchResponse.headers.get('Content-Encoding')) {
+			response.setHeader('Content-Encoding', 'gzip');
+			response.removeHeader('Content-Length');
+			try {
+				await Stream.pipeline(fetchResponse.body!, ZLib.createGzip(), response);
+			} catch (error) {
+				if (this.#configuration.logLevel >= ServerRendererLogLevelEnum.error) {
+					// eslint-disable-next-line no-console
+					console.log(Chalk.red(`\n✖ Failed to send response: ${error}\n`));
+				}
+				response.statusCode = 500;
+				response.setHeader('Content-Type', 'text/plain; charset=utf-8');
+				response.write('Internal Server Error');
+			}
+		} else if (fetchResponse.body) {
+			const reader = fetchResponse.body.getReader();
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					break;
+				}
+				response.write(value);
+			}
+		}
+
+		response.end();
+	}
+
+	/**
+	 * Returns the network IP address of the server.
+	 *
+	 * @returns The network IP address.
+	 */
+	#getNetworkIP(): string {
+		const interfaces = OS.networkInterfaces();
+		for (const interfaceName in interfaces) {
+			const networkInterface = interfaces[interfaceName];
+			if (networkInterface) {
+				for (const address of networkInterface) {
+					if (address.family === 'IPv4' && !address.internal) {
+						return address.address;
+					}
+				}
+			}
+		}
+		return '';
+	}
+
+	/**
+	 * Returns the cache key for the given request.
+	 *
+	 * @param url Request URL.
+	 * @param headers Request headers.
+	 * @param statusCode Response status code.
+	 * @returns The cache key.§
+	 */
+	#getCacheKey(url: URL, headers: { [key: string]: string }, statusCode: number): string {
+		return `${url.href}|${JSON.stringify(headers)}|${statusCode}`;
+	}
+}

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/config/DefaultServerRendererConfiguration.ts

@@ -0,0 +1,47 @@
+import DefaultBrowserSettings from 'happy-dom/lib/browser/DefaultBrowserSettings.js';
+import ServerRendererLogLevelEnum from '../enums/ServerRendererLogLevelEnum.js';
+import type IServerRendererConfiguration from '../types/IServerRendererConfiguration.js';
+import OS from 'os';
+import { BrowserErrorCaptureEnum } from 'happy-dom';
+import ServerRendererModeEnum from '../enums/ServerRendererModeEnum.js';
+
+export default <IServerRendererConfiguration>{
+	browser: {
+		...DefaultBrowserSettings,
+		errorCapture: BrowserErrorCaptureEnum.processLevel
+	},
+	outputDirectory: './happy-dom/render',
+	logLevel: ServerRendererLogLevelEnum.info,
+	debug: false,
+	inspect: false,
+	help: false,
+	cache: {
+		disable: false,
+		directory: './happy-dom/cache',
+		warmup: false
+	},
+	worker: {
+		disable: false,
+		maxConcurrency: Math.max(1, Math.floor(OS.cpus().length / 2))
+	},
+	render: {
+		maxConcurrency: 10,
+		timeout: 30000, // 30 seconds
+		incognitoContext: false,
+		serializableShadowRoots: false,
+		allShadowRoots: false,
+		excludeShadowRootTags: null,
+		disablePolyfills: false,
+		setupScript: null,
+		mode: ServerRendererModeEnum.browser
+	},
+	renderItems: null,
+	server: {
+		start: false,
+		serverURL: 'https://localhost:3000',
+		targetOrigin: null,
+		disableCache: false,
+		disableCacheQueue: false,
+		cacheTime: 60000 // 60 seconds
+	}
+};

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/enums/ServerRendererLogLevelEnum.ts

@@ -0,0 +1,9 @@
+enum ServerRendererLogLevelEnum {
+	none = 0,
+	error = 1,
+	warn = 2,
+	info = 3,
+	debug = 4
+}
+
+export default ServerRendererLogLevelEnum;

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/enums/ServerRendererModeEnum.ts

@@ -0,0 +1,8 @@
+enum ServerRendererModeEnum {
+	// Use a Browser instance in each worker to render pages.
+	browser = 'browser',
+	// Render a single page in each worker without using VM isolation which may not be supported in some execution environments.
+	page = 'page'
+}
+
+export default ServerRendererModeEnum;

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/index.ts

@@ -0,0 +1,19 @@
+import ServerRenderer from './ServerRenderer.js';
+import ServerRendererServer from './ServerRenderer.js';
+import IServerRendererItem from './types/IServerRendererItem.js';
+import IServerRendererResult from './types/IServerRendererResult.js';
+import IServerRendererConfiguration from './types/IServerRendererConfiguration.js';
+import IOptionalServerRendererConfiguration from './types/IOptionalServerRendererConfiguration.js';
+import ServerRendererLogLevelEnum from './enums/ServerRendererLogLevelEnum.js';
+import ServerRendererModeEnum from './enums/ServerRendererModeEnum.js';
+
+export {
+	ServerRenderer,
+	ServerRendererServer,
+	IServerRendererItem,
+	IServerRendererResult,
+	IServerRendererConfiguration,
+	IOptionalServerRendererConfiguration,
+	ServerRendererLogLevelEnum,
+	ServerRendererModeEnum
+};

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/types/IOptionalServerRendererConfiguration.ts

@@ -0,0 +1,127 @@
+import type IOptionalBrowserSettings from 'happy-dom/lib/browser/types/IOptionalBrowserSettings.js';
+import type ServerRendererLogLevelEnum from '../enums/ServerRendererLogLevelEnum.js';
+import type IServerRendererItem from './IServerRendererItem.js';
+import type ServerRendererModeEnum from '../enums/ServerRendererModeEnum.js';
+
+export default interface IOptionalServerRendererConfiguration {
+	/**
+	 * Settings for the browser.
+	 */
+	browser?: IOptionalBrowserSettings;
+
+	/**
+	 * Log level for the server renderer.
+	 */
+	logLevel?: ServerRendererLogLevelEnum;
+
+	/**
+	 * Enables debugging. This will override "browser.debug.traceWaitUntilComplete".
+	 */
+	debug?: boolean;
+
+	/**
+	 * Enables inspector.
+	 */
+	inspect?: boolean;
+
+	/**
+	 * Shows help information and exits.
+	 */
+	help?: boolean;
+
+	/**
+	 * Output directory.
+	 */
+	outputDirectory?: string;
+
+	/**
+	 * Cache settings.
+	 */
+	cache?: {
+		/**
+		 * Disables all caching.
+		 */
+		disable?: boolean;
+		/**
+		 * Directory for caching files.
+		 */
+		directory?: string;
+		/**
+		 * Warm up by rendering the first item before rendering the rest.
+		 */
+		warmup?: boolean;
+	};
+
+	/**
+	 * Settings for the worker.
+	 */
+	worker?: {
+		/**
+		 * Disables the worker.
+		 */
+		disable?: boolean;
+		/**
+		 * Maximum concurrency for the worker.
+		 */
+		maxConcurrency?: number;
+	};
+
+	/**
+	 * Settings for rendering.
+	 */
+	render?: {
+		/**
+		 * Maximum concurrency for rendering.
+		 */
+		maxConcurrency?: number;
+		/**
+		 * Timeout for rendering in milliseconds.
+		 */
+		timeout?: number;
+		/**
+		 * Use incognito context for rendering.
+		 */
+		incognitoContext?: boolean;
+		/**
+		 * Render shadow roots with the "serializable" option set to true.
+		 */
+		serializableShadowRoots?: boolean;
+		/**
+		 * Render all shadow roots, including those that are not serializable.
+		 */
+		allShadowRoots?: boolean;
+		/**
+		 * Tags to exclude from shadow root rendering.
+		 */
+		excludeShadowRootTags?: string[] | null;
+		/**
+		 * Disable polyfills used for unimplemented functionality.
+		 */
+		disablePolyfills?: boolean;
+		/**
+		 * Setup script to be injected before rendering.
+		 */
+		setupScript?: string | null;
+		/**
+		 * Rendering mode.
+		 */
+		mode?: ServerRendererModeEnum;
+	};
+
+	/**
+	 * List render items. Each item can be a URL string or an object specifying the URL or HTML string along with additional options.
+	 */
+	renderItems?: Array<string | IServerRendererItem> | null;
+
+	/**
+	 * Proxy server settings.
+	 */
+	server?: {
+		start?: boolean;
+		serverURL?: string;
+		targetOrigin?: string | null;
+		disableCache?: boolean;
+		disableCacheQueue?: boolean;
+		cacheTime?: number;
+	};
+}

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/types/IServerRendererConfiguration.ts

@@ -0,0 +1,126 @@
+import type IBrowserSettings from 'happy-dom/lib/browser/types/IBrowserSettings.js';
+import type ServerRendererLogLevelEnum from '../enums/ServerRendererLogLevelEnum.js';
+import type IServerRendererItem from './IServerRendererItem.js';
+import type ServerRendererModeEnum from '../enums/ServerRendererModeEnum.js';
+
+export default interface IServerRendererConfiguration {
+	/**
+	 * Settings for the browser.
+	 */
+	browser: IBrowserSettings;
+
+	/**
+	 * Log level for the server renderer.
+	 */
+	logLevel: ServerRendererLogLevelEnum;
+
+	/**
+	 * Enables debugging. This will override "browser.debug.traceWaitUntilComplete".
+	 */
+	debug: boolean;
+
+	/**
+	 * Enables inspector.
+	 */
+	inspect: boolean;
+
+	/**
+	 * Shows help information and exits.
+	 */
+	help: boolean;
+	/**
+	 * Output directory.
+	 */
+	outputDirectory: string;
+
+	/**
+	 * Cache settings.
+	 */
+	cache: {
+		/**
+		 * Disables all caching.
+		 */
+		disable: boolean;
+		/**
+		 * Directory for caching files.
+		 */
+		directory: string;
+		/**
+		 * Warm up by rendering the first item before rendering the rest.
+		 */
+		warmup: boolean;
+	};
+
+	/**
+	 * Settings for the worker.
+	 */
+	worker: {
+		/**
+		 * Disables the worker.
+		 */
+		disable: boolean;
+		/**
+		 * Maximum concurrency for the worker.
+		 */
+		maxConcurrency: number;
+	};
+
+	/**
+	 * Settings for rendering.
+	 */
+	render: {
+		/**
+		 * Maximum concurrency for rendering.
+		 */
+		maxConcurrency: number;
+		/**
+		 * Timeout for rendering in milliseconds.
+		 */
+		timeout: number;
+		/**
+		 * Use incognito context for rendering.
+		 */
+		incognitoContext: boolean;
+		/**
+		 * Render shadow roots with the "serializable" option set to true.
+		 */
+		serializableShadowRoots: boolean;
+		/**
+		 * Render all shadow roots, including those that are not serializable.
+		 */
+		allShadowRoots: boolean;
+		/**
+		 * Tags to exclude from shadow root rendering.
+		 */
+		excludeShadowRootTags: string[] | null;
+		/**
+		 * Disable polyfills used for unimplemented functionality.
+		 */
+		disablePolyfills: boolean;
+		/**
+		 * Setup script to be injected before rendering.
+		 */
+		setupScript: string | null;
+		/**
+		 * Rendering mode.
+		 */
+		mode: ServerRendererModeEnum;
+	};
+
+	/**
+	 * List render items. Each item can be a URL string or an object specifying the URL or HTML string along with additional options.
+	 */
+	renderItems: Array<string | IServerRendererItem> | null;
+
+	/**
+	 * Proxy server settings.
+	 */
+	server: {
+		start: boolean;
+		serverURL: string;
+		targetOrigin: string | null;
+		disableCache: boolean;
+		disableCacheQueue: boolean;
+		cacheTime: number;
+	};
+}

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/types/IServerRendererItem.ts

@@ -0,0 +1,6 @@
+export default interface IServerRendererItem {
+	url?: string;
+	html?: string;
+	outputFile?: string | null;
+	headers?: string[][] | { [key: string]: string } | null;
+}

package/vendor/happy-dom/packages/@happy-dom/server-renderer/src/types/IServerRendererResult.ts

@@ -0,0 +1,11 @@
+export default interface IServerRendererResult {
+	url: string | null;
+	content: string | null;
+	status: number | null;
+	statusText: string | null;
+	headers: { [key: string]: string } | null;
+	outputFile: string | null;
+	error: string | null;
+	pageErrors: string[];
+	pageConsole: string;
+}