@roomle/web-sdk 3.6.0 → 3.7.0-alpha.2

package/lib/roomle-headless-setup-LoBO7UJe.mjs

@@ -0,0 +1,1150 @@
+import { Image as e, ImageData as t, createCanvas as n } from "@napi-rs/canvas";
+import { createRequire as r } from "module";
+import { GlobalWindow as i, PropertySymbol as a } from "happy-dom";
+//#region packages/headless-core/src/setup-environment.ts
+var o = [
+	"fetch",
+	"Response",
+	"Request",
+	"Headers",
+	"AbortController",
+	"AbortSignal",
+	"ReadableStream",
+	"WritableStream",
+	"TransformStream",
+	"FormData",
+	"URL",
+	"URLSearchParams",
+	"constructor",
+	"undefined",
+	"NaN",
+	"global",
+	"globalThis"
+], s = class {
+	static #e = null;
+	static get isRegistered() {
+		return this.#e !== null;
+	}
+	static register(e) {
+		if (this.#e !== null) throw Error("Failed to register. Happy DOM has already been globally registered.");
+		let t = new i({
+			...e,
+			console: globalThis.console
+		});
+		this.#e = {};
+		let n = Object.getOwnPropertyDescriptors(t);
+		for (let e of Object.keys(n)) if (!o.includes(e)) {
+			let r = n[e], i = Object.getOwnPropertyDescriptor(globalThis, e);
+			(i?.value === void 0 || i?.value !== r?.value) && (this.#e[e] = i || null, r?.value === t && (t[e] = globalThis, r.value = globalThis), Object.defineProperty(globalThis, e, {
+				...r,
+				configurable: !0
+			}));
+		}
+		let r = Object.getOwnPropertySymbols(t);
+		for (let e of r) {
+			let n = Object.getOwnPropertyDescriptor(t, e);
+			this.#e[e] = null, n.value === t && (t[e] = globalThis, n.value = globalThis), Object.defineProperty(globalThis, e, {
+				...n,
+				configurable: !0
+			});
+		}
+		globalThis.document[a.defaultView] = globalThis;
+	}
+	static async unregister() {
+		if (this.#e === null) throw Error("Failed to unregister. Happy DOM has not previously been globally registered.");
+		let e = globalThis.happyDOM;
+		for (let e of Object.keys(this.#e)) this.#e[e] === null ? delete globalThis[e] : Object.defineProperty(globalThis, e, this.#e[e]);
+		this.#e = null, e && await e.close();
+	}
+}, c = r(import.meta.url), l = c("fs"), u = c("path"), d = c("url"), f = "";
+try {
+	f = u.dirname(d.fileURLToPath(import.meta.url));
+} catch {}
+var p = (e) => {
+	if (!f || !e.startsWith("/") || e.startsWith("//")) return null;
+	let t = u.join(f, e);
+	return l.existsSync(t) ? t : null;
+}, m = globalThis.fetch;
+globalThis.fetch = async (e, t) => {
+	let n = typeof e == "string" ? e : e instanceof URL ? e.href : e.url ?? String(e);
+	if (n.startsWith("file://")) {
+		let e = l.readFileSync(d.fileURLToPath(n));
+		return new Response(e, {
+			status: 200,
+			headers: { "Content-Type": "application/octet-stream" }
+		});
+	}
+	if (n.startsWith("/") && !n.startsWith("//")) {
+		let e = p(n);
+		return e ? new Response(l.readFileSync(e), {
+			status: 200,
+			headers: { "Content-Type": "application/octet-stream" }
+		}) : (console.warn(`[headless] fetch: root-relative asset not found: ${n} (bundle dir: ${f || "unknown"})`), new Response(null, {
+			status: 404,
+			statusText: "Not Found"
+		}));
+	}
+	return m.call(void 0, e, t);
+};
+var h = globalThis.Request;
+h && (globalThis.Request = new Proxy(h, {
+	construct(e, [t, n]) {
+		if (typeof t == "string" && t.startsWith("/") && !t.startsWith("//")) {
+			let e = p(t) ?? u.join(f || "/tmp", t);
+			t = d.pathToFileURL(e).href;
+		}
+		return Reflect.construct(e, n === void 0 ? [t] : [t, n], e);
+	},
+	get(e, t) {
+		return e[t];
+	}
+})), s.register(), globalThis.ImageData === void 0 && (globalThis.ImageData = t);
+var g = Symbol("napiImage"), _ = document.createElement.bind(document), v = document.createElementNS.bind(document), y = (e) => {
+	let t = e.drawImage.bind(e);
+	return e.drawImage = (e, ...n) => t(e?.[g] ?? e, ...n), e;
+}, b = null;
+try {
+	let { createContext: e } = await import("gl");
+	b = e, console.log("[headless] Using headless-gl (ANGLE) for real WebGL rendering");
+} catch (e) {
+	console.log(e), console.log("[headless] headless-gl not available, using mock WebGL context");
+}
+var x = (e) => {
+	let t = 1, n = () => ({ _mockId: t++ }), r = {
+		canvas: e,
+		drawingBufferWidth: e.width || 300,
+		drawingBufferHeight: e.height || 150,
+		drawingBufferColorSpace: "srgb",
+		getParameter(e) {
+			return {
+				7938: "WebGL 2.0 (Mock)",
+				35724: "OpenGL ES GLSL ES 3.00",
+				7936: "Mock",
+				7937: "Mock Headless Renderer",
+				3379: 16384,
+				34076: 16,
+				34921: 16,
+				34930: 32,
+				36347: 32,
+				35660: 4096,
+				35657: 4096,
+				35071: 16,
+				32883: 2048,
+				36063: 32,
+				34852: 8,
+				33001: 65536,
+				33002: 65536,
+				37154: 16,
+				36203: 2048,
+				35371: 16384,
+				35883: 16,
+				35376: 24,
+				35375: 256,
+				3378: new Int32Array([16384, 16384]),
+				34046: 16,
+				35658: 4096,
+				35661: 4096,
+				35978: 0,
+				2929: 1,
+				3413: 4,
+				3317: 4,
+				37445: 0,
+				37443: 0,
+				37444: 0,
+				37446: 0,
+				37447: 0
+			}[e] ?? 0;
+		},
+		getExtension(e) {
+			return e === "EXT_texture_filter_anisotropic" || e === "WEBKIT_EXT_texture_filter_anisotropic" ? {
+				TEXTURE_MAX_ANISOTROPY_EXT: 34046,
+				MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047
+			} : e === "EXT_color_buffer_float" || e === "EXT_color_buffer_half_float" || e === "OES_texture_float_linear" || e === "OES_texture_half_float_linear" || e === "EXT_float_blend" ? {} : null;
+		},
+		getSupportedExtensions() {
+			return [
+				"EXT_texture_filter_anisotropic",
+				"EXT_color_buffer_float",
+				"OES_texture_float_linear",
+				"OES_texture_half_float_linear",
+				"EXT_float_blend"
+			];
+		},
+		createShader: () => n(),
+		shaderSource() {},
+		compileShader() {},
+		getShaderParameter(e, t) {
+			return t === 35713 ? !0 : 0;
+		},
+		getShaderInfoLog() {
+			return "";
+		},
+		deleteShader() {},
+		createProgram: () => n(),
+		attachShader() {},
+		linkProgram() {},
+		getProgramParameter(e, t) {
+			return t === 35714 ? !0 : 0;
+		},
+		getProgramInfoLog() {
+			return "";
+		},
+		useProgram() {},
+		deleteProgram() {},
+		detachShader() {},
+		validateProgram() {},
+		getShaderPrecisionFormat() {
+			return {
+				rangeMin: 127,
+				rangeMax: 127,
+				precision: 23
+			};
+		},
+		getAttribLocation() {
+			return 0;
+		},
+		getUniformLocation() {
+			return n();
+		},
+		getActiveAttrib() {
+			return {
+				name: "a",
+				type: 5126,
+				size: 1
+			};
+		},
+		getActiveUniform() {
+			return {
+				name: "u",
+				type: 5126,
+				size: 1
+			};
+		},
+		uniform1f() {},
+		uniform2f() {},
+		uniform3f() {},
+		uniform4f() {},
+		uniform1i() {},
+		uniform2i() {},
+		uniform3i() {},
+		uniform4i() {},
+		uniform1ui() {},
+		uniform2ui() {},
+		uniform3ui() {},
+		uniform4ui() {},
+		uniform1fv() {},
+		uniform2fv() {},
+		uniform3fv() {},
+		uniform4fv() {},
+		uniform1iv() {},
+		uniform2iv() {},
+		uniform3iv() {},
+		uniform4iv() {},
+		uniform1uiv() {},
+		uniform2uiv() {},
+		uniform3uiv() {},
+		uniform4uiv() {},
+		uniformMatrix2fv() {},
+		uniformMatrix3fv() {},
+		uniformMatrix4fv() {},
+		uniformMatrix2x3fv() {},
+		uniformMatrix3x2fv() {},
+		uniformMatrix2x4fv() {},
+		uniformMatrix4x2fv() {},
+		uniformMatrix3x4fv() {},
+		uniformMatrix4x3fv() {},
+		createBuffer: () => n(),
+		bindBuffer() {},
+		bufferData() {},
+		bufferSubData() {},
+		deleteBuffer() {},
+		getBufferSubData() {},
+		copyBufferSubData() {},
+		isBuffer() {
+			return !0;
+		},
+		bindBufferBase() {},
+		bindBufferRange() {},
+		createVertexArray: () => n(),
+		bindVertexArray() {},
+		deleteVertexArray() {},
+		isVertexArray() {
+			return !0;
+		},
+		enableVertexAttribArray() {},
+		disableVertexAttribArray() {},
+		vertexAttribPointer() {},
+		vertexAttribIPointer() {},
+		vertexAttribDivisor() {},
+		vertexAttrib1f() {},
+		vertexAttrib2f() {},
+		vertexAttrib3f() {},
+		vertexAttrib4f() {},
+		vertexAttrib1fv() {},
+		vertexAttrib2fv() {},
+		vertexAttrib3fv() {},
+		vertexAttrib4fv() {},
+		createTexture: () => n(),
+		bindTexture() {},
+		activeTexture() {},
+		pixelStorei() {},
+		texImage2D() {},
+		texImage3D() {},
+		texSubImage2D() {},
+		texSubImage3D() {},
+		compressedTexImage2D() {},
+		compressedTexSubImage2D() {},
+		compressedTexImage3D() {},
+		compressedTexSubImage3D() {},
+		texParameteri() {},
+		texParameterf() {},
+		texStorage2D() {},
+		texStorage3D() {},
+		generateMipmap() {},
+		deleteTexture() {},
+		copyTexImage2D() {},
+		copyTexSubImage2D() {},
+		isTexture() {
+			return !0;
+		},
+		createFramebuffer: () => n(),
+		bindFramebuffer() {},
+		deleteFramebuffer() {},
+		framebufferTexture2D() {},
+		framebufferTextureLayer() {},
+		framebufferRenderbuffer() {},
+		checkFramebufferStatus() {
+			return 36053;
+		},
+		readPixels() {},
+		blitFramebuffer() {},
+		invalidateFramebuffer() {},
+		readBuffer() {},
+		drawBuffers() {},
+		isFramebuffer() {
+			return !0;
+		},
+		createRenderbuffer: () => n(),
+		bindRenderbuffer() {},
+		renderbufferStorage() {},
+		renderbufferStorageMultisample() {},
+		deleteRenderbuffer() {},
+		isRenderbuffer() {
+			return !0;
+		},
+		getRenderbufferParameter() {
+			return 0;
+		},
+		clear() {},
+		clearColor() {},
+		clearDepth() {},
+		clearStencil() {},
+		colorMask() {},
+		depthMask() {},
+		stencilMask() {},
+		stencilMaskSeparate() {},
+		viewport() {},
+		scissor() {},
+		drawArrays() {},
+		drawElements() {},
+		drawArraysInstanced() {},
+		drawElementsInstanced() {},
+		drawRangeElements() {},
+		enable() {},
+		disable() {},
+		isEnabled() {
+			return !1;
+		},
+		blendFunc() {},
+		blendFuncSeparate() {},
+		blendEquation() {},
+		blendEquationSeparate() {},
+		blendColor() {},
+		depthFunc() {},
+		depthRange() {},
+		stencilFunc() {},
+		stencilFuncSeparate() {},
+		stencilOp() {},
+		stencilOpSeparate() {},
+		cullFace() {},
+		frontFace() {},
+		lineWidth() {},
+		polygonOffset() {},
+		sampleCoverage() {},
+		createTransformFeedback: () => n(),
+		bindTransformFeedback() {},
+		beginTransformFeedback() {},
+		endTransformFeedback() {},
+		transformFeedbackVaryings() {},
+		deleteTransformFeedback() {},
+		pauseTransformFeedback() {},
+		resumeTransformFeedback() {},
+		createQuery: () => n(),
+		deleteQuery() {},
+		beginQuery() {},
+		endQuery() {},
+		getQueryParameter() {
+			return 0;
+		},
+		getQuery() {
+			return null;
+		},
+		fenceSync: () => n(),
+		deleteSync() {},
+		clientWaitSync() {
+			return 37149;
+		},
+		waitSync() {},
+		getSyncParameter() {
+			return 37145;
+		},
+		createSampler: () => n(),
+		deleteSampler() {},
+		bindSampler() {},
+		samplerParameteri() {},
+		samplerParameterf() {},
+		isSampler() {
+			return !0;
+		},
+		getUniformBlockIndex() {
+			return 0;
+		},
+		uniformBlockBinding() {},
+		getActiveUniformBlockParameter() {
+			return 0;
+		},
+		getActiveUniformBlockName() {
+			return "";
+		},
+		getUniformIndices() {
+			return [];
+		},
+		getActiveUniforms() {
+			return [];
+		},
+		finish() {},
+		flush() {},
+		getError() {
+			return 0;
+		},
+		isContextLost() {
+			return !1;
+		},
+		getContextAttributes() {
+			return {
+				alpha: !0,
+				antialias: !0,
+				depth: !0,
+				failIfMajorPerformanceCaveat: !1,
+				powerPreference: "default",
+				premultipliedAlpha: !0,
+				preserveDrawingBuffer: !1,
+				stencil: !0,
+				desynchronized: !1
+			};
+		},
+		getInternalformatParameter() {
+			return new Int32Array([8]);
+		},
+		hint() {},
+		makeXRCompatible() {
+			return Promise.resolve();
+		}
+	};
+	return Object.assign(r, {
+		DEPTH_BUFFER_BIT: 256,
+		STENCIL_BUFFER_BIT: 1024,
+		COLOR_BUFFER_BIT: 16384,
+		POINTS: 0,
+		LINES: 1,
+		LINE_LOOP: 2,
+		LINE_STRIP: 3,
+		TRIANGLES: 4,
+		TRIANGLE_STRIP: 5,
+		TRIANGLE_FAN: 6,
+		ZERO: 0,
+		ONE: 1,
+		SRC_COLOR: 768,
+		ONE_MINUS_SRC_COLOR: 769,
+		SRC_ALPHA: 770,
+		ONE_MINUS_SRC_ALPHA: 771,
+		DST_ALPHA: 772,
+		ONE_MINUS_DST_ALPHA: 773,
+		DST_COLOR: 774,
+		ONE_MINUS_DST_COLOR: 775,
+		SRC_ALPHA_SATURATE: 776,
+		CONSTANT_COLOR: 32769,
+		ONE_MINUS_CONSTANT_COLOR: 32770,
+		CONSTANT_ALPHA: 32771,
+		ONE_MINUS_CONSTANT_ALPHA: 32772,
+		FUNC_ADD: 32774,
+		FUNC_SUBTRACT: 32778,
+		FUNC_REVERSE_SUBTRACT: 32779,
+		MIN: 32775,
+		MAX: 32776,
+		BLEND_EQUATION: 32777,
+		BLEND_EQUATION_RGB: 32777,
+		BLEND_EQUATION_ALPHA: 34877,
+		BLEND_DST_RGB: 32968,
+		BLEND_SRC_RGB: 32969,
+		BLEND_DST_ALPHA: 32970,
+		BLEND_SRC_ALPHA: 32971,
+		BLEND_COLOR: 32773,
+		BLEND: 3042,
+		ARRAY_BUFFER: 34962,
+		ELEMENT_ARRAY_BUFFER: 34963,
+		ARRAY_BUFFER_BINDING: 34964,
+		ELEMENT_ARRAY_BUFFER_BINDING: 34965,
+		STREAM_DRAW: 35040,
+		STATIC_DRAW: 35044,
+		DYNAMIC_DRAW: 35048,
+		STREAM_READ: 35041,
+		STREAM_COPY: 35042,
+		STATIC_READ: 35045,
+		STATIC_COPY: 35046,
+		DYNAMIC_READ: 35049,
+		DYNAMIC_COPY: 35050,
+		BUFFER_SIZE: 34660,
+		BUFFER_USAGE: 34661,
+		CURRENT_VERTEX_ATTRIB: 34342,
+		CULL_FACE: 2884,
+		FRONT: 1028,
+		BACK: 1029,
+		FRONT_AND_BACK: 1032,
+		DEPTH_TEST: 2929,
+		DEPTH_WRITEMASK: 2930,
+		STENCIL_TEST: 2960,
+		SCISSOR_TEST: 3089,
+		POLYGON_OFFSET_FILL: 32823,
+		SAMPLE_ALPHA_TO_COVERAGE: 32926,
+		SAMPLE_COVERAGE: 32928,
+		DITHER: 3024,
+		NEVER: 512,
+		LESS: 513,
+		EQUAL: 514,
+		LEQUAL: 515,
+		GREATER: 516,
+		NOTEQUAL: 517,
+		GEQUAL: 518,
+		ALWAYS: 519,
+		KEEP: 7680,
+		REPLACE: 7681,
+		INCR: 7682,
+		DECR: 7683,
+		INVERT: 5386,
+		INCR_WRAP: 34055,
+		DECR_WRAP: 34056,
+		NEAREST: 9728,
+		LINEAR: 9729,
+		NEAREST_MIPMAP_NEAREST: 9984,
+		LINEAR_MIPMAP_NEAREST: 9985,
+		NEAREST_MIPMAP_LINEAR: 9986,
+		LINEAR_MIPMAP_LINEAR: 9987,
+		TEXTURE_MAG_FILTER: 10240,
+		TEXTURE_MIN_FILTER: 10241,
+		TEXTURE_WRAP_S: 10242,
+		TEXTURE_WRAP_T: 10243,
+		TEXTURE_2D: 3553,
+		TEXTURE_3D: 32879,
+		TEXTURE: 5890,
+		TEXTURE_CUBE_MAP: 34067,
+		TEXTURE_BINDING_CUBE_MAP: 34068,
+		TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
+		TEXTURE_CUBE_MAP_NEGATIVE_X: 34070,
+		TEXTURE_CUBE_MAP_POSITIVE_Y: 34071,
+		TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072,
+		TEXTURE_CUBE_MAP_POSITIVE_Z: 34073,
+		TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074,
+		MAX_CUBE_MAP_TEXTURE_SIZE: 34076,
+		TEXTURE0: 33984,
+		TEXTURE1: 33985,
+		TEXTURE2: 33986,
+		TEXTURE3: 33987,
+		TEXTURE4: 33988,
+		TEXTURE5: 33989,
+		TEXTURE6: 33990,
+		TEXTURE7: 33991,
+		TEXTURE8: 33992,
+		TEXTURE9: 33993,
+		TEXTURE10: 33994,
+		TEXTURE11: 33995,
+		TEXTURE12: 33996,
+		TEXTURE13: 33997,
+		TEXTURE14: 33998,
+		TEXTURE15: 33999,
+		TEXTURE16: 34e3,
+		TEXTURE17: 34001,
+		TEXTURE18: 34002,
+		TEXTURE19: 34003,
+		TEXTURE20: 34004,
+		TEXTURE21: 34005,
+		TEXTURE22: 34006,
+		TEXTURE23: 34007,
+		TEXTURE24: 34008,
+		TEXTURE25: 34009,
+		TEXTURE26: 34010,
+		TEXTURE27: 34011,
+		TEXTURE28: 34012,
+		TEXTURE29: 34013,
+		TEXTURE30: 34014,
+		TEXTURE31: 34015,
+		ACTIVE_TEXTURE: 34016,
+		REPEAT: 10497,
+		CLAMP_TO_EDGE: 33071,
+		MIRRORED_REPEAT: 33648,
+		FLOAT: 5126,
+		FLOAT_VEC2: 35664,
+		FLOAT_VEC3: 35665,
+		FLOAT_VEC4: 35666,
+		INT: 5124,
+		INT_VEC2: 35667,
+		INT_VEC3: 35668,
+		INT_VEC4: 35669,
+		UNSIGNED_INT: 5125,
+		BOOL: 35670,
+		BOOL_VEC2: 35671,
+		BOOL_VEC3: 35672,
+		BOOL_VEC4: 35673,
+		FLOAT_MAT2: 35674,
+		FLOAT_MAT3: 35675,
+		FLOAT_MAT4: 35676,
+		SAMPLER_2D: 35678,
+		SAMPLER_CUBE: 35680,
+		BYTE: 5120,
+		UNSIGNED_BYTE: 5121,
+		SHORT: 5122,
+		UNSIGNED_SHORT: 5123,
+		UNSIGNED_SHORT_4_4_4_4: 32819,
+		UNSIGNED_SHORT_5_5_5_1: 32820,
+		UNSIGNED_SHORT_5_6_5: 33635,
+		UNSIGNED_INT_24_8: 34042,
+		HALF_FLOAT: 5131,
+		FRAGMENT_SHADER: 35632,
+		VERTEX_SHADER: 35633,
+		MAX_VERTEX_ATTRIBS: 34921,
+		MAX_VERTEX_UNIFORM_VECTORS: 35660,
+		MAX_VARYING_VECTORS: 36347,
+		MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661,
+		MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35071,
+		MAX_TEXTURE_IMAGE_UNITS: 34930,
+		MAX_FRAGMENT_UNIFORM_VECTORS: 35657,
+		SHADER_TYPE: 35663,
+		DELETE_STATUS: 35712,
+		LINK_STATUS: 35714,
+		VALIDATE_STATUS: 35715,
+		ATTACHED_SHADERS: 35717,
+		ACTIVE_UNIFORMS: 35718,
+		ACTIVE_ATTRIBUTES: 35721,
+		COMPILE_STATUS: 35713,
+		FRAMEBUFFER: 36160,
+		RENDERBUFFER: 36161,
+		RGBA4: 32854,
+		RGB5_A1: 32855,
+		RGB565: 36194,
+		DEPTH_COMPONENT16: 33189,
+		DEPTH_COMPONENT24: 33190,
+		DEPTH_COMPONENT32F: 36012,
+		DEPTH24_STENCIL8: 35056,
+		DEPTH32F_STENCIL8: 36013,
+		STENCIL_INDEX8: 36168,
+		RENDERBUFFER_WIDTH: 36162,
+		RENDERBUFFER_HEIGHT: 36163,
+		RENDERBUFFER_INTERNAL_FORMAT: 36164,
+		FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048,
+		FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049,
+		FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050,
+		FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051,
+		COLOR_ATTACHMENT0: 36064,
+		COLOR_ATTACHMENT1: 36065,
+		COLOR_ATTACHMENT2: 36066,
+		COLOR_ATTACHMENT3: 36067,
+		DEPTH_ATTACHMENT: 36096,
+		STENCIL_ATTACHMENT: 36128,
+		DEPTH_STENCIL_ATTACHMENT: 33306,
+		DEPTH_STENCIL: 34041,
+		FRAMEBUFFER_COMPLETE: 36053,
+		FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054,
+		FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055,
+		FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057,
+		FRAMEBUFFER_UNSUPPORTED: 36061,
+		FRAMEBUFFER_BINDING: 36006,
+		RENDERBUFFER_BINDING: 36007,
+		MAX_RENDERBUFFER_SIZE: 34024,
+		INVALID_FRAMEBUFFER_OPERATION: 1286,
+		UNPACK_FLIP_Y_WEBGL: 37440,
+		UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441,
+		UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443,
+		READ_BUFFER: 3074,
+		UNPACK_ROW_LENGTH: 3314,
+		UNPACK_SKIP_ROWS: 3315,
+		UNPACK_SKIP_PIXELS: 3316,
+		PACK_ROW_LENGTH: 3330,
+		PACK_SKIP_ROWS: 3331,
+		PACK_SKIP_PIXELS: 3332,
+		TEXTURE_BINDING_3D: 32874,
+		UNPACK_SKIP_IMAGES: 32877,
+		UNPACK_IMAGE_HEIGHT: 32878,
+		MAX_3D_TEXTURE_SIZE: 32883,
+		MAX_ELEMENTS_VERTICES: 33001,
+		MAX_ELEMENTS_INDICES: 33002,
+		MAX_TEXTURE_LOD_BIAS: 34045,
+		MAX_DRAW_BUFFERS: 34852,
+		DRAW_BUFFER0: 34853,
+		MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657,
+		MAX_VERTEX_UNIFORM_COMPONENTS: 35658,
+		MAX_ARRAY_TEXTURE_LAYERS: 35071,
+		MIN_PROGRAM_TEXEL_OFFSET: 35076,
+		MAX_PROGRAM_TEXEL_OFFSET: 35077,
+		MAX_VARYING_COMPONENTS: 35659,
+		TEXTURE_2D_ARRAY: 35866,
+		TEXTURE_BINDING_2D_ARRAY: 35869,
+		UNIFORM_BUFFER: 35345,
+		UNIFORM_BUFFER_BINDING: 35368,
+		MAX_VERTEX_UNIFORM_BLOCKS: 35371,
+		MAX_FRAGMENT_UNIFORM_BLOCKS: 35373,
+		MAX_COMBINED_UNIFORM_BLOCKS: 35374,
+		MAX_UNIFORM_BUFFER_BINDINGS: 35375,
+		MAX_UNIFORM_BLOCK_SIZE: 35376,
+		UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380,
+		ACTIVE_UNIFORM_BLOCKS: 35382,
+		TRANSFORM_FEEDBACK_BUFFER: 35982,
+		TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983,
+		TRANSFORM_FEEDBACK_VARYINGS: 35971,
+		TRANSFORM_FEEDBACK: 36386,
+		PIXEL_PACK_BUFFER: 35051,
+		PIXEL_UNPACK_BUFFER: 35052,
+		COPY_READ_BUFFER: 36662,
+		COPY_WRITE_BUFFER: 36663,
+		DRAW_FRAMEBUFFER: 36009,
+		READ_FRAMEBUFFER: 36008,
+		DRAW_FRAMEBUFFER_BINDING: 36006,
+		READ_FRAMEBUFFER_BINDING: 36010,
+		RENDERBUFFER_SAMPLES: 36011,
+		MAX_COLOR_ATTACHMENTS: 36063,
+		TEXTURE_COMPARE_MODE: 34892,
+		TEXTURE_COMPARE_FUNC: 34893,
+		COMPARE_REF_TO_TEXTURE: 34894,
+		TEXTURE_WRAP_R: 32882,
+		TEXTURE_MIN_LOD: 33082,
+		TEXTURE_MAX_LOD: 33083,
+		TEXTURE_BASE_LEVEL: 33084,
+		TEXTURE_MAX_LEVEL: 33085,
+		TEXTURE_IMMUTABLE_FORMAT: 37167,
+		TEXTURE_IMMUTABLE_LEVELS: 33503,
+		RGBA8: 32856,
+		RGB8: 32849,
+		RG8: 33323,
+		R8: 33321,
+		RGBA16F: 34842,
+		RGB16F: 34843,
+		RG16F: 33327,
+		R16F: 33325,
+		RGBA32F: 34836,
+		RGB32F: 34837,
+		RG32F: 33328,
+		R32F: 33326,
+		RGBA8UI: 36220,
+		RGBA8I: 36238,
+		RGB8UI: 36221,
+		RGB8I: 36239,
+		RGBA16UI: 36214,
+		RGBA16I: 36232,
+		RGB16UI: 36215,
+		RGB16I: 36233,
+		RGBA32UI: 36208,
+		RGBA32I: 36226,
+		RGB32UI: 36209,
+		RGB32I: 36227,
+		R8I: 33329,
+		R8UI: 33330,
+		R16I: 33331,
+		R16UI: 33332,
+		R32I: 33333,
+		R32UI: 33334,
+		RG8I: 33335,
+		RG8UI: 33336,
+		RG16I: 33337,
+		RG16UI: 33338,
+		RG32I: 33339,
+		RG32UI: 33340,
+		R11F_G11F_B10F: 35898,
+		RGB9_E5: 35901,
+		SRGB8: 35905,
+		SRGB8_ALPHA8: 35907,
+		SRGB: 35904,
+		RGB10_A2: 32857,
+		RGB10_A2UI: 36975,
+		RGBA_INTEGER: 36249,
+		RGB_INTEGER: 36248,
+		RG_INTEGER: 33320,
+		RED_INTEGER: 36244,
+		ALPHA: 6406,
+		RGB: 6407,
+		RGBA: 6408,
+		LUMINANCE: 6409,
+		LUMINANCE_ALPHA: 6410,
+		DEPTH_COMPONENT: 6402,
+		RED: 6403,
+		RG: 33319,
+		VERSION: 7938,
+		SHADING_LANGUAGE_VERSION: 35724,
+		VENDOR: 7936,
+		RENDERER: 7937,
+		IMPLEMENTATION_COLOR_READ_TYPE: 35738,
+		IMPLEMENTATION_COLOR_READ_FORMAT: 35739,
+		NO_ERROR: 0,
+		INVALID_ENUM: 1280,
+		INVALID_VALUE: 1281,
+		INVALID_OPERATION: 1282,
+		OUT_OF_MEMORY: 1285,
+		CW: 2304,
+		CCW: 2305,
+		DONT_CARE: 4352,
+		FASTEST: 4353,
+		NICEST: 4354,
+		GENERATE_MIPMAP_HINT: 33170,
+		FRAGMENT_SHADER_DERIVATIVE_HINT: 35723,
+		VERTEX_ATTRIB_ARRAY_DIVISOR: 35070,
+		MAX_SAMPLES: 36183,
+		RASTERIZER_DISCARD: 35977,
+		ANY_SAMPLES_PASSED: 35887,
+		ANY_SAMPLES_PASSED_CONSERVATIVE: 36202,
+		TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976
+	}), new Proxy(r, { get(e, t) {
+		if (t in e) return e[t];
+		if (typeof t == "string") return /^[A-Z][A-Z0-9_]*$/.test(t) ? (console.warn(`[headless] Unknown WebGL constant accessed: ${t}`), 0) : () => {};
+	} });
+}, S = (e, t) => {
+	let n = e.width || 300, r = e.height || 150, i = b(n, r, {
+		createWebGL2Context: !0,
+		preserveDrawingBuffer: !0,
+		antialias: t?.antialias ?? !0,
+		alpha: t?.alpha ?? !0
+	}), a = {
+		TEXTURE_2D_ARRAY: 35866,
+		TEXTURE_BINDING_2D_ARRAY: 35869,
+		TEXTURE_3D: 32879,
+		TEXTURE_BINDING_3D: 32874,
+		TEXTURE_WRAP_R: 32882,
+		TEXTURE_COMPARE_MODE: 34892,
+		TEXTURE_COMPARE_FUNC: 34893,
+		COMPARE_REF_TO_TEXTURE: 34894,
+		TEXTURE_MIN_LOD: 33082,
+		TEXTURE_MAX_LOD: 33083,
+		TEXTURE_BASE_LEVEL: 33084,
+		TEXTURE_MAX_LEVEL: 33085,
+		TEXTURE_IMMUTABLE_FORMAT: 37167,
+		TEXTURE_IMMUTABLE_LEVELS: 33503,
+		UNIFORM_BUFFER: 35345,
+		UNIFORM_BUFFER_BINDING: 35368,
+		MAX_VERTEX_UNIFORM_BLOCKS: 35371,
+		MAX_FRAGMENT_UNIFORM_BLOCKS: 35373,
+		MAX_COMBINED_UNIFORM_BLOCKS: 35374,
+		MAX_UNIFORM_BUFFER_BINDINGS: 35375,
+		MAX_UNIFORM_BLOCK_SIZE: 35376,
+		UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380,
+		ACTIVE_UNIFORM_BLOCKS: 35382,
+		TRANSFORM_FEEDBACK_BUFFER: 35982,
+		TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983,
+		TRANSFORM_FEEDBACK_VARYINGS: 35971,
+		TRANSFORM_FEEDBACK: 36386,
+		PIXEL_PACK_BUFFER: 35051,
+		PIXEL_UNPACK_BUFFER: 35052,
+		COPY_READ_BUFFER: 36662,
+		COPY_WRITE_BUFFER: 36663,
+		DRAW_FRAMEBUFFER: 36009,
+		READ_FRAMEBUFFER: 36008,
+		DRAW_FRAMEBUFFER_BINDING: 36006,
+		READ_FRAMEBUFFER_BINDING: 36010,
+		RENDERBUFFER_SAMPLES: 36011,
+		MAX_COLOR_ATTACHMENTS: 36063,
+		COLOR_ATTACHMENT1: 36065,
+		COLOR_ATTACHMENT2: 36066,
+		COLOR_ATTACHMENT3: 36067,
+		DEPTH_COMPONENT24: 33190,
+		DEPTH_COMPONENT32F: 36012,
+		DEPTH24_STENCIL8: 35056,
+		DEPTH32F_STENCIL8: 36013,
+		READ_BUFFER: 3074,
+		UNPACK_ROW_LENGTH: 3314,
+		UNPACK_SKIP_ROWS: 3315,
+		UNPACK_SKIP_PIXELS: 3316,
+		UNPACK_IMAGE_HEIGHT: 32878,
+		UNPACK_SKIP_IMAGES: 32877,
+		PACK_ROW_LENGTH: 3330,
+		PACK_SKIP_ROWS: 3331,
+		PACK_SKIP_PIXELS: 3332,
+		RGBA8: 32856,
+		RGB8: 32849,
+		RG8: 33323,
+		R8: 33321,
+		RGBA16F: 34842,
+		RGB16F: 34843,
+		RG16F: 33327,
+		R16F: 33325,
+		RGBA32F: 34836,
+		RGB32F: 34837,
+		RG32F: 33328,
+		R32F: 33326,
+		RGBA8UI: 36220,
+		RGBA8I: 36238,
+		RGB8UI: 36221,
+		RGB8I: 36239,
+		RGBA16UI: 36214,
+		RGBA16I: 36232,
+		RGB16UI: 36215,
+		RGB16I: 36233,
+		RGBA32UI: 36208,
+		RGBA32I: 36226,
+		RGB32UI: 36209,
+		RGB32I: 36227,
+		R8I: 33329,
+		R8UI: 33330,
+		R16I: 33331,
+		R16UI: 33332,
+		R32I: 33333,
+		R32UI: 33334,
+		RG8I: 33335,
+		RG8UI: 33336,
+		RG16I: 33337,
+		RG16UI: 33338,
+		RG32I: 33339,
+		RG32UI: 33340,
+		R11F_G11F_B10F: 35898,
+		RGB9_E5: 35901,
+		SRGB8: 35905,
+		SRGB8_ALPHA8: 35907,
+		SRGB: 35904,
+		RGB10_A2: 32857,
+		RGB10_A2UI: 36975,
+		RGBA_INTEGER: 36249,
+		RGB_INTEGER: 36248,
+		RG_INTEGER: 33320,
+		RED_INTEGER: 36244,
+		RED: 6403,
+		RG: 33319,
+		HALF_FLOAT: 5131,
+		MIN: 32775,
+		MAX: 32776,
+		UNSIGNED_INT_24_8: 34042,
+		RASTERIZER_DISCARD: 35977,
+		ANY_SAMPLES_PASSED: 35887,
+		ANY_SAMPLES_PASSED_CONSERVATIVE: 36202,
+		TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976,
+		VERTEX_ATTRIB_ARRAY_DIVISOR: 35070,
+		MAX_3D_TEXTURE_SIZE: 32883,
+		MAX_ARRAY_TEXTURE_LAYERS: 35071,
+		MAX_DRAW_BUFFERS: 34852,
+		DRAW_BUFFER0: 34853,
+		FRAGMENT_SHADER_DERIVATIVE_HINT: 35723,
+		STREAM_READ: 35041,
+		STREAM_COPY: 35042,
+		STATIC_READ: 35045,
+		STATIC_COPY: 35046,
+		DYNAMIC_READ: 35049,
+		DYNAMIC_COPY: 35050,
+		VERSION: 7938,
+		SHADING_LANGUAGE_VERSION: 35724,
+		VENDOR: 7936,
+		RENDERER: 7937
+	}, o = i.getParameter.bind(i), s = {
+		7938: "WebGL 2.0 (headless-gl ANGLE)",
+		35724: "OpenGL ES GLSL ES 3.00",
+		7936: "headless-gl",
+		7937: "ANGLE",
+		36063: 8,
+		34852: 8,
+		32883: 2048,
+		35071: 2048,
+		35371: 16,
+		35373: 16,
+		35374: 24,
+		35375: 24,
+		35376: 16384,
+		35380: 256,
+		36183: 4,
+		36011: 4
+	}, c = () => {}, l = {
+		createVertexArray: i.createVertexArray?.bind(i) ?? (() => ({ _mockId: 1 })),
+		bindVertexArray: i.bindVertexArray?.bind(i) ?? c,
+		deleteVertexArray: i.deleteVertexArray?.bind(i) ?? c,
+		isVertexArray: i.isVertexArray?.bind(i) ?? (() => !0),
+		drawArraysInstanced: i.drawArraysInstanced?.bind(i) ?? c,
+		drawElementsInstanced: i.drawElementsInstanced?.bind(i) ?? c,
+		vertexAttribDivisor: i.vertexAttribDivisor?.bind(i) ?? c,
+		drawBuffers: i.drawBuffers?.bind(i) ?? c,
+		readBuffer: i.readBuffer?.bind(i) ?? c,
+		texImage3D: i.texImage3D?.bind(i) ?? c,
+		texSubImage3D: i.texSubImage3D?.bind(i) ?? c,
+		texStorage2D: i.texStorage2D?.bind(i) ?? c,
+		texStorage3D: i.texStorage3D?.bind(i) ?? c,
+		compressedTexImage3D: i.compressedTexImage3D?.bind(i) ?? c,
+		compressedTexSubImage3D: i.compressedTexSubImage3D?.bind(i) ?? c,
+		bindBufferBase: i.bindBufferBase?.bind(i) ?? c,
+		bindBufferRange: i.bindBufferRange?.bind(i) ?? c,
+		getUniformBlockIndex: i.getUniformBlockIndex?.bind(i) ?? (() => 0),
+		uniformBlockBinding: i.uniformBlockBinding?.bind(i) ?? c,
+		getActiveUniformBlockParameter: i.getActiveUniformBlockParameter?.bind(i) ?? (() => 0),
+		getActiveUniformBlockName: i.getActiveUniformBlockName?.bind(i) ?? (() => ""),
+		getUniformIndices: i.getUniformIndices?.bind(i) ?? (() => []),
+		getActiveUniforms: i.getActiveUniforms?.bind(i) ?? (() => []),
+		createTransformFeedback: i.createTransformFeedback?.bind(i) ?? (() => ({ _mockId: 1 })),
+		bindTransformFeedback: i.bindTransformFeedback?.bind(i) ?? c,
+		beginTransformFeedback: i.beginTransformFeedback?.bind(i) ?? c,
+		endTransformFeedback: i.endTransformFeedback?.bind(i) ?? c,
+		transformFeedbackVaryings: i.transformFeedbackVaryings?.bind(i) ?? c,
+		deleteTransformFeedback: i.deleteTransformFeedback?.bind(i) ?? c,
+		pauseTransformFeedback: i.pauseTransformFeedback?.bind(i) ?? c,
+		resumeTransformFeedback: i.resumeTransformFeedback?.bind(i) ?? c,
+		createQuery: i.createQuery?.bind(i) ?? (() => ({ _mockId: 1 })),
+		deleteQuery: i.deleteQuery?.bind(i) ?? c,
+		beginQuery: i.beginQuery?.bind(i) ?? c,
+		endQuery: i.endQuery?.bind(i) ?? c,
+		getQueryParameter: i.getQueryParameter?.bind(i) ?? (() => 0),
+		getQuery: i.getQuery?.bind(i) ?? (() => null),
+		fenceSync: i.fenceSync?.bind(i) ?? (() => ({ _mockId: 1 })),
+		deleteSync: i.deleteSync?.bind(i) ?? c,
+		clientWaitSync: i.clientWaitSync?.bind(i) ?? (() => 37149),
+		waitSync: i.waitSync?.bind(i) ?? c,
+		getSyncParameter: i.getSyncParameter?.bind(i) ?? (() => 37145),
+		createSampler: i.createSampler?.bind(i) ?? (() => ({ _mockId: 1 })),
+		deleteSampler: i.deleteSampler?.bind(i) ?? c,
+		bindSampler: i.bindSampler?.bind(i) ?? c,
+		samplerParameteri: i.samplerParameteri?.bind(i) ?? c,
+		samplerParameterf: i.samplerParameterf?.bind(i) ?? c,
+		isSampler: i.isSampler?.bind(i) ?? (() => !0),
+		blitFramebuffer: i.blitFramebuffer?.bind(i) ?? c,
+		invalidateFramebuffer: i.invalidateFramebuffer?.bind(i) ?? c,
+		framebufferTextureLayer: i.framebufferTextureLayer?.bind(i) ?? c,
+		renderbufferStorageMultisample: i.renderbufferStorageMultisample?.bind(i) ?? c,
+		getBufferSubData: i.getBufferSubData?.bind(i) ?? c,
+		copyBufferSubData: i.copyBufferSubData?.bind(i) ?? c,
+		drawRangeElements: i.drawRangeElements?.bind(i) ?? c,
+		vertexAttribIPointer: i.vertexAttribIPointer?.bind(i) ?? c,
+		uniform1ui: i.uniform1ui?.bind(i) ?? c,
+		uniform2ui: i.uniform2ui?.bind(i) ?? c,
+		uniform3ui: i.uniform3ui?.bind(i) ?? c,
+		uniform4ui: i.uniform4ui?.bind(i) ?? c,
+		uniform1uiv: i.uniform1uiv?.bind(i) ?? c,
+		uniform2uiv: i.uniform2uiv?.bind(i) ?? c,
+		uniform3uiv: i.uniform3uiv?.bind(i) ?? c,
+		uniform4uiv: i.uniform4uiv?.bind(i) ?? c,
+		uniformMatrix2x3fv: i.uniformMatrix2x3fv?.bind(i) ?? c,
+		uniformMatrix3x2fv: i.uniformMatrix3x2fv?.bind(i) ?? c,
+		uniformMatrix2x4fv: i.uniformMatrix2x4fv?.bind(i) ?? c,
+		uniformMatrix4x2fv: i.uniformMatrix4x2fv?.bind(i) ?? c,
+		uniformMatrix3x4fv: i.uniformMatrix3x4fv?.bind(i) ?? c,
+		uniformMatrix4x3fv: i.uniformMatrix4x3fv?.bind(i) ?? c,
+		getInternalformatParameter: i.getInternalformatParameter?.bind(i) ?? (() => new Int32Array([8]))
+	};
+	return new Proxy(i, { get(t, n) {
+		if (typeof n != "string") return t[n];
+		if (n === "canvas") return e;
+		if (n === "drawingBufferWidth") return e.width || 300;
+		if (n === "drawingBufferHeight") return e.height || 150;
+		if (n === "drawingBufferColorSpace") return "srgb";
+		if (n === "getParameter") return (e) => {
+			if (e in s) return s[e];
+			try {
+				return o(e);
+			} catch {
+				return 0;
+			}
+		};
+		if (n in l && typeof t[n] != "function") return l[n];
+		if (n in a && !(n in t)) return a[n];
+		let r = t[n];
+		return typeof r == "function" ? r.bind(t) : r;
+	} });
+}, C = (e = 300, r = 150) => {
+	let i = n(e, r), a = null, o = null, s = new Proxy(i, {
+		get(e, n) {
+			if (n === "style") return e._style ??= {};
+			if (n === "classList") return e._classList ??= {
+				add() {},
+				remove() {},
+				contains() {
+					return !1;
+				},
+				toggle() {}
+			};
+			if (n === Symbol.toStringTag) return "HTMLCanvasElement";
+			if (n === "getContext") return (t, n) => t === "2d" ? (a ||= y(e.getContext("2d", n)), a) : t === "webgl2" || t === "webgl" ? (o ||= b ? S(s, n) : x(s), o) : e.getContext(t, n);
+			if (n === "addEventListener" || n === "removeEventListener") return () => {};
+			if (n === "getBoundingClientRect") return () => ({
+				x: 0,
+				y: 0,
+				width: e.width,
+				height: e.height,
+				top: 0,
+				left: 0,
+				bottom: e.height,
+				right: e.width
+			});
+			if (n === "toDataURL" && o && b) return (n, r) => {
+				let i = e.width, a = e.height, s = new Uint8Array(i * a * 4);
+				o.readPixels(0, 0, i, a, o.RGBA ?? 6408, o.UNSIGNED_BYTE ?? 5121, s);
+				let c = new Uint8Array(i * a * 4), l = i * 4;
+				for (let e = 0; e < a; e++) c.set(s.subarray((a - e - 1) * l, (a - e) * l), e * l);
+				return e.getContext("2d").putImageData(new t(new Uint8ClampedArray(c.buffer), i, a), 0, 0), e.toDataURL(n, r);
+			};
+			let r = e[n];
+			return typeof r == "function" ? r.bind(e) : r;
+		},
+		set(e, t, n) {
+			if (e[t] = n, o && b && (t === "width" || t === "height")) {
+				let t = o.getExtension?.("STACKGL_resize_drawingbuffer");
+				t && t.resize(e.width, e.height);
+			}
+			return !0;
+		},
+		getPrototypeOf() {
+			return HTMLCanvasElement.prototype;
+		}
+	});
+	return s;
+}, w = () => {
+	let t = v("http://www.w3.org/1999/xhtml", "img"), n = new e();
+	t[g] = n;
+	let r = "";
+	return Object.defineProperty(t, "src", {
+		get() {
+			return r;
+		},
+		set(e) {
+			r = e, n.src = e;
+		},
+		configurable: !0
+	}), n.onload = () => {
+		Object.defineProperty(t, "width", {
+			value: n.width,
+			writable: !0,
+			configurable: !0
+		}), Object.defineProperty(t, "height", {
+			value: n.height,
+			writable: !0,
+			configurable: !0
+		}), Object.defineProperty(t, "naturalWidth", {
+			value: n.naturalWidth,
+			configurable: !0
+		}), Object.defineProperty(t, "naturalHeight", {
+			value: n.naturalHeight,
+			configurable: !0
+		}), Object.defineProperty(t, "complete", {
+			value: !0,
+			configurable: !0
+		}), t.dispatchEvent(new Event("load"));
+	}, n.onerror = (e) => {
+		t.dispatchEvent(new ErrorEvent("error", {
+			error: e,
+			message: e?.message
+		}));
+	}, t;
+};
+document.createElement = (e, t) => e.toLowerCase() === "canvas" ? C() : _(e, t), document.createElementNS = (e, t, n) => {
+	let r = t.toLowerCase();
+	return r === "canvas" ? C() : r === "img" ? w() : v(e, t, n);
+};
+//#endregion
+
+//# sourceMappingURL=roomle-headless-setup-LoBO7UJe.mjs.map