buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/module/JSONModule.ts

@@ -0,0 +1,58 @@
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type { URL } from 'url';
+import type IModule from './types/IModule.js';
+import type IModuleInit from './types/IModuleInit.js';
+
+/**
+ * JSON module.
+ */
+export default class JSONModule implements IModule {
+	public readonly url: URL;
+	readonly #window: BrowserWindow;
+	readonly #source: string;
+	#exports: { default: object } | null = null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param init Initialization options.
+	 */
+	constructor(init: IModuleInit) {
+		this.#window = init.window;
+		this.url = <URL>init.url;
+		this.#source = init.source;
+	}
+
+	/**
+	 * Compiles and evaluates the module.
+	 *
+	 * @returns Module exports.
+	 */
+	public async evaluate(): Promise<{ default: object }> {
+		if (this.#exports) {
+			return this.#exports;
+		}
+
+		let result: object;
+		try {
+			result = JSON.parse(this.#source);
+		} catch (error) {
+			throw new this.#window.TypeError(
+				`Failed to parse module "${this.url.href}": ${(<Error>error).message}`
+			);
+		}
+
+		this.#exports = { default: result };
+
+		return this.#exports;
+	}
+
+	/**
+	 * Compiles and preloads the module and its imports.
+	 *
+	 * @returns Promise.
+	 */
+	public async preload(): Promise<void> {
+		await this.evaluate();
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/module/ModuleFactory.ts

@@ -0,0 +1,148 @@
+import type IModule from './types/IModule.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import CSSModule from './CSSModule.js';
+import JSONModule from './JSONModule.js';
+import UnresolvedModule from './UnresolvedModule.js';
+import WindowBrowserContext from '../window/WindowBrowserContext.js';
+import ResourceFetch from '../fetch/ResourceFetch.js';
+import ECMAScriptModule from './ECMAScriptModule.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type IResourceFetchResponse from '../fetch/types/IResourceFetchResponse.js';
+import ModuleURLUtility from './ModuleURLUtility.js';
+import type Location from '../location/Location.js';
+
+/**
+ * Module factory.
+ */
+export default class ModuleFactory {
+	private window: BrowserWindow;
+	private parentURL: URL | Location;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param window Window.
+	 * @param parentURL Parent URL.
+	 */
+	constructor(window: BrowserWindow, parentURL: URL | Location) {
+		this.window = window;
+		this.parentURL = parentURL;
+	}
+
+	/**
+	 * Fetches the source code of the module from the given URL and creates a new module instance.
+	 *
+	 * @param url Module URL.
+	 * @param [parent] Parent module.
+	 * @param [options] Options.
+	 * @param [options.with] Options.
+	 * @param [options.with.type] Module type.
+	 */
+	public async getModule(url: string, options?: { with?: { type?: string } }): Promise<IModule> {
+		const window = this.window;
+		const parentURL = this.parentURL;
+		const absoluteURL = ModuleURLUtility.getURL(window, parentURL, url);
+		const absoluteURLString = absoluteURL.href;
+		const type = options?.with?.type || 'esm';
+
+		if (type !== 'esm' && type !== 'css' && type !== 'json') {
+			throw new window.TypeError(
+				`Failed to import module "${absoluteURL}" from "${parentURL}": Unknown type "${type}"`
+			);
+		}
+
+		const cached = <IModule>window[PropertySymbol.modules][type].get(absoluteURLString);
+
+		if (cached) {
+			if (cached instanceof UnresolvedModule) {
+				await new Promise((resolve, reject) => {
+					cached.addResolveListener(resolve, reject);
+				});
+				return <IModule>window[PropertySymbol.modules][type].get(absoluteURLString);
+			}
+			return cached;
+		}
+		const browserFrame = new WindowBrowserContext(window).getBrowserFrame();
+
+		if (!browserFrame) {
+			throw new window.TypeError(
+				`Failed to import module "${absoluteURL}" from "${parentURL}": Window is closed and is no longer attached to a frame`
+			);
+		}
+
+		const unresolvedModule = new UnresolvedModule({ window, url: absoluteURL });
+		const readyStateManager = window[PropertySymbol.readyStateManager];
+
+		const taskID = readyStateManager.startTask();
+
+		window[PropertySymbol.modules][type].set(absoluteURLString, unresolvedModule);
+
+		const resourceFetch = new ResourceFetch(window);
+		let response: IResourceFetchResponse;
+		try {
+			response = await resourceFetch.fetch(absoluteURL, 'module');
+		} catch (error) {
+			readyStateManager.endTask(taskID);
+			unresolvedModule.resolve(<Error>error);
+			throw error;
+		}
+
+		readyStateManager.endTask(taskID);
+
+		let module: IModule;
+
+		switch (type) {
+			case 'json':
+				module = new JSONModule({ window, url: absoluteURL, source: response.content });
+				break;
+			case 'css':
+				module = new CSSModule({ window, url: absoluteURL, source: response.content });
+				break;
+			case 'esm':
+				module = new ECMAScriptModule({
+					window,
+					url: absoluteURL,
+					source: response.content,
+					sourceURL: response.virtualServerFile || absoluteURLString,
+					factory: new ModuleFactory(window, absoluteURL)
+				});
+				break;
+		}
+
+		window[PropertySymbol.modules][type].set(absoluteURLString, module);
+
+		unresolvedModule.resolve();
+
+		return module;
+	}
+
+	/**
+	 * Imports a module.
+	 *
+	 * @param window Window.
+	 * @param parentURL Parent URL.
+	 * @param url URL.
+	 * @param [options] Options.
+	 * @param [options.with] With.
+	 * @param [options.with.type] Type.
+	 */
+	public async importModule(
+		url: string,
+		options?: { with?: { type?: string } }
+	): Promise<{ [key: string]: any }> {
+		const browserFrame = new WindowBrowserContext(this.window).getBrowserFrame();
+
+		if (!browserFrame) {
+			return {};
+		}
+
+		const asyncTaskManager = browserFrame[PropertySymbol.asyncTaskManager];
+		const taskID = asyncTaskManager?.startTask();
+		const module = await this.getModule(url, options);
+		const exports = await module.evaluate();
+
+		asyncTaskManager.endTask(taskID);
+
+		return exports;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/module/ModuleURLUtility.ts

@@ -0,0 +1,199 @@
+import { URL } from 'url';
+import * as PropertySymbol from '../PropertySymbol.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type Location from '../location/Location.js';
+import WindowBrowserContext from '../window/WindowBrowserContext.js';
+import Path from 'path';
+import FS from 'fs';
+import type IResolveNodeModules from './types/IResolveNodeModules.js';
+
+const MAIN_FIELDS = ['module', 'main'];
+const EXTENSIONS = ['.js', '.mjs'];
+
+/**
+ * Module URL utility.
+ */
+export default class ModuleURLUtility {
+	private static nodeModuleResolveCache: Map<string, string> = new Map();
+	private static packageJsonCache: Map<string, any> = new Map();
+
+	/**
+	 * Returns module URL based on parent URL and the import map.
+	 *
+	 * @param window Window.
+	 * @param parentURL Parent URL.
+	 * @param url Module URL.
+	 */
+	public static getURL(
+		window: BrowserWindow,
+		parentURL: URL | Location | string,
+		url: string
+	): URL {
+		const parentURLString = typeof parentURL === 'string' ? parentURL : parentURL.href;
+		const importMap = window[PropertySymbol.moduleImportMap];
+		const resolved = this.resolveURL(window, parentURLString, url);
+
+		if (!importMap) {
+			return new URL(resolved, parentURLString);
+		}
+
+		if (importMap.scopes.length) {
+			for (const scope of importMap.scopes) {
+				if (parentURLString.includes(scope.scope)) {
+					for (const rule of scope.rules) {
+						if (resolved.startsWith(rule.from)) {
+							return new URL(rule.to + resolved.replace(rule.from, ''), parentURLString);
+						}
+					}
+				}
+			}
+		}
+
+		if (importMap.imports.length) {
+			for (const rule of importMap.imports) {
+				if (resolved.startsWith(rule.from)) {
+					return new URL(rule.to + resolved.replace(rule.from, ''), parentURLString);
+				}
+			}
+		}
+
+		return new URL(resolved, parentURLString);
+	}
+
+	/**
+	 * Clears the internal caches.
+	 */
+	public static clearCache(): void {
+		this.nodeModuleResolveCache.clear();
+		this.packageJsonCache.clear();
+	}
+
+	/**
+	 * Resolves the module URL using the settings.
+	 *
+	 * @param window Window.
+	 * @param parentURL Parent URL.
+	 * @param url Module URL.
+	 */
+	private static resolveURL(window: BrowserWindow, parentURL: string, url: string): string {
+		const settings = new WindowBrowserContext(window).getSettings();
+		if (!settings) {
+			return url;
+		}
+		let resolvedURL = url;
+		if (settings.module.resolveNodeModules) {
+			resolvedURL = this.resolveNodeModuleURL(settings.module.resolveNodeModules, url);
+		}
+		if (settings.module.urlResolver) {
+			resolvedURL = settings.module.urlResolver({ url: resolvedURL, parentURL, window });
+		}
+		return resolvedURL;
+	}
+
+	/**
+	 * Resolves node module URL.
+	 *
+	 * @param resolveNodeModules Settings for resolving node modules.
+	 * @param url Module URL.
+	 */
+	private static resolveNodeModuleURL(
+		resolveNodeModules: IResolveNodeModules,
+		url: string
+	): string {
+		if (
+			url[0] === '.' ||
+			url[0] === '/' ||
+			url.startsWith('http://') ||
+			url.startsWith('https://')
+		) {
+			return url;
+		}
+
+		const slash = resolveNodeModules.url[resolveNodeModules.url.length - 1] === '/' ? '' : '/';
+		const baseURL = `${resolveNodeModules.url}${slash}`;
+		const nodeModulesDirectory = Path.resolve(resolveNodeModules.directory);
+		const parts = url.split('/');
+		const cached = this.nodeModuleResolveCache.get(url);
+
+		if (cached) {
+			return cached;
+		}
+
+		const packageName = url[0] === '@' ? `${parts[0]}/${parts[1]}` : parts[0];
+		let packageJson = this.packageJsonCache.get(packageName);
+
+		if (!packageJson) {
+			try {
+				packageJson = JSON.parse(
+					FS.readFileSync(Path.join(nodeModulesDirectory, packageName, 'package.json'), 'utf-8')
+				);
+				this.packageJsonCache.set(packageName, packageJson);
+			} catch {
+				return url;
+			}
+		}
+
+		if ((url[0] === '@' && parts.length === 2) || parts.length === 1) {
+			if (packageJson.exports?.['.']?.import) {
+				const resolvedURL = `${baseURL}${packageName}/${packageJson.exports['.'].import.replace('./', '')}`;
+				this.nodeModuleResolveCache.set(url, resolvedURL);
+				return resolvedURL;
+			}
+
+			const mainFields = resolveNodeModules.mainFields || MAIN_FIELDS;
+
+			for (const field of mainFields) {
+				if (
+					packageJson[field] &&
+					FS.existsSync(Path.join(nodeModulesDirectory, packageName, packageJson[field]))
+				) {
+					const resolvedURL = `${baseURL}${url}/${packageJson[field]}`;
+					this.nodeModuleResolveCache.set(url, resolvedURL);
+					return resolvedURL;
+				}
+			}
+
+			return url;
+		}
+
+		const subPath = parts.slice(url[0] === '@' ? 2 : 1).join('/');
+
+		if (packageJson.exports) {
+			for (const key of Object.keys(packageJson.exports)) {
+				const importEntry = Array.isArray(packageJson.exports[key].import)
+					? packageJson.exports[key].import[0]
+					: packageJson.exports[key].import;
+				if (importEntry) {
+					const regExp = new RegExp(
+						`^${key.replace('./', '').replace(/\./g, '\\.').replace(/\*/g, '(.*)')}$`
+					);
+					const match = subPath.match(regExp);
+					if (match) {
+						const resolvedSubPath = importEntry.replace('./', '').replace('*', match[1]);
+						const resolvedURL = `${baseURL}${packageName}/${resolvedSubPath}`;
+						this.nodeModuleResolveCache.set(url, resolvedURL);
+						return resolvedURL;
+					}
+				}
+			}
+		}
+
+		if (!url.endsWith('.js') && !url.endsWith('.mjs')) {
+			for (const ext of EXTENSIONS) {
+				if (FS.existsSync(Path.join(nodeModulesDirectory, `${url}${ext}`))) {
+					const resolvedURL = `${baseURL}${url}${ext}`;
+					this.nodeModuleResolveCache.set(url, resolvedURL);
+					return resolvedURL;
+				}
+			}
+		} else {
+			if (FS.existsSync(Path.join(nodeModulesDirectory, url))) {
+				const resolvedURL = `${baseURL}${url}`;
+				this.nodeModuleResolveCache.set(url, resolvedURL);
+				return resolvedURL;
+			}
+		}
+
+		return url;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/module/UnresolvedModule.ts

@@ -0,0 +1,81 @@
+import type BrowserWindow from '../window/BrowserWindow.js';
+import type { URL } from 'url';
+import type IModule from './types/IModule.js';
+
+interface IUnresolvedModuleInit {
+	window: BrowserWindow;
+	url: URL;
+}
+
+/**
+ * CSS module.
+ */
+export default class UnresolvedModule implements IModule {
+	public readonly url: URL;
+	readonly #window: BrowserWindow;
+	#hooks: { resolve: (value: unknown) => void; reject: (error: Error) => void }[] = [];
+	#error: Error | null = null;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param init Initialization options.
+	 */
+	constructor(init: IUnresolvedModuleInit) {
+		this.#window = init.window;
+		this.url = init.url;
+	}
+
+	/**
+	 * Compiles and evaluates the module.
+	 *
+	 * @returns Module exports.
+	 */
+	public async evaluate(): Promise<any> {
+		throw new this.#window.TypeError('Unresolved module. We should never end up here.');
+	}
+
+	/**
+	 * Compiles and preloads the module and its imports.
+	 *
+	 * @returns Promise.
+	 */
+	public async preload(): Promise<void> {
+		throw new this.#window.TypeError('Unresolved module. We should never end up here.');
+	}
+
+	/**
+	 * Add a hook to be called when the module is resolved.
+	 *
+	 * @param resolve Resolve.
+	 * @param reject Reject.
+	 */
+	public addResolveListener(
+		resolve: (value: unknown) => void,
+		reject: (error: Error) => void
+	): void {
+		if (this.#error) {
+			reject(this.#error);
+			return;
+		}
+		this.#hooks.push({ resolve, reject });
+	}
+
+	/**
+	 * Resolves the module.
+	 *
+	 * @param [error] Error.
+	 */
+	public resolve(error?: Error): void {
+		if (error) {
+			this.#error = error;
+		}
+		for (const hook of this.#hooks) {
+			if (error) {
+				hook.reject(error);
+			} else {
+				hook.resolve(null);
+			}
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/module/enums/ECMAScriptModuleEvaluateStateEnum.ts

@@ -0,0 +1,7 @@
+enum ECMAScriptModuleEvaluateStateEnum {
+	unevaluated = 'unevaluated',
+	ongoing = 'ongoing',
+	complete = 'complete'
+}
+
+export default ECMAScriptModuleEvaluateStateEnum;

package/vendor/happy-dom/packages/happy-dom/src/module/types/IECMAScriptModuleCachedResult.ts

@@ -0,0 +1,9 @@
+import type IECMAScriptModuleImport from './IECMAScriptModuleImport.js';
+
+/**
+ * ECMAScript module cached compilation result.
+ */
+export default interface IECMAScriptModuleCachedResult {
+	imports: IECMAScriptModuleImport[];
+	code: string;
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IECMAScriptModuleCompiledResult.ts

@@ -0,0 +1,19 @@
+import type IECMAScriptModuleImport from './IECMAScriptModuleImport.js';
+
+export default interface IECMAScriptModuleCompiledResult {
+	imports: IECMAScriptModuleImport[];
+	execute: (options: {
+		dispatchError: (error: Error) => void;
+		dynamicImport: (
+			url: string,
+			options?: { with?: { type?: string } }
+		) => Promise<{ [key: string]: any }>;
+		importMeta: {
+			url: string;
+			resolve: (url: string) => string;
+		};
+		imports: Map<string, { [key: string]: any }>;
+		exports: { [key: string]: any };
+		addCircularImportResolver: (resolver: () => void) => void;
+	}) => Promise<void>;
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IECMAScriptModuleImport.ts

@@ -0,0 +1,4 @@
+export default interface IECMAScriptModuleImport {
+	url: string;
+	type: string;
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IECMAScriptModuleInit.ts

@@ -0,0 +1,10 @@
+import type ModuleFactory from '../ModuleFactory.js';
+import type IModuleInit from './IModuleInit.js';
+
+/**
+ * ECMAScript module initialization options.
+ */
+export default interface IECMAScriptModuleInit extends IModuleInit {
+	factory: ModuleFactory;
+	sourceURL?: string | null;
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IModule.ts

@@ -0,0 +1,20 @@
+/**
+ * Module interface.
+ */
+export default interface IModule {
+	url: URL;
+
+	/**
+	 * Compiles and evaluates the module.
+	 *
+	 * @returns Module exports.
+	 */
+	evaluate(): Promise<{ [key: string]: any }>;
+
+	/**
+	 * Compiles and preloads the module and its imports.
+	 *
+	 * @returns Promise.
+	 */
+	preload(): Promise<void>;
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IModuleImportMap.ts

@@ -0,0 +1,10 @@
+import type IModuleImportMapRule from './IModuleImportMapRule.js';
+import type IModuleImportMapScope from './IModuleImportMapScope.js';
+
+/**
+ * @see https://html.spec.whatwg.org/multipage/webappapis.html#import-map
+ */
+export default interface IModuleImportMap {
+	imports: IModuleImportMapRule[];
+	scopes: IModuleImportMapScope[];
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IModuleImportMapRule.ts

@@ -0,0 +1,4 @@
+export default interface IModuleImportMapRule {
+	from: string;
+	to: string;
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IModuleImportMapScope.ts

@@ -0,0 +1,6 @@
+import type IModuleImportMapRule from './IModuleImportMapRule.js';
+
+export default interface IModuleImportMapScope {
+	scope: string;
+	rules: IModuleImportMapRule[];
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IModuleInit.ts

@@ -0,0 +1,12 @@
+import type Location from '../../location/Location.js';
+import type BrowserWindow from '../../window/BrowserWindow.js';
+import type { URL } from 'url';
+
+/**
+ * Module initialization options.
+ */
+export default interface IModuleInit {
+	window: BrowserWindow;
+	url: URL | Location;
+	source: string;
+}

package/vendor/happy-dom/packages/happy-dom/src/module/types/IResolveNodeModules.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface representing the structure for resolving node modules into an URL.
+ */
+export default interface IResolveNodeModules {
+	url: string;
+	directory: string;
+	mainFields?: string[];
+}

package/vendor/happy-dom/packages/happy-dom/src/mutation-observer/IMutationListener.ts

@@ -0,0 +1,7 @@
+import type IMutationObserverInit from './IMutationObserverInit.js';
+import type MutationRecord from './MutationRecord.js';
+
+export default interface IMutationListener {
+	options: IMutationObserverInit;
+	callback: WeakRef<(record: MutationRecord) => void>;
+}

package/vendor/happy-dom/packages/happy-dom/src/mutation-observer/IMutationObserverInit.ts

@@ -0,0 +1,14 @@
+/**
+ * Mutation observer init configurations.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserverInit
+ */
+export default interface IMutationObserverInit {
+	attributeFilter?: string[];
+	attributeOldValue?: boolean;
+	attributes?: boolean;
+	characterData?: boolean;
+	characterDataOldValue?: boolean;
+	childList?: boolean;
+	subtree?: boolean;
+}