kreuzcrawl-browser 0.3.0

"use strict";

globalThis.__kreuzcrawl_errors = [];

globalThis.addEventListener = globalThis.addEventListener || function () {};
globalThis.onunhandledrejection = function (e) {
	if (e?.preventDefault) e.preventDefault();
};

globalThis.onerror = function (msg, src, line, col, error) {
	globalThis.__kreuzcrawl_errors.push({
		msg: String(msg),
		src: String(src || ""),
		line,
		error: String(error || ""),
	});
};
globalThis.__windowListeners = {};
globalThis.addEventListener = function (type, fn) {
	if (!globalThis.__windowListeners[type]) globalThis.__windowListeners[type] = [];
	globalThis.__windowListeners[type].push(fn);
};
globalThis.removeEventListener = function (type, fn) {
	if (globalThis.__windowListeners[type]) {
		globalThis.__windowListeners[type] = globalThis.__windowListeners[type].filter((h) => h !== fn);
	}
};
globalThis.dispatchEvent = function (event) {
	if (!event) return true;
	const handlers = globalThis.__windowListeners[event.type] || [];
	for (const h of handlers) {
		try {
			h.call(globalThis, event);
		} catch (e) {
			console.error(e);
		}
	}
	return !event.defaultPrevented;
};

const _dom = (cmd, a1, a2) => Deno.core.ops.op_dom(cmd, String(a1 ?? ""), String(a2 ?? ""));

const _nativeFns = new Set();
const _origToString = Function.prototype.toString;
Function.prototype.toString = function () {
	if (_nativeFns.has(this)) {
		return `function ${this.name || ""}() { [native code] }`;
	}
	return _origToString.call(this);
};
function _markNative(fn) {
	if (typeof fn === "function") _nativeFns.add(fn);
	return fn;
}
_nativeFns.add(Function.prototype.toString);

[Error, TypeError, ReferenceError, SyntaxError, RangeError, URIError, EvalError].forEach((E) => {
	try {
		Object.defineProperty(E.prototype, "name", {
			value: E.name,
			writable: true,
			enumerable: false,
			configurable: false,
		});
	} catch (e) {}
});

const _stackCache = new WeakMap();
const _origStackDesc = Object.getOwnPropertyDescriptor(Error.prototype, "stack");
if (_origStackDesc && _origStackDesc.get) {
	Object.defineProperty(Error.prototype, "stack", {
		configurable: false,
		enumerable: false,
		get: function () {
			if (!_stackCache.has(this)) _stackCache.set(this, _origStackDesc.get.call(this));
			return _stackCache.get(this);
		},
	});
}

let _fpSeed = 0;
function _fpRand(salt) {
	let h = (_fpSeed ^ (salt || 0)) | 0;
	h = Math.imul(h ^ (h >>> 16), 0x45d9f3b);
	h = Math.imul(h ^ (h >>> 13), 0x45d9f3b);
	return ((h ^ (h >>> 16)) >>> 0) / 0xffffffff;
}
function _fpNoise(x, y, channel) {
	return (_fpRand(x * 7919 + y * 6271 + channel * 8923) - 0.5) * 4;
}

var _fpCache = null;
function _getFp() {
	if (_fpCache) return _fpCache;
	const gpuPool = [
		"ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 SUPER Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (NVIDIA, NVIDIA GeForce RTX 2070 SUPER Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (Intel, Intel(R) Iris(R) Xe Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (AMD, AMD Radeon RX 580 Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (NVIDIA, NVIDIA GeForce GTX 1080 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (Intel, Intel(R) UHD Graphics 770 Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (AMD, AMD Radeon RX 5700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)",
		"ANGLE (NVIDIA, NVIDIA GeForce RTX 3080 Direct3D11 vs_5_0 ps_5_0, D3D11)",
	];
	const gpuVendorPool = [
		"Google Inc. (NVIDIA)",
		"Google Inc. (NVIDIA)",
		"Google Inc. (NVIDIA)",
		"Google Inc. (Intel)",
		"Google Inc. (Intel)",
		"Google Inc. (AMD)",
		"Google Inc. (AMD)",
		"Google Inc. (NVIDIA)",
		"Google Inc. (NVIDIA)",
		"Google Inc. (Intel)",
		"Google Inc. (AMD)",
		"Google Inc. (NVIDIA)",
	];
	const idx = Math.floor(_fpRand(42) * gpuPool.length);
	const screenPool = [
		[1920, 1080],
		[2560, 1440],
		[1366, 768],
		[1536, 864],
		[1440, 900],
		[1680, 1050],
		[1280, 720],
		[3840, 2160],
	];
	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	let cfp = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUg";
	for (let i = 0; i < 40; i++) cfp += chars[Math.floor(_fpRand(500 + i) * 64)];
	cfp += "==";
	_fpCache = {
		gpu: gpuPool[idx],
		gpuVendor: gpuVendorPool[idx],
		audioBaseLatency: 0.002 + _fpRand(100) * 0.008,
		audioSampleRate: [44100, 48000][Math.floor(_fpRand(101) * 2)],
		compThreshold: -24 + (_fpRand(102) - 0.5) * 4,
		compKnee: 30 + (_fpRand(103) - 0.5) * 4,
		compRatio: 12 + (_fpRand(104) - 0.5) * 4,
		batteryLevel: 0.5 + _fpRand(200) * 0.5,
		batteryCharging: _fpRand(201) > 0.3,
		screen: screenPool[Math.floor(_fpRand(300) * screenPool.length)],
		canvasFingerprint: cfp,
	};
	return _fpCache;
}
function _fp(key) {
	return _getFp()[key];
}
globalThis._eventRegistry = globalThis._eventRegistry || {};
globalThis._formValues = globalThis._formValues || {};
globalThis._formChecked = globalThis._formChecked || {};
const _eventRegistry = globalThis._eventRegistry;
const _formValues = globalThis._formValues;
const _formChecked = globalThis._formChecked;
const _domParse = (cmd, a1, a2) => {
	try {
		return JSON.parse(_dom(cmd, a1, a2));
	} catch {
		return null;
	}
};
const _consoleFn = (level, args) => {
	try {
		Deno.core.ops.op_console_msg(
			level,
			args
				.map((a) => {
					if (a === null) return "null";
					if (a === undefined) return "undefined";
					if (a instanceof Error) return a.stack || a.message || String(a);
					if (typeof a === "object") {
						try {
							const s = JSON.stringify(a);
							return s === "{}" && a.message ? a.message : s;
						} catch {
							return String(a);
						}
					}
					return String(a);
				})
				.join(" "),
		);
	} catch {}
};

globalThis.console = {
	log: (...a) => _consoleFn("log", a),
	warn: (...a) => _consoleFn("warn", a),
	error: (...a) => _consoleFn("error", a),
	info: (...a) => _consoleFn("log", a),
	debug: () => {},
	dir: () => {},
	trace: () => {},
	table: () => {},
	group: () => {},
	groupEnd: () => {},
	groupCollapsed: () => {},
	time: () => {},
	timeEnd: () => {},
	timeLog: () => {},
	count: () => {},
	countReset: () => {},
	clear: () => {},
	assert: (c, ...a) => {
		if (!c) _consoleFn("error", ["Assertion failed:", ...a]);
	},
};

let _tid = 0;
const _pendingTimers = new Map();
const _clearedTimers = new Set();

globalThis.setTimeout = (fn, delay = 0, ...args) => {
	if (typeof fn !== "function") return ++_tid;
	const id = ++_tid;
	_pendingTimers.set(id, { fn, args, delay });
	Promise.resolve().then(() => {
		if (!_clearedTimers.has(id) && _pendingTimers.has(id)) {
			_pendingTimers.delete(id);
			try {
				fn(...args);
			} catch (e) {
				console.error("Timer error:", e);
			}
		}
	});
	return id;
};

globalThis.clearTimeout = (id) => {
	_clearedTimers.add(id);
	_pendingTimers.delete(id);
};
globalThis.setInterval = (fn, delay, ...args) => {
	return setTimeout(fn, delay, ...args);
};
globalThis.clearInterval = globalThis.clearTimeout;
globalThis.requestAnimationFrame = (fn) => setTimeout(fn, 0);
globalThis.cancelAnimationFrame = globalThis.clearTimeout;
globalThis.queueMicrotask = globalThis.queueMicrotask || ((fn) => Promise.resolve().then(fn));

class MessageChannel {
	constructor() {
		this.port1 = {
			onmessage: null,
			postMessage: () => {},
			close() {},
			addEventListener() {},
			removeEventListener() {},
		};
		this.port2 = {
			onmessage: null,
			postMessage: () => {},
			close() {},
			addEventListener() {},
			removeEventListener() {},
		};
		this.port1.postMessage = (data) => {
			Promise.resolve().then(() => {
				if (this.port2.onmessage) this.port2.onmessage({ data });
			});
		};
		this.port2.postMessage = (data) => {
			Promise.resolve().then(() => {
				if (this.port1.onmessage) this.port1.onmessage({ data });
			});
		};
	}
}
globalThis.MessageChannel = MessageChannel;
globalThis.MessagePort = class MessagePort {
	constructor() {}
	postMessage() {}
	close() {}
	addEventListener() {}
	removeEventListener() {}
};

class CSSStyleDeclaration {
	constructor() {
		this._props = {};
	}
	setProperty(name, value) {
		this._props[name] = String(value);
	}
	removeProperty(name) {
		const old = this._props[name];
		delete this._props[name];
		return old || "";
	}
	getPropertyValue(name) {
		return this._props[name] || "";
	}
	get cssText() {
		return Object.entries(this._props)
			.map(([k, v]) => `${k}: ${v}`)
			.join("; ");
	}
	set cssText(v) {
		this._props = {};
		if (v)
			v.split(";").forEach((p) => {
				const [k, ...rest] = p.split(":");
				if (k && rest.length) this._props[k.trim()] = rest.join(":").trim();
			});
	}
	get length() {
		return Object.keys(this._props).length;
	}
	item(i) {
		return Object.keys(this._props)[i] || "";
	}
}

const _styleProxy = (decl) =>
	new Proxy(decl, {
		get(t, p) {
			if (typeof p === "symbol" || p in t) return t[p];
			if (typeof p === "string") return t._props[p] || "";
			return undefined;
		},
		set(t, p, v) {
			if (typeof p === "string") {
				t._props[p] = String(v);
				return true;
			}
			t[p] = v;
			return true;
		},
	});

class Node {
	static ELEMENT_NODE = 1;
	static TEXT_NODE = 3;
	static COMMENT_NODE = 8;
	static DOCUMENT_NODE = 9;
	static DOCUMENT_FRAGMENT_NODE = 11;

	constructor(nid) {
		this._nid = nid;
	}
	get nodeType() {
		return +_dom("node_type", this._nid);
	}
	get nodeName() {
		return _domParse("node_name", this._nid) || "";
	}
	get ownerDocument() {
		return globalThis.document;
	}
	get textContent() {
		return _domParse("text_content", this._nid) ?? "";
	}
	set textContent(v) {
		const children = _domParse("child_nodes", this._nid) || [];
		for (const c of children) _dom("remove_child", c);
		if (v != null && v !== "") {
			const tn = +_dom("create_text_node", String(v));
			_dom("append_child", this._nid, tn);
		}
	}
	get nodeValue() {
		const t = this.nodeType;
		if (t === 3 || t === 8) return _domParse("text_content", this._nid) ?? "";
		return null;
	}
	set nodeValue(v) {
		const t = this.nodeType;
		if (t === 3 || t === 8) _dom("set_text_content", this._nid, String(v ?? ""));
	}
	get parentNode() {
		return _wrap(+_dom("parent_node", this._nid));
	}
	get parentElement() {
		const p = this.parentNode;
		return p && p.nodeType === 1 ? p : null;
	}
	get childNodes() {
		const ids = _domParse("child_nodes", this._nid) || [];
		const list = ids.map(_wrap).filter(Boolean);
		list.item = (i) => list[i] || null;
		return list;
	}
	get firstChild() {
		return _wrap(+_dom("first_child", this._nid));
	}
	get lastChild() {
		return _wrap(+_dom("last_child", this._nid));
	}
	get nextSibling() {
		return _wrap(+_dom("next_sibling", this._nid));
	}
	get previousSibling() {
		return _wrap(+_dom("prev_sibling", this._nid));
	}
	appendChild(c) {
		if (!c) return c;
		_dom("append_child", this._nid, c._nid);
		if (globalThis.__mutationObservers?.length) globalThis.__notifyMutation("childList", this._nid, [c._nid], []);
		if (c instanceof Element && c.tagName === "SCRIPT") {
			const scriptType = c.getAttribute("type") || "";
			if (scriptType && scriptType !== "text/javascript" && scriptType !== "application/javascript") {
				return c;
			}
			const src = c.getAttribute("src");
			if (src) {
				const fullUrl = src.startsWith("http")
					? src
					: new URL(src, globalThis.location?.href || "http://localhost/").href;
				const pageOrigin = (function () {
					try {
						return new URL(globalThis.location?.href || "about:blank").origin;
					} catch (e) {
						return "";
					}
				})();
				(async () => {
					try {
						const raw = await Deno.core.ops.op_fetch_url(fullUrl, "GET", "{}", "", pageOrigin, "no-cors");
						const parsed = JSON.parse(raw);
						if (parsed.body) {
							try {
								(0, eval)(parsed.body);
							} catch (e) {
								console.error("Dynamic script error (" + fullUrl + "):", e.message);
							}
						}
						if (typeof c.onload === "function")
							try {
								c.onload(new Event("load"));
							} catch (e) {}
						try {
							c.dispatchEvent(new Event("load"));
						} catch (e) {}
					} catch (e) {
						console.error("Dynamic script fetch error:", e.message);
						if (typeof c.onerror === "function")
							try {
								c.onerror(e);
							} catch (ex) {}
					}
				})();
			} else {
				const code = c.textContent;
				if (code) {
					try {
						(0, eval)(code);
					} catch (e) {
						console.error("Dynamic inline script error:", e.message);
					}
				}
			}
		}
		return c;
	}
	removeChild(c) {
		if (!c) return c;
		_dom("remove_child", c._nid);
		if (globalThis.__mutationObservers?.length) globalThis.__notifyMutation("childList", this._nid, [], [c._nid]);
		return c;
	}
	replaceChild(newChild, oldChild) {
		if (!oldChild || !newChild) return oldChild;
		_dom("insert_before", this._nid, newChild._nid, oldChild._nid);
		_dom("remove_child", oldChild._nid);
		return oldChild;
	}
	insertBefore(n, ref) {
		if (!n) return n;
		if (!ref) {
			this.appendChild(n);
			return n;
		}
		_dom("insert_before", this._nid, n._nid, ref._nid);
		return n;
	}
	contains(o) {
		return o ? _dom("contains", this._nid, o._nid) === "true" : false;
	}
	hasChildNodes() {
		return _dom("has_child_nodes", this._nid) === "true";
	}
	cloneNode(deep) {
		const t = this.nodeType;
		if (t === 1) {
			if (deep) {
				const wrapper = document.createElement("div");
				wrapper.innerHTML = _domParse("outer_html", this._nid) || "";
				const clone = wrapper.firstChild;
				return clone;
			}
			const el = document.createElement(this.nodeName.toLowerCase());
			const html = _domParse("outer_html", this._nid) || "";
			const attrMatch = html.match(/^<[a-zA-Z][^\s>]*([\s\S]*?)>/);
			if (attrMatch && attrMatch[1]) {
				const attrStr = attrMatch[1].trim();
				const re = /([a-zA-Z_:][a-zA-Z0-9_.:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
				let m;
				while ((m = re.exec(attrStr)) !== null) {
					const name = m[1];
					const val = m[2] !== undefined ? m[2] : m[3] !== undefined ? m[3] : m[4] || "";
					if (name !== this.nodeName.toLowerCase()) el.setAttribute(name, val);
				}
			}
			return el;
		}
		if (t === 3) return document.createTextNode(this.textContent);
		if (t === 8) return document.createComment(this.nodeValue || "");
		return null;
	}
	compareDocumentPosition(other) {
		if (!other) return 0;
		if (this._nid === other._nid) return 0;
		if (this.contains(other)) return 16 | 4; // DOCUMENT_POSITION_CONTAINED_BY | FOLLOWING
		if (other.contains && other.contains(this)) return 8 | 2; // DOCUMENT_POSITION_CONTAINS | PRECEDING
		return 4; // DOCUMENT_POSITION_FOLLOWING
	}
	getRootNode() {
		return globalThis.document;
	}
	normalize() {} // no-op
	isEqualNode(other) {
		return other && this._nid === other._nid;
	}
	isSameNode(other) {
		return other && this._nid === other._nid;
	}
	addEventListener() {}
	removeEventListener() {}
	dispatchEvent() {
		return true;
	}
}
class CharacterData extends Node {
	get data() {
		return _domParse("text_content", this._nid) ?? "";
	}
	set data(v) {
		_dom("set_text_content", this._nid, String(v ?? ""));
	}
	get length() {
		return this.data.length;
	}
	substringData(offset, count) {
		return this.data.substring(offset, offset + count);
	}
	appendData(s) {
		this.data += s;
	}
	insertData(offset, s) {
		const d = this.data;
		this.data = d.slice(0, offset) + s + d.slice(offset);
	}
	deleteData(offset, count) {
		const d = this.data;
		this.data = d.slice(0, offset) + d.slice(offset + count);
	}
	replaceData(offset, count, s) {
		const d = this.data;
		this.data = d.slice(0, offset) + s + d.slice(offset + count);
	}
}

class Text extends CharacterData {
	get nodeName() {
		return "#text";
	}
	get nodeType() {
		return 3;
	}
	get wholeText() {
		return this.data;
	}
	splitText(offset) {
		const d = this.data;
		const tail = d.substring(offset);
		this.data = d.substring(0, offset);
		const newNid = +_dom("create_text_node", tail);
		const parent = this.parentNode;
		if (parent) {
			const ref = this.nextSibling;
			parent.insertBefore(_wrap(newNid), ref);
		}
		return _wrap(newNid);
	}
	cloneNode() {
		return document.createTextNode(this.data);
	}
}

class Comment extends CharacterData {
	get nodeName() {
		return "#comment";
	}
	get nodeType() {
		return 8;
	}
	cloneNode() {
		return document.createComment(this.data);
	}
}

class Element extends Node {
	constructor(nid) {
		super(nid);
		this._style = _styleProxy(new CSSStyleDeclaration());
	}
	get tagName() {
		return _domParse("tag_name", this._nid) || "";
	}
	get localName() {
		return (this.tagName || "").toLowerCase();
	}
	get id() {
		return this.getAttribute("id") || "";
	}
	set id(v) {
		this.setAttribute("id", v);
	}
	get className() {
		return this.getAttribute("class") || "";
	}
	set className(v) {
		this.setAttribute("class", v);
	}
	get namespaceURI() {
		const tag = this.localName;
		if (tag === "svg" || this._ns === "http://www.w3.org/2000/svg") return "http://www.w3.org/2000/svg";
		return "http://www.w3.org/1999/xhtml";
	}
	get innerHTML() {
		return _domParse("inner_html", this._nid) ?? "";
	}
	set innerHTML(v) {
		if (this.localName === "template") {
			this.content.innerHTML = v;
			return;
		}
		_dom("set_inner_html", this._nid, String(v ?? ""));
	}
	get outerHTML() {
		return _domParse("outer_html", this._nid) ?? "";
	}
	get innerText() {
		return this.textContent;
	}
	set innerText(v) {
		this.textContent = v;
	}
	get children() {
		const ids = _domParse("element_children", this._nid) || [];
		return ids.map(_wrapEl).filter(Boolean);
	}
	get content() {
		if (this.localName !== "template") return undefined;
		if (!this._templateContent) this._templateContent = document.createDocumentFragment();
		return this._templateContent;
	}
	get childElementCount() {
		return this.children.length;
	}
	get firstElementChild() {
		return this.children[0] || null;
	}
	get lastElementChild() {
		const ch = this.children;
		return ch[ch.length - 1] || null;
	}
	get nextElementSibling() {
		let s = this.nextSibling;
		while (s && s.nodeType !== 1) s = s.nextSibling;
		return s;
	}
	get previousElementSibling() {
		let s = this.previousSibling;
		while (s && s.nodeType !== 1) s = s.previousSibling;
		return s;
	}
	get classList() {
		const el = this;
		const obj = {
			add: (...c) => {
				const s = new Set((el.className || "").split(/\s+/).filter(Boolean));
				c.forEach((x) => s.add(x));
				el.className = [...s].join(" ");
			},
			remove: (...c) => {
				const s = new Set((el.className || "").split(/\s+/).filter(Boolean));
				c.forEach((x) => s.delete(x));
				el.className = [...s].join(" ");
			},
			contains: (c) => (el.className || "").split(/\s+/).includes(c),
			toggle: (c, force) => {
				const has = obj.contains(c);
				if (force === true || (!has && force !== false)) {
					obj.add(c);
					return true;
				}
				obj.remove(c);
				return false;
			},
			get length() {
				return (el.className || "").split(/\s+/).filter(Boolean).length;
			},
			item: (i) => (el.className || "").split(/\s+/).filter(Boolean)[i] || null,
			forEach: (cb) => (el.className || "").split(/\s+/).filter(Boolean).forEach(cb),
			toString: () => el.className || "",
		};
		return obj;
	}
	get style() {
		return this._style;
	}
	set style(v) {
		if (typeof v === "string") this._style.cssText = v;
	}
	getAttribute(n) {
		return _domParse("get_attribute", this._nid, n);
	}
	setAttribute(n, v) {
		_dom("set_attribute", this._nid, n + "\0" + String(v));
		if (globalThis.__mutationObservers?.length) globalThis.__notifyMutation("attributes", this._nid, [], [], n);
	}
	setAttributeNS(ns, n, v) {
		this.setAttribute(n, v);
	} // Simplified NS handling
	removeAttribute(n) {
		_dom("remove_attribute", this._nid, n);
	}
	removeAttributeNS(ns, n) {
		this.removeAttribute(n);
	}
	hasAttribute(n) {
		return this.getAttribute(n) !== null;
	}
	hasAttributes() {
		return true;
	} // Simplified
	getAttributeNS(ns, n) {
		return this.getAttribute(n);
	}
	querySelector(s) {
		return _wrapEl(+_dom("query_selector", s));
	}
	querySelectorAll(s) {
		const ids = _domParse("query_selector_all", s) || [];
		const list = ids.map(_wrapEl).filter(Boolean);
		list.item = (i) => list[i] || null;
		list.forEach = Array.prototype.forEach.bind(list);
		return list;
	}
	getElementsByTagName(t) {
		return this.querySelectorAll(t);
	}
	getElementsByClassName(c) {
		return this.querySelectorAll("." + c);
	}
	matches(s) {
		const parent = this.parentNode;
		if (!parent || !parent.querySelectorAll) return false;
		const matches = parent.querySelectorAll(s);
		for (let i = 0; i < matches.length; i++) {
			if (matches[i]._nid === this._nid) return true;
		}
		return false;
	}
	closest(s) {
		let el = this;
		while (el) {
			if (el.nodeType === 1 && el.matches && el.matches(s)) return el;
			el = el.parentNode;
		}
		return null;
	}
	insertAdjacentHTML(position, html) {
		const parent = this.parentNode;
		switch (position) {
			case "beforebegin":
				if (parent) {
					const tmp = document.createElement("div");
					tmp.innerHTML = html;
					const children = tmp.childNodes;
					for (let i = 0; i < children.length; i++) parent.insertBefore(children[i], this);
				}
				break;
			case "afterbegin":
				{
					const tmp = document.createElement("div");
					tmp.innerHTML = html;
					const children = tmp.childNodes;
					const first = this.firstChild;
					for (let i = children.length - 1; i >= 0; i--) this.insertBefore(children[i], first);
				}
				break;
			case "beforeend":
				{
					const tmp = document.createElement("div");
					tmp.innerHTML = html;
					const children = tmp.childNodes;
					for (let i = 0; i < children.length; i++) this.appendChild(children[i]);
				}
				break;
			case "afterend":
				if (parent) {
					const tmp = document.createElement("div");
					tmp.innerHTML = html;
					const children = tmp.childNodes;
					const next = this.nextSibling;
					for (let i = 0; i < children.length; i++) parent.insertBefore(children[i], next);
				}
				break;
		}
	}
	addEventListener(type, handler, opts) {
		const key = this._nid;
		if (!_eventRegistry[key]) _eventRegistry[key] = {};
		if (!_eventRegistry[key][type]) _eventRegistry[key][type] = [];
		_eventRegistry[key][type].push(handler);
	}
	removeEventListener(type, handler) {
		const key = this._nid;
		if (_eventRegistry[key] && _eventRegistry[key][type]) {
			_eventRegistry[key][type] = _eventRegistry[key][type].filter((h) => h !== handler);
		}
	}
	dispatchEvent(event) {
		if (!event) return true;
		if (!event.target) event.target = this;
		event.currentTarget = this;
		const handlers = (_eventRegistry[this._nid] || {})[event.type] || [];
		for (const h of handlers) {
			try {
				h.call(this, event);
			} catch (e) {
				console.error(e);
			}
			if (event._immediatePropagationStopped) break;
		}
		if (event.bubbles && !event._propagationStopped && this.parentNode) {
			this.parentNode.dispatchEvent(event);
		}
		return !event.defaultPrevented;
	}
	click() {
		const cancelled = !this.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
		if (!cancelled) {
			const link = this.tagName === "A" ? this : this.closest ? this.closest("a[href]") : null;
			if (link) {
				const href = link.getAttribute("href");
				if (href && !href.startsWith("#") && !href.startsWith("javascript:")) {
					location.assign(href);
					return;
				}
			}
			const type = (this.getAttribute("type") || "").toLowerCase();
			if (type === "submit" || (this.localName === "button" && type !== "button" && type !== "reset")) {
				const form = this.closest ? this.closest("form") : null;
				if (form && typeof form.submit === "function") {
					form.submit(this);
				}
			}
		}
	}
	focus() {
		globalThis.__kreuzcrawl_focused = this;
		globalThis.__kreuzcrawl_click_target = this;
	}
	blur() {
		if (globalThis.__kreuzcrawl_focused === this) globalThis.__kreuzcrawl_focused = null;
	}
	get value() {
		if (_formValues[this._nid] !== undefined) return _formValues[this._nid];
		const tag = this.localName;
		if (tag === "textarea") return this.textContent;
		return this.getAttribute("value") || "";
	}
	set value(v) {
		_formValues[this._nid] = String(v);
		const tag = this.localName;
		if (tag === "textarea") {
			this.textContent = String(v);
		}
	}
	get checked() {
		if (_formChecked[this._nid] !== undefined) return _formChecked[this._nid];
		return this.hasAttribute("checked");
	}
	set checked(v) {
		_formChecked[this._nid] = !!v;
	}
	get selected() {
		if (this._selected !== undefined) return this._selected;
		return this.hasAttribute("selected");
	}
	set selected(v) {
		this._selected = !!v;
	}
	get disabled() {
		return this.hasAttribute("disabled");
	}
	set disabled(v) {
		if (v) this.setAttribute("disabled", "");
		else this.removeAttribute("disabled");
	}
	get type() {
		return this.getAttribute("type") || (this.localName === "input" ? "text" : "");
	}
	set type(v) {
		this.setAttribute("type", v);
	}
	get name() {
		return this.getAttribute("name") || "";
	}
	set name(v) {
		this.setAttribute("name", v);
	}
	get placeholder() {
		return this.getAttribute("placeholder") || "";
	}
	set placeholder(v) {
		this.setAttribute("placeholder", v);
	}
	get href() {
		return this.getAttribute("href") || "";
	}
	set href(v) {
		this.setAttribute("href", v);
	}
	get src() {
		return this.getAttribute("src") || "";
	}
	set src(v) {
		this.setAttribute("src", v);
		if (this.localName === "iframe" && v && v !== "about:blank") {
			this._loadIframeSrc(v);
		}
	}
	_loadIframeSrc(url) {
		let fullUrl = url;
		if (!url.includes("://")) {
			try {
				fullUrl = new URL(url, _domParse("document_url") || "about:blank").href;
			} catch (e) {}
		}
		const el = this;
		fetch(fullUrl, { mode: "no-cors" })
			.then(async (resp) => {
				if (resp.ok || resp.type === "opaque") {
					const html = await resp.text();
					el._iframeDoc = new _IframeDocument(html, fullUrl, el);
					el._iframeWin = new _IframeWindow(el._iframeDoc, fullUrl);
				} else {
					el._iframeDoc = new _IframeDocument(
						"<!DOCTYPE html><html><head></head><body></body></html>",
						fullUrl,
						el,
					);
					el._iframeWin = new _IframeWindow(el._iframeDoc, fullUrl);
				}
				_registerIframe(el);
				if (typeof el.onload === "function") {
					try {
						el.onload();
					} catch (e) {}
				} else {
					var onloadAttr = el.getAttribute("onload");
					if (onloadAttr)
						try {
							(0, eval)(onloadAttr);
						} catch (e) {}
				}
			})
			.catch(() => {
				el._iframeDoc = new _IframeDocument(
					"<!DOCTYPE html><html><head></head><body></body></html>",
					fullUrl,
					el,
				);
				el._iframeWin = new _IframeWindow(el._iframeDoc, fullUrl);
				_registerIframe(el);
				if (typeof el.onload === "function")
					try {
						el.onload();
					} catch (e) {}
			});
	}
	get contentDocument() {
		if (this.localName !== "iframe") return undefined;
		if (this._iframeDoc) {
			const pageOrigin = (function () {
				try {
					return new URL(_domParse("document_url")).origin;
				} catch (e) {
					return "";
				}
			})();
			const iframeOrigin = (function (url) {
				try {
					return new URL(url).origin;
				} catch (e) {
					return "";
				}
			})(this.src);
			if (
				pageOrigin === iframeOrigin ||
				this.src === "" ||
				this.src === "about:blank" ||
				!this.src.includes("://")
			) {
				return this._iframeDoc;
			}
			return null; // Cross-origin: blocked
		}
		if (!this._iframeDoc) {
			this._iframeDoc = new _IframeDocument(
				"<!DOCTYPE html><html><head></head><body></body></html>",
				"about:blank",
				this,
			);
			this._iframeWin = new _IframeWindow(this._iframeDoc, "about:blank");
		}
		return this._iframeDoc;
	}
	get contentWindow() {
		if (this.localName !== "iframe") return undefined;
		if (!this._iframeWin) {
			this.contentDocument; // side effect: creates _iframeDoc + _iframeWin
		}
		return this._iframeWin;
	}
	get action() {
		const action = this.getAttribute("action") || _domParse("document_url") || "";
		try {
			return new URL(action, _domParse("document_url") || "about:blank").href;
		} catch (e) {
			return action;
		}
	}
	set action(v) {
		this.setAttribute("action", v);
	}
	get method() {
		return this.getAttribute("method") || "get";
	}
	set method(v) {
		this.setAttribute("method", v);
	}
	get form() {
		let p = this.parentNode;
		while (p && p.localName !== "form") p = p.parentNode;
		return p;
	}
	get options() {
		if (this.localName !== "select") return [];
		return this.querySelectorAll("option");
	}
	get selectedIndex() {
		const opts = this.options;
		for (let i = 0; i < opts.length; i++) {
			if (opts[i].selected || opts[i].hasAttribute("selected")) return i;
		}
		return -1;
	}
	set selectedIndex(v) {
		const opts = this.options;
		for (let i = 0; i < opts.length; i++) {
			opts[i]._selected = i === v;
		}
	}
	submit(submitter) {
		const cancelled = !this.dispatchEvent(new Event("submit", { bubbles: true, cancelable: true }));
		if (cancelled) return;

		const pairs = [];
		const fields = this.querySelectorAll("input, select, textarea");
		for (let i = 0; i < fields.length; i++) {
			const f = fields[i];
			const name = f.getAttribute("name");
			if (!name) continue;
			if (f.getAttribute("disabled") !== null) continue;
			const tag = f.localName;
			const type = (f.getAttribute("type") || "").toLowerCase();
			if ((type === "checkbox" || type === "radio") && !f.checked) continue;
			if (type === "file" || type === "reset") continue;
			if (type === "button") continue;
			if (type === "submit" || tag === "button") {
				if (submitter && f !== submitter) continue;
				if (!submitter) continue; // default submit: don't include submit button value
			}

			let val;
			if (tag === "select") {
				const opt = f.querySelector("option[selected]") || f.querySelector("option");
				val = opt ? (opt.getAttribute("value") !== null ? opt.getAttribute("value") : opt.textContent) : "";
			} else if (tag === "textarea") {
				val = f.value || f.textContent || "";
			} else {
				val = f.value !== undefined ? f.value : f.getAttribute("value") || "";
			}
			const enc = (s) => encodeURIComponent(s).replace(/%20/g, "+").replace(/!/g, "%21");
			pairs.push(enc(name) + "=" + enc(val));
		}

		const action = this.getAttribute("action") || "";
		const method = (this.getAttribute("method") || "GET").toUpperCase();
		const baseUrl = globalThis.location?.href || "about:blank";
		let targetUrl;
		try {
			targetUrl = new URL(action, baseUrl).href;
		} catch (e) {
			targetUrl = action;
		}

		const encoded = pairs.join("&");
		if (method === "POST") {
			Deno.core.ops.op_navigate(targetUrl, "POST", encoded);
		} else {
			const sep = targetUrl.includes("?") ? "&" : "?";
			Deno.core.ops.op_navigate(targetUrl + (encoded ? sep + encoded : ""), "GET", "");
		}
	}
	reset() {
		this.dispatchEvent(new Event("reset", { bubbles: true }));
	}
	get dataset() {
		const el = this;
		return new Proxy(
			{},
			{
				get(_, k) {
					if (typeof k !== "string") return undefined;
					return el.getAttribute("data-" + k.replace(/([A-Z])/g, "-$1").toLowerCase());
				},
				set(_, k, v) {
					el.setAttribute("data-" + k.replace(/([A-Z])/g, "-$1").toLowerCase(), v);
					return true;
				},
			},
		);
	}
	get offsetWidth() {
		return 100;
	}
	get offsetHeight() {
		return 20;
	}
	get offsetTop() {
		return 0;
	}
	get offsetLeft() {
		return 0;
	}
	get clientWidth() {
		return 100;
	}
	get clientHeight() {
		return 20;
	}
	get scrollWidth() {
		return 100;
	}
	get scrollHeight() {
		return 20;
	}
	get scrollTop() {
		return 0;
	}
	set scrollTop(v) {}
	get scrollLeft() {
		return 0;
	}
	set scrollLeft(v) {}
	getBoundingClientRect() {
		globalThis.__kreuzcrawl_click_target = this;
		return {
			x: 8,
			y: 8,
			width: 100,
			height: 20,
			top: 8,
			right: 108,
			bottom: 28,
			left: 8,
			toJSON() {
				return this;
			},
		};
	}
	getClientRects() {
		return [this.getBoundingClientRect()];
	}
	scrollIntoView() {
		globalThis.__kreuzcrawl_click_target = this;
	}
	animate(keyframes, options) {
		const duration = typeof options === "number" ? options : options?.duration || 0;
		return {
			finished: Promise.resolve(),
			currentTime: 0,
			playState: "finished",
			effect: {
				getComputedTiming() {
					return { duration };
				},
			},
			cancel() {},
			finish() {},
			play() {},
			pause() {},
			reverse() {},
			addEventListener() {},
			removeEventListener() {},
			onfinish: null,
			oncancel: null,
		};
	}
	getAnimations() {
		return [];
	}
	get isConnected() {
		return true;
	}
	after() {}
	before() {}
	remove() {
		if (this.parentNode) this.parentNode.removeChild(this);
	}
	append(...nodes) {
		for (const n of nodes) {
			if (typeof n === "string") this.appendChild(document.createTextNode(n));
			else this.appendChild(n);
		}
	}
	prepend() {}
}

class Document extends Node {
	get documentElement() {
		return _wrapEl(+_dom("document_element"));
	}
	get head() {
		return this.querySelector("head");
	}
	get body() {
		return this.querySelector("body");
	}
	get doctype() {
		if (this._doctype !== undefined) return this._doctype;
		const info = _domParse("document_doctype");
		if (info && info.name) {
			this._doctype = new DocumentType(info.nodeId, info.name, info.publicId || "", info.systemId || "");
		} else {
			this._doctype = null;
		}
		return this._doctype;
	}
	get title() {
		return _domParse("document_title") ?? "";
	}
	set title(v) {}
	get URL() {
		return _domParse("document_url") ?? "";
	}
	get documentURI() {
		return this.URL;
	}
	get location() {
		return globalThis.location;
	}
	set location(url) {
		Deno.core.ops.op_navigate(_resolveUrl(String(url)), "GET", "");
	}
	get defaultView() {
		return globalThis;
	}
	get nodeType() {
		return 9;
	}
	get nodeName() {
		return "#document";
	}
	get ownerDocument() {
		return null;
	} // Document has no ownerDocument
	get compatMode() {
		return "CSS1Compat";
	}
	get characterSet() {
		return "UTF-8";
	}
	get contentType() {
		return "text/html";
	}
	get readyState() {
		return "complete";
	}
	get hidden() {
		return false;
	}
	get visibilityState() {
		return "visible";
	}
	getElementById(id) {
		return _wrapEl(+_dom("get_element_by_id", id));
	}
	querySelector(s) {
		return _wrapEl(+_dom("query_selector", s));
	}
	querySelectorAll(s) {
		const ids = _domParse("query_selector_all", s) || [];
		const list = ids.map(_wrapEl).filter(Boolean);
		list.item = (i) => list[i] || null;
		list.forEach = Array.prototype.forEach.bind(list);
		return list;
	}
	getElementsByTagName(t) {
		return this.querySelectorAll(t);
	}
	getElementsByClassName(c) {
		return this.querySelectorAll("." + c);
	}
	createElement(t) {
		const el = _wrapEl(+_dom("create_element", t.toLowerCase()));
		if (el && t.toLowerCase() === "template") {
			el._templateContent = this.createDocumentFragment();
		}
		return el;
	}
	createElementNS(ns, t) {
		const el = this.createElement(t);
		if (el) el._ns = ns;
		return el;
	}
	createTextNode(t) {
		return _wrap(+_dom("create_text_node", String(t)));
	}
	createComment(t) {
		const nid = +_dom("create_comment_node", String(t ?? ""));
		const n = new Comment(nid);
		_cache.set(nid, n);
		return n;
	}
	createDocumentFragment() {
		const nid = +_dom("create_document_fragment");
		const frag = new DocumentFragment(nid);
		_cache.set(nid, frag);
		return frag;
	}
	// Legacy DOM Level 2 event factory. Spec returns an event of the requested
	// class with an empty type until init*Event() is called. We previously
	// returned a generic Event for every type, which broke libraries that call
	// createEvent('CustomEvent').initCustomEvent(...) — see issue #41.
	createEvent(type) {
		const map = {
			customevent: CustomEvent,
			customevents: CustomEvent,
			mouseevent: MouseEvent,
			mouseevents: MouseEvent,
			keyboardevent: KeyboardEvent,
			keyboardevents: KeyboardEvent,
			focusevent: FocusEvent,
			inputevent: InputEvent,
			uievent: UIEvent,
			uievents: UIEvent,
			wheelevent: WheelEvent,
			pointerevent: PointerEvent,
			errorevent: ErrorEvent,
			popstateevent: PopStateEvent,
			animationevent: AnimationEvent,
			transitionevent: TransitionEvent,
		};
		const Cls = map[String(type || "").toLowerCase()] || Event;
		return new Cls("");
	}
	createRange() {
		return {
			setStart() {},
			setEnd() {},
			collapse() {},
			selectNodeContents() {},
			cloneContents() {
				return document.createDocumentFragment();
			},
		};
	}
	addEventListener(type, fn, opts) {}
	removeEventListener() {}
	dispatchEvent() {
		return true;
	}
	createTreeWalker(root, whatToShow, filter) {
		whatToShow = whatToShow || 0xffffffff; // NodeFilter.SHOW_ALL
		const walker = {
			root: root,
			currentNode: root,
			whatToShow: whatToShow,
			filter: filter || null,
			_accept(node) {
				const nodeType = node.nodeType;
				const show = (whatToShow >> (nodeType - 1)) & 1;
				if (!show) return false;
				if (this.filter) {
					if (typeof this.filter === "function") return this.filter(node) === 1;
					if (this.filter.acceptNode) return this.filter.acceptNode(node) === 1;
				}
				return true;
			},
			nextNode() {
				const node = this.currentNode;
				let child = node.firstChild;
				while (child) {
					if (this._accept(child)) {
						this.currentNode = child;
						return child;
					}
					if (child.firstChild) {
						child = child.firstChild;
						continue;
					}
					if (child.nextSibling) {
						child = child.nextSibling;
						continue;
					}
					let parent = child.parentNode;
					while (parent && parent !== this.root) {
						if (parent.nextSibling) {
							child = parent.nextSibling;
							break;
						}
						parent = parent.parentNode;
					}
					if (!parent || parent === this.root) return null;
				}
				return null;
			},
			previousNode() {
				const node = this.currentNode;
				if (node === this.root) return null;
				let sibling = node.previousSibling;
				if (sibling) {
					while (sibling.lastChild) sibling = sibling.lastChild;
					if (this._accept(sibling)) {
						this.currentNode = sibling;
						return sibling;
					}
				}
				const parent = node.parentNode;
				if (parent && parent !== this.root && this._accept(parent)) {
					this.currentNode = parent;
					return parent;
				}
				return null;
			},
			firstChild() {
				let child = this.currentNode.firstChild;
				while (child) {
					if (this._accept(child)) {
						this.currentNode = child;
						return child;
					}
					child = child.nextSibling;
				}
				return null;
			},
			lastChild() {
				let child = this.currentNode.lastChild;
				while (child) {
					if (this._accept(child)) {
						this.currentNode = child;
						return child;
					}
					child = child.previousSibling;
				}
				return null;
			},
			nextSibling() {
				let sibling = this.currentNode.nextSibling;
				while (sibling) {
					if (this._accept(sibling)) {
						this.currentNode = sibling;
						return sibling;
					}
					sibling = sibling.nextSibling;
				}
				return null;
			},
			previousSibling() {
				let sibling = this.currentNode.previousSibling;
				while (sibling) {
					if (this._accept(sibling)) {
						this.currentNode = sibling;
						return sibling;
					}
					sibling = sibling.previousSibling;
				}
				return null;
			},
			parentNode() {
				const parent = this.currentNode.parentNode;
				if (parent && parent !== this.root && this._accept(parent)) {
					this.currentNode = parent;
					return parent;
				}
				return null;
			},
		};
		return walker;
	}
	createNodeIterator(root, whatToShow, filter) {
		return this.createTreeWalker(root, whatToShow, filter);
	}
	getSelection() {
		return globalThis.getSelection();
	}
	get activeElement() {
		return globalThis.__kreuzcrawl_focused || this.body;
	}
	get implementation() {
		return {
			createHTMLDocument(title) {
				return globalThis.document;
			},
			createDocument() {
				return globalThis.document;
			},
			hasFeature() {
				return true;
			},
		};
	}
	get styleSheets() {
		return [];
	}
	get forms() {
		return [];
	}
	get images() {
		return [];
	}
	get links() {
		return [];
	}
	get scripts() {
		return this.querySelectorAll("script");
	}
	get cookie() {
		return Deno.core.ops.op_get_cookies();
	}
	set cookie(v) {
		if (!v) return;
		Deno.core.ops.op_set_cookie(v);
	}
	write(...args) {
		var html = args.join("");
		if (!html) return;
		var body = this.body;
		if (!body) return;
		var temp = this.createElement("div");
		temp.innerHTML = html;
		var children = temp.childNodes;
		for (var i = 0; i < children.length; i++) {
			body.appendChild(children[i]);
		}
	}
	writeln(...args) {
		this.write(args.join("") + "\n");
	}
	open() {
		var body = this.body;
		if (body) body.innerHTML = "";
		return this;
	}
	close() {
		return;
	}
	hasFocus() {
		return true;
	}
	execCommand() {
		return false;
	}
}

class DocumentFragment extends Node {
	get nodeType() {
		return 11;
	}
	get nodeName() {
		return "#document-fragment";
	}
	get innerHTML() {
		return _domParse("inner_html", this._nid) ?? "";
	}
	set innerHTML(v) {
		_dom("set_inner_html", this._nid, String(v ?? ""));
	}
	querySelector(s) {
		return _wrapEl(+_dom("query_selector", s));
	}
	querySelectorAll(s) {
		const ids = _domParse("query_selector_all", s) || [];
		const list = ids.map(_wrapEl).filter(Boolean);
		list.item = (i) => list[i] || null;
		return list;
	}
	get children() {
		const ids = _domParse("element_children", this._nid) || [];
		return ids.map(_wrapEl).filter(Boolean);
	}
	get firstElementChild() {
		return this.children[0] || null;
	}
	get lastElementChild() {
		const ch = this.children;
		return ch[ch.length - 1] || null;
	}
	getElementById(id) {
		return null;
	}
	cloneNode(deep) {
		const frag = document.createDocumentFragment();
		if (deep) frag.innerHTML = this.innerHTML;
		return frag;
	}
}

class DocumentType extends Node {
	constructor(nid, name, publicId, systemId) {
		super(nid);
		this._name = name;
		this._publicId = publicId;
		this._systemId = systemId;
	}
	get nodeType() {
		return 10;
	}
	get nodeName() {
		return this._name;
	}
	get name() {
		return this._name;
	}
	get publicId() {
		return this._publicId;
	}
	get systemId() {
		return this._systemId;
	}
	get ownerDocument() {
		return globalThis.document;
	}
}

const _cache = new Map();
function _wrap(nid) {
	if (nid < 0 || nid === null || nid === undefined || isNaN(nid)) return null;
	if (_cache.has(nid)) return _cache.get(nid);
	const t = +_dom("node_type", nid);
	let n;
	if (t === 1) n = new Element(nid);
	else if (t === 3) n = new Text(nid);
	else if (t === 8) n = new Comment(nid);
	else if (t === 9) n = new Document(nid);
	else n = new Node(nid);
	_cache.set(nid, n);
	return n;
}
function _wrapEl(nid) {
	if (nid < 0 || nid === null || nid === undefined || isNaN(nid)) return null;
	if (_cache.has(nid)) return _cache.get(nid);
	const n = new Element(nid);
	_cache.set(nid, n);
	return n;
}

globalThis.document = null;
function _resolveUrl(url) {
	if (!url) return url;
	if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("about:")) return url;
	try {
		return new URL(url, _domParse("document_url") || "about:blank").href;
	} catch (e) {
		return url;
	}
}
globalThis.location = {
	get href() {
		return _domParse("document_url") ?? "about:blank";
	},
	set href(url) {
		Deno.core.ops.op_navigate(_resolveUrl(url), "GET", "");
	},
	get origin() {
		try {
			return new URL(this.href).origin;
		} catch {
			return "";
		}
	},
	get protocol() {
		try {
			return new URL(this.href).protocol;
		} catch {
			return "";
		}
	},
	get host() {
		try {
			return new URL(this.href).host;
		} catch {
			return "";
		}
	},
	get hostname() {
		try {
			return new URL(this.href).hostname;
		} catch {
			return "";
		}
	},
	get pathname() {
		try {
			return new URL(this.href).pathname;
		} catch {
			return "/";
		}
	},
	get search() {
		try {
			return new URL(this.href).search;
		} catch {
			return "";
		}
	},
	get hash() {
		try {
			return new URL(this.href).hash;
		} catch {
			return "";
		}
	},
	get port() {
		try {
			return new URL(this.href).port;
		} catch {
			return "";
		}
	},
	toString() {
		return this.href;
	},
	assign(url) {
		Deno.core.ops.op_navigate(_resolveUrl(url), "GET", "");
	},
	reload() {},
	replace(url) {
		Deno.core.ops.op_navigate(_resolveUrl(url), "GET", "");
	},
};
const _locationObj = globalThis.location;
Object.defineProperty(globalThis, "location", {
	get() {
		return _locationObj;
	},
	set(url) {
		Deno.core.ops.op_navigate(_resolveUrl(String(url)), "GET", "");
	},
	configurable: false,
	enumerable: true,
});

globalThis.window = globalThis;
globalThis.self = globalThis;
globalThis.top = globalThis;
globalThis.parent = globalThis;
globalThis.frames = globalThis;
globalThis.frameElement = null;
globalThis.length = 0;

globalThis.Window = globalThis.Window || function Window() {};
Object.defineProperty(globalThis.Window, Symbol.hasInstance, {
	value(obj) {
		return obj === globalThis || (obj && obj.window === obj);
	},
	configurable: true,
});

const _iframeRegistry = [];
function _registerIframe(iframeEl) {
	const idx = _iframeRegistry.length;
	_iframeRegistry.push(iframeEl);
	globalThis.length = _iframeRegistry.length;
	Object.defineProperty(globalThis, idx, {
		get() {
			return iframeEl._iframeWin || null;
		},
		configurable: true,
		enumerable: false,
	});
}
globalThis.navigator = {
	get userAgent() {
		return (
			globalThis.__kreuzcrawl_ua ||
			"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"
		);
	},
	get appVersion() {
		return this.userAgent.replace("Mozilla/", "");
	},
	language: "en-US",
	languages: ["en-US", "en"],
	platform: "Linux x86_64",
	onLine: true,
	cookieEnabled: true,
	hardwareConcurrency: 8,
	maxTouchPoints: 0,
	vendor: "Google Inc.",
	product: "Gecko",
	productSub: "20030107",
	doNotTrack: null,
	deviceMemory: 8,
	connection: { effectiveType: "4g", rtt: 50, downlink: 10, saveData: false },
	get webdriver() {
		return undefined;
	},
	pdfViewerEnabled: true,
	get plugins() {
		const p = [
			{
				name: "PDF Viewer",
				filename: "internal-pdf-viewer",
				description: "Portable Document Format",
				length: 1,
			},
			{
				name: "Chrome PDF Viewer",
				filename: "internal-pdf-viewer",
				description: "Portable Document Format",
				length: 1,
			},
			{
				name: "Chromium PDF Viewer",
				filename: "internal-pdf-viewer",
				description: "Portable Document Format",
				length: 1,
			},
			{
				name: "Microsoft Edge PDF Viewer",
				filename: "internal-pdf-viewer",
				description: "Portable Document Format",
				length: 1,
			},
			{
				name: "WebKit built-in PDF",
				filename: "internal-pdf-viewer",
				description: "Portable Document Format",
				length: 1,
			},
		];
		p.item = (i) => p[i] || null;
		p.namedItem = (name) => p.find((x) => x.name === name) || null;
		p.refresh = () => {};
		return p;
	},
	get mimeTypes() {
		const m = [
			{
				type: "application/pdf",
				description: "Portable Document Format",
				suffixes: "pdf",
				enabledPlugin: null,
			},
			{
				type: "text/pdf",
				description: "Portable Document Format",
				suffixes: "pdf",
				enabledPlugin: null,
			},
		];
		m.item = (i) => m[i] || null;
		m.namedItem = (name) => m.find((x) => x.type === name) || null;
		return m;
	},
	userAgentData: {
		brands: [
			{ brand: "Google Chrome", version: "145" },
			{ brand: "Chromium", version: "145" },
			{ brand: "Not=A?Brand", version: "24" },
		],
		mobile: false,
		platform: "Linux",
		getHighEntropyValues(hints) {
			return Promise.resolve({
				architecture: "x86",
				bitness: "64",
				brands: [
					{ brand: "Google Chrome", version: "145" },
					{ brand: "Chromium", version: "145" },
					{ brand: "Not=A?Brand", version: "24" },
				],
				fullVersionList: [
					{ brand: "Google Chrome", version: "145.0.0.0" },
					{ brand: "Chromium", version: "145.0.0.0" },
					{ brand: "Not=A?Brand", version: "24.0.0.0" },
				],
				mobile: false,
				model: "",
				platform: "Linux",
				platformVersion: "6.8.0",
				uaFullVersion: "145.0.0.0",
			});
		},
		toJSON() {
			return { brands: this.brands, mobile: this.mobile, platform: this.platform };
		},
	},
	serviceWorker: {
		ready: Promise.resolve(),
		register() {
			return Promise.resolve();
		},
		getRegistrations() {
			return Promise.resolve([]);
		},
		controller: null,
	},
	mediaDevices: {
		enumerateDevices() {
			return Promise.resolve([
				{ deviceId: "default", kind: "audioinput", label: "", groupId: "default" },
				{ deviceId: "comms", kind: "audioinput", label: "", groupId: "comms" },
				{ deviceId: "default", kind: "audiooutput", label: "", groupId: "default" },
				{ deviceId: "", kind: "videoinput", label: "", groupId: "" },
			]);
		},
		getUserMedia() {
			return Promise.reject(new DOMException("NotAllowedError"));
		},
		getDisplayMedia() {
			return Promise.reject(new DOMException("NotAllowedError"));
		},
		addEventListener() {},
		removeEventListener() {},
	},
	clipboard: {
		writeText() {
			return Promise.resolve();
		},
		readText() {
			return Promise.resolve("");
		},
	},
	permissions: {
		query(params) {
			if (params?.name === "notifications") return Promise.resolve({ state: "prompt", onchange: null });
			return Promise.resolve({ state: "granted" });
		},
	},
	getBattery() {
		return Promise.resolve({
			charging: _fp("batteryCharging"),
			chargingTime: _fp("batteryCharging") ? 0 : Infinity,
			dischargingTime: _fp("batteryCharging") ? Infinity : Math.floor(3600 + _fpRand(250) * 7200),
			level: _fp("batteryLevel"),
			addEventListener() {},
		});
	},
	getGamepads() {
		return [];
	},
	sendBeacon() {
		return true;
	},
	javaEnabled() {
		return false;
	},
};

globalThis.chrome = {
	app: {
		isInstalled: false,
		InstallState: { DISABLED: "disabled", INSTALLED: "installed", NOT_INSTALLED: "not_installed" },
		RunningState: { CANNOT_RUN: "cannot_run", READY_TO_RUN: "ready_to_run", RUNNING: "running" },
	},
	runtime: {
		OnInstalledReason: {},
		OnRestartRequiredReason: {},
		PlatformArch: {},
		PlatformNaclArch: {},
		PlatformOs: {},
		RequestUpdateCheckStatus: {},
		connect() {
			return {};
		},
		sendMessage() {},
	},
	csi() {
		return {};
	},
	loadTimes() {
		return {};
	},
};

globalThis.Notification = class Notification {
	static permission = "default";
	static requestPermission() {
		return Promise.resolve("default");
	}
	constructor() {}
};

globalThis.WebGLRenderingContext = class WebGLRenderingContext {};
globalThis.WebGL2RenderingContext = class WebGL2RenderingContext {};

globalThis.screen = {
	width: 1920,
	height: 1080,
	availWidth: 1920,
	availHeight: 1040,
	colorDepth: 24,
	pixelDepth: 24,
	availTop: 0,
	availLeft: 0,
	orientation: {
		type: "landscape-primary",
		angle: 0,
		addEventListener() {},
		removeEventListener() {},
		dispatchEvent() {
			return true;
		},
	},
};
globalThis.visualViewport = {
	width: 1920,
	height: 1000,
	offsetLeft: 0,
	offsetTop: 0,
	scale: 1,
	addEventListener() {},
	removeEventListener() {},
};
globalThis.devicePixelRatio = 1;
globalThis.innerWidth = 1920;
globalThis.innerHeight = 1000;
globalThis.outerWidth = 1920;
globalThis.outerHeight = 1080;
globalThis.scrollX = 0;
globalThis.scrollY = 0;
globalThis.pageXOffset = 0;
globalThis.pageYOffset = 0;

globalThis.__fetchInterceptEnabled = false;
globalThis.__fetchInterceptCallback = null; // Set by CDP to handle paused requests

function _base64ToUint8Array(b64) {
	const clean = String(b64 || "").replace(/[\r\n\s]/g, "");
	if (!clean) return new Uint8Array();
	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	const padding = clean.endsWith("==") ? 2 : clean.endsWith("=") ? 1 : 0;
	const bytes = new Uint8Array(((clean.length * 3) >> 2) - padding);
	let out = 0;
	for (let i = 0; i < clean.length; i += 4) {
		const a = alphabet.indexOf(clean[i]);
		const b = alphabet.indexOf(clean[i + 1]);
		const c = clean[i + 2] === "=" ? 0 : alphabet.indexOf(clean[i + 2]);
		const d = clean[i + 3] === "=" ? 0 : alphabet.indexOf(clean[i + 3]);
		const n = (a << 18) | (b << 12) | (c << 6) | d;
		if (out < bytes.length) bytes[out++] = (n >> 16) & 0xff;
		if (out < bytes.length) bytes[out++] = (n >> 8) & 0xff;
		if (out < bytes.length) bytes[out++] = n & 0xff;
	}
	return bytes;
}

function _bodyToUint8Array(body) {
	if (body == null) return new Uint8Array();
	if (body instanceof Uint8Array) return body;
	if (body instanceof ArrayBuffer) return new Uint8Array(body);
	if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
	return new TextEncoder().encode(String(body));
}

function _arrayBufferFromBytes(bytes) {
	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
}

function _installWasmStreamingFallback() {
	if (typeof WebAssembly === "undefined") return;
	if (WebAssembly.instantiateStreaming && WebAssembly.instantiateStreaming.__kreuzcrawlFallback) return;
	const nativeInstantiateStreaming = WebAssembly.instantiateStreaming;
	const fallback = async function instantiateStreaming(source, imports) {
		const response = await source;
		if (response && typeof response.arrayBuffer === "function") {
			return WebAssembly.instantiate(await response.arrayBuffer(), imports);
		}
		if (typeof nativeInstantiateStreaming === "function") {
			return nativeInstantiateStreaming.call(WebAssembly, response, imports);
		}
		return WebAssembly.instantiate(response, imports);
	};
	fallback.__kreuzcrawlFallback = true;
	WebAssembly.instantiateStreaming = fallback;
}
_installWasmStreamingFallback();

globalThis.fetch = async (input, init = {}) => {
	let url =
		typeof input === "string"
			? input
			: input instanceof Request
				? input.url
				: typeof URL === "function" && input instanceof URL
					? input.href
					: input?.url || input?.href || String(input || "");
	if (url && !url.includes("://")) {
		try {
			const base = _domParse("document_url") || "about:blank";
			url = new URL(url, base).href;
		} catch (e) {
			/* keep as-is if URL resolution fails */
		}
	}
	const method = init.method || (input instanceof Request ? input.method : "GET");
	const hdrs = JSON.stringify(
		init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers || {},
	);
	const body = init.body ? String(init.body) : "";
	const fetchMode = init.mode || (input instanceof Request ? input.mode : "cors");
	const pageOrigin = (function () {
		try {
			const u = new URL(_domParse("document_url") || "about:blank");
			return u.origin;
		} catch (e) {
			return "";
		}
	})();
	const raw = await Deno.core.ops.op_fetch_url(url, method, hdrs, body, pageOrigin, fetchMode);
	const parsed = JSON.parse(raw);
	if (parsed.blocked) {
		const err = new TypeError("net::ERR_FAILED");
		err.name = "AbortError";
		err.__aborted = true;
		throw err;
	}
	if (parsed.corsBlocked) {
		throw new TypeError("Failed to fetch: " + (parsed.corsError || "CORS error"));
	}
	const respType = parsed.status === 0 ? "opaque" : fetchMode === "no-cors" ? "opaque" : "basic";
	const responseBody = parsed.bodyBase64 ? _base64ToUint8Array(parsed.bodyBase64) : parsed.body || "";
	return new Response(responseBody, {
		status: parsed.status,
		statusText: "",
		headers: parsed.headers || {},
		type: respType,
		url: parsed.url || url,
		redirected: false,
	});
};

if (typeof Headers === "undefined") {
	globalThis.Headers = class Headers {
		constructor(init = {}) {
			this._h = {};
			if (init) {
				if (init instanceof Headers) {
					init.forEach((v, k) => {
						this._h[k] = v;
					});
				} else if (typeof init === "object") {
					for (const [k, v] of Object.entries(init)) this._h[k.toLowerCase()] = String(v);
				}
			}
		}
		get(n) {
			return this._h[n.toLowerCase()] ?? null;
		}
		set(n, v) {
			this._h[n.toLowerCase()] = String(v);
		}
		has(n) {
			return n.toLowerCase() in this._h;
		}
		delete(n) {
			delete this._h[n.toLowerCase()];
		}
		append(n, v) {
			this._h[n.toLowerCase()] = String(v);
		}
		forEach(cb) {
			for (const [k, v] of Object.entries(this._h)) cb(v, k, this);
		}
		entries() {
			return Object.entries(this._h)[Symbol.iterator]();
		}
		keys() {
			return Object.keys(this._h)[Symbol.iterator]();
		}
		values() {
			return Object.values(this._h)[Symbol.iterator]();
		}
		[Symbol.iterator]() {
			return this.entries();
		}
	};
}

globalThis.XMLHttpRequest = class XMLHttpRequest {
	static UNSENT = 0;
	static OPENED = 1;
	static HEADERS_RECEIVED = 2;
	static LOADING = 3;
	static DONE = 4;
	UNSENT = 0;
	OPENED = 1;
	HEADERS_RECEIVED = 2;
	LOADING = 3;
	DONE = 4;

	constructor() {
		this.readyState = 0;
		this.status = 0;
		this.statusText = "";
		this.responseText = "";
		this.responseXML = null;
		this.responseURL = "";
		this.responseType = "";
		this.response = null;
		this.timeout = 0;
		this.withCredentials = false;
		this.upload = { addEventListener() {}, removeEventListener() {} };
		this._method = "GET";
		this._url = "";
		this._headers = {};
		this._responseHeaders = {};
		this._aborted = false;
		this._listeners = {};
		this.onreadystatechange = null;
		this.onload = null;
		this.onerror = null;
		this.onabort = null;
		this.onprogress = null;
		this.ontimeout = null;
		this.onloadstart = null;
		this.onloadend = null;
	}

	open(method, url, async_) {
		this._method = method;
		this._url = url;
		this._headers = {};
		this._responseHeaders = {};
		this._aborted = false;
		this.status = 0;
		this.statusText = "";
		this.responseText = "";
		this.response = null;
		this._setReadyState(1);
	}

	setRequestHeader(name, value) {
		this._headers[name] = value;
	}

	getResponseHeader(name) {
		const lower = name.toLowerCase();
		for (const [k, v] of Object.entries(this._responseHeaders)) {
			if (k.toLowerCase() === lower) return v;
		}
		return null;
	}

	getAllResponseHeaders() {
		return Object.entries(this._responseHeaders)
			.map(([k, v]) => k + ": " + v)
			.join("\r\n");
	}

	overrideMimeType(mime) {
		this._overrideMime = mime;
	}

	send(body) {
		if (this.readyState !== 1) return;
		if (this._aborted) return;

		const xhr = this;
		this._fireEvent("loadstart");

		let url = this._url;
		if (url && !url.includes("://")) {
			try {
				const base = _domParse("document_url") || "about:blank";
				url = new URL(url, base).href;
			} catch (e) {}
		}

		fetch(url, {
			method: this._method,
			headers: this._headers,
			body: body || undefined,
			mode: "cors",
		})
			.then(async (resp) => {
				if (xhr._aborted) return;

				xhr.status = resp.status;
				xhr.statusText = resp.statusText || "";
				xhr.responseURL = resp.url || url;

				if (resp.headers) {
					resp.headers.forEach((v, k) => {
						xhr._responseHeaders[k] = v;
					});
				}

				xhr._setReadyState(2); // HEADERS_RECEIVED

				const text = await resp.text();
				if (xhr._aborted) return;

				xhr.responseText = text;
				xhr._setReadyState(3); // LOADING

				switch (xhr.responseType) {
					case "json":
						try {
							xhr.response = JSON.parse(text);
						} catch (e) {
							xhr.response = null;
						}
						break;
					case "text":
					case "":
						xhr.response = text;
						break;
					case "arraybuffer":
						xhr.response = new TextEncoder().encode(text).buffer;
						break;
					case "blob":
						xhr.response = new Blob([text]);
						break;
					case "document":
						xhr.response = text; // simplified
						break;
					default:
						xhr.response = text;
				}

				xhr._setReadyState(4); // DONE
				xhr._fireEvent("load");
				xhr._fireEvent("loadend");
			})
			.catch((err) => {
				if (xhr._aborted) return;
				xhr.status = 0;
				xhr.readyState = 4;
				xhr._fireEvent("readystatechange");
				if (err && err.__aborted) {
					xhr._aborted = true;
					xhr._fireEvent("abort");
					xhr._fireEvent("loadend");
					if (xhr.onabort) xhr.onabort(err);
				} else {
					xhr._fireEvent("error");
					xhr._fireEvent("loadend");
					if (xhr.onerror) xhr.onerror(err);
				}
			});
	}

	abort() {
		this._aborted = true;
		if (this.readyState > 0 && this.readyState < 4) {
			this._setReadyState(4);
			this._fireEvent("abort");
			this._fireEvent("loadend");
		}
		this.readyState = 0;
	}

	addEventListener(type, handler) {
		if (!this._listeners[type]) this._listeners[type] = [];
		this._listeners[type].push(handler);
	}

	removeEventListener(type, handler) {
		if (this._listeners[type]) {
			this._listeners[type] = this._listeners[type].filter((h) => h !== handler);
		}
	}

	_setReadyState(state) {
		this.readyState = state;
		this._fireEvent("readystatechange");
		if (this.onreadystatechange) {
			try {
				this.onreadystatechange();
			} catch (e) {}
		}
	}

	_fireEvent(type) {
		const event = { type, target: this, currentTarget: this, bubbles: false };
		const handlers = this._listeners[type] || [];
		for (const h of handlers) {
			try {
				h.call(this, event);
			} catch (e) {}
		}
		const prop = "on" + type;
		if (type !== "readystatechange" && typeof this[prop] === "function") {
			try {
				this[prop](event);
			} catch (e) {}
		}
	}
};
_markNative(XMLHttpRequest);
_markNative(XMLHttpRequest.prototype.open);
_markNative(XMLHttpRequest.prototype.send);
_markNative(XMLHttpRequest.prototype.abort);
_markNative(XMLHttpRequest.prototype.setRequestHeader);
_markNative(XMLHttpRequest.prototype.getResponseHeader);
_markNative(XMLHttpRequest.prototype.getAllResponseHeaders);

if (typeof URL === "undefined" || !URL.prototype) {
	globalThis.URL = class URL {
		constructor(url, base) {
			let full = url;
			if (base && !url.includes("://")) {
				var bm = base.match(/^(https?:\/\/[^/?#]+)(\/[^?#]*)?/);
				if (bm) {
					var bOrigin = bm[1];
					var bPath = bm[2] || "/";
					if (url.startsWith("/")) {
						full = bOrigin + url;
					} else if (url.startsWith("?") || url.startsWith("#")) {
						full = bOrigin + bPath + url;
					} else {
						var dir = bPath.substring(0, bPath.lastIndexOf("/") + 1);
						full = bOrigin + dir + url;
					}
				}
			}
			const m = full.match(/^(https?):\/\/([^/?#]+)(\/[^?#]*)?(\?[^#]*)?(#.*)?$/);
			if (m) {
				this.protocol = m[1] + ":";
				this.host = m[2];
				this.hostname = m[2].split(":")[0];
				this.port = m[2].includes(":") ? m[2].split(":")[1] : "";
				this.pathname = m[3] || "/";
				this.search = m[4] || "";
				this.hash = m[5] || "";
			} else {
				this.protocol = "";
				this.host = "";
				this.hostname = "";
				this.port = "";
				this.pathname = full;
				this.search = "";
				this.hash = "";
			}
			this.href = full;
			this.origin = this.protocol + "//" + this.host;
			this.searchParams = new URLSearchParams(this.search);
		}
		toString() {
			return this.href;
		}
		toJSON() {
			return this.href;
		}
		static createObjectURL() {
			return "blob:null/fake-" + Math.random().toString(36).slice(2);
		}
		static revokeObjectURL() {}
	};
}

globalThis.requestIdleCallback =
	globalThis.requestIdleCallback ||
	function requestIdleCallback(cb, opts) {
		const start = Date.now();
		return setTimeout(() => {
			cb({
				didTimeout: false,
				timeRemaining() {
					return Math.max(0, 50 - (Date.now() - start));
				},
			});
		}, 1);
	};
globalThis.cancelIdleCallback =
	globalThis.cancelIdleCallback ||
	function cancelIdleCallback(id) {
		clearTimeout(id);
	};
_markNative(globalThis.requestIdleCallback);
_markNative(globalThis.cancelIdleCallback);

if (typeof Request === "undefined") {
	globalThis.Request = class Request {
		constructor(input, init = {}) {
			if (typeof input === "string") {
				this.url = input;
			} else if (input instanceof Request) {
				this.url = input.url;
				init = { ...input, ...init };
			} else if (typeof URL === "function" && input instanceof URL) {
				this.url = input.href;
			} else {
				this.url = input?.url || input?.href || String(input);
			}
			this.method = (init.method || "GET").toUpperCase();
			this.headers = new Headers(init.headers);
			this.body = init.body || null;
			this.mode = init.mode || "cors";
			this.credentials = init.credentials || "same-origin";
			this.redirect = init.redirect || "follow";
			this.referrer = init.referrer || "";
			this.signal = init.signal || {
				aborted: false,
				addEventListener() {},
				removeEventListener() {},
			};
			this.cache = init.cache || "default";
		}
		clone() {
			return new Request(this.url, { method: this.method, headers: this.headers, body: this.body });
		}
		async text() {
			return this.body ? String(this.body) : "";
		}
		async json() {
			return JSON.parse(await this.text());
		}
		async arrayBuffer() {
			return new TextEncoder().encode(await this.text()).buffer;
		}
	};
}

if (typeof Response === "undefined") {
	globalThis.Response = class Response {
		constructor(body, init = {}) {
			this._bodyBytes = _bodyToUint8Array(body);
			this.status = init.status || 200;
			this.statusText = init.statusText || "";
			this.ok = this.status >= 200 && this.status < 300;
			this.headers = new Headers(init.headers);
			this.type = init.type || "basic";
			this.url = init.url || "";
			this.redirected = !!init.redirected;
		}
		async text() {
			return new TextDecoder().decode(this._bodyBytes);
		}
		async json() {
			return JSON.parse(await this.text());
		}
		async arrayBuffer() {
			return _arrayBufferFromBytes(this._bodyBytes);
		}
		async blob() {
			return new Blob([this._bodyBytes]);
		}
		clone() {
			return new Response(this._bodyBytes, {
				status: this.status,
				statusText: this.statusText,
				headers: this.headers,
				type: this.type,
				url: this.url,
				redirected: this.redirected,
			});
		}
		static error() {
			return new Response(null, { status: 0 });
		}
		static redirect(url, status) {
			return new Response(null, { status: status || 302, headers: { Location: url } });
		}
		static json(data, init) {
			return new Response(JSON.stringify(data), {
				...init,
				headers: { "content-type": "application/json", ...init?.headers },
			});
		}
	};
}

if (!Element.prototype.replaceWith) {
	Element.prototype.replaceWith = function (...nodes) {
		const parent = this.parentNode;
		if (!parent) return;
		for (const n of nodes) {
			if (typeof n === "string") parent.insertBefore(document.createTextNode(n), this);
			else parent.insertBefore(n, this);
		}
		parent.removeChild(this);
	};
	_markNative(Element.prototype.replaceWith);
}
if (!Element.prototype.before) {
	Element.prototype.before = function (...nodes) {
		const parent = this.parentNode;
		if (!parent) return;
		for (const n of nodes) {
			if (typeof n === "string") parent.insertBefore(document.createTextNode(n), this);
			else parent.insertBefore(n, this);
		}
	};
	_markNative(Element.prototype.before);
}
if (!Element.prototype.after) {
	Element.prototype.after = function (...nodes) {
		const parent = this.parentNode;
		if (!parent) return;
		const ref = this.nextSibling;
		for (const n of nodes) {
			if (typeof n === "string") parent.insertBefore(document.createTextNode(n), ref);
			else parent.insertBefore(n, ref);
		}
	};
	_markNative(Element.prototype.after);
}

if (!("isConnected" in Node.prototype)) {
	Object.defineProperty(Node.prototype, "isConnected", {
		get() {
			let node = this;
			while (node) {
				if (node.nodeType === 9) return true; // Document node
				node = node.parentNode;
			}
			return false;
		},
	});
}

globalThis.ResizeObserver = class ResizeObserver {
	constructor(callback) {
		this._callback = callback;
		this._targets = [];
	}
	observe(el) {
		this._targets.push(el);
		Promise.resolve().then(() => {
			this._callback(
				[
					{
						target: el,
						contentRect: {
							x: 0,
							y: 0,
							width: 100,
							height: 20,
							top: 0,
							left: 0,
							bottom: 20,
							right: 100,
						},
						borderBoxSize: [{ blockSize: 20, inlineSize: 100 }],
						contentBoxSize: [{ blockSize: 20, inlineSize: 100 }],
					},
				],
				this,
			);
		});
	}
	unobserve(el) {
		this._targets = this._targets.filter((t) => t !== el);
	}
	disconnect() {
		this._targets = [];
	}
};

if (typeof TextEncoder === "undefined") {
	globalThis.TextEncoder = class TextEncoder {
		get encoding() {
			return "utf-8";
		}
		encode(str) {
			str = String(str);
			const buf = [];
			for (let i = 0; i < str.length; i++) {
				let c = str.charCodeAt(i);
				if (c < 0x80) buf.push(c);
				else if (c < 0x800) {
					buf.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
				} else if (c < 0xd800 || c >= 0xe000) {
					buf.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
				} else {
					c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
					buf.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
				}
			}
			return new Uint8Array(buf);
		}
		encodeInto(str, dest) {
			const enc = this.encode(str);
			dest.set(enc.slice(0, dest.length));
			return { read: str.length, written: Math.min(enc.length, dest.length) };
		}
	};
}
if (typeof TextDecoder === "undefined") {
	globalThis.TextDecoder = class TextDecoder {
		constructor(label) {
			this.encoding = label || "utf-8";
		}
		decode(buf) {
			if (!buf) return "";
			const bytes = ArrayBuffer.isView(buf)
				? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)
				: new Uint8Array(buf);
			let str = "",
				i = 0;
			while (i < bytes.length) {
				const c = bytes[i++];
				if (c < 0x80) str += String.fromCharCode(c);
				else if (c < 0xe0) str += String.fromCharCode(((c & 0x1f) << 6) | (bytes[i++] & 0x3f));
				else if (c < 0xf0) {
					const b1 = bytes[i++],
						b2 = bytes[i++];
					str += String.fromCharCode(((c & 0x0f) << 12) | ((b1 & 0x3f) << 6) | (b2 & 0x3f));
				} else {
					const b1 = bytes[i++],
						b2 = bytes[i++],
						b3 = bytes[i++];
					const cp = ((c & 0x07) << 18) | ((b1 & 0x3f) << 12) | ((b2 & 0x3f) << 6) | (b3 & 0x3f);
					if (cp > 0xffff) {
						const s = cp - 0x10000;
						str += String.fromCharCode(0xd800 + (s >> 10), 0xdc00 + (s & 0x3ff));
					} else str += String.fromCharCode(cp);
				}
			}
			return str;
		}
	};
}

globalThis.matchMedia = _markNative(function matchMedia(q) {
	return {
		matches: false,
		media: q,
		addListener() {},
		removeListener() {},
		addEventListener() {},
		removeEventListener() {},
		dispatchEvent() {
			return true;
		},
	};
});
globalThis.getComputedStyle = (el) => {
	if (!el) el = document.body || {};
	const style = el?.style || el?._style || new CSSStyleDeclaration();
	return new Proxy(style, {
		get(target, prop) {
			if (prop === Symbol.toPrimitive || prop === Symbol.toStringTag) return undefined;
			if (prop in target) return target[prop];
			if (typeof prop === "string") {
				const v = target.getPropertyValue ? target.getPropertyValue(prop) : "";
				if (v) return v;
				const defaults = {
					display: "block",
					visibility: "visible",
					opacity: "1",
					position: "static",
					overflow: "visible",
					transform: "none",
					transition: "none",
					animation: "none",
					float: "none",
					clear: "none",
					width: "auto",
					height: "auto",
					top: "auto",
					left: "auto",
					right: "auto",
					bottom: "auto",
					margin: "0px",
					padding: "0px",
					"margin-top": "0px",
					"margin-right": "0px",
					"margin-bottom": "0px",
					"margin-left": "0px",
					"padding-top": "0px",
					"padding-right": "0px",
					"padding-bottom": "0px",
					"padding-left": "0px",
					"font-size": "16px",
					"line-height": "normal",
					"font-weight": "400",
					color: "rgb(0, 0, 0)",
					"background-color": "rgba(0, 0, 0, 0)",
					"border-width": "0px",
					"border-style": "none",
					"border-color": "rgb(0, 0, 0)",
					"z-index": "auto",
					"pointer-events": "auto",
					"box-sizing": "content-box",
					cursor: "auto",
				};
				const kebabProp = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
				if (defaults[prop]) return defaults[prop];
				if (defaults[kebabProp]) return defaults[kebabProp];
				return "";
			}
			if (prop === "getPropertyValue") {
				return (name) => {
					const v = target.getPropertyValue ? target.getPropertyValue(name) : "";
					if (v) return v;
					const defaults = {
						transform: "none",
						opacity: "1",
						display: "block",
						visibility: "visible",
					};
					return defaults[name] || defaults[name.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] || "";
				};
			}
			if (prop === "length") return 0;
			return undefined;
		},
	});
};
globalThis.getSelection = _markNative(function getSelection() {
	return {
		rangeCount: 0,
		anchorNode: null,
		anchorOffset: 0,
		focusNode: null,
		focusOffset: 0,
		isCollapsed: true,
		type: "None",
		removeAllRanges() {
			this.rangeCount = 0;
		},
		addRange(range) {
			this.rangeCount = 1;
			this._range = range;
		},
		getRangeAt(i) {
			return this._range || null;
		},
		collapse(node, offset) {
			this.anchorNode = node;
			this.anchorOffset = offset || 0;
			this.isCollapsed = true;
		},
		extend(node, offset) {
			this.focusNode = node;
			this.focusOffset = offset || 0;
		},
		selectAllChildren(node) {},
		deleteFromDocument() {},
		containsNode(node) {
			return false;
		},
		toString() {
			return "";
		},
	};
});

globalThis.CSSStyleSheet = class CSSStyleSheet {
	constructor(options) {
		this.cssRules = [];
		this.ownerRule = null;
		this.disabled = false;
		this._rules = [];
	}
	insertRule(rule, index) {
		const idx = index ?? this._rules.length;
		this._rules.splice(idx, 0, { cssText: rule, type: 1 });
		this.cssRules = this._rules;
		return idx;
	}
	deleteRule(index) {
		this._rules.splice(index, 1);
		this.cssRules = this._rules;
	}
	addRule(selector, style, index) {
		return this.insertRule(selector + "{" + style + "}", index);
	}
	removeRule(index) {
		this.deleteRule(index);
	}
	replace(text) {
		this._rules = [{ cssText: text, type: 1 }];
		this.cssRules = this._rules;
		return Promise.resolve(this);
	}
	replaceSync(text) {
		this._rules = [{ cssText: text, type: 1 }];
		this.cssRules = this._rules;
	}
};

Object.defineProperty(Document.prototype, "adoptedStyleSheets", {
	get() {
		return this._adoptedStyleSheets || [];
	},
	set(sheets) {
		this._adoptedStyleSheets = sheets;
	},
});

globalThis.__mutationObservers = [];
globalThis.MutationObserver = class MutationObserver {
	constructor(callback) {
		this._callback = callback;
		this._targets = [];
		this._records = [];
	}
	observe(target, options) {
		this._targets.push({ target, options: options || {} });
		globalThis.__mutationObservers.push(this);
	}
	disconnect() {
		this._targets = [];
		const idx = globalThis.__mutationObservers.indexOf(this);
		if (idx >= 0) globalThis.__mutationObservers.splice(idx, 1);
	}
	takeRecords() {
		const r = this._records.slice();
		this._records = [];
		return r;
	}
	_notify(records) {
		this._records.push(...records);
		Promise.resolve().then(() => {
			if (this._records.length > 0) {
				const batch = this._records.splice(0);
				try {
					this._callback(batch, this);
				} catch (e) {
					/* observer errors shouldn't propagate */
				}
			}
		});
	}
};
globalThis.__notifyMutation = function (type, target_nid, addedNodes, removedNodes, attributeName) {
	if (!globalThis.__mutationObservers.length) return;
	const target = globalThis._cache?.get(target_nid) || null;
	if (!target) return;
	const record = {
		type: type, // 'childList', 'attributes', 'characterData'
		target: target,
		addedNodes: (addedNodes || []).map((nid) => globalThis._cache?.get(nid) || null).filter(Boolean),
		removedNodes: (removedNodes || []).map((nid) => globalThis._cache?.get(nid) || null).filter(Boolean),
		attributeName: attributeName || null,
		oldValue: null,
		previousSibling: null,
		nextSibling: null,
	};
	for (const obs of globalThis.__mutationObservers) {
		for (const t of obs._targets) {
			if (t.target._nid === target_nid || (t.options.subtree && target.contains && target.closest && true)) {
				obs._notify([record]);
				break;
			}
		}
	}
};

globalThis.ShadowRoot = class ShadowRoot {};
globalThis.customElements = {
	_registry: new Map(),
	define(name, cls, opts) {
		this._registry.set(name, cls);
	},
	get(name) {
		return this._registry.get(name);
	},
	whenDefined(name) {
		return Promise.resolve(this._registry.get(name));
	},
	upgrade() {},
};
globalThis.NodeFilter = { SHOW_ELEMENT: 1, SHOW_TEXT: 4, SHOW_ALL: 0xffffffff };
globalThis.ResizeObserver = class {
	constructor() {}
	observe() {}
	unobserve() {}
	disconnect() {}
};
globalThis.IntersectionObserver = class {
	constructor(callback) {
		this._callback = callback;
	}
	observe(el) {
		Promise.resolve().then(() => {
			this._callback(
				[
					{
						target: el,
						isIntersecting: true,
						intersectionRatio: 1,
						boundingClientRect: el.getBoundingClientRect
							? el.getBoundingClientRect()
							: { x: 0, y: 0, width: 100, height: 20 },
						intersectionRect: el.getBoundingClientRect
							? el.getBoundingClientRect()
							: { x: 0, y: 0, width: 100, height: 20 },
						rootBounds: { x: 0, y: 0, width: 1280, height: 720 },
					},
				],
				this,
			);
		});
	}
	unobserve() {}
	disconnect() {}
};
globalThis.PerformanceObserver = class {
	constructor() {}
	observe() {}
	disconnect() {}
};

globalThis.Event = class Event {
	constructor(t, o = {}) {
		this.type = t;
		this.bubbles = !!o.bubbles;
		this.cancelable = !!o.cancelable;
		this.composed = !!o.composed;
		this.defaultPrevented = false;
		this.target = null;
		this.currentTarget = null;
		this.eventPhase = 0;
		this.timeStamp = Date.now();
		this._propagationStopped = false;
		this._immediatePropagationStopped = false;
	}
	get isTrusted() {
		return true;
	}
	preventDefault() {
		if (this.cancelable) this.defaultPrevented = true;
	}
	stopPropagation() {
		this._propagationStopped = true;
	}
	stopImmediatePropagation() {
		this._propagationStopped = true;
		this._immediatePropagationStopped = true;
	}
	initEvent(type, bubbles, cancelable) {
		this.type = type;
		this.bubbles = !!bubbles;
		this.cancelable = !!cancelable;
		this.defaultPrevented = false;
		this._propagationStopped = false;
		this._immediatePropagationStopped = false;
	}
};
globalThis.CustomEvent = class extends Event {
	constructor(t, o = {}) {
		super(t, o);
		this.detail = o.detail;
	}
	// Legacy DOM Level 2 init; some libraries (Starbucks China bundle, older
	// analytics shims) still call createEvent('CustomEvent') + initCustomEvent
	// instead of new CustomEvent(...). See issue #41.
	initCustomEvent(type, bubbles, cancelable, detail) {
		this.type = type;
		this.bubbles = !!bubbles;
		this.cancelable = !!cancelable;
		this.detail = detail;
	}
};
globalThis.MouseEvent = class extends Event {
	constructor(t, o = {}) {
		super(t, o);
		this.clientX = o.clientX || 0;
		this.clientY = o.clientY || 0;
	}
};
globalThis.KeyboardEvent = class extends Event {
	constructor(t, o = {}) {
		super(t, o);
		this.key = o.key || "";
		this.code = o.code || "";
	}
};
globalThis.FocusEvent = class extends Event {};
globalThis.InputEvent = class extends Event {
	constructor(t, o = {}) {
		super(t, o);
		this.data = o.data || null;
		this.inputType = o.inputType || "";
	}
};
globalThis.ErrorEvent = class extends Event {
	constructor(t, o = {}) {
		super(t, o);
		this.message = o.message || "";
		this.error = o.error || null;
	}
};
globalThis.PointerEvent = class extends Event {
	constructor(t, o = {}) {
		super(t, o);
	}
};
globalThis.AnimationEvent = class extends Event {};
globalThis.TransitionEvent = class extends Event {};
globalThis.UIEvent = class extends Event {};
globalThis.WheelEvent = class extends Event {};
globalThis.PopStateEvent = class extends Event {};
globalThis.HashChangeEvent = class extends Event {};
globalThis.MessageEvent = class extends Event {
	constructor(t, o = {}) {
		super(t, o);
		this.data = o.data;
	}
};
globalThis.ClipboardEvent = class extends Event {};
globalThis.SubmitEvent = class extends Event {};

globalThis.AbortController = class AbortController {
	constructor() {
		this.signal = {
			aborted: false,
			addEventListener() {},
			removeEventListener() {},
			onabort: null,
		};
	}
	abort() {
		this.signal.aborted = true;
	}
};
globalThis.AbortSignal = {
	timeout(ms) {
		return { aborted: false, addEventListener() {}, removeEventListener() {} };
	},
};
if (typeof Blob === "undefined")
	globalThis.Blob = class Blob {
		constructor(parts = [], opts = {}) {
			this._data = parts.join("");
			this.size = this._data.length;
			this.type = opts.type || "";
		}
		async text() {
			return this._data;
		}
	};
if (typeof File === "undefined")
	globalThis.File = class extends Blob {
		constructor(parts, name, opts) {
			super(parts, opts);
			this.name = name;
		}
	};
if (typeof FormData === "undefined")
	globalThis.FormData = class FormData {
		constructor() {
			this._d = [];
		}
		append(k, v) {
			this._d.push([k, v]);
		}
		get(k) {
			const e = this._d.find(([a]) => a === k);
			return e ? e[1] : null;
		}
		getAll(k) {
			return this._d.filter(([a]) => a === k).map(([, v]) => v);
		}
		has(k) {
			return this._d.some(([a]) => a === k);
		}
		entries() {
			return this._d[Symbol.iterator]();
		}
		forEach(cb) {
			this._d.forEach(([k, v]) => cb(v, k));
		}
	};
if (typeof URLSearchParams === "undefined")
	globalThis.URLSearchParams = class {
		constructor(init = "") {
			this._p = [];
			if (typeof init === "string") {
				init.replace(/^\?/, "")
					.split("&")
					.forEach((p) => {
						const [k, ...v] = p.split("=");
						if (k) this.append(decodeURIComponent(k), decodeURIComponent(v.join("=")));
					});
			} else if (init && typeof init[Symbol.iterator] === "function") {
				for (const pair of init) if (pair && pair.length >= 2) this.append(pair[0], pair[1]);
			} else if (init && typeof init === "object") {
				Object.keys(init).forEach((k) => this.append(k, init[k]));
			}
		}
		append(k, v) {
			this._p.push([String(k), String(v)]);
		}
		get(k) {
			const p = this._p.find(([key]) => key === String(k));
			return p ? p[1] : null;
		}
		set(k, v) {
			this.delete(k);
			this.append(k, v);
		}
		delete(k) {
			k = String(k);
			this._p = this._p.filter(([key]) => key !== k);
		}
		has(k) {
			k = String(k);
			return this._p.some(([key]) => key === k);
		}
		toString() {
			return this._p.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
		}
		forEach(cb) {
			this._p.forEach(([k, v]) => cb(v, k, this));
		}
	};

globalThis.DOMParser = class {
	parseFromString(s, t) {
		return globalThis.document;
	}
};
globalThis.XMLSerializer = class XMLSerializer {
	serializeToString(node) {
		if (!node) return "";
		if (node.nodeType === 10) {
			let s = "<!DOCTYPE " + (node.name || "html");
			if (node.publicId) s += ' PUBLIC "' + node.publicId + '"';
			if (node.systemId) {
				if (!node.publicId) s += " SYSTEM";
				s += ' "' + node.systemId + '"';
			}
			s += ">";
			return s;
		}
		if (node.outerHTML !== undefined) return node.outerHTML;
		if (node.nodeType === 9) {
			let s = "";
			if (node.doctype) s += this.serializeToString(node.doctype);
			if (node.documentElement) s += node.documentElement.outerHTML;
			return s;
		}
		if (node.nodeType === 3) return node.textContent || "";
		if (node.nodeType === 8) return "<!--" + (node.textContent || "") + "-->";
		return "";
	}
};
globalThis.performance = globalThis.performance || {
	now: () => Date.now(),
	mark() {},
	measure() {},
	clearMarks() {},
	clearMeasures() {},
	clearResourceTimings() {},
	getEntries() {
		return [];
	},
	getEntriesByName() {
		return [];
	},
	getEntriesByType() {
		return [];
	},
	setResourceTimingBufferSize() {},
	timeOrigin: 0,
	timing: { navigationStart: 0, domContentLoadedEventEnd: 0, loadEventEnd: 0 },
	navigation: { type: 0, redirectCount: 0 },
	memory: {
		jsHeapSizeLimit: 2172649472,
		totalJSHeapSize: 19321856,
		usedJSHeapSize: 16781520,
	},
};

Object.defineProperty(Document.prototype, "fonts", {
	get() {
		return {
			ready: Promise.resolve(),
			check() {
				return true;
			},
			load() {
				return Promise.resolve([]);
			},
			add() {},
			delete() {
				return false;
			},
			clear() {},
			has() {
				return false;
			},
			forEach() {},
			get size() {
				return 0;
			},
			get status() {
				return "loaded";
			},
			addEventListener() {},
			removeEventListener() {},
			dispatchEvent() {
				return true;
			},
			[Symbol.iterator]() {
				return [][Symbol.iterator]();
			},
		};
	},
	configurable: true,
});
globalThis.crypto = globalThis.crypto || {
	getRandomValues(arr) {
		for (let i = 0; i < arr.length; i++) arr[i] = Math.floor(Math.random() * 256);
		return arr;
	},
	randomUUID() {
		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
			const r = (Math.random() * 16) | 0;
			return (c === "x" ? r : (r & 3) | 8).toString(16);
		});
	},
};
globalThis.structuredClone = globalThis.structuredClone || ((v) => JSON.parse(JSON.stringify(v)));
globalThis.reportError = globalThis.reportError || ((e) => console.error(e));

const _mkStore = () => {
	const s = {};
	return {
		getItem: (k) => s[k] ?? null,
		setItem: (k, v) => {
			s[k] = String(v);
		},
		removeItem: (k) => {
			delete s[k];
		},
		clear: () => {
			for (const k in s) delete s[k];
		},
		get length() {
			return Object.keys(s).length;
		},
		key: (i) => Object.keys(s)[i] ?? null,
	};
};
globalThis.localStorage = _mkStore();
globalThis.sessionStorage = _mkStore();

globalThis.btoa =
	globalThis.btoa ||
	((s) => {
		const b = new TextEncoder().encode(s);
		const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		let r = "";
		for (let i = 0; i < b.length; i += 3) {
			const a = b[i],
				bb = b[i + 1] ?? 0,
				cc = b[i + 2] ?? 0;
			r +=
				c[a >> 2] +
				c[((a & 3) << 4) | (bb >> 4)] +
				(i + 1 < b.length ? c[((bb & 15) << 2) | (cc >> 6)] : "=") +
				(i + 2 < b.length ? c[cc & 63] : "=");
		}
		return r;
	});
globalThis.atob =
	globalThis.atob ||
	((s) => {
		const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		const r = [];
		for (let i = 0; i < s.length; i += 4) {
			const a = c.indexOf(s[i]),
				b = c.indexOf(s[i + 1]),
				cc = c.indexOf(s[i + 2]),
				d = c.indexOf(s[i + 3]);
			r.push((a << 2) | (b >> 4));
			if (cc >= 0) r.push(((b & 15) << 4) | (cc >> 2));
			if (d >= 0) r.push(((cc & 3) << 6) | d);
		}
		return String.fromCharCode(...r);
	});

globalThis.history = {
	length: 1,
	state: null,
	pushState() {},
	replaceState() {},
	go() {},
	back() {},
	forward() {},
	scrollRestoration: "auto",
};
globalThis.screenX = 0;
globalThis.screenY = 0;
globalThis.screenLeft = 0;
globalThis.screenTop = 0;
globalThis.pageXOffset = 0;
globalThis.pageYOffset = 0;
globalThis.scrollX = 0;
globalThis.scrollY = 0;

globalThis.CSS = {
	supports() {
		return false;
	},
	escape(s) {
		return s;
	},
};

globalThis.HTMLElement = Element;
globalThis.HTMLDivElement = Element;
globalThis.HTMLSpanElement = Element;
globalThis.HTMLParagraphElement = Element;
globalThis.HTMLAnchorElement = Element;
globalThis.HTMLImageElement = Element;
globalThis.HTMLInputElement = Element;
globalThis.HTMLButtonElement = Element;
globalThis.HTMLFormElement = Element;
globalThis.HTMLSelectElement = Element;
globalThis.HTMLTextAreaElement = Element;
globalThis.HTMLLabelElement = Element;
globalThis.HTMLTableElement = Element;
globalThis.HTMLIFrameElement = Element;
globalThis.HTMLCanvasElement = Element;
globalThis.HTMLVideoElement = Element;
globalThis.HTMLAudioElement = Element;
globalThis.HTMLScriptElement = Element;
globalThis.HTMLStyleElement = Element;
globalThis.HTMLLinkElement = Element;
globalThis.HTMLMetaElement = Element;
globalThis.HTMLHeadElement = Element;
globalThis.HTMLBodyElement = Element;
globalThis.HTMLHtmlElement = Element;
globalThis.HTMLBRElement = Element;
globalThis.HTMLHRElement = Element;
globalThis.HTMLUListElement = Element;
globalThis.HTMLOListElement = Element;
globalThis.HTMLLIElement = Element;
globalThis.HTMLPreElement = Element;
globalThis.HTMLHeadingElement = Element;
globalThis.HTMLTemplateElement = Element;
globalThis.HTMLSlotElement = Element;
globalThis.HTMLOptionElement = Element;
globalThis.HTMLDataListElement = Element;
globalThis.HTMLFieldSetElement = Element;
globalThis.HTMLLegendElement = Element;
globalThis.HTMLProgressElement = Element;
globalThis.HTMLDetailsElement = Element;
globalThis.HTMLDialogElement = Element;
globalThis.SVGElement = Element;
globalThis.SVGSVGElement = Element;
globalThis.CharacterData = CharacterData;
globalThis.Text = Text;
globalThis.Comment = Comment;
globalThis.DocumentFragment = DocumentFragment;
globalThis.DocumentType = DocumentType;
globalThis.Node = Node;
globalThis.Element = Element;
globalThis.Document = Document;
globalThis.EventTarget = Node;
globalThis.Range = class Range {
	setStart() {}
	setEnd() {}
	collapse() {}
	selectNodeContents() {}
	deleteContents() {}
	cloneContents() {
		return document.createDocumentFragment();
	}
	insertNode() {}
	getBoundingClientRect() {
		return { x: 0, y: 0, width: 0, height: 0, top: 0, right: 0, bottom: 0, left: 0 };
	}
};

[
	navigator.getBattery,
	navigator.getGamepads,
	navigator.sendBeacon,
	navigator.javaEnabled,
	navigator.serviceWorker?.register,
	navigator.permissions?.query,
	navigator.credentials?.get,
	globalThis.fetch,
	globalThis.matchMedia,
	globalThis.getComputedStyle,
	globalThis.getSelection,
	globalThis.requestAnimationFrame,
	globalThis.cancelAnimationFrame,
	globalThis.setTimeout,
	globalThis.clearTimeout,
	globalThis.setInterval,
	globalThis.clearInterval,
	globalThis.queueMicrotask,
	globalThis.structuredClone,
	globalThis.reportError,
	globalThis.btoa,
	globalThis.atob,
	console.log,
	console.warn,
	console.error,
	console.info,
	console.debug,
	console.dir,
	console.assert,
	Element.prototype.getAttribute,
	Element.prototype.setAttribute,
	Element.prototype.removeAttribute,
	Element.prototype.hasAttribute,
	Element.prototype.querySelector,
	Element.prototype.querySelectorAll,
	Element.prototype.getElementsByTagName,
	Element.prototype.getElementsByClassName,
	Element.prototype.matches,
	Element.prototype.closest,
	Element.prototype.getBoundingClientRect,
	Element.prototype.getClientRects,
	Element.prototype.addEventListener,
	Element.prototype.removeEventListener,
	Element.prototype.dispatchEvent,
	Element.prototype.click,
	Element.prototype.focus,
	Element.prototype.blur,
	Element.prototype.cloneNode,
	Element.prototype.attachShadow,
	Element.prototype.insertAdjacentHTML,
	Element.prototype.scrollIntoView,
	Element.prototype.append,
	Element.prototype.remove,
	Element.prototype.getContext,
	Element.prototype.toDataURL,
	Element.prototype.toBlob,
	Node.prototype.appendChild,
	Node.prototype.removeChild,
	Node.prototype.replaceChild,
	Node.prototype.insertBefore,
	Node.prototype.contains,
	Node.prototype.hasChildNodes,
	Node.prototype.cloneNode,
	Document.prototype.getElementById,
	Document.prototype.querySelector,
	Document.prototype.querySelectorAll,
	Document.prototype.getElementsByTagName,
	Document.prototype.createElement,
	Document.prototype.createElementNS,
	Document.prototype.createTextNode,
	Document.prototype.createComment,
	Document.prototype.createDocumentFragment,
	Document.prototype.createEvent,
	Document.prototype.hasFocus,
	Notification,
	Notification.requestPermission,
	window.chrome?.csi,
	window.chrome?.loadTimes,
	MutationObserver,
	ResizeObserver,
	IntersectionObserver,
	PerformanceObserver,
	XMLSerializer,
	XMLSerializer.prototype.serializeToString,
].forEach((fn) => {
	if (typeof fn === "function") _markNative(fn);
});

class _IframeDocument {
	constructor(html, url, iframeEl) {
		this._url = url;
		this._iframeEl = iframeEl;
		this.nodeType = 9;
		this.nodeName = "#document";
		this.readyState = "complete";
		this.characterSet = "UTF-8";
		this.contentType = "text/html";
		this.visibilityState = "visible";
		this.hidden = false;

		this._root = document.createElement("html");
		this._head = document.createElement("head");
		this._body = document.createElement("body");
		this._root.appendChild(this._head);
		this._root.appendChild(this._body);
		var bodyContent = html
			.replace(/^<!DOCTYPE[^>]*>/i, "")
			.replace(/<\/?html[^>]*>/gi, "")
			.replace(/<head[^>]*>[\s\S]*?<\/head>/gi, "")
			.replace(/<\/?body[^>]*>/gi, "")
			.replace(/^\s+/, ""); // trim leading whitespace (before <body> content)
		if (bodyContent) {
			this._body.innerHTML = bodyContent;
		}

		this._title = "";
		if (this._head) {
			const titleEl = this._head.querySelector("title");
			if (titleEl) this._title = titleEl.textContent;
		}
	}

	get documentElement() {
		return this._root;
	}
	get head() {
		return this._head;
	}
	get body() {
		return this._body;
	}
	get title() {
		return this._title;
	}
	set title(v) {
		this._title = v;
	}
	get URL() {
		return this._url;
	}
	get documentURI() {
		return this._url;
	}
	get location() {
		return this._iframeEl?.contentWindow?.location;
	}
	get defaultView() {
		return this._iframeEl?.contentWindow;
	}
	get ownerDocument() {
		return null;
	}
	get compatMode() {
		return "CSS1Compat";
	}
	get activeElement() {
		return this._body;
	}

	getElementById(id) {
		return this._root.querySelector("#" + id);
	}
	querySelector(sel) {
		return this._root.querySelector(sel);
	}
	querySelectorAll(sel) {
		return this._root.querySelectorAll(sel);
	}
	getElementsByTagName(tag) {
		return this._root.querySelectorAll(tag);
	}
	getElementsByClassName(cls) {
		return this._root.querySelectorAll("." + cls);
	}
	createElement(tag) {
		return document.createElement(tag);
	}
	createElementNS(ns, tag) {
		return document.createElementNS(ns, tag);
	}
	createTextNode(text) {
		return document.createTextNode(text);
	}
	createComment(text) {
		return document.createComment(text);
	}
	createDocumentFragment() {
		return document.createDocumentFragment();
	}
	createEvent(type) {
		return document.createEvent(type);
	}
	hasFocus() {
		return false;
	}

	get cookie() {
		return "";
	}
	set cookie(v) {}
	get implementation() {
		return document.implementation;
	}
	get styleSheets() {
		return [];
	}

	addEventListener() {}
	removeEventListener() {}
	dispatchEvent() {
		return true;
	}

	write(html) {
		if (this._body) this._body.innerHTML += html;
	}
	writeln(html) {
		this.write(html + "\n");
	}
	open() {
		if (this._body) this._body.innerHTML = "";
	}
	close() {}
}

class _IframeWindow {
	constructor(doc, url) {
		this.document = doc;
		this._url = url;
		this.self = this;
		this.top = globalThis;
		this.parent = globalThis;
		this.window = this;
		this.frames = this;
		this.frameElement = null;
		this.length = 0;
		this.name = "";
		this.closed = false;
		this.navigator = globalThis.navigator;
		this.screen = globalThis.screen;
		this.innerWidth = 300;
		this.innerHeight = 150;
		this.outerWidth = 300;
		this.outerHeight = 150;
		this.devicePixelRatio = globalThis.devicePixelRatio;
		this.localStorage = globalThis.localStorage;
		this.sessionStorage = globalThis.sessionStorage;
		this.performance = globalThis.performance;
		this.crypto = globalThis.crypto;
		this.console = globalThis.console;
		this.chrome = globalThis.chrome;

		try {
			const u = new URL(url);
			this.location = {
				href: url,
				origin: u.origin,
				protocol: u.protocol,
				host: u.host,
				hostname: u.hostname,
				port: u.port,
				pathname: u.pathname,
				search: u.search,
				hash: u.hash,
				toString() {
					return url;
				},
				assign() {},
				reload() {},
				replace() {},
			};
		} catch (e) {
			this.location = {
				href: url,
				origin: "",
				protocol: "",
				host: "",
				hostname: "",
				port: "",
				pathname: "/",
				search: "",
				hash: "",
				toString() {
					return url;
				},
				assign() {},
				reload() {},
				replace() {},
			};
		}
	}

	postMessage(data, origin) {
		const event = new MessageEvent("message", {
			data: data,
			origin: this.location.origin,
			source: this,
		});
		Promise.resolve().then(() => {
			globalThis.dispatchEvent?.(event);
		});
	}

	setTimeout(fn, ms) {
		return globalThis.setTimeout(fn, ms);
	}
	clearTimeout(id) {
		globalThis.clearTimeout(id);
	}
	setInterval(fn, ms) {
		return globalThis.setInterval(fn, ms);
	}
	clearInterval(id) {
		globalThis.clearInterval(id);
	}
	requestAnimationFrame(fn) {
		return globalThis.requestAnimationFrame(fn);
	}

	addEventListener(type, fn) {
		if (!this._listeners) this._listeners = {};
		if (!this._listeners[type]) this._listeners[type] = [];
		this._listeners[type].push(fn);
	}
	removeEventListener(type, fn) {
		if (this._listeners?.[type]) {
			this._listeners[type] = this._listeners[type].filter((h) => h !== fn);
		}
	}
	dispatchEvent(event) {
		const handlers = this._listeners?.[event?.type] || [];
		for (const h of handlers) {
			try {
				h.call(this, event);
			} catch (e) {}
		}
		return true;
	}

	getComputedStyle(el) {
		return globalThis.getComputedStyle(el);
	}
	matchMedia(q) {
		return globalThis.matchMedia(q);
	}
	getSelection() {
		return globalThis.getSelection();
	}
	fetch(input, init) {
		return globalThis.fetch(input, init);
	}
	close() {
		this.closed = true;
	}
	focus() {}
	blur() {}
}

globalThis.__ariaQuerySelector = function (root, selector) {
	return null;
};
globalThis.__ariaQuerySelectorAll = async function* (root, selector) {
	/* yields nothing */
};
class _Canvas2D {
	constructor(canvas) {
		this.canvas = canvas;
		this._w = canvas.width || 300;
		this._h = canvas.height || 150;
		this._buf = new Uint8ClampedArray(this._w * this._h * 4);
		for (let i = 0; i < this._w * this._h; i++) {
			this._buf[i * 4 + 0] = 255 + Math.floor(_fpNoise(i % this._w, Math.floor(i / this._w), 0));
			this._buf[i * 4 + 1] = 255 + Math.floor(_fpNoise(i % this._w, Math.floor(i / this._w), 1));
			this._buf[i * 4 + 2] = 255 + Math.floor(_fpNoise(i % this._w, Math.floor(i / this._w), 2));
			this._buf[i * 4 + 3] = 255;
		}
		this.fillStyle = "#000000";
		this.strokeStyle = "#000000";
		this.lineWidth = 1;
		this.font = "10px sans-serif";
		this.textAlign = "start";
		this.textBaseline = "alphabetic";
		this.globalAlpha = 1;
		this.globalCompositeOperation = "source-over";
		this._stateStack = [];
	}
	_parseColor(css) {
		if (!css || css === "none") return [0, 0, 0, 0];
		if (css.startsWith("#")) {
			const hex = css.slice(1);
			if (hex.length === 3)
				return [
					parseInt(hex[0] + hex[0], 16),
					parseInt(hex[1] + hex[1], 16),
					parseInt(hex[2] + hex[2], 16),
					255,
				];
			if (hex.length === 6)
				return [
					parseInt(hex.slice(0, 2), 16),
					parseInt(hex.slice(2, 4), 16),
					parseInt(hex.slice(4, 6), 16),
					255,
				];
			if (hex.length === 8)
				return [
					parseInt(hex.slice(0, 2), 16),
					parseInt(hex.slice(2, 4), 16),
					parseInt(hex.slice(4, 6), 16),
					parseInt(hex.slice(6, 8), 16),
				];
		}
		const m = css.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
		if (m) return [+m[1], +m[2], +m[3], m[4] !== undefined ? Math.round(+m[4] * 255) : 255];
		const named = {
			red: [255, 0, 0, 255],
			green: [0, 128, 0, 255],
			blue: [0, 0, 255, 255],
			white: [255, 255, 255, 255],
			black: [0, 0, 0, 255],
			yellow: [255, 255, 0, 255],
			orange: [255, 165, 0, 255],
			gray: [128, 128, 128, 255],
			transparent: [0, 0, 0, 0],
		};
		return named[css] || [0, 0, 0, 255];
	}
	_setPixel(x, y, r, g, b, a) {
		x = Math.round(x);
		y = Math.round(y);
		if (x < 0 || x >= this._w || y < 0 || y >= this._h) return;
		const idx = (y * this._w + x) * 4;
		const alpha = (a / 255) * this.globalAlpha;
		this._buf[idx + 0] = Math.round(r * alpha + this._buf[idx + 0] * (1 - alpha));
		this._buf[idx + 1] = Math.round(g * alpha + this._buf[idx + 1] * (1 - alpha));
		this._buf[idx + 2] = Math.round(b * alpha + this._buf[idx + 2] * (1 - alpha));
		this._buf[idx + 3] = Math.min(255, Math.round(a * alpha + this._buf[idx + 3] * (1 - alpha)));
	}
	fillRect(x, y, w, h) {
		const [r, g, b, a] = this._parseColor(this.fillStyle);
		x = Math.round(x);
		y = Math.round(y);
		w = Math.round(w);
		h = Math.round(h);
		for (let py = Math.max(0, y); py < Math.min(this._h, y + h); py++) {
			for (let px = Math.max(0, x); px < Math.min(this._w, x + w); px++) {
				this._setPixel(px, py, r, g, b, a);
			}
		}
	}
	clearRect(x, y, w, h) {
		x = Math.round(x);
		y = Math.round(y);
		w = Math.round(w);
		h = Math.round(h);
		for (let py = Math.max(0, y); py < Math.min(this._h, y + h); py++) {
			for (let px = Math.max(0, x); px < Math.min(this._w, x + w); px++) {
				const idx = (py * this._w + px) * 4;
				this._buf[idx] = this._buf[idx + 1] = this._buf[idx + 2] = this._buf[idx + 3] = 0;
			}
		}
	}
	strokeRect(x, y, w, h) {
		const [r, g, b, a] = this._parseColor(this.strokeStyle);
		const lw = this.lineWidth;
		for (let px = Math.round(x); px < Math.round(x + w); px++) {
			for (let l = 0; l < lw; l++) {
				this._setPixel(px, Math.round(y) + l, r, g, b, a);
				this._setPixel(px, Math.round(y + h) - 1 - l, r, g, b, a);
			}
		}
		for (let py = Math.round(y); py < Math.round(y + h); py++) {
			for (let l = 0; l < lw; l++) {
				this._setPixel(Math.round(x) + l, py, r, g, b, a);
				this._setPixel(Math.round(x + w) - 1 - l, py, r, g, b, a);
			}
		}
	}
	fillText(text, x, y) {
		const [r, g, b, a] = this._parseColor(this.fillStyle);
		const fontSize = parseInt(this.font) || 10;
		const scale = Math.max(1, Math.round(fontSize / 10));
		const str = String(text);
		let cx = Math.round(x);
		for (let i = 0; i < str.length; i++) {
			const code = str.charCodeAt(i);
			for (let row = 0; row < 7; row++) {
				for (let col = 0; col < 5; col++) {
					const on =
						(_fpRand(code * 100 + row * 10 + col) > 0.45 && row > 0 && row < 6 && col > 0 && col < 4) ||
						_fpRand(code * 200 + row * 7 + col) > 0.7;
					if (on) {
						for (let sy = 0; sy < scale; sy++) {
							for (let sx = 0; sx < scale; sx++) {
								this._setPixel(
									cx + col * scale + sx,
									Math.round(y) - 7 * scale + row * scale + sy,
									r,
									g,
									b,
									a,
								);
							}
						}
					}
				}
			}
			cx += 6 * scale;
		}
	}
	strokeText(text, x, y) {
		this.fillText(text, x, y);
	}
	measureText(t) {
		const fontSize = parseInt(this.font) || 10;
		const scale = Math.max(1, Math.round(fontSize / 10));
		return {
			width: String(t).length * 6 * scale,
			actualBoundingBoxAscent: 7 * scale,
			actualBoundingBoxDescent: 2 * scale,
		};
	}
	getImageData(x, y, w, h) {
		x = Math.round(x);
		y = Math.round(y);
		w = Math.round(w);
		h = Math.round(h);
		const data = new Uint8ClampedArray(w * h * 4);
		for (let py = 0; py < h; py++) {
			for (let px = 0; px < w; px++) {
				const srcX = x + px,
					srcY = y + py;
				const dstIdx = (py * w + px) * 4;
				if (srcX >= 0 && srcX < this._w && srcY >= 0 && srcY < this._h) {
					const srcIdx = (srcY * this._w + srcX) * 4;
					data[dstIdx] = this._buf[srcIdx];
					data[dstIdx + 1] = this._buf[srcIdx + 1];
					data[dstIdx + 2] = this._buf[srcIdx + 2];
					data[dstIdx + 3] = this._buf[srcIdx + 3];
				}
			}
		}
		return { data, width: w, height: h };
	}
	putImageData(imageData, dx, dy) {
		dx = Math.round(dx);
		dy = Math.round(dy);
		const { data, width: w, height: h } = imageData;
		for (let py = 0; py < h; py++) {
			for (let px = 0; px < w; px++) {
				const srcIdx = (py * w + px) * 4;
				const x = dx + px,
					y = dy + py;
				if (x >= 0 && x < this._w && y >= 0 && y < this._h) {
					const dstIdx = (y * this._w + x) * 4;
					this._buf[dstIdx] = data[srcIdx];
					this._buf[dstIdx + 1] = data[srcIdx + 1];
					this._buf[dstIdx + 2] = data[srcIdx + 2];
					this._buf[dstIdx + 3] = data[srcIdx + 3];
				}
			}
		}
	}
	createImageData(w, h) {
		return { data: new Uint8ClampedArray(w * h * 4), width: w, height: h };
	}
	drawImage(img, sx, sy, sw, sh, dx, dy, dw, dh) {
		if (img && img._ctx && img._ctx._buf) {
			const src = img._ctx;
			dx = dx ?? sx;
			dy = dy ?? sy;
			dw = dw ?? sw ?? src._w;
			dh = dh ?? sh ?? src._h;
			for (let py = 0; py < dh; py++) {
				for (let px = 0; px < dw; px++) {
					const srcX = Math.floor((sx || 0) + (px * (sw || src._w)) / dw);
					const srcY = Math.floor((sy || 0) + (py * (sh || src._h)) / dh);
					if (srcX >= 0 && srcX < src._w && srcY >= 0 && srcY < src._h) {
						const srcIdx = (srcY * src._w + srcX) * 4;
						this._setPixel(
							dx + px,
							dy + py,
							src._buf[srcIdx],
							src._buf[srcIdx + 1],
							src._buf[srcIdx + 2],
							src._buf[srcIdx + 3],
						);
					}
				}
			}
		}
	}
	beginPath() {
		this._path = [];
	}
	closePath() {}
	moveTo(x, y) {
		if (this._path) this._path.push({ t: "M", x, y });
	}
	lineTo(x, y) {
		if (this._path) this._path.push({ t: "L", x, y });
	}
	bezierCurveTo() {}
	quadraticCurveTo() {}
	arc(x, y, r, s, e) {
		if (this._path) this._path.push({ t: "A", x, y, r });
	}
	arcTo() {}
	rect(x, y, w, h) {
		this.fillRect(x, y, w, h);
	}
	fill() {}
	stroke() {}
	clip() {}
	save() {
		this._stateStack.push({
			fillStyle: this.fillStyle,
			strokeStyle: this.strokeStyle,
			globalAlpha: this.globalAlpha,
			font: this.font,
			lineWidth: this.lineWidth,
		});
	}
	restore() {
		const s = this._stateStack.pop();
		if (s) Object.assign(this, s);
	}
	translate() {}
	rotate() {}
	scale() {}
	setTransform() {}
	resetTransform() {}
	transform() {}
	createLinearGradient(x0, y0, x1, y1) {
		return { addColorStop() {}, _x0: x0, _y0: y0, _x1: x1, _y1: y1 };
	}
	createRadialGradient() {
		return { addColorStop() {} };
	}
	createPattern() {
		return {};
	}
	isPointInPath() {
		return false;
	}
	isPointInStroke() {
		return false;
	}
}

Element.prototype.getContext = function getContext(type) {
	if (type === "2d") {
		if (!this._ctx) {
			this._ctx = new _Canvas2D(this);
		}
		return this._ctx;
	}
	if (type === "webgl" || type === "experimental-webgl" || type === "webgl2") {
		return {
			canvas: this,
			getExtension(name) {
				if (name === "WEBGL_debug_renderer_info")
					return { UNMASKED_VENDOR_WEBGL: 0x9245, UNMASKED_RENDERER_WEBGL: 0x9246 };
				return null;
			},
			getParameter(pname) {
				if (pname === 0x9245) return _fp("gpuVendor");
				if (pname === 0x9246) return _fp("gpu");
				if (pname === 0x1f01) return "WebKit WebGL"; // GL_RENDERER
				if (pname === 0x1f00) return "WebKit"; // GL_VENDOR
				if (pname === 0x1f02) return "OpenGL ES 3.0 (ANGLE)"; // GL_VERSION
				if (pname === 0x8b8c) return "WebGL GLSL ES 3.00 (ANGLE)"; // GL_SHADING_LANGUAGE_VERSION
				return 0;
			},
			getSupportedExtensions() {
				return [
					"WEBGL_debug_renderer_info",
					"EXT_texture_filter_anisotropic",
					"WEBGL_compressed_texture_s3tc",
					"WEBGL_lose_context",
				];
			},
			getShaderPrecisionFormat() {
				return { rangeMin: 127, rangeMax: 127, precision: 23 };
			},
			createBuffer() {
				return {};
			},
			createShader() {
				return {};
			},
			createProgram() {
				return {};
			},
			shaderSource() {},
			compileShader() {},
			attachShader() {},
			linkProgram() {},
			getProgramParameter() {
				return true;
			},
			useProgram() {},
			deleteShader() {},
			bindBuffer() {},
			bufferData() {},
			enableVertexAttribArray() {},
			vertexAttribPointer() {},
			drawArrays() {},
			drawElements() {},
			viewport() {},
			clear() {},
			clearColor() {},
			enable() {},
			disable() {},
			blendFunc() {},
			depthFunc() {},
			getUniformLocation() {
				return {};
			},
			getAttribLocation() {
				return 0;
			},
			uniform1f() {},
			uniform1i() {},
			uniformMatrix4fv() {},
			createTexture() {
				return {};
			},
			bindTexture() {},
			texImage2D() {},
			texParameteri() {},
			activeTexture() {},
			pixelStorei() {},
			generateMipmap() {},
			createFramebuffer() {
				return {};
			},
			bindFramebuffer() {},
			framebufferTexture2D() {},
			readPixels(x, y, w, h, f, t, d) {
				if (d) for (let i = 0; i < d.length; i++) d[i] = Math.floor(Math.random() * 256);
			},
			VERTEX_SHADER: 0x8b31,
			FRAGMENT_SHADER: 0x8b30,
			LINK_STATUS: 0x8b82,
			ARRAY_BUFFER: 0x8892,
			STATIC_DRAW: 0x88e4,
			FLOAT: 0x1406,
			TRIANGLES: 0x0004,
			COLOR_BUFFER_BIT: 0x4000,
			DEPTH_BUFFER_BIT: 0x100,
			TEXTURE_2D: 0x0de1,
			RGBA: 0x1908,
			UNSIGNED_BYTE: 0x1401,
		};
	}
	return null;
};
Element.prototype.toDataURL = function (type) {
	if (this._ctx && this._ctx._buf) {
		const ctx = this._ctx;
		const w = ctx._w,
			h = ctx._h,
			buf = ctx._buf;
		let hash = _fpSeed;
		for (let i = 0; i < buf.length; i += 37) {
			hash = ((hash << 5) - hash + buf[i]) | 0;
		}
		const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		let b64 = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUg";
		for (let i = 0; i < 60; i++) {
			hash = ((hash << 5) - hash + i) | 0;
			b64 += chars[(hash >>> 0) % 64];
		}
		return b64 + "==";
	}
	return _fp("canvasFingerprint");
};
Element.prototype.toBlob = function (cb, type, q) {
	cb(new Blob([""]));
};

_markNative(Element.prototype.getContext);
_markNative(Element.prototype.toDataURL);
_markNative(Element.prototype.toBlob);

Element.prototype.attachShadow = function attachShadow(opts) {
	const host = this;
	const children = [];
	const shadow = {
		mode: opts?.mode || "open",
		host: host,
		get innerHTML() {
			return children.map((c) => c.outerHTML || c.textContent || "").join("");
		},
		set innerHTML(v) {
			children.length = 0;
			if (v) {
				const tmp = document.createElement("div");
				tmp.innerHTML = v;
				for (let i = 0; i < tmp.childNodes.length; i++) children.push(tmp.childNodes[i]);
			}
		},
		get childNodes() {
			return children;
		},
		get firstChild() {
			return children[0] || null;
		},
		get lastChild() {
			return children[children.length - 1] || null;
		},
		get firstElementChild() {
			return children.find((c) => c.nodeType === 1) || null;
		},
		get children() {
			return children.filter((c) => c.nodeType === 1);
		},
		appendChild(c) {
			if (c) {
				children.push(c);
				try {
					c.parentNode = shadow;
				} catch (_) {
					/* parentNode is getter-only on Node, ignore */
				}
			}
			return c;
		},
		insertBefore(n, ref) {
			if (!n) return n;
			if (!ref) {
				shadow.appendChild(n);
				return n;
			}
			const idx = children.indexOf(ref);
			if (idx >= 0) {
				children.splice(idx, 0, n);
				try {
					n.parentNode = shadow;
				} catch (_) {}
			} else shadow.appendChild(n);
			return n;
		},
		removeChild(c) {
			const idx = children.indexOf(c);
			if (idx >= 0) children.splice(idx, 1);
			return c;
		},
		replaceChild(n, o) {
			const idx = children.indexOf(o);
			if (idx >= 0) {
				children[idx] = n;
				try {
					n.parentNode = shadow;
				} catch (_) {}
			}
			return o;
		},
		querySelector(s) {
			for (const c of children) {
				if (c.matches && c.matches(s)) return c;
				if (c.querySelector) {
					const r = c.querySelector(s);
					if (r) return r;
				}
			}
			return null;
		},
		querySelectorAll(s) {
			const results = [];
			for (const c of children) {
				if (c.matches && c.matches(s)) results.push(c);
				if (c.querySelectorAll) results.push(...c.querySelectorAll(s));
			}
			return results;
		},
		getElementById(id) {
			return shadow.querySelector("#" + id);
		},
		contains(n) {
			return children.includes(n);
		},
		getRootNode() {
			return shadow;
		},
		get ownerDocument() {
			return document;
		},
		get nodeType() {
			return 11;
		}, // DOCUMENT_FRAGMENT_NODE
		get nodeName() {
			return "#document-fragment";
		},
		addEventListener() {},
		removeEventListener() {},
		dispatchEvent() {
			return true;
		},
		cloneNode() {
			return shadow;
		},
	};
	this.shadowRoot = shadow;
	return shadow;
};

_markNative(Element.prototype.attachShadow);

globalThis.AudioContext = class AudioContext {
	constructor() {
		this.sampleRate = _fp("audioSampleRate");
		this.state = "running";
		this.currentTime = 0;
		this.baseLatency = _fp("audioBaseLatency");
		this.destination = {
			maxChannelCount: 2,
			numberOfInputs: 1,
			numberOfOutputs: 0,
			channelCount: 2,
		};
	}
	createOscillator() {
		return {
			type: "sine",
			frequency: { value: 440, setValueAtTime() {} },
			connect() {},
			start() {},
			stop() {},
			disconnect() {},
			addEventListener() {},
		};
	}
	createDynamicsCompressor() {
		return {
			threshold: { value: _fp("compThreshold") },
			knee: { value: _fp("compKnee") },
			ratio: { value: _fp("compRatio") },
			attack: { value: 0.003 },
			release: { value: 0.25 },
			reduction: 0,
			connect() {},
			disconnect() {},
		};
	}
	createAnalyser() {
		return {
			fftSize: 2048,
			frequencyBinCount: 1024,
			connect() {},
			disconnect() {},
			getByteFrequencyData(a) {
				for (let i = 0; i < a.length; i++) a[i] = Math.floor(_fpRand(600 + i) * 10);
			},
			getFloatFrequencyData(a) {
				for (let i = 0; i < a.length; i++) a[i] = -100 + _fpRand(700 + i) * 5;
			},
		};
	}
	createGain() {
		return { gain: { value: 1, setValueAtTime() {} }, connect() {}, disconnect() {} };
	}
	createBiquadFilter() {
		return {
			type: "lowpass",
			frequency: { value: 350 },
			Q: { value: 1 },
			connect() {},
			disconnect() {},
		};
	}
	createBufferSource() {
		return { buffer: null, connect() {}, start() {}, stop() {}, disconnect() {}, loop: false };
	}
	createBuffer(ch, len, rate) {
		return {
			length: len,
			sampleRate: rate,
			numberOfChannels: ch,
			getChannelData(c) {
				return new Float32Array(len);
			},
			duration: len / rate,
		};
	}
	createScriptProcessor() {
		return { connect() {}, disconnect() {}, onaudioprocess: null };
	}
	decodeAudioData(buf) {
		return Promise.resolve(this.createBuffer(2, 44100, 44100));
	}
	resume() {
		this.state = "running";
		return Promise.resolve();
	}
	suspend() {
		this.state = "suspended";
		return Promise.resolve();
	}
	close() {
		this.state = "closed";
		return Promise.resolve();
	}
};
globalThis.OfflineAudioContext = class OfflineAudioContext extends AudioContext {
	constructor(ch, len, rate) {
		super();
		this.length = len || 44100;
	}
	startRendering() {
		return Promise.resolve(this.createBuffer(2, this.length, 44100));
	}
};
globalThis.webkitAudioContext = globalThis.AudioContext;

globalThis.speechSynthesis = {
	speaking: false,
	pending: false,
	paused: false,
	getVoices() {
		return [
			{
				name: "Google US English",
				lang: "en-US",
				default: true,
				localService: true,
				voiceURI: "Google US English",
			},
		];
	},
	speak() {},
	cancel() {},
	pause() {},
	resume() {},
	addEventListener() {},
	removeEventListener() {},
	onvoiceschanged: null,
};
globalThis.SpeechSynthesisUtterance = class SpeechSynthesisUtterance {
	constructor(t) {
		this.text = t;
		this.lang = "en-US";
		this.rate = 1;
		this.pitch = 1;
		this.volume = 1;
	}
};

globalThis.MediaStream = class MediaStream {
	constructor() {
		this.id = "";
		this.active = true;
	}
	getTracks() {
		return [];
	}
	getAudioTracks() {
		return [];
	}
	getVideoTracks() {
		return [];
	}
	addTrack() {}
	removeTrack() {}
	clone() {
		return new MediaStream();
	}
};
globalThis.MediaStreamTrack = class MediaStreamTrack {
	constructor() {
		this.kind = "";
		this.enabled = true;
		this.readyState = "live";
	}
	stop() {}
	clone() {
		return new MediaStreamTrack();
	}
};
globalThis.RTCPeerConnection = class RTCPeerConnection {
	constructor() {
		this.localDescription = null;
		this.remoteDescription = null;
		this.iceConnectionState = "new";
		this.iceGatheringState = "new";
		this.signalingState = "stable";
		this.connectionState = "new";
	}
	createOffer() {
		return Promise.resolve({ type: "offer", sdp: "" });
	}
	createAnswer() {
		return Promise.resolve({ type: "answer", sdp: "" });
	}
	setLocalDescription() {
		return Promise.resolve();
	}
	setRemoteDescription() {
		return Promise.resolve();
	}
	addIceCandidate() {
		return Promise.resolve();
	}
	close() {}
	createDataChannel() {
		return { close() {}, send() {}, addEventListener() {}, removeEventListener() {} };
	}
	addEventListener() {}
	removeEventListener() {}
	getStats() {
		return Promise.resolve(new Map());
	}
};
globalThis.RTCSessionDescription = class RTCSessionDescription {
	constructor(d) {
		this.type = d?.type;
		this.sdp = d?.sdp;
	}
};
globalThis.RTCIceCandidate = class RTCIceCandidate {
	constructor(d) {
		this.candidate = d?.candidate || "";
	}
};

globalThis.indexedDB = {
	open(name, version) {
		const req = {
			result: null,
			error: null,
			onsuccess: null,
			onerror: null,
			onupgradeneeded: null,
		};
		Promise.resolve().then(() => {
			req.result = {
				name,
				version: version || 1,
				objectStoreNames: {
					contains() {
						return false;
					},
					length: 0,
				},
				createObjectStore() {
					return { createIndex() {} };
				},
				transaction() {
					return {
						objectStore() {
							return {
								get() {
									return { onsuccess: null, onerror: null };
								},
								put() {
									return { onsuccess: null };
								},
								delete() {
									return { onsuccess: null };
								},
							};
						},
					};
				},
				close() {},
			};
			if (req.onsuccess) req.onsuccess({ target: req });
		});
		return req;
	},
	deleteDatabase() {
		return { onsuccess: null, onerror: null };
	},
};
globalThis.IDBKeyRange = {
	only(v) {
		return v;
	},
	lowerBound(v) {
		return v;
	},
	upperBound(v) {
		return v;
	},
	bound(l, u) {
		return [l, u];
	},
};

globalThis.caches = {
	open() {
		return Promise.resolve({
			match() {
				return Promise.resolve(undefined);
			},
			put() {
				return Promise.resolve();
			},
			delete() {
				return Promise.resolve(false);
			},
			keys() {
				return Promise.resolve([]);
			},
		});
	},
	match() {
		return Promise.resolve(undefined);
	},
	has() {
		return Promise.resolve(false);
	},
	delete() {
		return Promise.resolve(false);
	},
	keys() {
		return Promise.resolve([]);
	},
};

_markNative(AudioContext);
_markNative(OfflineAudioContext);
_markNative(SpeechSynthesisUtterance);
_markNative(MediaStream);
_markNative(MediaStreamTrack);
_markNative(RTCPeerConnection);
_markNative(RTCSessionDescription);
_markNative(RTCIceCandidate);

const _OrigDateTimeFormat = Intl.DateTimeFormat;
const _defaultTZ = "America/New_York";
Intl.DateTimeFormat = function (locales, options) {
	if (!options) options = {};
	if (!options.timeZone) options.timeZone = _defaultTZ;
	return new _OrigDateTimeFormat(locales, options);
};
Intl.DateTimeFormat.prototype = _OrigDateTimeFormat.prototype;
Intl.DateTimeFormat.supportedLocalesOf = _OrigDateTimeFormat.supportedLocalesOf;
const _origResolved = _OrigDateTimeFormat.prototype.resolvedOptions;
_OrigDateTimeFormat.prototype.resolvedOptions = function () {
	const r = _origResolved.call(this);
	if (r.timeZone === "UTC") r.timeZone = _defaultTZ;
	return r;
};

if (typeof PointerEvent === "undefined") {
	globalThis.PointerEvent = class PointerEvent extends MouseEvent {
		constructor(type, opts = {}) {
			super(type, opts);
			this.pointerId = opts.pointerId || 0;
			this.width = opts.width || 1;
			this.height = opts.height || 1;
			this.pressure = opts.pressure || 0;
			this.pointerType = opts.pointerType || "mouse";
		}
	};
}

if (typeof navigator.credentials === "undefined") {
	navigator.credentials = {
		get() {
			return Promise.resolve(null);
		},
		create() {
			return Promise.resolve(null);
		},
		store() {
			return Promise.resolve();
		},
		preventSilentAccess() {
			return Promise.resolve();
		},
	};
}

globalThis.opener = null;

globalThis.Worker = class Worker {
	constructor(url) {
		this.onmessage = null;
		this.onerror = null;
		this._terminated = false;
		this._listeners = {};
		const worker = this;

		if (typeof url === "string" && (url.startsWith("blob:") || url.startsWith("http"))) {
			const blobContent = globalThis.__blobStore?.[url];
			if (blobContent) {
				this._code = blobContent;
			} else {
				(async () => {
					try {
						const resp = await fetch(url);
						worker._code = await resp.text();
					} catch (e) {
						if (worker.onerror) worker.onerror(e);
					}
				})();
			}
		}
	}
	postMessage(data) {
		if (this._terminated) return;
		const worker = this;
		setTimeout(() => {
			if (worker._terminated || !worker._code) return;
			try {
				const workerSelf = {
					onmessage: null,
					postMessage: (msg) => {
						const evt = { data: msg };
						if (worker.onmessage) worker.onmessage(evt);
						const handlers = worker._listeners["message"] || [];
						for (const h of handlers) h(evt);
					},
					addEventListener: (type, fn) => {
						workerSelf["on" + type] = fn;
					},
					close: () => {
						worker._terminated = true;
					},
					crypto: globalThis.crypto,
					TextEncoder: globalThis.TextEncoder,
					TextDecoder: globalThis.TextDecoder,
					atob: globalThis.atob,
					btoa: globalThis.btoa,
					setTimeout: globalThis.setTimeout,
					setInterval: globalThis.setInterval,
					clearTimeout: globalThis.clearTimeout,
					clearInterval: globalThis.clearInterval,
					fetch: globalThis.fetch,
					console: globalThis.console,
				};
				const fn = new Function("self", "postMessage", "addEventListener", "close", worker._code);
				fn(workerSelf, workerSelf.postMessage, workerSelf.addEventListener, workerSelf.close);
				if (workerSelf.onmessage) workerSelf.onmessage({ data });
			} catch (e) {
				console.error("Worker error:", e.message);
				if (worker.onerror) worker.onerror(e);
			}
		}, 0);
	}
	terminate() {
		this._terminated = true;
	}
	addEventListener(type, fn) {
		if (!this._listeners[type]) this._listeners[type] = [];
		this._listeners[type].push(fn);
	}
	removeEventListener(type, fn) {
		if (this._listeners[type]) this._listeners[type] = this._listeners[type].filter((h) => h !== fn);
	}
};

globalThis.__blobStore = globalThis.__blobStore || {};
const _origCreateObjectURL = URL.createObjectURL;
URL.createObjectURL = function (blob) {
	if (blob && typeof blob.text === "function") {
		const id = "blob:kreuzcrawl/" + Math.random().toString(36).substring(2);
		blob.text().then((text) => {
			globalThis.__blobStore[id] = text;
		});
		return id;
	}
	return "blob:kreuzcrawl/fallback";
};
URL.revokeObjectURL = function (url) {
	delete globalThis.__blobStore[url];
};

globalThis.scrollTo = function (x, y) {};
globalThis.scrollBy = function (x, y) {};
globalThis.scroll = function (x, y) {};
globalThis.focus = function () {};
globalThis.blur = function () {};
globalThis.print = function () {};
globalThis.alert = function () {};
globalThis.confirm = function () {
	return true;
};
globalThis.prompt = function () {
	return null;
};
globalThis.open = function () {
	return null;
};
globalThis.close = function () {};
globalThis.stop = function () {};
globalThis.postMessage = function () {};
globalThis.requestIdleCallback =
	globalThis.requestIdleCallback ||
	function (cb) {
		return setTimeout(cb, 0);
	};
globalThis.cancelIdleCallback =
	globalThis.cancelIdleCallback ||
	function (id) {
		clearTimeout(id);
	};
if (typeof ReadableStream === "undefined") {
	globalThis.ReadableStream = class ReadableStream {
		constructor(source = {}, strategy = {}) {
			this._source = source;
			this._queue = [];
			this._closed = false;
			this.locked = false;
			if (source.start)
				source.start({
					enqueue: (chunk) => this._queue.push(chunk),
					close: () => {
						this._closed = true;
					},
					error: () => {},
				});
		}
		getReader() {
			this.locked = true;
			const stream = this;
			return {
				read() {
					if (stream._queue.length > 0) return Promise.resolve({ value: stream._queue.shift(), done: false });
					if (stream._closed) return Promise.resolve({ value: undefined, done: true });
					return Promise.resolve({ value: undefined, done: true });
				},
				releaseLock() {
					stream.locked = false;
				},
				cancel() {
					stream._closed = true;
					return Promise.resolve();
				},
				get closed() {
					return stream._closed ? Promise.resolve() : new Promise(() => {});
				},
			};
		}
		cancel() {
			this._closed = true;
			return Promise.resolve();
		}
		pipeTo(dest) {
			return Promise.resolve();
		}
		pipeThrough(transform) {
			return transform.readable || new ReadableStream();
		}
		tee() {
			return [new ReadableStream(), new ReadableStream()];
		}
		[Symbol.asyncIterator]() {
			const reader = this.getReader();
			return {
				next: () => reader.read(),
				return: () => {
					reader.releaseLock();
					return Promise.resolve({ done: true });
				},
			};
		}
	};
}
if (typeof WritableStream === "undefined") {
	globalThis.WritableStream = class WritableStream {
		constructor(sink = {}) {
			this._sink = sink;
			this.locked = false;
		}
		getWriter() {
			this.locked = true;
			const stream = this;
			return {
				write(chunk) {
					if (stream._sink.write) stream._sink.write(chunk);
					return Promise.resolve();
				},
				close() {
					if (stream._sink.close) stream._sink.close();
					return Promise.resolve();
				},
				abort() {
					return Promise.resolve();
				},
				releaseLock() {
					stream.locked = false;
				},
				get ready() {
					return Promise.resolve();
				},
				get closed() {
					return Promise.resolve();
				},
				get desiredSize() {
					return 1;
				},
			};
		}
		close() {
			return Promise.resolve();
		}
		abort() {
			return Promise.resolve();
		}
	};
}
if (typeof TransformStream === "undefined") {
	globalThis.TransformStream = class TransformStream {
		constructor(transformer = {}) {
			this.readable = new ReadableStream();
			this.writable = new WritableStream();
		}
	};
}

if (!globalThis.crypto) globalThis.crypto = {};
if (!globalThis.crypto.subtle) {
	globalThis.crypto.subtle = {
		async digest(algorithm, data) {
			const name = typeof algorithm === "string" ? algorithm : algorithm?.name || "SHA-256";
			const bytes = new Uint8Array(data instanceof ArrayBuffer ? data : data.buffer || data);
			let hash = 0x811c9dc5;
			for (let i = 0; i < bytes.length; i++) {
				hash ^= bytes[i];
				hash = Math.imul(hash, 0x01000193);
			}
			const size = name.includes("512") ? 64 : name.includes("384") ? 48 : 32;
			const result = new Uint8Array(size);
			for (let i = 0; i < size; i++) {
				hash = Math.imul(hash ^ i, 0x45d9f3b);
				result[i] = (hash >>> 0) & 0xff;
			}
			return result.buffer;
		},
		async encrypt() {
			throw new DOMException("NotSupportedError");
		},
		async decrypt() {
			throw new DOMException("NotSupportedError");
		},
		async sign() {
			return new ArrayBuffer(32);
		},
		async verify() {
			return true;
		},
		async generateKey() {
			return { type: "secret", algorithm: {}, extractable: false, usages: [] };
		},
		async importKey() {
			return { type: "secret", algorithm: {}, extractable: false, usages: [] };
		},
		async exportKey() {
			return new ArrayBuffer(32);
		},
		async deriveBits() {
			return new ArrayBuffer(32);
		},
		async deriveKey() {
			return { type: "secret", algorithm: {}, extractable: false, usages: [] };
		},
		async wrapKey() {
			return new ArrayBuffer(32);
		},
		async unwrapKey() {
			return { type: "secret", algorithm: {}, extractable: false, usages: [] };
		},
	};
}

if (typeof DOMRect === "undefined") {
	globalThis.DOMRect = class DOMRect {
		constructor(x = 0, y = 0, w = 0, h = 0) {
			this.x = x;
			this.y = y;
			this.width = w;
			this.height = h;
			this.top = y;
			this.right = x + w;
			this.bottom = y + h;
			this.left = x;
		}
		toJSON() {
			return {
				x: this.x,
				y: this.y,
				width: this.width,
				height: this.height,
				top: this.top,
				right: this.right,
				bottom: this.bottom,
				left: this.left,
			};
		}
		static fromRect(r = {}) {
			return new DOMRect(r.x, r.y, r.width, r.height);
		}
	};
}
if (typeof DOMPoint === "undefined") {
	globalThis.DOMPoint = class DOMPoint {
		constructor(x = 0, y = 0, z = 0, w = 1) {
			this.x = x;
			this.y = y;
			this.z = z;
			this.w = w;
		}
		static fromPoint(p = {}) {
			return new DOMPoint(p.x, p.y, p.z, p.w);
		}
	};
}
if (typeof DOMMatrix === "undefined") {
	globalThis.DOMMatrix = class DOMMatrix {
		constructor() {
			this.a = 1;
			this.b = 0;
			this.c = 0;
			this.d = 1;
			this.e = 0;
			this.f = 0;
			this.is2D = true;
			this.isIdentity = true;
		}
		static fromMatrix() {
			return new DOMMatrix();
		}
		static fromFloat32Array() {
			return new DOMMatrix();
		}
		static fromFloat64Array() {
			return new DOMMatrix();
		}
		multiply() {
			return new DOMMatrix();
		}
		inverse() {
			return new DOMMatrix();
		}
		translate() {
			return new DOMMatrix();
		}
		scale() {
			return new DOMMatrix();
		}
		rotate() {
			return new DOMMatrix();
		}
		transformPoint(p) {
			return new DOMPoint(p?.x || 0, p?.y || 0);
		}
	};
}

if (typeof Image === "undefined") {
	globalThis.Image = class Image {
		constructor(w, h) {
			this.width = w || 0;
			this.height = h || 0;
			this.src = "";
			this.onload = null;
			this.onerror = null;
			this.complete = false;
			this.naturalWidth = 0;
			this.naturalHeight = 0;
		}
		addEventListener() {}
		removeEventListener() {}
		setAttribute(k, v) {
			this[k] = v;
			if (k === "src" && this.onload)
				setTimeout(() => {
					this.complete = true;
					this.onload();
				}, 0);
		}
		getAttribute(k) {
			return this[k];
		}
	};
}

if (typeof Audio === "undefined") {
	globalThis.Audio = class Audio {
		constructor(src) {
			this.src = src || "";
			this.paused = true;
			this.volume = 1;
			this.currentTime = 0;
			this.duration = 0;
		}
		play() {
			return Promise.resolve();
		}
		pause() {
			this.paused = true;
		}
		load() {}
		addEventListener() {}
		removeEventListener() {}
	};
}

if (typeof FileReader === "undefined") {
	globalThis.FileReader = class FileReader {
		constructor() {
			this.result = null;
			this.readyState = 0;
			this.onload = null;
			this.onerror = null;
		}
		readAsText(blob) {
			if (blob?.text)
				blob.text().then((t) => {
					this.result = t;
					this.readyState = 2;
					if (this.onload) this.onload({ target: this });
				});
		}
		readAsDataURL(blob) {
			this.result = "data:;base64,";
			this.readyState = 2;
			if (this.onload) setTimeout(() => this.onload({ target: this }), 0);
		}
		readAsArrayBuffer(blob) {
			this.result = new ArrayBuffer(0);
			this.readyState = 2;
			if (this.onload) setTimeout(() => this.onload({ target: this }), 0);
		}
		abort() {
			this.readyState = 0;
		}
		addEventListener(t, fn) {
			if (t === "load") this.onload = fn;
		}
		removeEventListener() {}
	};
}

if (typeof EventSource === "undefined") {
	globalThis.EventSource = class EventSource {
		constructor(url) {
			this.url = url;
			this.readyState = 0;
			this.onopen = null;
			this.onmessage = null;
			this.onerror = null;
		}
		close() {
			this.readyState = 2;
		}
		addEventListener() {}
		removeEventListener() {}
		static CONNECTING = 0;
		static OPEN = 1;
		static CLOSED = 2;
	};
}

if (typeof WebSocket === "undefined") {
	globalThis.WebSocket = class WebSocket {
		constructor(url, protocols) {
			this.url = url;
			this.readyState = 0;
			this.bufferedAmount = 0;
			this.onopen = null;
			this.onmessage = null;
			this.onerror = null;
			this.onclose = null;
			this.protocol = "";
		}
		send(data) {}
		close(code, reason) {
			this.readyState = 3;
			if (this.onclose) this.onclose({ code: code || 1000, reason: reason || "", wasClean: true });
		}
		addEventListener() {}
		removeEventListener() {}
		static CONNECTING = 0;
		static OPEN = 1;
		static CLOSING = 2;
		static CLOSED = 3;
	};
}

if (typeof BroadcastChannel === "undefined") {
	globalThis.BroadcastChannel = class BroadcastChannel {
		constructor(name) {
			this.name = name;
			this.onmessage = null;
		}
		postMessage(msg) {}
		close() {}
		addEventListener() {}
		removeEventListener() {}
	};
}

if (typeof MediaQueryList === "undefined") {
	globalThis.MediaQueryList = class MediaQueryList {
		constructor(q) {
			this.media = q || "";
			this.matches = false;
		}
		addListener() {}
		removeListener() {}
		addEventListener() {}
		removeEventListener() {}
	};
}

if (typeof ImageData === "undefined") {
	globalThis.ImageData = class ImageData {
		constructor(w, h) {
			if (w instanceof Uint8ClampedArray) {
				this.data = w;
				this.width = h;
				this.height = w.length / (4 * h);
			} else {
				this.width = w;
				this.height = h;
				this.data = new Uint8ClampedArray(w * h * 4);
			}
		}
	};
}

if (typeof CanvasRenderingContext2D === "undefined") {
	globalThis.CanvasRenderingContext2D = class CanvasRenderingContext2D {};
}

if (typeof OffscreenCanvas === "undefined") {
	globalThis.OffscreenCanvas = class OffscreenCanvas {
		constructor(w, h) {
			this.width = w;
			this.height = h;
		}
		getContext(type) {
			return globalThis.document?.createElement("canvas")?.getContext(type) || null;
		}
		convertToBlob() {
			return Promise.resolve(new Blob([""]));
		}
		transferToImageBitmap() {
			return {};
		}
	};
}

if (typeof Path2D === "undefined") {
	globalThis.Path2D = class Path2D {
		constructor() {}
		moveTo() {}
		lineTo() {}
		arc() {}
		rect() {}
		closePath() {}
		addPath() {}
	};
}

if (typeof ImageBitmap === "undefined") {
	globalThis.ImageBitmap = class ImageBitmap {
		constructor() {
			this.width = 0;
			this.height = 0;
		}
		close() {}
	};
	globalThis.createImageBitmap = function () {
		return Promise.resolve(new ImageBitmap());
	};
}

if (typeof Selection === "undefined") {
	globalThis.Selection = class Selection {
		constructor() {
			this.anchorNode = null;
			this.focusNode = null;
			this.rangeCount = 0;
			this.isCollapsed = true;
			this.type = "None";
		}
		getRangeAt() {
			return null;
		}
		collapse() {}
		extend() {}
		selectAllChildren() {}
		deleteFromDocument() {}
		addRange() {}
		removeRange() {}
		removeAllRanges() {}
		toString() {
			return "";
		}
	};
}

if (typeof NodeFilter === "undefined") {
	globalThis.NodeFilter = {
		SHOW_ALL: 0xffffffff,
		SHOW_ELEMENT: 1,
		SHOW_TEXT: 4,
		SHOW_COMMENT: 128,
		FILTER_ACCEPT: 1,
		FILTER_REJECT: 2,
		FILTER_SKIP: 3,
	};
}

if (typeof TreeWalker === "undefined") {
	globalThis.TreeWalker = class TreeWalker {
		constructor(root) {
			this.root = root;
			this.currentNode = root;
			this.whatToShow = 0xffffffff;
			this.filter = null;
		}
		parentNode() {
			return this.currentNode?.parentNode || null;
		}
		firstChild() {
			return this.currentNode?.firstChild || null;
		}
		lastChild() {
			return this.currentNode?.lastChild || null;
		}
		previousSibling() {
			return this.currentNode?.previousSibling || null;
		}
		nextSibling() {
			return this.currentNode?.nextSibling || null;
		}
		nextNode() {
			return null;
		}
		previousNode() {
			return null;
		}
	};
}

if (typeof Range === "undefined") {
	globalThis.Range = class Range {
		constructor() {
			this.startContainer = null;
			this.startOffset = 0;
			this.endContainer = null;
			this.endOffset = 0;
			this.collapsed = true;
			this.commonAncestorContainer = null;
		}
		setStart(n, o) {
			this.startContainer = n;
			this.startOffset = o;
		}
		setEnd(n, o) {
			this.endContainer = n;
			this.endOffset = o;
		}
		collapse() {}
		selectNode() {}
		selectNodeContents() {}
		cloneContents() {
			return document?.createDocumentFragment();
		}
		deleteContents() {}
		insertNode() {}
		getBoundingClientRect() {
			return new DOMRect();
		}
		getClientRects() {
			return [];
		}
		cloneRange() {
			return new Range();
		}
		toString() {
			return "";
		}
	};
}

if (typeof SharedWorker === "undefined") {
	globalThis.SharedWorker = class SharedWorker {
		constructor() {
			this.port = {
				postMessage() {},
				onmessage: null,
				start() {},
				close() {},
				addEventListener() {},
				removeEventListener() {},
			};
			this.onerror = null;
		}
	};
}
if (typeof ServiceWorkerContainer === "undefined") {
	globalThis.ServiceWorkerContainer = class {
		register() {
			return Promise.resolve();
		}
		getRegistrations() {
			return Promise.resolve([]);
		}
	};
}

if (typeof URLPattern === "undefined") {
	globalThis.URLPattern = class URLPattern {
		constructor(pattern) {
			this._pattern = pattern || {};
		}
		test() {
			return false;
		}
		exec() {
			return null;
		}
	};
}

if (typeof Document !== "undefined" && !Document.prototype.importNode) {
	Document.prototype.importNode = function (node, deep) {
		return node?.cloneNode(!!deep) || null;
	};
}

// Document.elementFromPoint / elementsFromPoint — no layout engine, so this is a stub:
// in-viewport coords return <body> (or <html> as fallback), out-of-viewport returns null.
// Wrong-but-non-throwing beats "undefined", which traps ad/analytics bootstraps in retry loops
// (see issue #63).
if (typeof Document !== "undefined" && !Document.prototype.elementFromPoint) {
	Document.prototype.elementFromPoint = function (x, y) {
		if (typeof x !== "number" || typeof y !== "number" || !isFinite(x) || !isFinite(y)) {
			return null;
		}
		var w = (typeof window !== "undefined" && window.innerWidth) || 0;
		var h = (typeof window !== "undefined" && window.innerHeight) || 0;
		if (x < 0 || y < 0 || x > w || y > h) {
			return null;
		}
		return this.body || this.documentElement || null;
	};
	Document.prototype.elementsFromPoint = function (x, y) {
		var el = this.elementFromPoint(x, y);
		return el ? [el] : [];
	};
}
if (typeof ShadowRoot !== "undefined" && !ShadowRoot.prototype.elementFromPoint) {
	ShadowRoot.prototype.elementFromPoint = function (x, y) {
		return Document.prototype.elementFromPoint.call(globalThis.document || this, x, y);
	};
	ShadowRoot.prototype.elementsFromPoint = function (x, y) {
		return Document.prototype.elementsFromPoint.call(globalThis.document || this, x, y);
	};
}

globalThis.__kreuzcrawl_init = function () {
	_fpSeed = Date.now() ^ ((Math.random() * 0xffffffff) >>> 0);
	_fpCache = null;
	_installWasmStreamingFallback();

	globalThis.document = new Document(+_dom("document_node_id"));

	const scr = _fp("screen");
	const sw = scr[0],
		sh = scr[1];
	globalThis.screen = {
		width: sw,
		height: sh,
		availWidth: sw,
		availHeight: sh - 40,
		colorDepth: 24,
		pixelDepth: 24,
		availTop: 0,
		availLeft: 0,
		orientation: {
			type: "landscape-primary",
			angle: 0,
			addEventListener() {},
			removeEventListener() {},
			dispatchEvent() {
				return true;
			},
		},
	};
	globalThis.visualViewport = {
		width: sw,
		height: sh - 80,
		offsetLeft: 0,
		offsetTop: 0,
		scale: 1,
		addEventListener() {},
		removeEventListener() {},
	};
	globalThis.devicePixelRatio = sw >= 2560 ? 2 : 1;
	globalThis.innerWidth = sw;
	globalThis.innerHeight = sh - 80;
	globalThis.outerWidth = sw;
	globalThis.outerHeight = sh;

	const t0 = Date.now();
	globalThis.performance.timeOrigin = t0;
	globalThis.performance.timing = {
		navigationStart: t0,
		domContentLoadedEventEnd: t0,
		loadEventEnd: t0,
	};

	const hide = (obj, props) => {
		for (const p of props) {
			if (p in obj) {
				try {
					Object.defineProperty(obj, p, { enumerable: false, configurable: true });
				} catch (e) {}
			}
		}
	};
	const toHide = Object.keys(globalThis).filter(
		(k) => k.startsWith("_") || k.includes("kreuzcrawl") || k.includes("Kreuzcrawl"),
	);
	for (const p of toHide) {
		try {
			Object.defineProperty(globalThis, p, { enumerable: false });
		} catch (e) {}
	}
	delete globalThis.__kreuzcrawl_init;
};