buninu-browser 0.0.2

package/vendor/happy-dom/packages/@happy-dom/jest-environment/src/index.ts

@@ -0,0 +1,192 @@
+/* eslint-disable filenames/match-exported */
+
+import type VM from 'vm';
+import * as JestUtil from 'jest-util';
+import { ModuleMocker } from 'jest-mock';
+import { LegacyFakeTimers, ModernFakeTimers } from '@jest/fake-timers';
+import type { JestEnvironment, EnvironmentContext } from '@jest/environment';
+import type { IOptionalBrowserSettings } from 'happy-dom';
+import { Window, BrowserErrorCaptureEnum } from 'happy-dom';
+import type { Script } from 'vm';
+import type { Global, Config } from '@jest/types';
+
+/**
+ * Happy DOM Jest Environment.
+ */
+export default class HappyDOMEnvironment implements JestEnvironment {
+	public fakeTimers: LegacyFakeTimers<number> | null = null;
+	public fakeTimersModern: ModernFakeTimers | null = null;
+	public window: Window;
+	public global: Global.Global;
+	public moduleMocker: ModuleMocker;
+
+	/**
+	 * jest-environment-jsdom" has the default set to ['browser']
+	 * As changing this value would be a breaking change, we will keep it at ['node', 'node-addons'] until we do a major release
+	 *
+	 * @see https://stackoverflow.com/questions/72428323/jest-referenceerror-vue-is-not-defined
+	 */
+	public customExportConditions = ['node', 'node-addons'];
+
+	private _configuredExportConditions: string[];
+
+	/**
+	 * Constructor.
+	 *
+	 * @param config Jest config.
+	 * @param config.globalConfig jest global config.
+	 * @param config.projectConfig jest project config.
+	 * @param options Options.
+	 */
+	constructor(
+		config:
+			| { globalConfig: Config.GlobalConfig; projectConfig: Config.ProjectConfig }
+			| Config.ProjectConfig,
+		options?: EnvironmentContext
+	) {
+		let projectConfig: Config.ProjectConfig;
+		let globals: Config.ConfigGlobals;
+		if (isJestConfigVersion29(config)) {
+			// Jest 29
+			globals = config.globals;
+			projectConfig = config;
+		} else if (isJestConfigVersion28(config)) {
+			// Jest < 29
+			globals = config.projectConfig.globals;
+			projectConfig = config.projectConfig;
+		} else {
+			throw new Error('Unsupported jest version.');
+		}
+
+		this._configuredExportConditions = [];
+
+		if ('customExportConditions' in projectConfig.testEnvironmentOptions) {
+			const { customExportConditions } = projectConfig.testEnvironmentOptions;
+			if (
+				Array.isArray(customExportConditions) &&
+				customExportConditions.every((condition) => typeof condition === 'string')
+			) {
+				this._configuredExportConditions = customExportConditions;
+			} else {
+				throw new Error('Custom export conditions specified but they are not an array of strings');
+			}
+		}
+
+		// Initialize Window and Global
+		this.window = new Window({
+			url: 'http://localhost/',
+			...projectConfig.testEnvironmentOptions,
+			console: options?.console || console,
+			settings: {
+				...(<IOptionalBrowserSettings>projectConfig.testEnvironmentOptions?.settings),
+				errorCapture: BrowserErrorCaptureEnum.disabled
+			}
+		});
+		this.global = <Global.Global>(<unknown>this.window);
+		this.moduleMocker = new ModuleMocker(<typeof globalThis>(<unknown>this.window));
+
+		// Node's error-message stack size is limited to 10, but it's pretty useful to see more than that when a test fails.
+		this.global.Error.stackTraceLimit = 100;
+
+		// TODO: Remove this ASAP as it currently causes tests to run really slow.
+		this.global.Buffer = Buffer;
+
+		// Needed as Jest is using it
+		this.window['global'] = this.global;
+
+		JestUtil.installCommonGlobals(<typeof globalThis>(<unknown>this.window), globals);
+
+		// For some reason Jest removes the global setImmediate and clearImmediate, so we need to add them back.
+		// This is especially important for Jest 30+ where these are no longer available.
+		this.global.setImmediate = global.setImmediate;
+		this.global.clearImmediate = global.clearImmediate;
+
+		this.fakeTimers = new LegacyFakeTimers({
+			config: projectConfig,
+			global: <typeof globalThis>(<unknown>this.window),
+			moduleMocker: this.moduleMocker,
+			timerConfig: {
+				idToRef: (id: number) => id,
+				refToId: (ref: number) => ref
+			}
+		});
+
+		this.fakeTimersModern = new ModernFakeTimers({
+			config: projectConfig,
+			global: <typeof globalThis>(<unknown>this.window)
+		});
+
+		// Jest is using the setTimeout function from Happy DOM internally for detecting when a test times out, but this causes window.happyDOM?.waitUntilComplete() and window.happyDOM?.abort() to not work as expected.
+		// Hopefully Jest can fix this in the future as this fix is not very pretty.
+		const happyDOMSetTimeout = this.global.setTimeout;
+		(<(...args: unknown[]) => number>this.global.setTimeout) = (...args: unknown[]): number => {
+			if (new Error('stack').stack!.includes('/jest-jasmine')) {
+				// @ts-ignore
+				return global.setTimeout.call(global, ...args);
+			}
+			// @ts-ignore
+			return happyDOMSetTimeout.call(this.global, ...args);
+		};
+	}
+	/**
+	 * Respect any export conditions specified as options
+	 * https://jestjs.io/docs/configuration#testenvironmentoptions-object
+	 */
+	public exportConditions(): string[] {
+		return this._configuredExportConditions ?? this.customExportConditions;
+	}
+
+	/**
+	 * Setup.
+	 *
+	 * @returns Promise.
+	 */
+	public async setup(): Promise<void> {}
+
+	/**
+	 * Teardown.
+	 *
+	 * @returns Promise.
+	 */
+	public async teardown(): Promise<void> {
+		this.fakeTimers!.dispose();
+		this.fakeTimersModern!.dispose();
+
+		await (<Window>(<unknown>this.global)).happyDOM.abort();
+		(<Window>(<unknown>this.global)).close();
+
+		this.global = null!;
+		this.moduleMocker = null!;
+		this.fakeTimers = null;
+		this.fakeTimersModern = null;
+	}
+
+	/**
+	 * Runs a script.
+	 *
+	 * @param script Script.
+	 * @returns Result.
+	 */
+	public runScript(script: Script): null {
+		return script.runInContext(this.global);
+	}
+
+	/**
+	 * Returns the VM context.
+	 *
+	 * @returns Context.
+	 */
+	public getVmContext(): VM.Context {
+		return this.global;
+	}
+}
+
+function isJestConfigVersion29(config: unknown): config is Config.ProjectConfig {
+	return Object.getOwnPropertyDescriptor(config, 'globals') !== undefined;
+}
+
+function isJestConfigVersion28(
+	config: unknown
+): config is { globalConfig: Config.GlobalConfig; projectConfig: Config.ProjectConfig } {
+	return Object.getOwnPropertyDescriptor(config, 'projectConfig') !== undefined;
+}

package/vendor/happy-dom/packages/@happy-dom/jest-environment/tsconfig.json

@@ -0,0 +1,30 @@
+{
+	"compilerOptions": {
+		"outDir": "lib",
+		"rootDir": "src",
+		"target": "ES2022",
+		"declaration": true,
+		"declarationMap": true,
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"esModuleInterop": true,
+		"experimentalDecorators": true,
+		"allowSyntheticDefaultImports": true,
+		"resolveJsonModule": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noImplicitReturns": false,
+		"noImplicitAny": true,
+		"removeComments": false,
+		"preserveConstEnums": true,
+		"strict": true,
+		"sourceMap": true,
+		"skipLibCheck": true,
+		"composite": true,
+		"incremental": true,
+		"tsBuildInfoFile": ".turbo/.tsbuildinfo",
+		"lib": ["ES2022", "dom"],
+		"types": ["node"]
+	},
+	"include": ["@types/node", "src"]
+}

package/vendor/happy-dom/packages/@happy-dom/node-canvas-adapter/README.md

@@ -0,0 +1,48 @@
+![Happy DOM Logo](https://github.com/capricorn86/happy-dom/raw/master/docs/happy-dom-logo.jpg)
+
+Pluggable canvas adapter for [Happy DOM](https://github.com/capricorn86/happy-dom) using [node-canvas](https://github.com/Automattic/node-canvas).
+
+## Installation
+
+```bash
+npm install canvas @happy-dom/node-canvas-adapter
+```
+
+## Documentation
+
+You will find the documentation in the [Happy DOM Wiki](https://github.com/capricorn86/happy-dom/wiki) under [Node Canvas Adapter](https://github.com/capricorn86/happy-dom/wiki/Node-Canvas-Adapter).
+
+## Usage
+
+```typescript
+import { Window } from 'happy-dom';
+import { CanvasAdapter } from '@happy-dom/node-canvas-adapter';
+
+const window = new Window({
+  settings: {
+    canvasAdapter: new CanvasAdapter(),
+    // Optionally, enable image file loading (e.g. for <img> elements)
+    enableImageFileLoading: true
+  }
+});
+
+const canvas = window.document.createElement('canvas');
+const context = canvas.getContext('2d');
+
+canvas.width = 200;
+canvas.height = 200;
+
+// Now you can use canvas context
+context.fillStyle = 'red';
+context.fillRect(0, 0, 100, 100);
+
+// Get data URL
+const dataUrl = canvas.toDataURL();
+
+// Output the data URL
+console.log(dataUrl);
+```
+
+## 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/node-canvas-adapter/package.json

@@ -0,0 +1,41 @@
+{
+	"name": "@happy-dom/node-canvas-adapter",
+	"version": "0.0.0",
+	"license": "MIT",
+	"homepage": "https://github.com/capricorn86/happy-dom/tree/master/packages/@happy-dom/node-canvas-adapter",
+	"repository": "https://github.com/capricorn86/happy-dom",
+	"author": "David Ortner",
+	"description": "Pluggable canvas adapter for happy-dom using node-canvas.",
+	"main": "lib/index.js",
+	"type": "module",
+	"keywords": [
+		"canvas",
+		"happy-dom",
+		"adapter",
+		"node-canvas",
+		"rendering"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"compile": "tsc",
+		"watch": "tsc -w --preserveWatchOutput",
+		"test": "vitest run",
+		"test:debug": "vitest run --inspect-brk --no-file-parallelism"
+	},
+	"peerDependencies": {
+		"canvas": "^3.2.3",
+		"happy-dom": ">=20.9.0"
+	},
+	"devDependencies": {
+		"@vitest/ui": "^4.0.16",
+		"canvas": "^3.2.3",
+		"happy-dom": "^0.0.0",
+		"typescript": "^5.8.3",
+		"vitest": "^4.0.16"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/vendor/happy-dom/packages/@happy-dom/node-canvas-adapter/src/CanvasAdapter.ts

@@ -0,0 +1,275 @@
+import { createCanvas, Image as CanvasImage } from 'canvas';
+import {
+	HTMLCanvasElement,
+	HTMLImageElement,
+	OffscreenCanvas,
+	ImageData,
+	PropertySymbol,
+	type ICanvasAdapter,
+	type ICanvasRenderingContext2D,
+	type ICanvasAdapterCaller,
+	type ICanvasShape,
+	type Blob,
+	HTMLVideoElement,
+	ImageBitmap
+} from 'happy-dom';
+
+const EXTENDED_SYMBOL = Symbol('extended');
+
+/**
+ * Canvas adapter that delegates rendering to the `canvas` npm package.
+ *
+ * @example
+ * ```typescript
+ * import { Window } from 'happy-dom';
+ * import { CanvasAdapter } from '@happy-dom/node-canvas-adapter';
+ *
+ * const window = new Window({
+ *   settings: { canvasAdapter: new CanvasAdapter() }
+ * });
+ *
+ * const canvas = window.document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ * ```
+ */
+export default class CanvasAdapter implements ICanvasAdapter {
+	readonly #canvases = new WeakMap<ICanvasShape, ReturnType<typeof createCanvas>>();
+
+	/**
+	 * Returns or creates a node-canvas instance bound to the given canvas element.
+	 *
+	 * @param canvas The canvas element.
+	 * @returns The bound node-canvas instance.
+	 */
+	#getNodeCanvas(canvas: ICanvasShape): ReturnType<typeof createCanvas> {
+		const existing = this.#canvases.get(canvas);
+		if (existing !== undefined) {
+			return existing;
+		}
+		const nodeCanvas = createCanvas(canvas.width, canvas.height);
+		this.#canvases.set(canvas, nodeCanvas);
+		return nodeCanvas;
+	}
+
+	/**
+	 * Creates a rendering context for the given canvas element.
+	 *
+	 * @param canvas.canvas
+	 * @param canvas The canvas element.
+	 * @param canvas.window Window.
+	 * @param contextType The context identifier ('2d', 'webgl', etc.).
+	 * @param contextAttributes Optional context creation attributes.
+	 * @param canvas.canvasType
+	 * @returns The rendering context, or null if the type is unsupported.
+	 *
+	 * @example
+	 * ```typescript
+	 * const ctx = adapter.getContext(canvas, '2d');
+	 * ```
+	 */
+	public getContext(
+		{ canvas, window }: ICanvasAdapterCaller,
+		contextType: string,
+		contextAttributes?: Record<string, unknown>
+	): ICanvasRenderingContext2D | null {
+		if (contextType !== '2d') {
+			return null;
+		}
+		const context = this.#getNodeCanvas(canvas).getContext('2d', contextAttributes);
+
+		if (context === null) {
+			return null;
+		}
+
+		if ((<any>context)[EXTENDED_SYMBOL]) {
+			return <ICanvasRenderingContext2D>(<unknown>context);
+		}
+
+		(<any>context)[EXTENDED_SYMBOL] = true;
+
+		// drawImage()
+		const originalDrawImage = context.drawImage;
+		context.drawImage = (...args: any[]) => {
+			const shape = <ICanvasShape>args[0];
+			const drawImageBuffer = (buffer: Buffer): void => {
+				const canvasImage = new CanvasImage();
+				canvasImage.src = buffer;
+				canvasImage.width = shape.width;
+				canvasImage.height = shape.height;
+				args[0] = canvasImage;
+				(<any>originalDrawImage).apply(context, args);
+			};
+			if (shape instanceof HTMLImageElement) {
+				if (shape[PropertySymbol.buffer]) {
+					drawImageBuffer(shape[PropertySymbol.buffer]);
+					return;
+				}
+				if (!shape.complete) {
+					shape.addEventListener('load', () => {
+						if (shape[PropertySymbol.buffer]) {
+							drawImageBuffer(shape[PropertySymbol.buffer]);
+						}
+					});
+				}
+				return;
+			}
+			if (shape instanceof HTMLVideoElement) {
+				// Not supported yet
+				return;
+			}
+			if (
+				shape instanceof ImageBitmap ||
+				shape instanceof HTMLCanvasElement ||
+				shape instanceof OffscreenCanvas
+			) {
+				const nodeCanvas = this.#getNodeCanvas(
+					(<ImageBitmap>shape)[PropertySymbol.canvas] || shape
+				);
+				if (nodeCanvas) {
+					args[0] = nodeCanvas;
+					(<any>originalDrawImage).apply(context, args);
+				}
+				return;
+			}
+		};
+
+		// createImageData()
+		const originalCreateImageData = context.createImageData;
+		context.createImageData = (...args: any[]) => {
+			const imageData = originalCreateImageData.apply(context, <any>args);
+			return new ImageData(imageData.data, imageData.width, imageData.height);
+		};
+
+		// putImageData()
+		const originalPutImageData = context.putImageData;
+		context.putImageData = (...args: any[]) => {
+			const imageData = args[0];
+			if (!(imageData instanceof ImageData)) {
+				throw new window.TypeError(
+					`Failed to execute 'putImageData' on 'CanvasRenderingContext2D': parameter 1 is not of type 'ImageData'`
+				);
+			}
+			const canvasImageData = (<any>originalCreateImageData).call(
+				context,
+				imageData.width,
+				imageData.height
+			);
+			canvasImageData.data.set(imageData.data);
+			args[0] = canvasImageData;
+			(<any>originalPutImageData).apply(context, args);
+		};
+
+		// getImageData()
+		const originalGetImageData = context.getImageData;
+		context.getImageData = (...args: any[]) => {
+			const imageData = originalGetImageData.apply(context, <any>args);
+			return new ImageData(imageData.data, imageData.width, imageData.height);
+		};
+
+		// createPattern()
+		const originalCreatePattern = context.createPattern;
+		context.createPattern = (
+			shape: any,
+			repetition: '' | 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat'
+		): any => {
+			if (shape instanceof HTMLImageElement) {
+				if (!shape[PropertySymbol.buffer]) {
+					return null;
+				}
+
+				const canvasImage = new CanvasImage();
+				canvasImage.src = shape[PropertySymbol.buffer];
+				canvasImage.width = shape.width;
+				canvasImage.height = shape.height;
+				return originalCreatePattern.call(context, canvasImage, repetition);
+			}
+			if (shape instanceof HTMLVideoElement) {
+				// Not supported yet
+				return null;
+			}
+			if (
+				shape instanceof ImageBitmap ||
+				shape instanceof HTMLCanvasElement ||
+				shape instanceof OffscreenCanvas
+			) {
+				const nodeCanvas = this.#getNodeCanvas(
+					(<ImageBitmap>shape)[PropertySymbol.canvas] || shape
+				);
+				if (nodeCanvas) {
+					return originalCreatePattern.call(context, nodeCanvas, repetition);
+				}
+			}
+			return null;
+		};
+
+		return <ICanvasRenderingContext2D>(<unknown>context);
+	}
+
+	/**
+	 * Serialize the canvas content as a data URL.
+	 *
+	 * @param caller Information about the caller, including the canvas element and its associated window and browser frame.
+	 * @param caller.canvas Canvas.
+	 * @param type MIME type of the output image.
+	 * @param quality Encoder quality for lossy formats, in the range 0–1.
+	 * @returns A data URL string.
+	 *
+	 * @example
+	 * ```typescript
+	 * const url = adapter.toDataURL(canvas, 'image/png');
+	 * ```
+	 */
+	public toDataURL({ canvas }: ICanvasAdapterCaller, type?: string, quality?: unknown): string {
+		const nodeCanvas = this.#getNodeCanvas(canvas);
+		if (type === 'image/jpeg') {
+			return nodeCanvas.toDataURL('image/jpeg', <number>quality);
+		}
+		return nodeCanvas.toDataURL('image/png');
+	}
+
+	/**
+	 * Creates a Blob from the canvas content and passes it to the callback.
+	 *
+	 * @param caller Information about the caller, including the canvas element and its associated window and browser frame.
+	 * @param caller.canvas Canvas.
+	 * @param caller.window Window.
+	 * @param canvas The canvas element.
+	 * @param callback Receives the resulting Blob, or null on failure.
+	 * @param type MIME type of the output image.
+	 * @param quality Encoder quality for lossy formats, in the range 0–1.
+	 *
+	 * @example
+	 * ```typescript
+	 * adapter.toBlob(canvas, (blob) => console.log(blob?.size));
+	 * ```
+	 */
+	public toBlob(
+		{ canvas, window }: ICanvasAdapterCaller,
+		callback: (blob: Blob | null) => void,
+		type?: string,
+		quality?: unknown
+	): void {
+		const nodeCanvas = this.#getNodeCanvas(canvas);
+		if (type === 'image/jpeg') {
+			nodeCanvas.toBuffer(
+				(error, buffer) => {
+					if (error !== null) {
+						callback(null);
+						return;
+					}
+					callback(new window.Blob([new Uint8Array(buffer)], { type: 'image/jpeg' }));
+				},
+				'image/jpeg',
+				{ quality: <number>quality }
+			);
+			return;
+		}
+		nodeCanvas.toBuffer((error, buffer) => {
+			if (error !== null) {
+				callback(null);
+				return;
+			}
+			callback(new window.Blob([new Uint8Array(buffer)], { type: type ?? 'image/png' }));
+		});
+	}
+}

package/vendor/happy-dom/packages/@happy-dom/node-canvas-adapter/src/index.ts

@@ -0,0 +1 @@
+export { default as CanvasAdapter } from './CanvasAdapter.js';

package/vendor/happy-dom/packages/@happy-dom/server-renderer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 David Ortner (capricorn86)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.