buninu-browser 0.0.2

package/vendor/happy-dom/packages/@happy-dom/server-renderer/README.md

@@ -0,0 +1,100 @@
+![Happy DOM Logo](https://github.com/capricorn86/happy-dom/raw/master/docs/happy-dom-logo.jpg)
+
+Use [Happy DOM](https://github.com/capricorn86/happy-dom) for server-side rendering (SSR) or static site generation (SSG).
+
+The benefit of using this tool compared to other SSR and SSG solutions, is that it is not tied to a specific framework. For example, you can use React, Vue, Angular and Lit on the same page. The page is rendered as a whole and outputted as HTML.
+
+This tool uses a worker pool by default to render multiple pages in parallel. Each worker can also render multiple pages in parallel that shares resources.
+
+
+## Installation
+
+```bash
+npm install @happy-dom/server-renderer --save-dev
+```
+
+## Documentation
+
+You will find the documentation in the [Happy DOM Wiki](https://github.com/capricorn86/happy-dom/wiki) under [Server-Renderer](https://github.com/capricorn86/happy-dom/wiki/Server-Renderer).
+
+## Usage
+
+### Command Line
+
+See all available command line arguments in the [Command Line Documentation](https://github.com/capricorn86/happy-dom/wiki/Server-Renderer-CLI-Arguments).
+
+Note that JavaScript is disabled by default. To enable JavaScript, use the flag `--javascript`. A VM Context is not an isolated environment, and if you run untrusted JavaScript code you are at risk of RCE (Remote Code Execution) attacks. [Read more about risks and recommended security precautions here](https://github.com/capricorn86/happy-dom/wiki/JavaScript-Evaluation-Warning).
+
+**Example 1**
+
+Render to the file `./happy-dom/render/gb/en/index.html`.
+
+```bash
+npx @happy-dom/server-renderer --javascript "https://example.com/gb/en/"
+```
+
+or if you have it installed
+
+```bash
+happy-dom-sr --javascript "https://example.com/gb/en/"
+```
+
+**Example 2**
+
+Start proxy server.
+
+```bash
+happy-dom-sr --javascript --server --server.targetOrigin="https://example.com"
+```
+
+### JavaScript
+
+See all available configuration options in the [Javascript API Documentation](https://github.com/capricorn86/happy-dom/wiki/ServerRenderer).
+
+Note that JavaScript is disabled by default. To enable JavaScript, set the configuration `browser.enableJavaScriptEvaluation` to true. A VM Context is not an isolated environment, and if you run untrusted JavaScript code you are at risk of RCE (Remote Code Execution) attacks. [Read more about risks and recommended security precautions here](https://github.com/capricorn86/happy-dom/wiki/JavaScript-Evaluation-Warning).
+
+**Example 1**
+
+```javascript
+import { ServerRenderer } from '@happy-dom/server-renderer';
+
+const renderer = new ServerRenderer({
+   // Your configuration options
+   browser: {
+      enableJavaScriptEvaluation: true,
+   },
+});
+
+const result = await renderer.render(['https://example.com/gb/en/']);
+
+// URL of the rendered page
+console.log(result[0].url);
+
+// The rendered HTML
+console.log(result[0].content);
+```
+
+**Example 2**
+
+```javascript
+import { ServerRenderer } from '@happy-dom/server-renderer';
+
+const renderer = new ServerRenderer({
+   // Your configuration options
+   browser: {
+      enableJavaScriptEvaluation: true,
+   },
+});
+
+const result = await renderer.render([{ url: 'https://example.com/gb/en/', html: '<div id="app"></div><script>document.getElementById("app").innerHTML = "Hello World!";</script>' }]);
+
+// URL of the rendered page
+console.log(result[0].url);
+
+// The rendered HTML
+console.log(result[0].content);
+```
+
+## Happy DOM
+
+[Documentation](https://github.com/capricorn86/happy-dom/wiki) | [Getting Started](https://github.com/capricorn86/happy-dom/wiki/Getting-started) | [Setup as Test Environment](https://github.com/capricorn86/happy-dom/wiki/Setup-as-Test-Environment) | [GitHub](https://github.com/capricorn86/happy-dom/)

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

@@ -0,0 +1,30 @@
+#!/bin/env node
+'use strict';
+
+import ServerRenderer from '../../lib/ServerRenderer.js';
+import ProcessArgumentsParser from '../../lib/utilities/ProcessArgumentsParser.js';
+
+main();
+
+/**
+ * Main method.
+ */
+async function main(): Promise<void> {
+	const configuration = await ProcessArgumentsParser.getConfiguration(process.argv);
+
+	if (configuration.help) {
+		const HelpPrinter = (await import('../../lib/utilities/HelpPrinter.js')).default;
+		HelpPrinter.print();
+		process.exit(0);
+	}
+
+	if (configuration.server.start) {
+		const server = new (await import('../../lib/ServerRendererServer.js')).default(configuration);
+
+		await server.start();
+	} else {
+		const renderer = new ServerRenderer(configuration);
+
+		await renderer.render();
+	}
+}

package/vendor/happy-dom/packages/@happy-dom/server-renderer/package.json

@@ -0,0 +1,62 @@
+{
+	"name": "@happy-dom/server-renderer",
+	"version": "0.0.0",
+	"license": "MIT",
+	"homepage": "https://github.com/capricorn86/happy-dom/tree/master/packages/@happy-dom/server-renderer",
+	"repository": "https://github.com/capricorn86/happy-dom",
+	"author": "David Ortner",
+	"description": "Use Happy DOM for server-side rendering (SSR) or as a static site generator (SSG).",
+	"main": "lib/index.js",
+	"type": "module",
+	"keywords": [
+		"jsdom",
+		"happy",
+		"dom",
+		"webcomponents",
+		"web",
+		"component",
+		"custom",
+		"elements",
+		"server-side",
+		"rendering",
+		"server",
+		"renderer",
+		"ssr",
+		"static",
+		"site",
+		"generator",
+		"ssg"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"bin": {
+		"happy-dom-sr": "bin/lib/happy-dom-sr.js"
+	},
+	"scripts": {
+		"compile": "tsc && tsc --project ./bin",
+		"watch": "concurrently --raw \"tsc -w --preserveWatchOutput\" \"tsc -w --preserveWatchOutput --project ./bin\"",
+		"test": "vitest run",
+		"test:ui": "vitest --ui",
+		"test:watch": "vitest",
+		"test:debug": "vitest run --inspect-brk --no-file-parallelism"
+	},
+	"dependencies": {
+		"@happy-dom/global-registrator": "^0.0.0",
+		"chalk": "^5.4.1",
+		"happy-dom": "^0.0.0"
+	},
+	"devDependencies": {
+		"@types/node": ">=20.0.0",
+		"@typescript-eslint/eslint-plugin": "^5.16.0",
+		"@typescript-eslint/parser": "^5.16.0",
+		"@vitest/ui": "^2.1.4",
+		"concurrently": "^9.1.2",
+		"prettier": "^2.6.0",
+		"typescript": "^5.0.4",
+		"vitest": "^4.1.8"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

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

@@ -0,0 +1,368 @@
+import type IOptionalServerRendererConfiguration from './types/IOptionalServerRendererConfiguration.js';
+import type IServerRendererItem from './types/IServerRendererItem.js';
+import { Worker } from 'worker_threads';
+import type IServerRendererResult from './types/IServerRendererResult.js';
+import ServerRendererLogLevelEnum from './enums/ServerRendererLogLevelEnum.js';
+import type IServerRendererConfiguration from './types/IServerRendererConfiguration.js';
+import ServerRendererConfigurationFactory from './utilities/ServerRendererConfigurationFactory.js';
+import Path from 'path';
+import Inspector from 'node:inspector';
+import ServerRendererBrowser from './ServerRendererBrowser.js';
+// eslint-disable-next-line import/no-named-as-default
+import Chalk from 'chalk';
+import ServerRendererModeEnum from './enums/ServerRendererModeEnum.js';
+
+interface IWorkerWaitingItem {
+	items: IServerRendererItem[];
+	resolve: (results: IServerRendererResult[]) => void;
+	reject: (error: Error) => void;
+}
+
+/**
+ * Server renderer.
+ */
+export default class ServerRenderer {
+	#configuration: IServerRendererConfiguration;
+	#workerPool: { busy: Worker[]; free: Worker[]; waiting: IWorkerWaitingItem[] } = {
+		busy: [],
+		free: [],
+		waiting: []
+	};
+	#browser: ServerRendererBrowser | null = null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param configuration Configuration.
+	 */
+	constructor(configuration?: IOptionalServerRendererConfiguration) {
+		this.#configuration = ServerRendererConfigurationFactory.createConfiguration(configuration);
+
+		if (this.#configuration.worker.disable && this.#configuration.inspect) {
+			Inspector.open();
+			Inspector.waitForDebugger();
+		}
+	}
+
+	/**
+	 * Server renders URLs or HTML strings.
+	 *
+	 * @param [renderItems] List render items. Each item can be a URL string or an object specifying the URL or HTML string along with additional options.
+	 * @param [options] Options.
+	 * @param [options.keepAlive] Keep the workers and browser alive. This is useful when using the renderer in a server. The workers can be closed with the `close()` method.
+	 */
+	public async render(
+		renderItems?: Array<string | IServerRendererItem> | null,
+		options?: { keepAlive?: boolean }
+	): Promise<IServerRendererResult[]> {
+		const startTime = performance.now();
+		const configuration = this.#configuration;
+		const items = renderItems || configuration.renderItems;
+		const parsedItems: IServerRendererItem[] = [];
+
+		if (!items || !items.length) {
+			if (configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+				// eslint-disable-next-line no-console
+				console.log(Chalk.bold(`\nNo URLs to render\n`));
+			}
+			return [];
+		}
+
+		for (const item of items) {
+			if (typeof item === 'string') {
+				parsedItems.push({ url: item });
+			} else {
+				parsedItems.push({
+					url: item.url,
+					html: item.html,
+					outputFile: item.outputFile
+						? Path.join(configuration.outputDirectory, item.outputFile)
+						: null,
+					headers: item.headers ?? null
+				});
+			}
+		}
+
+		if (configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+			if (configuration.inspect) {
+				// eslint-disable-next-line no-console
+				console.log(Chalk.blue(Chalk.bold(`\n🔍 Inspector enabled`)));
+			}
+
+			if (configuration.debug) {
+				// eslint-disable-next-line no-console
+				console.log(Chalk.blue(Chalk.bold(`\n🔨 Debug mode enabled`)));
+			}
+
+			// eslint-disable-next-line no-console
+			console.log(
+				Chalk.bold(
+					`\nRendering ${parsedItems.length} page${parsedItems.length > 1 ? 's' : ''}...\n`
+				)
+			);
+		}
+
+		let results: IServerRendererResult[] = [];
+
+		if (!configuration.cache.disable && configuration.cache.warmup) {
+			const item = parsedItems.shift();
+			if (item) {
+				if (configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+					// eslint-disable-next-line no-console
+					console.log('\nWarming up cache...\n');
+				}
+
+				results = results.concat(await this.#runInWorker([item]));
+
+				if (configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+					// eslint-disable-next-line no-console
+					console.log('\nCache warmup complete.\n');
+				}
+			}
+		}
+
+		if (parsedItems.length) {
+			const promises = [];
+
+			while (parsedItems.length) {
+				const maxConcurrency =
+					configuration.render.mode === ServerRendererModeEnum.page
+						? 1
+						: configuration.render.maxConcurrency;
+				const chunk = parsedItems.splice(0, maxConcurrency);
+				promises.push(
+					this.#runInWorker(chunk).then((chunkResults) => {
+						results = results.concat(chunkResults);
+					})
+				);
+			}
+
+			await Promise.all(promises);
+		}
+
+		if (configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+			const time = (performance.now() - startTime) / 1000;
+			const minutes = Math.floor(time / 60);
+			const seconds = Math.round((time % 60) * 100) / 100;
+			// eslint-disable-next-line no-console
+			console.log(
+				Chalk.bold(
+					`\nRendered ${items.length} page${items.length > 1 ? 's' : ''} in ${
+						minutes ? `${minutes} minutes and ` : ''
+					}${seconds} seconds\n`
+				)
+			);
+		}
+
+		if (!options?.keepAlive) {
+			await this.close();
+		}
+
+		return results;
+	}
+
+	/**
+	 * Closes the workers and browser.
+	 */
+	public async close(): Promise<void> {
+		for (const worker of this.#workerPool.busy) {
+			worker.terminate();
+		}
+
+		for (const worker of this.#workerPool.free) {
+			worker.terminate();
+		}
+
+		this.#workerPool.busy = [];
+		this.#workerPool.free = [];
+		this.#workerPool.waiting = [];
+
+		if (this.#browser) {
+			await this.#browser.close();
+			this.#browser = null;
+		}
+	}
+
+	/**
+	 * Runs in a worker.
+	 *
+	 * @param items Items.
+	 */
+	#runInWorker(items: IServerRendererItem[]): Promise<IServerRendererResult[]> {
+		const configuration = this.#configuration;
+
+		if (configuration.worker.disable) {
+			if (configuration.render.mode === ServerRendererModeEnum.page) {
+				throw new Error(
+					'Page rendering mode cannot be used when worker threads are disabled. Please enable worker threads or use browser rendering mode.'
+				);
+			}
+
+			if (!this.#browser) {
+				this.#browser = new ServerRendererBrowser(configuration);
+			}
+
+			return this.#browser.render(items).then((results) => {
+				this.outputResults(results);
+				return results;
+			});
+		}
+
+		return new Promise((resolve, reject) => {
+			if (this.#workerPool.free.length === 0) {
+				const maxConcurrency = configuration.inspect ? 1 : configuration.worker.maxConcurrency;
+				if (this.#workerPool.busy.length >= maxConcurrency) {
+					this.#workerPool.waiting.push({ items, resolve, reject });
+					return;
+				}
+				const script =
+					configuration.render.mode === ServerRendererModeEnum.page
+						? 'ServerRendererPageWorker.js'
+						: 'ServerRendererBrowserWorker.js';
+				const worker = new Worker(new URL(script, import.meta.url), {
+					workerData: {
+						configuration: configuration
+					}
+				});
+				this.#workerPool.free.push(worker);
+			}
+
+			if (this.#workerPool.free.length > 0) {
+				const worker = this.#workerPool.free.pop()!;
+
+				this.#workerPool.busy.push(worker);
+
+				const done = (): void => {
+					worker.off('message', listeners.message);
+					worker.off('error', listeners.error);
+					worker.off('exit', listeners.exit);
+
+					this.#workerPool.busy.splice(this.#workerPool.busy.indexOf(worker), 1);
+					this.#workerPool.free.push(worker);
+
+					const waiting = this.#workerPool.waiting.shift();
+
+					if (waiting) {
+						this.#runInWorker(waiting.items).then(waiting.resolve).catch(waiting.reject);
+					}
+				};
+				const listeners: {
+					message: (message: any) => void;
+					error: (error: Error) => void;
+					exit: (code: number) => void;
+				} = {
+					message: (data) => {
+						const results = <IServerRendererResult[]>data.results;
+						this.outputResults(results);
+						done();
+						resolve(results);
+					},
+					error: (error: Error) => {
+						if (configuration.logLevel >= ServerRendererLogLevelEnum.error) {
+							for (const item of items) {
+								// eslint-disable-next-line no-console
+								console.error(Chalk.bold(Chalk.red(`\n❌ Failed to render page "${item.url}"\n`)));
+								// eslint-disable-next-line no-console
+								console.error(Chalk.red(error + '\n'));
+							}
+						}
+
+						done();
+						resolve(
+							items.map((item) => ({
+								url: item.url || null,
+								content: null,
+								status: 200,
+								statusText: 'OK',
+								headers: {},
+								outputFile: item.outputFile ?? null,
+								error: `${error.message}\n${error.stack}`,
+								pageConsole: '',
+								pageErrors: []
+							}))
+						);
+					},
+					exit: (code: number) => {
+						// Closed intentionally, either by the user or with terminate()
+						if (code === 0) {
+							return;
+						}
+
+						this.#workerPool.busy.splice(this.#workerPool.busy.indexOf(worker), 1);
+
+						for (const worker of this.#workerPool.free) {
+							worker.terminate();
+						}
+
+						for (const worker of this.#workerPool.busy) {
+							worker.terminate();
+						}
+
+						this.#workerPool.busy = [];
+						this.#workerPool.free = [];
+						this.#workerPool.waiting = [];
+
+						reject(new Error(`Worker stopped with exit code ${code}`));
+					}
+				};
+
+				worker.on('message', listeners.message);
+				worker.on('error', listeners.error);
+				worker.on('exit', listeners.exit);
+
+				worker.postMessage({ items });
+			}
+		});
+	}
+
+	/**
+	 * Outputs results to the console.
+	 *
+	 * @param results Results.
+	 */
+	private outputResults(results: IServerRendererResult[]): void {
+		const configuration = this.#configuration;
+
+		if (configuration.logLevel === ServerRendererLogLevelEnum.none) {
+			return;
+		}
+
+		for (const result of results) {
+			if (result.error) {
+				if (configuration.logLevel >= ServerRendererLogLevelEnum.error) {
+					// eslint-disable-next-line no-console
+					console.error(Chalk.bold(Chalk.red(`\n❌ Failed to render page "${result.url}"\n`)));
+					// eslint-disable-next-line no-console
+					console.error(Chalk.red(result.error + '\n'));
+				}
+			} else if (result.pageErrors.length) {
+				if (configuration.logLevel >= ServerRendererLogLevelEnum.warn) {
+					// eslint-disable-next-line no-console
+					console.log(Chalk.bold(`• Rendered page "${result.url}"`));
+					// eslint-disable-next-line no-console
+					console.log(
+						Chalk.bold(
+							Chalk.yellow(
+								`\n⚠️ Warning! Errors where outputted to the browser when the page was rendered.\n`
+							)
+						)
+					);
+					// eslint-disable-next-line no-console
+					for (const error of result.pageErrors) {
+						// eslint-disable-next-line no-console
+						console.log(Chalk.red(error + '\n'));
+					}
+				}
+			} else {
+				if (configuration.logLevel >= ServerRendererLogLevelEnum.info) {
+					// eslint-disable-next-line no-console
+					console.log(Chalk.bold(`• Rendered page "${result.url}"`));
+				}
+			}
+			if (configuration.logLevel >= ServerRendererLogLevelEnum.debug && result.pageConsole) {
+				// eslint-disable-next-line no-console
+				console.log(Chalk.gray(result.pageConsole));
+			}
+		}
+	}
+}

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

@@ -0,0 +1,142 @@
+import Browser from 'happy-dom/lib/browser/Browser.js';
+import type IServerRendererConfiguration from './types/IServerRendererConfiguration.js';
+import type IServerRendererItem from './types/IServerRendererItem.js';
+import type IServerRendererResult from './types/IServerRendererResult.js';
+import ServerRendererPage from './ServerRendererPage.js';
+
+/**
+ * Server renderer browser.
+ */
+export default class ServerRendererBrowser {
+	#configuration: IServerRendererConfiguration;
+	#browser: Browser;
+	#isCacheLoaded: boolean = false;
+	#pageRenderer: ServerRendererPage;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param configuration Configuration.
+	 */
+	constructor(configuration: IServerRendererConfiguration) {
+		this.#configuration = configuration;
+		const settings =
+			configuration.debug && configuration.browser.debug?.traceWaitUntilComplete === -1
+				? {
+						...configuration.browser,
+						debug: {
+							...configuration.browser.debug,
+							traceWaitUntilComplete: configuration.render.timeout
+						}
+					}
+				: configuration.browser;
+		this.#browser = new Browser({ settings });
+		this.#pageRenderer = new ServerRendererPage(configuration);
+	}
+
+	/**
+	 * Renders URLs.
+	 *
+	 * @param items Items.
+	 */
+	public async render(items: IServerRendererItem[]): Promise<IServerRendererResult[]> {
+		const browser = this.#browser;
+
+		await this.#loadCache(browser);
+
+		let results: IServerRendererResult[];
+
+		if (items.length > this.#configuration.render.maxConcurrency) {
+			results = [];
+			while (items.length) {
+				const chunk = items.splice(0, this.#configuration.render.maxConcurrency);
+				const promises = [];
+				for (const url of chunk) {
+					promises.push(
+						this.#renderPage(browser, url).then((result) => {
+							results.push(result);
+						})
+					);
+				}
+				await Promise.all(promises);
+			}
+		} else {
+			const promises = [];
+			for (const url of items) {
+				promises.push(this.#renderPage(browser, url));
+			}
+			results = await Promise.all(promises);
+		}
+
+		await this.#saveCache(browser);
+
+		return results;
+	}
+
+	/**
+	 * Closes the browser.
+	 */
+	public async close(): Promise<void> {
+		await this.#browser.close();
+		this.#browser = null!;
+		this.#isCacheLoaded = false;
+	}
+
+	/**
+	 * Renders a page.
+	 *
+	 * @param browser Browser.
+	 * @param item Item.
+	 */
+	async #renderPage(browser: Browser, item: IServerRendererItem): Promise<IServerRendererResult> {
+		const responseCache = browser.defaultContext.responseCache;
+		const preflightResponseCache = browser.defaultContext.preflightResponseCache;
+		const configuration = this.#configuration;
+		const context =
+			configuration.render.incognitoContext || configuration.cache.disable
+				? browser.newIncognitoContext()
+				: browser.defaultContext;
+		const page = context.newPage();
+
+		if (configuration.render.incognitoContext && !configuration.cache.disable) {
+			// @ts-ignore
+			context.responseCache = responseCache;
+			// @ts-ignore
+			context.preflightResponseCache = preflightResponseCache;
+		}
+
+		return this.#pageRenderer.render(page, item);
+	}
+
+	/**
+	 * Loads cache from disk.
+	 *
+	 * @param browser Browser.
+	 */
+	async #loadCache(browser: Browser): Promise<void> {
+		if (
+			this.#configuration.cache.disable ||
+			!this.#configuration.cache.directory ||
+			this.#isCacheLoaded
+		) {
+			return;
+		}
+
+		this.#isCacheLoaded = true;
+
+		await browser.defaultContext.responseCache.fileSystem.load(this.#configuration.cache.directory);
+	}
+
+	/**
+	 * Saves cache to disk.
+	 *
+	 * @param browser Browser.
+	 */
+	async #saveCache(browser: Browser): Promise<void> {
+		if (this.#configuration.cache.disable || !this.#configuration.cache.directory) {
+			return;
+		}
+
+		await browser.defaultContext.responseCache.fileSystem.save(this.#configuration.cache.directory);
+	}
+}