aoi-comp 1.0.0

package/dist/WebGLRenderer-CurPxJtF.js

@@ -0,0 +1,2210 @@
+import { n as e } from "./rolldown-runtime-CWhphoD1.js";
+import { Q as t, R as n, V as r, W as i, Z as a, a as o, b as s, d as c, et as l, it as u, l as d, m as f, nt as p, o as m, p as ee, r as h, rt as g, s as _, t as te, y as v } from "./Geometry-CN7W9DnD.js";
+import { D as ne, O as y, S as re, _ as ie, b, d as x, h as S, n as ae, p as oe, r as se, t as ce, w as C, y as le } from "./RenderTargetSystem-D_FiZPnb.js";
+import { a as w, c as ue, f as T, i as de, n as fe, o as pe, s as me, t as E, u as he } from "./BufferResource-CVU-ZRRz.js";
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/utils/browser/isSafari.mjs
+function ge() {
+	let { userAgent: e } = s.get().getNavigator();
+	return /^((?!chrome|android).)*safari/i.test(e);
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/batcher/gl/GlBatchAdaptor.mjs
+var D = class {
+	constructor() {
+		this._tempState = m.for2d(), this._didUploadHash = {};
+	}
+	init(e) {
+		e.renderer.runners.contextChange.add(this);
+	}
+	contextChange() {
+		this._didUploadHash = {};
+	}
+	start(e, t, n) {
+		let r = e.renderer, i = this._didUploadHash[n.uid];
+		r.shader.bind(n, i), i || (this._didUploadHash[n.uid] = !0), r.shader.updateUniformGroup(r.globalUniforms.uniformGroup), r.geometry.bind(t, n.glProgram);
+	}
+	execute(e, t) {
+		let n = e.renderer;
+		this._tempState.blendMode = t.blendMode, n.state.set(this._tempState);
+		let r = t.textures.textures;
+		for (let e = 0; e < t.textures.count; e++) n.texture.bind(r[e], e);
+		n.geometry.draw(t.topology, t.size, t.start);
+	}
+};
+D.extension = {
+	type: [g.WebGLPipesAdaptor],
+	name: "batch"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/buffer/const.mjs
+var O = /* @__PURE__ */ ((e) => (e[e.ELEMENT_ARRAY_BUFFER = 34963] = "ELEMENT_ARRAY_BUFFER", e[e.ARRAY_BUFFER = 34962] = "ARRAY_BUFFER", e[e.UNIFORM_BUFFER = 35345] = "UNIFORM_BUFFER", e))(O || {}), _e = class {
+	constructor(e, t) {
+		this._lastBindBaseLocation = -1, this._lastBindCallId = -1, this.buffer = e || null, this.updateID = -1, this.byteLength = -1, this.type = t;
+	}
+	destroy() {
+		this.buffer = null, this.updateID = -1, this.byteLength = -1, this.type = -1, this._lastBindBaseLocation = -1, this._lastBindCallId = -1;
+	}
+}, k = class {
+	constructor(e) {
+		this._boundBufferBases = /* @__PURE__ */ Object.create(null), this._minBaseLocation = 0, this._nextBindBaseIndex = this._minBaseLocation, this._bindCallId = 0, this._renderer = e, this._managedBuffers = new x({
+			renderer: e,
+			type: "resource",
+			onUnload: this.onBufferUnload.bind(this),
+			name: "glBuffer"
+		});
+	}
+	destroy() {
+		this._managedBuffers.destroy(), this._renderer = null, this._gl = null, this._boundBufferBases = {};
+	}
+	contextChange() {
+		this._gl = this._renderer.gl, this.destroyAll(!0), this._maxBindings = this._renderer.limits.maxUniformBindings;
+	}
+	getGlBuffer(e) {
+		return e._gcLastUsed = this._renderer.gc.now, e._gpuData[this._renderer.uid] || this.createGLBuffer(e);
+	}
+	bind(e) {
+		let { _gl: t } = this, n = this.getGlBuffer(e);
+		t.bindBuffer(n.type, n.buffer);
+	}
+	bindBufferBase(e, t) {
+		let { _gl: n } = this;
+		this._boundBufferBases[t] !== e && (this._boundBufferBases[t] = e, e._lastBindBaseLocation = t, n.bindBufferBase(n.UNIFORM_BUFFER, t, e.buffer));
+	}
+	nextBindBase(e) {
+		this._bindCallId++, this._minBaseLocation = 0, e && (this._boundBufferBases[0] = null, this._minBaseLocation = 1, this._nextBindBaseIndex < 1 && (this._nextBindBaseIndex = 1));
+	}
+	freeLocationForBufferBase(e) {
+		let t = this.getLastBindBaseLocation(e);
+		if (t >= this._minBaseLocation) return e._lastBindCallId = this._bindCallId, t;
+		let n = 0, r = this._nextBindBaseIndex;
+		for (; n < 2;) {
+			r >= this._maxBindings && (r = this._minBaseLocation, n++);
+			let e = this._boundBufferBases[r];
+			if (e && e._lastBindCallId === this._bindCallId) {
+				r++;
+				continue;
+			}
+			break;
+		}
+		return t = r, this._nextBindBaseIndex = r + 1, n >= 2 ? -1 : (e._lastBindCallId = this._bindCallId, this._boundBufferBases[t] = null, t);
+	}
+	getLastBindBaseLocation(e) {
+		let t = e._lastBindBaseLocation;
+		return this._boundBufferBases[t] === e ? t : -1;
+	}
+	bindBufferRange(e, t, n, r) {
+		let { _gl: i } = this;
+		n ||= 0, t ||= 0, this._boundBufferBases[t] = null, i.bindBufferRange(i.UNIFORM_BUFFER, t || 0, e.buffer, n * 256, r || 256);
+	}
+	updateBuffer(e) {
+		let { _gl: t } = this, n = this.getGlBuffer(e);
+		if (e._updateID === n.updateID) return n;
+		n.updateID = e._updateID, t.bindBuffer(n.type, n.buffer);
+		let r = e.data, i = e.descriptor.usage & h.STATIC ? t.STATIC_DRAW : t.DYNAMIC_DRAW;
+		return r ? n.byteLength >= r.byteLength ? t.bufferSubData(n.type, e._updateOffset, r, e._updateOffset / r.BYTES_PER_ELEMENT, (e._updateSize || r.byteLength) / r.BYTES_PER_ELEMENT) : (n.byteLength = r.byteLength, t.bufferData(n.type, r, i)) : (n.byteLength = e.descriptor.size, t.bufferData(n.type, n.byteLength, i)), n;
+	}
+	destroyAll(e = !1) {
+		this._managedBuffers.removeAll(e);
+	}
+	onBufferUnload(e, t = !1) {
+		let n = e._gpuData[this._renderer.uid];
+		n && (t || this._gl.deleteBuffer(n.buffer));
+	}
+	createGLBuffer(e) {
+		let { _gl: t } = this, n = O.ARRAY_BUFFER;
+		e.descriptor.usage & h.INDEX ? n = O.ELEMENT_ARRAY_BUFFER : e.descriptor.usage & h.UNIFORM && (n = O.UNIFORM_BUFFER);
+		let r = new _e(t.createBuffer(), n);
+		return e._gpuData[this._renderer.uid] = r, this._managedBuffers.add(e), r;
+	}
+	resetState() {
+		this._boundBufferBases = /* @__PURE__ */ Object.create(null);
+	}
+};
+k.extension = {
+	type: [g.WebGLSystem],
+	name: "buffer"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/context/GlContextSystem.mjs
+var A = class e {
+	constructor(e) {
+		this.supports = {
+			uint32Indices: !0,
+			uniformBufferObject: !0,
+			vertexArrayObject: !0,
+			srgbTextures: !0,
+			nonPowOf2wrapping: !0,
+			msaa: !0,
+			nonPowOf2mipmaps: !0
+		}, this._renderer = e, this.extensions = /* @__PURE__ */ Object.create(null), this.handleContextLost = this.handleContextLost.bind(this), this.handleContextRestored = this.handleContextRestored.bind(this);
+	}
+	get isLost() {
+		return !this.gl || this.gl.isContextLost();
+	}
+	contextChange(e) {
+		this.gl = e, this._renderer.gl = e;
+	}
+	init(t) {
+		t = {
+			...e.defaultOptions,
+			...t
+		};
+		let r = this.multiView = t.multiView;
+		if (t.context && r && (n("Renderer created with both a context and multiview enabled. Disabling multiView as both cannot work together."), r = !1), r ? this.canvas = s.get().createCanvas(this._renderer.canvas.width, this._renderer.canvas.height) : this.canvas = this._renderer.view.canvas, t.context) this.initFromContext(t.context);
+		else {
+			let e = this._renderer.background.alpha < 1, n = t.premultipliedAlpha ?? !0, r = t.antialias && !this._renderer.backBuffer.useBackBuffer;
+			this.createContext(t.preferWebGLVersion, {
+				alpha: e,
+				premultipliedAlpha: n,
+				antialias: r,
+				stencil: !0,
+				preserveDrawingBuffer: t.preserveDrawingBuffer,
+				powerPreference: t.powerPreference ?? "default"
+			});
+		}
+	}
+	ensureCanvasSize(e) {
+		if (!this.multiView) {
+			e !== this.canvas && n("multiView is disabled, but targetCanvas is not the main canvas");
+			return;
+		}
+		let { canvas: t } = this;
+		(t.width < e.width || t.height < e.height) && (t.width = Math.max(e.width, e.width), t.height = Math.max(e.height, e.height));
+	}
+	initFromContext(e) {
+		this.gl = e, this.webGLVersion = e instanceof s.get().getWebGLRenderingContext() ? 1 : 2, this.getExtensions(), this.validateContext(e), this._renderer.runners.contextChange.emit(e);
+		let t = this._renderer.view.canvas;
+		t.addEventListener("webglcontextlost", this.handleContextLost, !1), t.addEventListener("webglcontextrestored", this.handleContextRestored, !1);
+	}
+	createContext(e, t) {
+		let n, r = this.canvas;
+		if (e === 2 && (n = r.getContext("webgl2", t)), !n && (n = r.getContext("webgl", t), !n)) throw Error("This browser does not support WebGL. Try using the canvas renderer");
+		this.gl = n, this.initFromContext(this.gl);
+	}
+	getExtensions() {
+		let { gl: e } = this, t = {
+			anisotropicFiltering: e.getExtension("EXT_texture_filter_anisotropic"),
+			floatTextureLinear: e.getExtension("OES_texture_float_linear"),
+			s3tc: e.getExtension("WEBGL_compressed_texture_s3tc"),
+			s3tc_sRGB: e.getExtension("WEBGL_compressed_texture_s3tc_srgb"),
+			etc: e.getExtension("WEBGL_compressed_texture_etc"),
+			etc1: e.getExtension("WEBGL_compressed_texture_etc1"),
+			pvrtc: e.getExtension("WEBGL_compressed_texture_pvrtc") || e.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc"),
+			atc: e.getExtension("WEBGL_compressed_texture_atc"),
+			astc: e.getExtension("WEBGL_compressed_texture_astc"),
+			bptc: e.getExtension("EXT_texture_compression_bptc"),
+			rgtc: e.getExtension("EXT_texture_compression_rgtc"),
+			loseContext: e.getExtension("WEBGL_lose_context")
+		};
+		if (this.webGLVersion === 1) this.extensions = {
+			...t,
+			drawBuffers: e.getExtension("WEBGL_draw_buffers"),
+			depthTexture: e.getExtension("WEBGL_depth_texture"),
+			vertexArrayObject: e.getExtension("OES_vertex_array_object") || e.getExtension("MOZ_OES_vertex_array_object") || e.getExtension("WEBKIT_OES_vertex_array_object"),
+			uint32ElementIndex: e.getExtension("OES_element_index_uint"),
+			floatTexture: e.getExtension("OES_texture_float"),
+			floatTextureLinear: e.getExtension("OES_texture_float_linear"),
+			textureHalfFloat: e.getExtension("OES_texture_half_float"),
+			textureHalfFloatLinear: e.getExtension("OES_texture_half_float_linear"),
+			vertexAttribDivisorANGLE: e.getExtension("ANGLE_instanced_arrays"),
+			srgb: e.getExtension("EXT_sRGB")
+		};
+		else {
+			this.extensions = {
+				...t,
+				colorBufferFloat: e.getExtension("EXT_color_buffer_float")
+			};
+			let n = e.getExtension("WEBGL_provoking_vertex");
+			n && n.provokingVertexWEBGL(n.FIRST_VERTEX_CONVENTION_WEBGL);
+		}
+	}
+	handleContextLost(e) {
+		e.preventDefault(), this._contextLossForced && (this._contextLossForced = !1, setTimeout(() => {
+			this.gl.isContextLost() && this.extensions.loseContext?.restoreContext();
+		}, 0));
+	}
+	handleContextRestored() {
+		this.getExtensions(), this._renderer.runners.contextChange.emit(this.gl);
+	}
+	destroy() {
+		let e = this._renderer.view.canvas;
+		this._renderer = null, e.removeEventListener("webglcontextlost", this.handleContextLost), e.removeEventListener("webglcontextrestored", this.handleContextRestored), this.gl.useProgram(null), this.extensions.loseContext?.loseContext();
+	}
+	forceContextLoss() {
+		this.extensions.loseContext?.loseContext(), this._contextLossForced = !0;
+	}
+	validateContext(e) {
+		let t = e.getContextAttributes();
+		t && !t.stencil && n("Provided WebGL context does not have a stencil buffer, masks may not render correctly");
+		let r = this.supports, i = this.webGLVersion === 2, a = this.extensions;
+		r.uint32Indices = i || !!a.uint32ElementIndex, r.uniformBufferObject = i, r.vertexArrayObject = i || !!a.vertexArrayObject, r.srgbTextures = i || !!a.srgb, r.nonPowOf2wrapping = i, r.nonPowOf2mipmaps = i, r.msaa = i, r.uint32Indices || n("Provided WebGL context does not support 32 index buffer, large scenes may not render correctly");
+	}
+};
+A.extension = {
+	type: [g.WebGLSystem],
+	name: "context"
+}, A.defaultOptions = {
+	context: null,
+	premultipliedAlpha: !0,
+	preserveDrawingBuffer: !1,
+	powerPreference: void 0,
+	preferWebGLVersion: 2,
+	multiView: !1
+};
+var ve = A, j = /* @__PURE__ */ ((e) => (e[e.RGBA = 6408] = "RGBA", e[e.RGB = 6407] = "RGB", e[e.RG = 33319] = "RG", e[e.RED = 6403] = "RED", e[e.RGBA_INTEGER = 36249] = "RGBA_INTEGER", e[e.RGB_INTEGER = 36248] = "RGB_INTEGER", e[e.RG_INTEGER = 33320] = "RG_INTEGER", e[e.RED_INTEGER = 36244] = "RED_INTEGER", e[e.ALPHA = 6406] = "ALPHA", e[e.LUMINANCE = 6409] = "LUMINANCE", e[e.LUMINANCE_ALPHA = 6410] = "LUMINANCE_ALPHA", e[e.DEPTH_COMPONENT = 6402] = "DEPTH_COMPONENT", e[e.DEPTH_STENCIL = 34041] = "DEPTH_STENCIL", e))(j || {}), M = /* @__PURE__ */ ((e) => (e[e.TEXTURE_2D = 3553] = "TEXTURE_2D", e[e.TEXTURE_CUBE_MAP = 34067] = "TEXTURE_CUBE_MAP", e[e.TEXTURE_2D_ARRAY = 35866] = "TEXTURE_2D_ARRAY", e[e.TEXTURE_CUBE_MAP_POSITIVE_X = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X", e[e.TEXTURE_CUBE_MAP_NEGATIVE_X = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X", e[e.TEXTURE_CUBE_MAP_POSITIVE_Y = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y", e[e.TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y", e[e.TEXTURE_CUBE_MAP_POSITIVE_Z = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z", e[e.TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z", e))(M || {}), N = /* @__PURE__ */ ((e) => (e[e.UNSIGNED_BYTE = 5121] = "UNSIGNED_BYTE", e[e.UNSIGNED_SHORT = 5123] = "UNSIGNED_SHORT", e[e.UNSIGNED_SHORT_5_6_5 = 33635] = "UNSIGNED_SHORT_5_6_5", e[e.UNSIGNED_SHORT_4_4_4_4 = 32819] = "UNSIGNED_SHORT_4_4_4_4", e[e.UNSIGNED_SHORT_5_5_5_1 = 32820] = "UNSIGNED_SHORT_5_5_5_1", e[e.UNSIGNED_INT = 5125] = "UNSIGNED_INT", e[e.UNSIGNED_INT_10F_11F_11F_REV = 35899] = "UNSIGNED_INT_10F_11F_11F_REV", e[e.UNSIGNED_INT_2_10_10_10_REV = 33640] = "UNSIGNED_INT_2_10_10_10_REV", e[e.UNSIGNED_INT_24_8 = 34042] = "UNSIGNED_INT_24_8", e[e.UNSIGNED_INT_5_9_9_9_REV = 35902] = "UNSIGNED_INT_5_9_9_9_REV", e[e.BYTE = 5120] = "BYTE", e[e.SHORT = 5122] = "SHORT", e[e.INT = 5124] = "INT", e[e.FLOAT = 5126] = "FLOAT", e[e.FLOAT_32_UNSIGNED_INT_24_8_REV = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV", e[e.HALF_FLOAT = 36193] = "HALF_FLOAT", e))(N || {}), P = {
+	uint8x2: N.UNSIGNED_BYTE,
+	uint8x4: N.UNSIGNED_BYTE,
+	sint8x2: N.BYTE,
+	sint8x4: N.BYTE,
+	unorm8x2: N.UNSIGNED_BYTE,
+	unorm8x4: N.UNSIGNED_BYTE,
+	snorm8x2: N.BYTE,
+	snorm8x4: N.BYTE,
+	uint16x2: N.UNSIGNED_SHORT,
+	uint16x4: N.UNSIGNED_SHORT,
+	sint16x2: N.SHORT,
+	sint16x4: N.SHORT,
+	unorm16x2: N.UNSIGNED_SHORT,
+	unorm16x4: N.UNSIGNED_SHORT,
+	snorm16x2: N.SHORT,
+	snorm16x4: N.SHORT,
+	float16x2: N.HALF_FLOAT,
+	float16x4: N.HALF_FLOAT,
+	float32: N.FLOAT,
+	float32x2: N.FLOAT,
+	float32x3: N.FLOAT,
+	float32x4: N.FLOAT,
+	uint32: N.UNSIGNED_INT,
+	uint32x2: N.UNSIGNED_INT,
+	uint32x3: N.UNSIGNED_INT,
+	uint32x4: N.UNSIGNED_INT,
+	sint32: N.INT,
+	sint32x2: N.INT,
+	sint32x3: N.INT,
+	sint32x4: N.INT
+};
+function ye(e) {
+	return P[e] ?? P.float32;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/geometry/GlGeometrySystem.mjs
+var be = {
+	"point-list": 0,
+	"line-list": 1,
+	"line-strip": 3,
+	"triangle-list": 4,
+	"triangle-strip": 5
+}, xe = class {
+	constructor() {
+		this.vaoCache = /* @__PURE__ */ Object.create(null);
+	}
+	destroy() {
+		this.vaoCache = /* @__PURE__ */ Object.create(null);
+	}
+}, F = class {
+	constructor(e) {
+		this._renderer = e, this._activeGeometry = null, this._activeVao = null, this.hasVao = !0, this.hasInstance = !0, this._managedGeometries = new x({
+			renderer: e,
+			type: "resource",
+			onUnload: this.onGeometryUnload.bind(this),
+			name: "glGeometry"
+		});
+	}
+	contextChange() {
+		let e = this.gl = this._renderer.gl;
+		if (!this._renderer.context.supports.vertexArrayObject) throw Error("[PixiJS] Vertex Array Objects are not supported on this device");
+		this.destroyAll(!0);
+		let t = this._renderer.context.extensions.vertexArrayObject;
+		t && (e.createVertexArray = () => t.createVertexArrayOES(), e.bindVertexArray = (e) => t.bindVertexArrayOES(e), e.deleteVertexArray = (e) => t.deleteVertexArrayOES(e));
+		let n = this._renderer.context.extensions.vertexAttribDivisorANGLE;
+		n && (e.drawArraysInstanced = (e, t, r, i) => {
+			n.drawArraysInstancedANGLE(e, t, r, i);
+		}, e.drawElementsInstanced = (e, t, r, i, a) => {
+			n.drawElementsInstancedANGLE(e, t, r, i, a);
+		}, e.vertexAttribDivisor = (e, t) => n.vertexAttribDivisorANGLE(e, t)), this._activeGeometry = null, this._activeVao = null;
+	}
+	bind(e, t) {
+		let n = this.gl;
+		this._activeGeometry = e;
+		let r = this.getVao(e, t);
+		this._activeVao !== r && (this._activeVao = r, n.bindVertexArray(r)), this.updateBuffers();
+	}
+	resetState() {
+		this.unbind();
+	}
+	updateBuffers() {
+		let e = this._activeGeometry, t = this._renderer.buffer;
+		for (let n = 0; n < e.buffers.length; n++) {
+			let r = e.buffers[n];
+			t.updateBuffer(r);
+		}
+		e._gcLastUsed = this._renderer.gc.now;
+	}
+	checkCompatibility(e, t) {
+		let n = e.attributes, r = t._attributeData;
+		for (let e in r) if (!n[e]) throw Error(`shader and geometry incompatible, geometry missing the "${e}" attribute`);
+	}
+	getSignature(e, t) {
+		let n = e.attributes, r = t._attributeData, i = ["g", e.uid];
+		for (let e in n) r[e] && i.push(e, r[e].location);
+		return i.join("-");
+	}
+	getVao(e, t) {
+		return e._gpuData[this._renderer.uid]?.vaoCache[t._key] || this.initGeometryVao(e, t);
+	}
+	initGeometryVao(e, t, n = !0) {
+		let r = this._renderer.gl, i = this._renderer.buffer;
+		this._renderer.shader._getProgramData(t), this.checkCompatibility(e, t);
+		let a = this.getSignature(e, t), o = e._gpuData[this._renderer.uid];
+		o || (o = new xe(), e._gpuData[this._renderer.uid] = o, this._managedGeometries.add(e));
+		let s = o.vaoCache, c = s[a];
+		if (c) return s[t._key] = c, c;
+		ue(e, t._attributeData);
+		let l = e.buffers;
+		c = r.createVertexArray(), r.bindVertexArray(c);
+		for (let e = 0; e < l.length; e++) {
+			let t = l[e];
+			i.bind(t);
+		}
+		return this.activateVao(e, t), s[t._key] = c, s[a] = c, r.bindVertexArray(null), c;
+	}
+	onGeometryUnload(e, t = !1) {
+		let n = e._gpuData[this._renderer.uid];
+		if (!n) return;
+		let r = n.vaoCache;
+		if (!t) for (let e in r) this._activeVao !== r[e] && this.resetState(), this.gl.deleteVertexArray(r[e]);
+	}
+	destroyAll(e = !1) {
+		this._managedGeometries.removeAll(e);
+	}
+	activateVao(e, t) {
+		let n = this._renderer.gl, r = this._renderer.buffer, i = e.attributes;
+		e.indexBuffer && r.bind(e.indexBuffer);
+		let a = null;
+		for (let e in i) {
+			let o = i[e], s = o.buffer, c = r.getGlBuffer(s), l = t._attributeData[e];
+			if (l) {
+				a !== c && (r.bind(s), a = c);
+				let e = l.location;
+				n.enableVertexAttribArray(e);
+				let t = ee(o.format), i = ye(o.format);
+				if (l.format?.substring(1, 4) === "int" ? n.vertexAttribIPointer(e, t.size, i, o.stride, o.offset) : n.vertexAttribPointer(e, t.size, i, t.normalised, o.stride, o.offset), o.instance) if (this.hasInstance) {
+					let t = o.divisor ?? 1;
+					n.vertexAttribDivisor(e, t);
+				} else throw Error("geometry error, GPU Instancing is not supported on this device");
+			}
+		}
+	}
+	draw(e, t, n, r) {
+		let { gl: i } = this._renderer, a = this._activeGeometry, o = be[e || a.topology];
+		if (r ??= a.instanceCount, a.indexBuffer) {
+			let e = a.indexBuffer.data.BYTES_PER_ELEMENT, s = e === 2 ? i.UNSIGNED_SHORT : i.UNSIGNED_INT;
+			r === 1 ? i.drawElements(o, t || a.indexBuffer.data.length, s, (n || 0) * e) : i.drawElementsInstanced(o, t || a.indexBuffer.data.length, s, (n || 0) * e, r);
+		} else r === 1 ? i.drawArrays(o, n || 0, t || a.vertexCount) : i.drawArraysInstanced(o, n || 0, t || a.vertexCount, r);
+		return this;
+	}
+	unbind() {
+		this.gl.bindVertexArray(null), this._activeVao = null, this._activeGeometry = null;
+	}
+	destroy() {
+		this._managedGeometries.destroy(), this._renderer = null, this.gl = null, this._activeVao = null, this._activeGeometry = null;
+	}
+};
+F.extension = {
+	type: [g.WebGLSystem],
+	name: "geometry"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/GlBackBufferSystem.mjs
+var Se = new te({ attributes: { aPosition: [
+	-1,
+	-1,
+	3,
+	-1,
+	-1,
+	3
+] } }), I = class e {
+	constructor(e) {
+		this.useBackBuffer = !1, this._useBackBufferThisRender = !1, this._renderer = e;
+	}
+	init(t = {}) {
+		let { useBackBuffer: i, antialias: a } = {
+			...e.defaultOptions,
+			...t
+		};
+		this.useBackBuffer = i, this._antialias = a, this._renderer.context.supports.msaa || (n("antialiasing, is not supported on when using the back buffer"), this._antialias = !1), this._state = m.for2d();
+		let o = new f({
+			vertex: "\n                attribute vec2 aPosition;\n                out vec2 vUv;\n\n                void main() {\n                    gl_Position = vec4(aPosition, 0.0, 1.0);\n\n                    vUv = (aPosition + 1.0) / 2.0;\n\n                    // flip dem UVs\n                    vUv.y = 1.0 - vUv.y;\n                }",
+			fragment: "\n                in vec2 vUv;\n                out vec4 finalColor;\n\n                uniform sampler2D uTexture;\n\n                void main() {\n                    finalColor = texture(uTexture, vUv);\n                }",
+			name: "big-triangle"
+		});
+		this._bigTriangleShader = new _({
+			glProgram: o,
+			resources: { uTexture: r.WHITE.source }
+		});
+	}
+	renderStart(e) {
+		let t = this._renderer.renderTarget.getRenderTarget(e.target);
+		if (this._useBackBufferThisRender = this.useBackBuffer && !!t.isRoot, this._useBackBufferThisRender) {
+			let t = this._renderer.renderTarget.getRenderTarget(e.target);
+			this._targetTexture = t.colorTexture, e.target = this._getBackBufferTexture(t.colorTexture);
+		}
+	}
+	renderEnd() {
+		this._presentBackBuffer();
+	}
+	_presentBackBuffer() {
+		let e = this._renderer;
+		e.renderTarget.finishRenderPass(), this._useBackBufferThisRender && (e.renderTarget.bind({
+			target: this._targetTexture,
+			clear: !1
+		}), this._bigTriangleShader.resources.uTexture = this._backBufferTexture.source, e.encoder.draw({
+			geometry: Se,
+			shader: this._bigTriangleShader,
+			state: this._state
+		}));
+	}
+	_getBackBufferTexture(e) {
+		return this._backBufferTexture = this._backBufferTexture || new r({ source: new i({
+			width: e.width,
+			height: e.height,
+			resolution: e._resolution,
+			antialias: this._antialias
+		}) }), this._backBufferTexture.source.resize(e.width, e.height, e._resolution), this._backBufferTexture;
+	}
+	destroy() {
+		this._backBufferTexture &&= (this._backBufferTexture.destroy(), null);
+	}
+};
+I.extension = {
+	type: [g.WebGLSystem],
+	name: "backBuffer",
+	priority: 1
+}, I.defaultOptions = { useBackBuffer: !1 };
+var Ce = I, L = class {
+	constructor(e) {
+		this._colorMaskCache = 15, this._renderer = e;
+	}
+	setMask(e) {
+		this._colorMaskCache !== e && (this._colorMaskCache = e, this._renderer.gl.colorMask(!!(e & 8), !!(e & 4), !!(e & 2), !!(e & 1)));
+	}
+};
+L.extension = {
+	type: [g.WebGLSystem],
+	name: "colorMask"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/GlEncoderSystem.mjs
+var R = class {
+	constructor(e) {
+		this.commandFinished = Promise.resolve(), this._renderer = e;
+	}
+	setGeometry(e, t) {
+		this._renderer.geometry.bind(e, t.glProgram);
+	}
+	finishRenderPass() {}
+	draw(e) {
+		let t = this._renderer, { geometry: n, shader: r, state: i, skipSync: a, topology: o, size: s, start: c, instanceCount: l } = e;
+		t.shader.bind(r, a), t.geometry.bind(n, t.shader._activeProgram), i && t.state.set(i), t.geometry.draw(o, s, c, l ?? n.instanceCount);
+	}
+	destroy() {
+		this._renderer = null;
+	}
+};
+R.extension = {
+	type: [g.WebGLSystem],
+	name: "encoder"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/GlLimitsSystem.mjs
+var z = class {
+	constructor(e) {
+		this._renderer = e;
+	}
+	contextChange() {
+		let e = this._renderer.gl;
+		this.maxTextures = e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS), this.maxBatchableTextures = re(this.maxTextures, e);
+		let t = this._renderer.context.webGLVersion === 2;
+		this.maxUniformBindings = t ? e.getParameter(e.MAX_UNIFORM_BUFFER_BINDINGS) : 0;
+	}
+	destroy() {}
+};
+z.extension = {
+	type: [g.WebGLSystem],
+	name: "limits"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/GlRenderTarget.mjs
+var we = class {
+	constructor() {
+		this.width = -1, this.height = -1, this.msaa = !1, this._attachedMipLevel = 0, this._attachedLayer = 0, this.msaaRenderBuffer = [];
+	}
+}, B = class {
+	constructor(e) {
+		this._stencilCache = {
+			enabled: !1,
+			stencilReference: 0,
+			stencilMode: C.NONE
+		}, this._renderTargetStencilState = /* @__PURE__ */ Object.create(null), e.renderTarget.onRenderTargetChange.add(this);
+	}
+	contextChange(e) {
+		this._gl = e, this._comparisonFuncMapping = {
+			always: e.ALWAYS,
+			never: e.NEVER,
+			equal: e.EQUAL,
+			"not-equal": e.NOTEQUAL,
+			less: e.LESS,
+			"less-equal": e.LEQUAL,
+			greater: e.GREATER,
+			"greater-equal": e.GEQUAL
+		}, this._stencilOpsMapping = {
+			keep: e.KEEP,
+			zero: e.ZERO,
+			replace: e.REPLACE,
+			invert: e.INVERT,
+			"increment-clamp": e.INCR,
+			"decrement-clamp": e.DECR,
+			"increment-wrap": e.INCR_WRAP,
+			"decrement-wrap": e.DECR_WRAP
+		}, this.resetState();
+	}
+	onRenderTargetChange(e) {
+		if (this._activeRenderTarget === e) return;
+		this._activeRenderTarget = e;
+		let t = this._renderTargetStencilState[e.uid];
+		t ||= this._renderTargetStencilState[e.uid] = {
+			stencilMode: C.DISABLED,
+			stencilReference: 0
+		}, this.setStencilMode(t.stencilMode, t.stencilReference);
+	}
+	resetState() {
+		this._stencilCache.enabled = !1, this._stencilCache.stencilMode = C.NONE, this._stencilCache.stencilReference = 0;
+	}
+	setStencilMode(e, t) {
+		let n = this._renderTargetStencilState[this._activeRenderTarget.uid], r = this._gl, i = me[e], a = this._stencilCache;
+		if (n.stencilMode = e, n.stencilReference = t, e === C.DISABLED) {
+			this._stencilCache.enabled && (this._stencilCache.enabled = !1, r.disable(r.STENCIL_TEST));
+			return;
+		}
+		this._stencilCache.enabled || (this._stencilCache.enabled = !0, r.enable(r.STENCIL_TEST)), (e !== a.stencilMode || a.stencilReference !== t) && (a.stencilMode = e, a.stencilReference = t, r.stencilFunc(this._comparisonFuncMapping[i.stencilBack.compare], t, 255), r.stencilOp(r.KEEP, r.KEEP, this._stencilOpsMapping[i.stencilBack.passOp]));
+	}
+};
+B.extension = {
+	type: [g.WebGLSystem],
+	name: "stencil"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/utils/createUboElementsSTD40.mjs
+var V = {
+	f32: 4,
+	i32: 4,
+	"vec2<f32>": 8,
+	"vec3<f32>": 12,
+	"vec4<f32>": 16,
+	"vec2<i32>": 8,
+	"vec3<i32>": 12,
+	"vec4<i32>": 16,
+	u32: 4,
+	"vec2<u32>": 8,
+	"vec3<u32>": 12,
+	"vec4<u32>": 16,
+	"mat2x2<f32>": 32,
+	"mat3x3<f32>": 48,
+	"mat4x4<f32>": 64
+};
+function Te(e) {
+	let t = e.map((e) => ({
+		data: e,
+		offset: 0,
+		size: 0
+	})), n = 0, r = 0;
+	for (let e = 0; e < t.length; e++) {
+		let i = t[e];
+		if (n = V[i.data.type], !n) throw Error(`Unknown type ${i.data.type}`);
+		i.data.size > 1 && (n = Math.max(n, 16) * i.data.size);
+		let a = n === 12 ? 16 : n;
+		i.size = n;
+		let o = r % 16;
+		o > 0 && 16 - o < a ? r += (16 - o) % 16 : r += (n - o % n) % n, i.offset = r, r += n;
+	}
+	return r = Math.ceil(r / 16) * 16, {
+		uboElements: t,
+		size: r
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/utils/generateArraySyncSTD40.mjs
+function Ee(e, t) {
+	let n = Math.max(V[e.data.type] / 16, 1), r = e.data.value.length / e.data.size, i = (4 - r % 4) % 4, a = e.data.type.indexOf("i32") >= 0 ? "dataInt32" : "data";
+	return `
+        v = uv.${e.data.name};
+        offset += ${t};
+
+        arrayOffset = offset;
+
+        t = 0;
+
+        for(var i=0; i < ${e.data.size * n}; i++)
+        {
+            for(var j = 0; j < ${r}; j++)
+            {
+                ${a}[arrayOffset++] = v[t++];
+            }
+            ${i === 0 ? "" : `arrayOffset += ${i};`}
+        }
+    `;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/utils/createUboSyncSTD40.mjs
+function De(e) {
+	return de(e, fe, Ee);
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/GlUboSystem.mjs
+var H = class extends pe {
+	constructor() {
+		super({
+			createUboElements: Te,
+			generateUboSync: De
+		});
+	}
+};
+H.extension = {
+	type: [g.WebGLSystem],
+	name: "ubo"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetAdaptor.mjs
+var Oe = class {
+	constructor() {
+		this._clearColorCache = [
+			0,
+			0,
+			0,
+			0
+		], this._viewPortCache = new t(), this._boundFramebuffer = void 0;
+	}
+	init(e, t) {
+		this._renderer = e, this._renderTargetSystem = t, e.runners.contextChange.add(this);
+	}
+	contextChange() {
+		this._clearColorCache = [
+			0,
+			0,
+			0,
+			0
+		], this._viewPortCache = new t(), this._boundFramebuffer = void 0;
+		let e = this._renderer.gl;
+		this._drawBuffersCache = [];
+		for (let t = 1; t <= 16; t++) this._drawBuffersCache[t] = Array.from({ length: t }, (t, n) => e.COLOR_ATTACHMENT0 + n);
+	}
+	copyToTexture(e, t, n, r, i) {
+		let a = this._renderTargetSystem, o = this._renderer, s = a.getGpuRenderTarget(e), c = o.gl;
+		return this.finishRenderPass(e), c.bindFramebuffer(c.FRAMEBUFFER, s.resolveTargetFramebuffer), this._boundFramebuffer = s.resolveTargetFramebuffer, o.texture.bind(t, 0), c.copyTexSubImage2D(c.TEXTURE_2D, 0, i.x, i.y, n.x, n.y, r.width, r.height), t;
+	}
+	copyDepthTexture(e, t, n, r, i) {
+		let a = this._renderTargetSystem, o = this._renderer.gl;
+		this.finishRenderPass(e);
+		let s = a.getRenderTarget(t), c = a.getGpuRenderTarget(e), l = a.getGpuRenderTarget(s);
+		o.bindFramebuffer(o.READ_FRAMEBUFFER, c.framebuffer), o.bindFramebuffer(o.DRAW_FRAMEBUFFER, l.framebuffer), this._boundFramebuffer = void 0, o.blitFramebuffer(n.x, n.y, n.x + r.width, n.y + r.height, i.x, i.y, i.x + r.width, i.y + r.height, o.DEPTH_BUFFER_BIT, o.NEAREST);
+	}
+	startRenderPass(e, t = !0, n, r, i = 0, a = 0) {
+		let o = this._renderTargetSystem.getGpuRenderTarget(e);
+		if (a !== 0 && this._renderer.context.webGLVersion < 2) throw Error("[RenderTargetSystem] Rendering to array layers requires WebGL2.");
+		if (i > 0) {
+			if (o.msaa) throw Error("[RenderTargetSystem] Rendering to mip levels is not supported with MSAA render targets.");
+			if (this._renderer.context.webGLVersion < 2) throw Error("[RenderTargetSystem] Rendering to mip levels requires WebGL2.");
+		}
+		e.colorAttachments.forEach((e) => {
+			this._renderer.texture.unbind(e.texture);
+		});
+		let s = this._renderer.gl;
+		this.bindFramebuffer(o.framebuffer), !e.isRoot && e.colorAttachments.length > 0 && (o._attachedMipLevel !== i || o._attachedLayer !== a) && (e.colorAttachments.forEach((e, t) => {
+			let n = e.texture, r = this._renderer.texture.getGlSource(n);
+			if (r.target === s.TEXTURE_2D) {
+				if (a !== 0) throw Error("[RenderTargetSystem] layer must be 0 when rendering to 2D textures in WebGL.");
+				s.framebufferTexture2D(s.FRAMEBUFFER, s.COLOR_ATTACHMENT0 + t, s.TEXTURE_2D, r.texture, i);
+			} else if (r.target === s.TEXTURE_2D_ARRAY) {
+				if (this._renderer.context.webGLVersion < 2) throw Error("[RenderTargetSystem] Rendering to 2D array textures requires WebGL2.");
+				s.framebufferTextureLayer(s.FRAMEBUFFER, s.COLOR_ATTACHMENT0 + t, r.texture, i, a);
+			} else if (r.target === s.TEXTURE_CUBE_MAP) {
+				if (a < 0 || a > 5) throw Error("[RenderTargetSystem] Cube map layer must be between 0 and 5.");
+				s.framebufferTexture2D(s.FRAMEBUFFER, s.COLOR_ATTACHMENT0 + t, s.TEXTURE_CUBE_MAP_POSITIVE_X + a, r.texture, i);
+			} else throw Error("[RenderTargetSystem] Unsupported texture target for render-to-layer in WebGL.");
+		}), o._attachedMipLevel = i, o._attachedLayer = a), o.framebuffer && (e.depthStencilAttachment ? this._attachDepthStencilTexture(e, i, a) : !o.depthStencilRenderBuffer && (e.stencil || e.depth) && this._initStencil(o)), e.colorAttachments.length > 1 && this._setDrawBuffers(e, s);
+		let c = r.y;
+		e.isRoot && (c = e.pixelHeight - r.height - r.y);
+		let l = this._viewPortCache;
+		(l.x !== r.x || l.y !== c || l.width !== r.width || l.height !== r.height) && (l.x = r.x, l.y = c, l.width = r.width, l.height = r.height, s.viewport(r.x, c, r.width, r.height)), this.clear(e, t, n);
+	}
+	finishRenderPass(e) {
+		let t = this._renderTargetSystem.getGpuRenderTarget(e);
+		if (!t.msaa || e.colorAttachments.length === 0) return;
+		let n = this._renderer.gl;
+		n.bindFramebuffer(n.FRAMEBUFFER, t.resolveTargetFramebuffer), n.bindFramebuffer(n.READ_FRAMEBUFFER, t.framebuffer), n.blitFramebuffer(0, 0, t.width, t.height, 0, 0, t.width, t.height, n.COLOR_BUFFER_BIT, n.NEAREST), n.bindFramebuffer(n.FRAMEBUFFER, t.framebuffer), this._boundFramebuffer = t.framebuffer;
+	}
+	initGpuRenderTarget(e) {
+		let t = this._renderer.gl, n = new we();
+		n._attachedMipLevel = 0, n._attachedLayer = 0;
+		let r = e.colorTexture;
+		return r instanceof v ? (this._renderer.context.ensureCanvasSize(r.resource), n.framebuffer = null, n) : (n.width = e.pixelWidth, n.height = e.pixelHeight, e.colorAttachments.length === 0 ? this._initDepth(e, n) : this._initColor(e, n), e.depthStencilAttachment && this._attachDepthStencilTexture(e, 0, 0), t.bindFramebuffer(t.FRAMEBUFFER, null), this._boundFramebuffer = null, n);
+	}
+	destroyGpuRenderTarget(e) {
+		let t = this._renderer.gl;
+		e.framebuffer &&= (t.deleteFramebuffer(e.framebuffer), null), e.resolveTargetFramebuffer &&= (t.deleteFramebuffer(e.resolveTargetFramebuffer), null), e.depthStencilRenderBuffer &&= (t.deleteRenderbuffer(e.depthStencilRenderBuffer), null), e.msaaRenderBuffer.forEach((e) => {
+			t.deleteRenderbuffer(e);
+		}), e.msaaRenderBuffer = null;
+	}
+	clear(e, t, n, r, i = 0, a = 0) {
+		if (!t) return;
+		if (a !== 0) throw Error("[RenderTargetSystem] Clearing array layers is not supported in WebGL renderer.");
+		let o = this._renderTargetSystem;
+		if (typeof t == "boolean" && (t = t ? y.ALL : y.NONE), e.colorAttachments.length === 0 && (t &= ~y.COLOR, !t)) return;
+		let s = this._renderer.gl, c = !!(t & y.DEPTH) && !this._renderer.state.depthMaskEnabled;
+		if (t & y.COLOR) {
+			n ??= o.defaultClearColor;
+			let e = this._clearColorCache, t = n;
+			(e[0] !== t[0] || e[1] !== t[1] || e[2] !== t[2] || e[3] !== t[3]) && (e[0] = t[0], e[1] = t[1], e[2] = t[2], e[3] = t[3], s.clearColor(t[0], t[1], t[2], t[3]));
+		}
+		c && s.depthMask(!0), s.clear(t), c && s.depthMask(!1);
+	}
+	resizeGpuRenderTarget(e) {
+		if (e.isRoot) return;
+		let t = this._renderTargetSystem.getGpuRenderTarget(e);
+		t.width = e.pixelWidth, t.height = e.pixelHeight, e.colorAttachments.length > 0 && this._resizeColor(e, t), t.depthStencilRenderBuffer && this._resizeStencil(t), this._boundFramebuffer = void 0;
+	}
+	_initColor(e, t) {
+		let r = this._renderer, i = r.gl, a = i.createFramebuffer();
+		if (t.resolveTargetFramebuffer = a, i.bindFramebuffer(i.FRAMEBUFFER, a), e.colorAttachments.forEach((e, a) => {
+			let o = e.texture;
+			o.antialias && (r.context.supports.msaa ? t.msaa = !0 : n("[RenderTexture] Antialiasing on textures is not supported in WebGL1")), r.texture.bindSource(o, 0);
+			let s = r.texture.getGlSource(o), c = s.texture;
+			if (s.target === i.TEXTURE_2D) i.framebufferTexture2D(i.FRAMEBUFFER, i.COLOR_ATTACHMENT0 + a, i.TEXTURE_2D, c, 0);
+			else if (s.target === i.TEXTURE_2D_ARRAY) {
+				if (r.context.webGLVersion < 2) throw Error("[RenderTargetSystem] TEXTURE_2D_ARRAY requires WebGL2.");
+				i.framebufferTextureLayer(i.FRAMEBUFFER, i.COLOR_ATTACHMENT0 + a, c, 0, 0);
+			} else if (s.target === i.TEXTURE_CUBE_MAP) i.framebufferTexture2D(i.FRAMEBUFFER, i.COLOR_ATTACHMENT0 + a, i.TEXTURE_CUBE_MAP_POSITIVE_X, c, 0);
+			else throw Error("[RenderTargetSystem] Unsupported texture target for framebuffer attachment.");
+		}), t.msaa) {
+			let n = i.createFramebuffer();
+			t.framebuffer = n, i.bindFramebuffer(i.FRAMEBUFFER, n), e.colorAttachments.forEach((e, n) => {
+				let r = i.createRenderbuffer();
+				t.msaaRenderBuffer[n] = r;
+			});
+		} else t.framebuffer = a;
+		this._resizeColor(e, t);
+	}
+	_initDepth(e, t) {
+		let n = this._renderer;
+		if (n.context.webGLVersion < 2) throw Error("[RenderTargetSystem] Depth-only render targets require WebGL2.");
+		let r = n.gl, i = r.createFramebuffer();
+		t.resolveTargetFramebuffer = i, t.framebuffer = i, r.bindFramebuffer(r.FRAMEBUFFER, i), r.drawBuffers([r.NONE]), r.readBuffer(r.NONE);
+	}
+	_resizeColor(e, t) {
+		let n = e.colorAttachments[0].texture;
+		if (t._attachedMipLevel = 0, t._attachedLayer = 0, e.colorAttachments.forEach((e, t) => {
+			t !== 0 && e.texture.resize(n.width, n.height, n._resolution);
+		}), t.msaa) {
+			let n = this._renderer, r = n.gl, i = t.framebuffer;
+			r.bindFramebuffer(r.FRAMEBUFFER, i), e.colorAttachments.forEach((e, i) => {
+				let a = e.texture;
+				n.texture.bindSource(a, 0);
+				let o = n.texture.getGlSource(a).internalFormat, s = t.msaaRenderBuffer[i];
+				r.bindRenderbuffer(r.RENDERBUFFER, s), r.renderbufferStorageMultisample(r.RENDERBUFFER, 4, o, a.pixelWidth, a.pixelHeight), r.framebufferRenderbuffer(r.FRAMEBUFFER, r.COLOR_ATTACHMENT0 + i, r.RENDERBUFFER, s);
+			});
+		}
+	}
+	_attachDepthStencilTexture(e, t, n) {
+		let r = this._renderer, i = r.gl, a = e.depthStencilAttachment.texture, o = r.texture.getGlSource(a), s = o.texture, c = a.format, l;
+		l = c === "depth24plus-stencil8" || c === "depth32float-stencil8" ? i.DEPTH_STENCIL_ATTACHMENT : c === "stencil8" ? i.STENCIL_ATTACHMENT : i.DEPTH_ATTACHMENT, o.target === i.TEXTURE_2D ? i.framebufferTexture2D(i.FRAMEBUFFER, l, i.TEXTURE_2D, s, t) : o.target === i.TEXTURE_2D_ARRAY ? i.framebufferTextureLayer(i.FRAMEBUFFER, l, s, t, n) : o.target === i.TEXTURE_CUBE_MAP && i.framebufferTexture2D(i.FRAMEBUFFER, l, i.TEXTURE_CUBE_MAP_POSITIVE_X + n, s, t);
+	}
+	_initStencil(e) {
+		if (e.framebuffer === null) return;
+		let t = this._renderer.gl, n = t.createRenderbuffer();
+		e.depthStencilRenderBuffer = n, t.bindRenderbuffer(t.RENDERBUFFER, n), t.framebufferRenderbuffer(t.FRAMEBUFFER, t.DEPTH_STENCIL_ATTACHMENT, t.RENDERBUFFER, n), this._resizeStencil(e);
+	}
+	_resizeStencil(e) {
+		let t = this._renderer.gl;
+		t.bindRenderbuffer(t.RENDERBUFFER, e.depthStencilRenderBuffer), e.msaa ? t.renderbufferStorageMultisample(t.RENDERBUFFER, 4, t.DEPTH24_STENCIL8, e.width, e.height) : t.renderbufferStorage(t.RENDERBUFFER, this._renderer.context.webGLVersion === 2 ? t.DEPTH24_STENCIL8 : t.DEPTH_STENCIL, e.width, e.height);
+	}
+	prerender(e) {
+		if (e.colorAttachments.length === 0) return;
+		let t = e.colorAttachments[0].texture.resource;
+		this._renderer.context.multiView && v.test(t) && this._renderer.context.ensureCanvasSize(t);
+	}
+	postrender(e) {
+		if (!this._renderer.context.multiView || e.colorAttachments.length === 0) return;
+		let t = e.colorAttachments[0].texture;
+		if (v.test(t.resource)) {
+			let e = this._renderer.context.canvas, n = t;
+			n.context2D.drawImage(e, 0, n.pixelHeight - e.height);
+		}
+	}
+	_setDrawBuffers(e, t) {
+		let r = e.colorAttachments.length, i = this._drawBuffersCache[r];
+		if (this._renderer.context.webGLVersion === 1) {
+			let e = this._renderer.context.extensions.drawBuffers;
+			e ? e.drawBuffersWEBGL(i) : n("[RenderTexture] This WebGL1 context does not support rendering to multiple targets");
+		} else t.drawBuffers(i);
+	}
+	resetState() {
+		this._boundFramebuffer = void 0, this._viewPortCache = new t(), this._clearColorCache = [
+			0,
+			0,
+			0,
+			0
+		];
+	}
+	bindFramebuffer(e) {
+		this._boundFramebuffer !== e && (this._boundFramebuffer = e, this._renderer.gl.bindFramebuffer(this._renderer.gl.FRAMEBUFFER, e));
+	}
+}, ke = class extends ce {
+	constructor(e) {
+		super(e), this.adaptor = new Oe(), this.adaptor.init(e, this);
+	}
+	resetState() {
+		this.adaptor.resetState();
+	}
+};
+ke.extension = {
+	type: [g.WebGLSystem],
+	name: "renderTarget"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/shared/texture/TextureView.mjs
+var Ae = class extends p {
+	constructor(e, t) {
+		super(), this._resourceType = "textureView", this._resourceId = a("resource"), this._touched = 0, this.source = e, this.viewDescriptor = t, this._onChange = this._onChange.bind(this), this._onDestroy = this._onDestroy.bind(this), this.source.on("change", this._onChange), this.source.on("destroy", this._onDestroy);
+	}
+	_onChange() {
+		this.emit("change", this);
+	}
+	_onDestroy() {
+		this.destroy();
+	}
+	get destroyed() {
+		return this.source.destroyed;
+	}
+	destroy() {
+		this.source && (this.source.off("change", this._onChange), this.source.off("destroy", this._onDestroy)), this.emit("destroy", this), this.removeAllListeners();
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/GenerateShaderSyncCode.mjs
+function je(e, t) {
+	let n = [], r = ["\n        var g = s.groups;\n        var sS = r.shader;\n        var p = s.glProgram;\n        var ugS = r.uniformGroup;\n        var resources;\n    "], a = !1, o = 0, s = t._getProgramData(e.glProgram);
+	for (let l in e.groups) {
+		let u = e.groups[l];
+		n.push(`
+            resources = g[${l}].resources;
+        `);
+		for (let d in u.resources) {
+			let f = u.resources[d];
+			if (f instanceof c) if (f.ubo) {
+				let t = e._uniformBindMap[l][Number(d)];
+				n.push(`
+                        sS.bindUniformBlock(
+                            resources[${d}],
+                            '${t}',
+                            ${e.glProgram._uniformBlockData[t].index}
+                        );
+                    `);
+			} else n.push(`
+                        ugS.updateUniformGroup(resources[${d}], p, sD);
+                    `);
+			else if (f instanceof E) {
+				let t = e._uniformBindMap[l][Number(d)];
+				n.push(`
+                    sS.bindUniformBlock(
+                        resources[${d}],
+                        '${t}',
+                        ${e.glProgram._uniformBlockData[t].index}
+                    );
+                `);
+			} else if (f instanceof i || f instanceof Ae) {
+				let i = e._uniformBindMap[l][d], c = s.uniformData[i];
+				c && (a || (a = !0, r.push("\n                        var tS = r.texture;\n                        ")), t._gl.uniform1i(c.location, o), n.push(`
+                        tS.bind(resources[${d}], ${o});
+                    `), o++);
+			}
+		}
+	}
+	let l = [...r, ...n].join("\n");
+	return Function("r", "s", "sD", l);
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/GlProgramData.mjs
+var Me = class {
+	constructor(e, t) {
+		this.program = e, this.uniformData = t, this.uniformGroups = {}, this.uniformDirtyGroups = {}, this.uniformBlockBindings = {};
+	}
+	destroy() {
+		this.uniformData = null, this.uniformGroups = null, this.uniformDirtyGroups = null, this.uniformBlockBindings = null, this.program = null;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/compileShader.mjs
+function U(e, t, n) {
+	let r = e.createShader(t);
+	return e.shaderSource(r, n), e.compileShader(r), r;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/defaultValue.mjs
+function W(e) {
+	let t = Array(e);
+	for (let e = 0; e < t.length; e++) t[e] = !1;
+	return t;
+}
+function G(e, t) {
+	switch (e) {
+		case "float": return 0;
+		case "vec2": return new Float32Array(2 * t);
+		case "vec3": return new Float32Array(3 * t);
+		case "vec4": return new Float32Array(4 * t);
+		case "int":
+		case "uint":
+		case "sampler2D":
+		case "sampler2DArray": return 0;
+		case "ivec2": return new Int32Array(2 * t);
+		case "ivec3": return new Int32Array(3 * t);
+		case "ivec4": return new Int32Array(4 * t);
+		case "uvec2": return new Uint32Array(2 * t);
+		case "uvec3": return new Uint32Array(3 * t);
+		case "uvec4": return new Uint32Array(4 * t);
+		case "bool": return !1;
+		case "bvec2": return W(2 * t);
+		case "bvec3": return W(3 * t);
+		case "bvec4": return W(4 * t);
+		case "mat2": return new Float32Array([
+			1,
+			0,
+			0,
+			1
+		]);
+		case "mat3": return new Float32Array([
+			1,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			1
+		]);
+		case "mat4": return new Float32Array([
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1
+		]);
+	}
+	return null;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/mapType.mjs
+var K = null, q = {
+	FLOAT: "float",
+	FLOAT_VEC2: "vec2",
+	FLOAT_VEC3: "vec3",
+	FLOAT_VEC4: "vec4",
+	INT: "int",
+	INT_VEC2: "ivec2",
+	INT_VEC3: "ivec3",
+	INT_VEC4: "ivec4",
+	UNSIGNED_INT: "uint",
+	UNSIGNED_INT_VEC2: "uvec2",
+	UNSIGNED_INT_VEC3: "uvec3",
+	UNSIGNED_INT_VEC4: "uvec4",
+	BOOL: "bool",
+	BOOL_VEC2: "bvec2",
+	BOOL_VEC3: "bvec3",
+	BOOL_VEC4: "bvec4",
+	FLOAT_MAT2: "mat2",
+	FLOAT_MAT3: "mat3",
+	FLOAT_MAT4: "mat4",
+	SAMPLER_2D: "sampler2D",
+	INT_SAMPLER_2D: "sampler2D",
+	UNSIGNED_INT_SAMPLER_2D: "sampler2D",
+	SAMPLER_2D_SHADOW: "sampler2DShadow",
+	SAMPLER_CUBE: "samplerCube",
+	INT_SAMPLER_CUBE: "samplerCube",
+	UNSIGNED_INT_SAMPLER_CUBE: "samplerCube",
+	SAMPLER_CUBE_SHADOW: "samplerCubeShadow",
+	SAMPLER_2D_ARRAY: "sampler2DArray",
+	INT_SAMPLER_2D_ARRAY: "sampler2DArray",
+	UNSIGNED_INT_SAMPLER_2D_ARRAY: "sampler2DArray",
+	SAMPLER_2D_ARRAY_SHADOW: "sampler2DArrayShadow"
+}, Ne = {
+	float: "float32",
+	vec2: "float32x2",
+	vec3: "float32x3",
+	vec4: "float32x4",
+	int: "sint32",
+	ivec2: "sint32x2",
+	ivec3: "sint32x3",
+	ivec4: "sint32x4",
+	uint: "uint32",
+	uvec2: "uint32x2",
+	uvec3: "uint32x3",
+	uvec4: "uint32x4",
+	bool: "uint32",
+	bvec2: "uint32x2",
+	bvec3: "uint32x3",
+	bvec4: "uint32x4"
+};
+function J(e, t) {
+	if (!K) {
+		let t = Object.keys(q);
+		K = {};
+		for (let n = 0; n < t.length; ++n) {
+			let r = t[n];
+			K[e[r]] = q[r];
+		}
+	}
+	return K[t];
+}
+function Pe(e, t) {
+	return Ne[J(e, t)] || "float32";
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/extractAttributesFromGlProgram.mjs
+function Fe(e, t, n = !1) {
+	let r = {}, i = t.getProgramParameter(e, t.ACTIVE_ATTRIBUTES);
+	for (let n = 0; n < i; n++) {
+		let i = t.getActiveAttrib(e, n);
+		if (i.name.startsWith("gl_")) continue;
+		let a = Pe(t, i.type);
+		r[i.name] = {
+			location: 0,
+			format: a,
+			stride: ee(a).stride,
+			offset: 0,
+			instance: !1,
+			start: 0
+		};
+	}
+	let a = Object.keys(r);
+	if (n) {
+		a.sort((e, t) => e > t ? 1 : -1);
+		for (let n = 0; n < a.length; n++) r[a[n]].location = n, t.bindAttribLocation(e, n, a[n]);
+		t.linkProgram(e);
+	} else for (let n = 0; n < a.length; n++) r[a[n]].location = t.getAttribLocation(e, a[n]);
+	return r;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/getUboData.mjs
+function Ie(e, t) {
+	if (!t.ACTIVE_UNIFORM_BLOCKS) return {};
+	let n = {}, r = t.getProgramParameter(e, t.ACTIVE_UNIFORM_BLOCKS);
+	for (let i = 0; i < r; i++) {
+		let r = t.getActiveUniformBlockName(e, i);
+		n[r] = {
+			name: r,
+			index: t.getUniformBlockIndex(e, r),
+			size: t.getActiveUniformBlockParameter(e, i, t.UNIFORM_BLOCK_DATA_SIZE)
+		};
+	}
+	return n;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/getUniformData.mjs
+function Le(e, t) {
+	let n = {}, r = t.getProgramParameter(e, t.ACTIVE_UNIFORMS);
+	for (let i = 0; i < r; i++) {
+		let r = t.getActiveUniform(e, i), a = r.name.replace(/\[.*?\]$/, ""), o = !!r.name.match(/\[.*?\]$/), s = J(t, r.type);
+		n[a] = {
+			name: a,
+			index: i,
+			type: s,
+			size: r.size,
+			isArray: o,
+			value: G(s, r.size)
+		};
+	}
+	return n;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/logProgramError.mjs
+function Y(e, t) {
+	let n = e.getShaderSource(t);
+	if (n === null) {
+		console.error("PixiJS Error: Could not retrieve shader source (WebGL context may be lost).");
+		return;
+	}
+	let r = n.split("\n").map((e, t) => `${t}: ${e}`), i = e.getShaderInfoLog(t) ?? "", a = i.split("\n"), o = {}, s = a.map((e) => parseFloat(e.replace(/^ERROR\: 0\:([\d]+)\:.*$/, "$1"))).filter((e) => e && !o[e] ? (o[e] = !0, !0) : !1), c = [""];
+	s.forEach((e) => {
+		r[e - 1] = `%c${r[e - 1]}%c`, c.push("background: #FF0000; color:#FFFFFF; font-size: 10px", "font-size: 10px");
+	}), c[0] = r.join("\n"), console.error(i), console.groupCollapsed("click to view full shader code"), console.warn(...c), console.groupEnd();
+}
+function Re(e, t, n, r) {
+	e.getProgramParameter(t, e.LINK_STATUS) || (e.getShaderParameter(n, e.COMPILE_STATUS) || Y(e, n), e.getShaderParameter(r, e.COMPILE_STATUS) || Y(e, r), console.error("PixiJS Error: Could not initialize shader."), e.getProgramInfoLog(t) !== "" && console.warn("PixiJS Warning: gl.getProgramInfoLog()", e.getProgramInfoLog(t)));
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/program/generateProgram.mjs
+function ze(e, t) {
+	let r = U(e, e.VERTEX_SHADER, t.vertex), i = U(e, e.FRAGMENT_SHADER, t.fragment), a = e.createProgram();
+	e.attachShader(a, r), e.attachShader(a, i);
+	let o = t.transformFeedbackVaryings;
+	o && (typeof e.transformFeedbackVaryings == "function" ? e.transformFeedbackVaryings(a, o.names, o.bufferMode === "separate" ? e.SEPARATE_ATTRIBS : e.INTERLEAVED_ATTRIBS) : n("TransformFeedback is not supported but TransformFeedbackVaryings are given.")), e.linkProgram(a), e.getProgramParameter(a, e.LINK_STATUS) || Re(e, a, r, i), t._attributeData = Fe(a, e, !/^[ \t]*#[ \t]*version[ \t]+300[ \t]+es[ \t]*$/m.test(t.vertex)), t._uniformData = Le(a, e), t._uniformBlockData = Ie(a, e), e.deleteShader(r), e.deleteShader(i);
+	let s = {};
+	for (let n in t._uniformData) {
+		let r = t._uniformData[n];
+		s[n] = {
+			location: e.getUniformLocation(a, n),
+			value: G(r.type, r.size)
+		};
+	}
+	return new Me(a, s);
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/GlShaderSystem.mjs
+var X = {
+	textureCount: 0,
+	blockIndex: 0
+}, Be = class {
+	constructor(e) {
+		this._activeProgram = null, this._programDataHash = /* @__PURE__ */ Object.create(null), this._shaderSyncFunctions = /* @__PURE__ */ Object.create(null), this._renderer = e;
+	}
+	contextChange(e) {
+		this._gl = e, this._programDataHash = /* @__PURE__ */ Object.create(null), this._shaderSyncFunctions = /* @__PURE__ */ Object.create(null), this._activeProgram = null;
+	}
+	bind(e, t) {
+		if (this._setProgram(e.glProgram), t) return;
+		X.textureCount = 0, X.blockIndex = 0;
+		let n = this._shaderSyncFunctions[e.glProgram._key];
+		n ||= this._shaderSyncFunctions[e.glProgram._key] = this._generateShaderSync(e, this), this._renderer.buffer.nextBindBase(!!e.glProgram.transformFeedbackVaryings), n(this._renderer, e, X);
+	}
+	updateUniformGroup(e) {
+		this._renderer.uniformGroup.updateUniformGroup(e, this._activeProgram, X);
+	}
+	bindUniformBlock(e, t, n = 0) {
+		let r = this._renderer.buffer, i = this._getProgramData(this._activeProgram), a = e._bufferResource;
+		a || this._renderer.ubo.updateUniformGroup(e);
+		let o = e.buffer, s = r.updateBuffer(o), c = r.freeLocationForBufferBase(s);
+		if (a) {
+			let { offset: t, size: n } = e;
+			t === 0 && n === o.data.byteLength ? r.bindBufferBase(s, c) : r.bindBufferRange(s, c, t);
+		} else r.getLastBindBaseLocation(s) !== c && r.bindBufferBase(s, c);
+		let l = this._activeProgram._uniformBlockData[t].index;
+		i.uniformBlockBindings[n] !== c && (i.uniformBlockBindings[n] = c, this._renderer.gl.uniformBlockBinding(i.program, l, c));
+	}
+	_setProgram(e) {
+		if (this._activeProgram === e) return;
+		this._activeProgram = e;
+		let t = this._getProgramData(e);
+		this._gl.useProgram(t.program);
+	}
+	_getProgramData(e) {
+		return this._programDataHash[e._key] || this._createProgramData(e);
+	}
+	_createProgramData(e) {
+		let t = e._key;
+		return this._programDataHash[t] = ze(this._gl, e), this._programDataHash[t];
+	}
+	destroy() {
+		for (let e of Object.keys(this._programDataHash)) this._programDataHash[e].destroy();
+		this._programDataHash = null, this._shaderSyncFunctions = null, this._activeProgram = null, this._renderer = null, this._gl = null;
+	}
+	_generateShaderSync(e, t) {
+		return je(e, t);
+	}
+	resetState() {
+		this._activeProgram = null;
+	}
+};
+Be.extension = {
+	type: [g.WebGLSystem],
+	name: "shader"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/utils/generateUniformsSyncTypes.mjs
+var Ve = {
+	f32: "if (cv !== v) {\n            cu.value = v;\n            gl.uniform1f(location, v);\n        }",
+	"vec2<f32>": "if (cv[0] !== v[0] || cv[1] !== v[1]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            gl.uniform2f(location, v[0], v[1]);\n        }",
+	"vec3<f32>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            gl.uniform3f(location, v[0], v[1], v[2]);\n        }",
+	"vec4<f32>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            cv[3] = v[3];\n            gl.uniform4f(location, v[0], v[1], v[2], v[3]);\n        }",
+	i32: "if (cv !== v) {\n            cu.value = v;\n            gl.uniform1i(location, v);\n        }",
+	"vec2<i32>": "if (cv[0] !== v[0] || cv[1] !== v[1]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            gl.uniform2i(location, v[0], v[1]);\n        }",
+	"vec3<i32>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            gl.uniform3i(location, v[0], v[1], v[2]);\n        }",
+	"vec4<i32>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            cv[3] = v[3];\n            gl.uniform4i(location, v[0], v[1], v[2], v[3]);\n        }",
+	u32: "if (cv !== v) {\n            cu.value = v;\n            gl.uniform1ui(location, v);\n        }",
+	"vec2<u32>": "if (cv[0] !== v[0] || cv[1] !== v[1]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            gl.uniform2ui(location, v[0], v[1]);\n        }",
+	"vec3<u32>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            gl.uniform3ui(location, v[0], v[1], v[2]);\n        }",
+	"vec4<u32>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            cv[3] = v[3];\n            gl.uniform4ui(location, v[0], v[1], v[2], v[3]);\n        }",
+	bool: "if (cv !== v) {\n            cu.value = v;\n            gl.uniform1i(location, v);\n        }",
+	"vec2<bool>": "if (cv[0] !== v[0] || cv[1] !== v[1]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            gl.uniform2i(location, v[0], v[1]);\n        }",
+	"vec3<bool>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            gl.uniform3i(location, v[0], v[1], v[2]);\n        }",
+	"vec4<bool>": "if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {\n            cv[0] = v[0];\n            cv[1] = v[1];\n            cv[2] = v[2];\n            cv[3] = v[3];\n            gl.uniform4i(location, v[0], v[1], v[2], v[3]);\n        }",
+	"mat2x2<f32>": "gl.uniformMatrix2fv(location, false, v);",
+	"mat3x3<f32>": "gl.uniformMatrix3fv(location, false, v);",
+	"mat4x4<f32>": "gl.uniformMatrix4fv(location, false, v);"
+}, He = {
+	f32: "gl.uniform1fv(location, v);",
+	"vec2<f32>": "gl.uniform2fv(location, v);",
+	"vec3<f32>": "gl.uniform3fv(location, v);",
+	"vec4<f32>": "gl.uniform4fv(location, v);",
+	"mat2x2<f32>": "gl.uniformMatrix2fv(location, false, v);",
+	"mat3x3<f32>": "gl.uniformMatrix3fv(location, false, v);",
+	"mat4x4<f32>": "gl.uniformMatrix4fv(location, false, v);",
+	i32: "gl.uniform1iv(location, v);",
+	"vec2<i32>": "gl.uniform2iv(location, v);",
+	"vec3<i32>": "gl.uniform3iv(location, v);",
+	"vec4<i32>": "gl.uniform4iv(location, v);",
+	u32: "gl.uniform1iv(location, v);",
+	"vec2<u32>": "gl.uniform2iv(location, v);",
+	"vec3<u32>": "gl.uniform3iv(location, v);",
+	"vec4<u32>": "gl.uniform4iv(location, v);",
+	bool: "gl.uniform1iv(location, v);",
+	"vec2<bool>": "gl.uniform2iv(location, v);",
+	"vec3<bool>": "gl.uniform3iv(location, v);",
+	"vec4<bool>": "gl.uniform4iv(location, v);"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/utils/generateUniformsSync.mjs
+function Ue(e, t) {
+	let n = ["\n        var v = null;\n        var cv = null;\n        var cu = null;\n        var t = 0;\n        var gl = renderer.gl;\n        var name = null;\n    "];
+	for (let r in e.uniforms) {
+		if (!t[r]) {
+			e.uniforms[r] instanceof c ? e.uniforms[r].ubo ? n.push(`
+                        renderer.shader.bindUniformBlock(uv.${r}, "${r}");
+                    `) : n.push(`
+                        renderer.shader.updateUniformGroup(uv.${r});
+                    `) : e.uniforms[r] instanceof E && n.push(`
+                        renderer.shader.bindBufferResource(uv.${r}, "${r}");
+                    `);
+			continue;
+		}
+		let i = e.uniformStructures[r], a = !1;
+		for (let e = 0; e < w.length; e++) {
+			let t = w[e];
+			if (i.type === t.type && t.test(i)) {
+				n.push(`name = "${r}";`, w[e].uniform), a = !0;
+				break;
+			}
+		}
+		if (!a) {
+			let e = (i.size === 1 ? Ve : He)[i.type].replace("location", `ud["${r}"].location`);
+			n.push(`
+            cu = ud["${r}"];
+            cv = cu.value;
+            v = uv["${r}"];
+            ${e};`);
+		}
+	}
+	return Function("ud", "uv", "renderer", "syncData", n.join("\n"));
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/shader/GlUniformGroupSystem.mjs
+var We = class {
+	constructor(e) {
+		this._cache = {}, this._uniformGroupSyncHash = {}, this._renderer = e, this.gl = null, this._cache = {};
+	}
+	contextChange(e) {
+		this.gl = e;
+	}
+	updateUniformGroup(e, t, n) {
+		let r = this._renderer.shader._getProgramData(t);
+		(!e.isStatic || e._dirtyId !== r.uniformDirtyGroups[e.uid]) && (r.uniformDirtyGroups[e.uid] = e._dirtyId, this._getUniformSyncFunction(e, t)(r.uniformData, e.uniforms, this._renderer, n));
+	}
+	_getUniformSyncFunction(e, t) {
+		return this._uniformGroupSyncHash[e._signature]?.[t._key] || this._createUniformSyncFunction(e, t);
+	}
+	_createUniformSyncFunction(e, t) {
+		let n = this._uniformGroupSyncHash[e._signature] || (this._uniformGroupSyncHash[e._signature] = {}), r = this._getSignature(e, t._uniformData, "u");
+		return this._cache[r] || (this._cache[r] = this._generateUniformsSync(e, t._uniformData)), n[t._key] = this._cache[r], n[t._key];
+	}
+	_generateUniformsSync(e, t) {
+		return Ue(e, t);
+	}
+	_getSignature(e, t, n) {
+		let r = e.uniforms, i = [`${n}-`];
+		for (let e in r) i.push(e), t[e] && i.push(t[e].type);
+		return i.join("-");
+	}
+	destroy() {
+		this._renderer = null, this._cache = null;
+	}
+};
+We.extension = {
+	type: [g.WebGLSystem],
+	name: "uniformGroup"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/state/mapWebGLBlendModesToPixi.mjs
+function Ge(e) {
+	let t = {};
+	if (t.normal = [e.ONE, e.ONE_MINUS_SRC_ALPHA], t.add = [e.ONE, e.ONE], t.multiply = [
+		e.DST_COLOR,
+		e.ONE_MINUS_SRC_ALPHA,
+		e.ONE,
+		e.ONE_MINUS_SRC_ALPHA
+	], t.screen = [
+		e.ONE,
+		e.ONE_MINUS_SRC_COLOR,
+		e.ONE,
+		e.ONE_MINUS_SRC_ALPHA
+	], t.none = [0, 0], t["normal-npm"] = [
+		e.SRC_ALPHA,
+		e.ONE_MINUS_SRC_ALPHA,
+		e.ONE,
+		e.ONE_MINUS_SRC_ALPHA
+	], t["add-npm"] = [
+		e.SRC_ALPHA,
+		e.ONE,
+		e.ONE,
+		e.ONE
+	], t["screen-npm"] = [
+		e.SRC_ALPHA,
+		e.ONE_MINUS_SRC_COLOR,
+		e.ONE,
+		e.ONE_MINUS_SRC_ALPHA
+	], t.erase = [e.ZERO, e.ONE_MINUS_SRC_ALPHA], !(e instanceof s.get().getWebGLRenderingContext())) t.min = [
+		e.ONE,
+		e.ONE,
+		e.ONE,
+		e.ONE,
+		e.MIN,
+		e.MIN
+	], t.max = [
+		e.ONE,
+		e.ONE,
+		e.ONE,
+		e.ONE,
+		e.MAX,
+		e.MAX
+	];
+	else {
+		let n = e.getExtension("EXT_blend_minmax");
+		n && (t.min = [
+			e.ONE,
+			e.ONE,
+			e.ONE,
+			e.ONE,
+			n.MIN_EXT,
+			n.MIN_EXT
+		], t.max = [
+			e.ONE,
+			e.ONE,
+			e.ONE,
+			e.ONE,
+			n.MAX_EXT,
+			n.MAX_EXT
+		]);
+	}
+	return t;
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/state/GlStateSystem.mjs
+var { BLEND: Ke, OFFSET: qe, CULLING: Je, DEPTH_TEST: Ye, WINDING: Xe, DEPTH_MASK: Ze } = o, Qe = class e {
+	constructor(e) {
+		this._invertFrontFace = !1, this.gl = null, this.stateId = 0, this.polygonOffset = 0, this.blendMode = "none", this._blendEq = !1, this.map = [], this.map[Ke] = this.setBlend, this.map[qe] = this.setOffset, this.map[Je] = this.setCullFace, this.map[Ye] = this.setDepthTest, this.map[Xe] = this.setFrontFace, this.map[Ze] = this.setDepthMask, this.checks = [], this.defaultState = m.for2d(), e.renderTarget.onRenderTargetChange.add(this);
+	}
+	onRenderTargetChange(e) {
+		this._invertFrontFace = !e.isRoot != !!e.flipY, this._cullFace ? this.setFrontFace(this._frontFace) : this._frontFaceDirty = !0;
+	}
+	contextChange(e) {
+		this.gl = e, this.blendModesMap = Ge(e), this.resetState();
+	}
+	set(e) {
+		if (e ||= this.defaultState, this.stateId !== e.data) {
+			let t = this.stateId ^ e.data, n = 0;
+			for (; t;) t & 1 && this.map[n].call(this, !!(e.data & 1 << n)), t >>= 1, n++;
+			this.stateId = e.data;
+		}
+		for (let t = 0; t < this.checks.length; t++) this.checks[t](this, e);
+	}
+	forceState(e) {
+		e ||= this.defaultState;
+		for (let t = 0; t < this.map.length; t++) this.map[t].call(this, !!(e.data & 1 << t));
+		for (let t = 0; t < this.checks.length; t++) this.checks[t](this, e);
+		this.stateId = e.data;
+	}
+	setBlend(t) {
+		this._updateCheck(e._checkBlendMode, t), this.gl[t ? "enable" : "disable"](this.gl.BLEND);
+	}
+	setOffset(t) {
+		this._updateCheck(e._checkPolygonOffset, t), this.gl[t ? "enable" : "disable"](this.gl.POLYGON_OFFSET_FILL);
+	}
+	setDepthTest(e) {
+		this.gl[e ? "enable" : "disable"](this.gl.DEPTH_TEST);
+	}
+	setDepthMask(e) {
+		this.gl.depthMask(e);
+	}
+	get depthMaskEnabled() {
+		return !!(this.stateId & 1 << Ze);
+	}
+	setCullFace(e) {
+		this._cullFace = e, this.gl[e ? "enable" : "disable"](this.gl.CULL_FACE), this._cullFace && this._frontFaceDirty && this.setFrontFace(this._frontFace);
+	}
+	setFrontFace(e) {
+		this._frontFace = e, this._frontFaceDirty = !1;
+		let t = this._invertFrontFace ? !e : e;
+		this._glFrontFace !== t && (this._glFrontFace = t, this.gl.frontFace(this.gl[t ? "CW" : "CCW"]));
+	}
+	setBlendMode(e) {
+		if (this.blendModesMap[e] || (e = "normal"), e === this.blendMode) return;
+		this.blendMode = e;
+		let t = this.blendModesMap[e], n = this.gl;
+		t.length === 2 ? n.blendFunc(t[0], t[1]) : n.blendFuncSeparate(t[0], t[1], t[2], t[3]), t.length === 6 ? (this._blendEq = !0, n.blendEquationSeparate(t[4], t[5])) : this._blendEq && (this._blendEq = !1, n.blendEquationSeparate(n.FUNC_ADD, n.FUNC_ADD));
+	}
+	setPolygonOffset(e, t) {
+		this.gl.polygonOffset(e, t);
+	}
+	resetState() {
+		this._glFrontFace = !1, this._frontFace = !1, this._cullFace = !1, this._frontFaceDirty = !1, this._invertFrontFace = !1, this.gl.frontFace(this.gl.CCW), this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, !1), this.forceState(this.defaultState), this._blendEq = !0, this.blendMode = "", this.setBlendMode("normal");
+	}
+	_updateCheck(e, t) {
+		let n = this.checks.indexOf(e);
+		t && n === -1 ? this.checks.push(e) : !t && n !== -1 && this.checks.splice(n, 1);
+	}
+	static _checkBlendMode(e, t) {
+		e.setBlendMode(t.blendMode);
+	}
+	static _checkPolygonOffset(e, t) {
+		e.setPolygonOffset(1, t.polygonOffset);
+	}
+	destroy() {
+		this.gl = null, this.checks.length = 0;
+	}
+};
+Qe.extension = {
+	type: [g.WebGLSystem],
+	name: "state"
+};
+var $e = Qe, et = class {
+	constructor(e) {
+		this.target = M.TEXTURE_2D, this._layerInitMask = 0, this.texture = e, this.width = -1, this.height = -1, this.type = N.UNSIGNED_BYTE, this.internalFormat = j.RGBA, this.format = j.RGBA, this.samplerType = 0;
+	}
+	destroy() {}
+}, tt = {
+	id: "buffer",
+	upload(e, t, n, r, i, a = !1) {
+		let o = i || t.target;
+		!a && t.width === e.width && t.height === e.height ? n.texSubImage2D(o, 0, 0, 0, e.width, e.height, t.format, t.type, e.resource) : n.texImage2D(o, 0, t.internalFormat, e.width, e.height, 0, t.format, t.type, e.resource), t.width = e.width, t.height = e.height;
+	}
+}, nt = {
+	"bc1-rgba-unorm": !0,
+	"bc1-rgba-unorm-srgb": !0,
+	"bc2-rgba-unorm": !0,
+	"bc2-rgba-unorm-srgb": !0,
+	"bc3-rgba-unorm": !0,
+	"bc3-rgba-unorm-srgb": !0,
+	"bc4-r-unorm": !0,
+	"bc4-r-snorm": !0,
+	"bc5-rg-unorm": !0,
+	"bc5-rg-snorm": !0,
+	"bc6h-rgb-ufloat": !0,
+	"bc6h-rgb-float": !0,
+	"bc7-rgba-unorm": !0,
+	"bc7-rgba-unorm-srgb": !0,
+	"etc2-rgb8unorm": !0,
+	"etc2-rgb8unorm-srgb": !0,
+	"etc2-rgb8a1unorm": !0,
+	"etc2-rgb8a1unorm-srgb": !0,
+	"etc2-rgba8unorm": !0,
+	"etc2-rgba8unorm-srgb": !0,
+	"eac-r11unorm": !0,
+	"eac-r11snorm": !0,
+	"eac-rg11unorm": !0,
+	"eac-rg11snorm": !0,
+	"astc-4x4-unorm": !0,
+	"astc-4x4-unorm-srgb": !0,
+	"astc-5x4-unorm": !0,
+	"astc-5x4-unorm-srgb": !0,
+	"astc-5x5-unorm": !0,
+	"astc-5x5-unorm-srgb": !0,
+	"astc-6x5-unorm": !0,
+	"astc-6x5-unorm-srgb": !0,
+	"astc-6x6-unorm": !0,
+	"astc-6x6-unorm-srgb": !0,
+	"astc-8x5-unorm": !0,
+	"astc-8x5-unorm-srgb": !0,
+	"astc-8x6-unorm": !0,
+	"astc-8x6-unorm-srgb": !0,
+	"astc-8x8-unorm": !0,
+	"astc-8x8-unorm-srgb": !0,
+	"astc-10x5-unorm": !0,
+	"astc-10x5-unorm-srgb": !0,
+	"astc-10x6-unorm": !0,
+	"astc-10x6-unorm-srgb": !0,
+	"astc-10x8-unorm": !0,
+	"astc-10x8-unorm-srgb": !0,
+	"astc-10x10-unorm": !0,
+	"astc-10x10-unorm-srgb": !0,
+	"astc-12x10-unorm": !0,
+	"astc-12x10-unorm-srgb": !0,
+	"astc-12x12-unorm": !0,
+	"astc-12x12-unorm-srgb": !0
+}, rt = {
+	id: "compressed",
+	upload(e, t, n, r, i, a) {
+		let o = i ?? t.target;
+		n.pixelStorei(n.UNPACK_ALIGNMENT, 4);
+		let s = e.pixelWidth, c = e.pixelHeight, l = !!nt[e.format];
+		for (let r = 0; r < e.resource.length; r++) {
+			let i = e.resource[r];
+			l ? n.compressedTexImage2D(o, r, t.internalFormat, s, c, 0, i) : n.texImage2D(o, r, t.internalFormat, s, c, 0, t.format, t.type, i), s = Math.max(s >> 1, 1), c = Math.max(c >> 1, 1);
+		}
+	}
+}, it = [
+	"right",
+	"left",
+	"top",
+	"bottom",
+	"front",
+	"back"
+];
+function at(e) {
+	return {
+		id: "cube",
+		upload(t, n, r, i) {
+			let a = t.faces;
+			for (let t = 0; t < it.length; t++) {
+				let o = a[it[t]];
+				o.resource && ((e[o.uploadMethodId] || e.image).upload(o, n, r, i, M.TEXTURE_CUBE_MAP_POSITIVE_X + t, (n._layerInitMask & 1 << t) == 0), n._layerInitMask |= 1 << t);
+			}
+			n.width = t.pixelWidth, n.height = t.pixelHeight;
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/uploaders/glUploadImageResource.mjs
+var ot = {
+	id: "image",
+	upload(e, t, n, r, i, a = !1) {
+		let o = i || t.target, s = e.pixelWidth, c = e.pixelHeight, l = e.resourceWidth, u = e.resourceHeight, d = r === 2, f = a || t.width !== s || t.height !== c, p = l >= s && u >= c, m = e.resource;
+		(d ? st : ct)(n, o, t, s, c, l, u, m, f, p), t.width = s, t.height = c;
+	}
+};
+function st(e, t, n, r, i, a, o, s, c, l) {
+	if (!l) {
+		c && e.texImage2D(t, 0, n.internalFormat, r, i, 0, n.format, n.type, null), e.texSubImage2D(t, 0, 0, 0, a, o, n.format, n.type, s);
+		return;
+	}
+	if (!c) {
+		e.texSubImage2D(t, 0, 0, 0, n.format, n.type, s);
+		return;
+	}
+	e.texImage2D(t, 0, n.internalFormat, r, i, 0, n.format, n.type, s);
+}
+function ct(e, t, n, r, i, a, o, s, c, l) {
+	if (!l) {
+		c && e.texImage2D(t, 0, n.internalFormat, r, i, 0, n.format, n.type, null), e.texSubImage2D(t, 0, 0, 0, n.format, n.type, s);
+		return;
+	}
+	if (!c) {
+		e.texSubImage2D(t, 0, 0, 0, n.format, n.type, s);
+		return;
+	}
+	e.texImage2D(t, 0, n.internalFormat, n.format, n.type, s);
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/uploaders/glUploadVideoResource.mjs
+var lt = ge(), ut = {
+	id: "video",
+	upload(e, t, n, r, i, a = lt) {
+		if (!e.isValid) {
+			let e = i ?? t.target;
+			n.texImage2D(e, 0, t.internalFormat, 1, 1, 0, t.format, t.type, null);
+			return;
+		}
+		ot.upload(e, t, n, r, i, a);
+	}
+}, dt = {
+	linear: 9729,
+	nearest: 9728
+}, ft = {
+	linear: {
+		linear: 9987,
+		nearest: 9985
+	},
+	nearest: {
+		linear: 9986,
+		nearest: 9984
+	}
+}, Z = {
+	"clamp-to-edge": 33071,
+	repeat: 10497,
+	"mirror-repeat": 33648
+}, pt = {
+	never: 512,
+	less: 513,
+	equal: 514,
+	"less-equal": 515,
+	greater: 516,
+	"not-equal": 517,
+	"greater-equal": 518,
+	always: 519
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/utils/applyStyleParams.mjs
+function mt(e, t, n, r, i, a, o, s) {
+	let c = a;
+	if (!s || e.addressModeU !== "repeat" || e.addressModeV !== "repeat" || e.addressModeW !== "repeat") {
+		let n = Z[o ? "clamp-to-edge" : e.addressModeU], r = Z[o ? "clamp-to-edge" : e.addressModeV], a = Z[o ? "clamp-to-edge" : e.addressModeW];
+		t[i](c, t.TEXTURE_WRAP_S, n), t[i](c, t.TEXTURE_WRAP_T, r), t.TEXTURE_WRAP_R && t[i](c, t.TEXTURE_WRAP_R, a);
+	}
+	if ((!s || e.magFilter !== "linear") && t[i](c, t.TEXTURE_MAG_FILTER, dt[e.magFilter]), n) {
+		if (!s || e.mipmapFilter !== "linear") {
+			let n = ft[e.minFilter][e.mipmapFilter];
+			t[i](c, t.TEXTURE_MIN_FILTER, n);
+		}
+	} else t[i](c, t.TEXTURE_MIN_FILTER, dt[e.minFilter]);
+	if (r && e.maxAnisotropy > 1) {
+		let n = Math.min(e.maxAnisotropy, t.getParameter(r.MAX_TEXTURE_MAX_ANISOTROPY_EXT));
+		t[i](c, r.TEXTURE_MAX_ANISOTROPY_EXT, n);
+	}
+	e.compare ? (t[i](c, t.TEXTURE_COMPARE_FUNC, pt[e.compare]), t[i](c, t.TEXTURE_COMPARE_MODE, t.COMPARE_REF_TO_TEXTURE)) : s || t[i](c, t.TEXTURE_COMPARE_MODE, t.NONE);
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/utils/mapFormatToGlFormat.mjs
+function ht(e) {
+	return {
+		r8unorm: e.RED,
+		r8snorm: e.RED,
+		r8uint: e.RED,
+		r8sint: e.RED,
+		r16uint: e.RED,
+		r16sint: e.RED,
+		r16float: e.RED,
+		rg8unorm: e.RG,
+		rg8snorm: e.RG,
+		rg8uint: e.RG,
+		rg8sint: e.RG,
+		r32uint: e.RED,
+		r32sint: e.RED,
+		r32float: e.RED,
+		rg16uint: e.RG,
+		rg16sint: e.RG,
+		rg16float: e.RG,
+		rgba8unorm: e.RGBA,
+		"rgba8unorm-srgb": e.RGBA,
+		rgba8snorm: e.RGBA,
+		rgba8uint: e.RGBA,
+		rgba8sint: e.RGBA,
+		bgra8unorm: e.RGBA,
+		"bgra8unorm-srgb": e.RGBA,
+		rgb9e5ufloat: e.RGB,
+		rgb10a2unorm: e.RGBA,
+		rg11b10ufloat: e.RGB,
+		rg32uint: e.RG,
+		rg32sint: e.RG,
+		rg32float: e.RG,
+		rgba16uint: e.RGBA,
+		rgba16sint: e.RGBA,
+		rgba16float: e.RGBA,
+		rgba32uint: e.RGBA,
+		rgba32sint: e.RGBA,
+		rgba32float: e.RGBA,
+		stencil8: e.STENCIL_INDEX8,
+		depth16unorm: e.DEPTH_COMPONENT,
+		depth24plus: e.DEPTH_COMPONENT,
+		"depth24plus-stencil8": e.DEPTH_STENCIL,
+		depth32float: e.DEPTH_COMPONENT,
+		"depth32float-stencil8": e.DEPTH_STENCIL
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/utils/mapFormatToGlInternalFormat.mjs
+function gt(e, t) {
+	let n = {}, r = e.RGBA;
+	return e instanceof s.get().getWebGLRenderingContext() ? t.srgb && (n = {
+		"rgba8unorm-srgb": t.srgb.SRGB8_ALPHA8_EXT,
+		"bgra8unorm-srgb": t.srgb.SRGB8_ALPHA8_EXT
+	}) : (n = {
+		"rgba8unorm-srgb": e.SRGB8_ALPHA8,
+		"bgra8unorm-srgb": e.SRGB8_ALPHA8
+	}, r = e.RGBA8), {
+		r8unorm: e.R8,
+		r8snorm: e.R8_SNORM,
+		r8uint: e.R8UI,
+		r8sint: e.R8I,
+		r16uint: e.R16UI,
+		r16sint: e.R16I,
+		r16float: e.R16F,
+		rg8unorm: e.RG8,
+		rg8snorm: e.RG8_SNORM,
+		rg8uint: e.RG8UI,
+		rg8sint: e.RG8I,
+		r32uint: e.R32UI,
+		r32sint: e.R32I,
+		r32float: e.R32F,
+		rg16uint: e.RG16UI,
+		rg16sint: e.RG16I,
+		rg16float: e.RG16F,
+		rgba8unorm: e.RGBA,
+		...n,
+		rgba8snorm: e.RGBA8_SNORM,
+		rgba8uint: e.RGBA8UI,
+		rgba8sint: e.RGBA8I,
+		bgra8unorm: r,
+		rgb9e5ufloat: e.RGB9_E5,
+		rgb10a2unorm: e.RGB10_A2,
+		rg11b10ufloat: e.R11F_G11F_B10F,
+		rg32uint: e.RG32UI,
+		rg32sint: e.RG32I,
+		rg32float: e.RG32F,
+		rgba16uint: e.RGBA16UI,
+		rgba16sint: e.RGBA16I,
+		rgba16float: e.RGBA16F,
+		rgba32uint: e.RGBA32UI,
+		rgba32sint: e.RGBA32I,
+		rgba32float: e.RGBA32F,
+		stencil8: e.STENCIL_INDEX8,
+		depth16unorm: e.DEPTH_COMPONENT16,
+		depth24plus: e.DEPTH_COMPONENT24,
+		"depth24plus-stencil8": e.DEPTH24_STENCIL8,
+		depth32float: e.DEPTH_COMPONENT32F,
+		"depth32float-stencil8": e.DEPTH32F_STENCIL8,
+		...t.s3tc ? {
+			"bc1-rgba-unorm": t.s3tc.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+			"bc2-rgba-unorm": t.s3tc.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+			"bc3-rgba-unorm": t.s3tc.COMPRESSED_RGBA_S3TC_DXT5_EXT
+		} : {},
+		...t.s3tc_sRGB ? {
+			"bc1-rgba-unorm-srgb": t.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+			"bc2-rgba-unorm-srgb": t.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+			"bc3-rgba-unorm-srgb": t.s3tc_sRGB.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
+		} : {},
+		...t.rgtc ? {
+			"bc4-r-unorm": t.rgtc.COMPRESSED_RED_RGTC1_EXT,
+			"bc4-r-snorm": t.rgtc.COMPRESSED_SIGNED_RED_RGTC1_EXT,
+			"bc5-rg-unorm": t.rgtc.COMPRESSED_RED_GREEN_RGTC2_EXT,
+			"bc5-rg-snorm": t.rgtc.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT
+		} : {},
+		...t.bptc ? {
+			"bc6h-rgb-float": t.bptc.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT,
+			"bc6h-rgb-ufloat": t.bptc.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT,
+			"bc7-rgba-unorm": t.bptc.COMPRESSED_RGBA_BPTC_UNORM_EXT,
+			"bc7-rgba-unorm-srgb": t.bptc.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT
+		} : {},
+		...t.etc ? {
+			"etc2-rgb8unorm": t.etc.COMPRESSED_RGB8_ETC2,
+			"etc2-rgb8unorm-srgb": t.etc.COMPRESSED_SRGB8_ETC2,
+			"etc2-rgb8a1unorm": t.etc.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+			"etc2-rgb8a1unorm-srgb": t.etc.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+			"etc2-rgba8unorm": t.etc.COMPRESSED_RGBA8_ETC2_EAC,
+			"etc2-rgba8unorm-srgb": t.etc.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+			"eac-r11unorm": t.etc.COMPRESSED_R11_EAC,
+			"eac-rg11unorm": t.etc.COMPRESSED_SIGNED_RG11_EAC
+		} : {},
+		...t.astc ? {
+			"astc-4x4-unorm": t.astc.COMPRESSED_RGBA_ASTC_4x4_KHR,
+			"astc-4x4-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+			"astc-5x4-unorm": t.astc.COMPRESSED_RGBA_ASTC_5x4_KHR,
+			"astc-5x4-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
+			"astc-5x5-unorm": t.astc.COMPRESSED_RGBA_ASTC_5x5_KHR,
+			"astc-5x5-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+			"astc-6x5-unorm": t.astc.COMPRESSED_RGBA_ASTC_6x5_KHR,
+			"astc-6x5-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+			"astc-6x6-unorm": t.astc.COMPRESSED_RGBA_ASTC_6x6_KHR,
+			"astc-6x6-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+			"astc-8x5-unorm": t.astc.COMPRESSED_RGBA_ASTC_8x5_KHR,
+			"astc-8x5-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+			"astc-8x6-unorm": t.astc.COMPRESSED_RGBA_ASTC_8x6_KHR,
+			"astc-8x6-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+			"astc-8x8-unorm": t.astc.COMPRESSED_RGBA_ASTC_8x8_KHR,
+			"astc-8x8-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+			"astc-10x5-unorm": t.astc.COMPRESSED_RGBA_ASTC_10x5_KHR,
+			"astc-10x5-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+			"astc-10x6-unorm": t.astc.COMPRESSED_RGBA_ASTC_10x6_KHR,
+			"astc-10x6-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+			"astc-10x8-unorm": t.astc.COMPRESSED_RGBA_ASTC_10x8_KHR,
+			"astc-10x8-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+			"astc-10x10-unorm": t.astc.COMPRESSED_RGBA_ASTC_10x10_KHR,
+			"astc-10x10-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+			"astc-12x10-unorm": t.astc.COMPRESSED_RGBA_ASTC_12x10_KHR,
+			"astc-12x10-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+			"astc-12x12-unorm": t.astc.COMPRESSED_RGBA_ASTC_12x12_KHR,
+			"astc-12x12-unorm-srgb": t.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
+		} : {}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/utils/mapFormatToGlType.mjs
+function _t(e) {
+	return {
+		r8unorm: e.UNSIGNED_BYTE,
+		r8snorm: e.BYTE,
+		r8uint: e.UNSIGNED_BYTE,
+		r8sint: e.BYTE,
+		r16uint: e.UNSIGNED_SHORT,
+		r16sint: e.SHORT,
+		r16float: e.HALF_FLOAT,
+		rg8unorm: e.UNSIGNED_BYTE,
+		rg8snorm: e.BYTE,
+		rg8uint: e.UNSIGNED_BYTE,
+		rg8sint: e.BYTE,
+		r32uint: e.UNSIGNED_INT,
+		r32sint: e.INT,
+		r32float: e.FLOAT,
+		rg16uint: e.UNSIGNED_SHORT,
+		rg16sint: e.SHORT,
+		rg16float: e.HALF_FLOAT,
+		rgba8unorm: e.UNSIGNED_BYTE,
+		"rgba8unorm-srgb": e.UNSIGNED_BYTE,
+		rgba8snorm: e.BYTE,
+		rgba8uint: e.UNSIGNED_BYTE,
+		rgba8sint: e.BYTE,
+		bgra8unorm: e.UNSIGNED_BYTE,
+		"bgra8unorm-srgb": e.UNSIGNED_BYTE,
+		rgb9e5ufloat: e.UNSIGNED_INT_5_9_9_9_REV,
+		rgb10a2unorm: e.UNSIGNED_INT_2_10_10_10_REV,
+		rg11b10ufloat: e.UNSIGNED_INT_10F_11F_11F_REV,
+		rg32uint: e.UNSIGNED_INT,
+		rg32sint: e.INT,
+		rg32float: e.FLOAT,
+		rgba16uint: e.UNSIGNED_SHORT,
+		rgba16sint: e.SHORT,
+		rgba16float: e.HALF_FLOAT,
+		rgba32uint: e.UNSIGNED_INT,
+		rgba32sint: e.INT,
+		rgba32float: e.FLOAT,
+		stencil8: e.UNSIGNED_BYTE,
+		depth16unorm: e.UNSIGNED_SHORT,
+		depth24plus: e.UNSIGNED_INT,
+		"depth24plus-stencil8": e.UNSIGNED_INT_24_8,
+		depth32float: e.FLOAT,
+		"depth32float-stencil8": e.FLOAT_32_UNSIGNED_INT_24_8_REV
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/utils/mapViewDimensionToGlTarget.mjs
+function vt(e) {
+	return {
+		"2d": e.TEXTURE_2D,
+		cube: e.TEXTURE_CUBE_MAP,
+		"1d": null,
+		"3d": e?.TEXTURE_3D || null,
+		"2d-array": e?.TEXTURE_2D_ARRAY || null,
+		"cube-array": e?.TEXTURE_CUBE_MAP_ARRAY || null
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/texture/GlTextureSystem.mjs
+var yt = 4, Q = class e {
+	constructor(t) {
+		this._glSamplers = /* @__PURE__ */ Object.create(null), this._boundTextures = [], this._activeTextureLocation = -1, this._boundSamplers = /* @__PURE__ */ Object.create(null), this._premultiplyAlpha = !1, this._useSeparateSamplers = !1, this._renderer = t, this._managedTextures = new x({
+			renderer: t,
+			type: "resource",
+			onUnload: this.onSourceUnload.bind(this),
+			name: "glTexture"
+		});
+		let n = {
+			image: ot,
+			buffer: tt,
+			video: ut,
+			compressed: rt,
+			...e.uploadExtensions
+		};
+		this._uploads = {
+			...n,
+			cube: at(n)
+		};
+	}
+	get managedTextures() {
+		return Object.values(this._managedTextures.items);
+	}
+	contextChange(e) {
+		this._gl = e, this._mapFormatToInternalFormat || (this._mapFormatToInternalFormat = gt(e, this._renderer.context.extensions), this._mapFormatToType = _t(e), this._mapFormatToFormat = ht(e), this._mapViewDimensionToGlTarget = vt(e)), this._managedTextures.removeAll(!0), this._glSamplers = /* @__PURE__ */ Object.create(null), this._boundSamplers = /* @__PURE__ */ Object.create(null), this._premultiplyAlpha = !1;
+		for (let e = 0; e < 16; e++) this.bind(r.EMPTY, e);
+	}
+	initSource(e) {
+		this.bind(e);
+	}
+	bind(e, t = 0) {
+		let n = e.source;
+		e ? (this.bindSource(n, t), this._useSeparateSamplers && this._bindSampler(n.style, t)) : (this.bindSource(null, t), this._useSeparateSamplers && this._bindSampler(null, t));
+	}
+	bindSource(e, t = 0) {
+		let n = this._gl;
+		if (e._gcLastUsed = this._renderer.gc.now, this._boundTextures[t] !== e) {
+			this._boundTextures[t] = e, this._activateLocation(t), e ||= r.EMPTY.source;
+			let i = this.getGlSource(e);
+			n.bindTexture(i.target, i.texture);
+		}
+	}
+	_bindSampler(e, t = 0) {
+		let n = this._gl;
+		if (!e) {
+			this._boundSamplers[t] = null, n.bindSampler(t, null);
+			return;
+		}
+		let r = this._getGlSampler(e);
+		this._boundSamplers[t] !== r && (this._boundSamplers[t] = r, n.bindSampler(t, r));
+	}
+	unbind(e) {
+		let t = e.source, n = this._boundTextures, r = this._gl;
+		for (let e = 0; e < n.length; e++) if (n[e] === t) {
+			this._activateLocation(e);
+			let i = this.getGlSource(t);
+			r.bindTexture(i.target, null), n[e] = null;
+		}
+	}
+	_activateLocation(e) {
+		this._activeTextureLocation !== e && (this._activeTextureLocation = e, this._gl.activeTexture(this._gl.TEXTURE0 + e));
+	}
+	_initSource(e) {
+		let t = this._gl, n = new et(t.createTexture());
+		if (n.type = this._mapFormatToType[e.format], n.internalFormat = this._mapFormatToInternalFormat[e.format], n.format = this._mapFormatToFormat[e.format], n.target = this._mapViewDimensionToGlTarget[e.viewDimension], n.target === null) throw Error(`Unsupported view dimension: ${e.viewDimension} with this webgl version: ${this._renderer.context.webGLVersion}`);
+		if (e.autoGenerateMipmaps && (this._renderer.context.supports.nonPowOf2mipmaps || e.isPowerOfTwo)) {
+			let t = Math.max(e.width, e.height);
+			e.mipLevelCount = Math.floor(Math.log2(t)) + 1;
+		}
+		return e._gpuData[this._renderer.uid] = n, this._managedTextures.add(e) && (e.on("update", this.onSourceUpdate, this), e.on("resize", this.onSourceUpdate, this), e.on("styleChange", this.onStyleChange, this), e.on("updateMipmaps", this.onUpdateMipmaps, this)), this.onSourceUpdate(e), this.updateStyle(e, !1), n;
+	}
+	onStyleChange(e) {
+		this.updateStyle(e, !1);
+	}
+	updateStyle(e, t) {
+		let n = this._gl, r = this.getGlSource(e);
+		n.bindTexture(r.target, r.texture), this._boundTextures[this._activeTextureLocation] = e, mt(e.style, n, e.mipLevelCount > 1, this._renderer.context.extensions.anisotropicFiltering, "texParameteri", r.target, !this._renderer.context.supports.nonPowOf2wrapping && !e.isPowerOfTwo, t);
+	}
+	onSourceUnload(e, t = !1) {
+		let n = e._gpuData[this._renderer.uid];
+		n && (t || (this.unbind(e), this._gl.deleteTexture(n.texture)), e.off("update", this.onSourceUpdate, this), e.off("resize", this.onSourceUpdate, this), e.off("styleChange", this.onStyleChange, this), e.off("updateMipmaps", this.onUpdateMipmaps, this));
+	}
+	onSourceUpdate(e) {
+		let t = this._gl, n = this.getGlSource(e);
+		t.bindTexture(n.target, n.texture), this._boundTextures[this._activeTextureLocation] = e;
+		let r = e.alphaMode === "premultiply-alpha-on-upload";
+		if (this._premultiplyAlpha !== r && (this._premultiplyAlpha = r, t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, r)), this._uploads[e.uploadMethodId]) this._uploads[e.uploadMethodId].upload(e, n, t, this._renderer.context.webGLVersion);
+		else if (n.target === t.TEXTURE_2D) this._initEmptyTexture2D(n, e);
+		else if (n.target === t.TEXTURE_2D_ARRAY) this._initEmptyTexture2DArray(n, e);
+		else if (n.target === t.TEXTURE_CUBE_MAP) this._initEmptyTextureCube(n, e);
+		else throw Error("[GlTextureSystem] Unsupported texture target for empty allocation.");
+		this._applyMipRange(n, e), e.autoGenerateMipmaps && e.mipLevelCount > 1 && this.onUpdateMipmaps(e, !1);
+	}
+	onUpdateMipmaps(e, t = !0) {
+		t && this.bindSource(e, 0);
+		let n = this.getGlSource(e);
+		this._gl.generateMipmap(n.target);
+	}
+	_initEmptyTexture2D(e, t) {
+		let n = this._gl;
+		n.texImage2D(n.TEXTURE_2D, 0, e.internalFormat, t.pixelWidth, t.pixelHeight, 0, e.format, e.type, null);
+		let r = Math.max(t.pixelWidth >> 1, 1), i = Math.max(t.pixelHeight >> 1, 1);
+		for (let a = 1; a < t.mipLevelCount; a++) n.texImage2D(n.TEXTURE_2D, a, e.internalFormat, r, i, 0, e.format, e.type, null), r = Math.max(r >> 1, 1), i = Math.max(i >> 1, 1);
+	}
+	_initEmptyTexture2DArray(e, t) {
+		if (this._renderer.context.webGLVersion !== 2) throw Error("[GlTextureSystem] TEXTURE_2D_ARRAY requires WebGL2.");
+		let n = this._gl, r = Math.max(t.arrayLayerCount | 0, 1);
+		n.texImage3D(n.TEXTURE_2D_ARRAY, 0, e.internalFormat, t.pixelWidth, t.pixelHeight, r, 0, e.format, e.type, null);
+		let i = Math.max(t.pixelWidth >> 1, 1), a = Math.max(t.pixelHeight >> 1, 1);
+		for (let o = 1; o < t.mipLevelCount; o++) n.texImage3D(n.TEXTURE_2D_ARRAY, o, e.internalFormat, i, a, r, 0, e.format, e.type, null), i = Math.max(i >> 1, 1), a = Math.max(a >> 1, 1);
+	}
+	_initEmptyTextureCube(e, t) {
+		let n = this._gl;
+		for (let r = 0; r < 6; r++) n.texImage2D(n.TEXTURE_CUBE_MAP_POSITIVE_X + r, 0, e.internalFormat, t.pixelWidth, t.pixelHeight, 0, e.format, e.type, null);
+		let r = Math.max(t.pixelWidth >> 1, 1), i = Math.max(t.pixelHeight >> 1, 1);
+		for (let a = 1; a < t.mipLevelCount; a++) {
+			for (let t = 0; t < 6; t++) n.texImage2D(n.TEXTURE_CUBE_MAP_POSITIVE_X + t, a, e.internalFormat, r, i, 0, e.format, e.type, null);
+			r = Math.max(r >> 1, 1), i = Math.max(i >> 1, 1);
+		}
+	}
+	_applyMipRange(e, t) {
+		if (this._renderer.context.webGLVersion !== 2 || t.mipLevelCount <= 1) return;
+		let n = this._gl, r = Math.max((t.mipLevelCount | 0) - 1, 0);
+		n.texParameteri(e.target, n.TEXTURE_BASE_LEVEL, 0), n.texParameteri(e.target, n.TEXTURE_MAX_LEVEL, r);
+	}
+	_initSampler(e) {
+		let t = this._gl, n = this._gl.createSampler();
+		return this._glSamplers[e._resourceId] = n, mt(e, t, this._boundTextures[this._activeTextureLocation].mipLevelCount > 1, this._renderer.context.extensions.anisotropicFiltering, "samplerParameteri", n, !1, !0), this._glSamplers[e._resourceId];
+	}
+	_getGlSampler(e) {
+		return this._glSamplers[e._resourceId] || this._initSampler(e);
+	}
+	getGlSource(e) {
+		return e._gcLastUsed = this._renderer.gc.now, e._gpuData[this._renderer.uid] || this._initSource(e);
+	}
+	generateCanvas(e) {
+		let { pixels: t, width: n, height: r } = this.getPixels(e), i = s.get().createCanvas();
+		i.width = n, i.height = r;
+		let a = i.getContext("2d");
+		if (a) {
+			let e = a.createImageData(n, r);
+			e.data.set(t), a.putImageData(e, 0, 0);
+		}
+		return i;
+	}
+	getPixels(e) {
+		let t = e.source.resolution, n = e.frame, r = Math.max(Math.round(n.width * t), 1), i = Math.max(Math.round(n.height * t), 1), a = new Uint8Array(yt * r * i), o = this._renderer, s = o.renderTarget.getRenderTarget(e), c = o.renderTarget.getGpuRenderTarget(s), l = o.gl;
+		return o.renderTarget.adaptor.bindFramebuffer(c.resolveTargetFramebuffer), l.readPixels(Math.round(n.x * t), Math.round(n.y * t), r, i, l.RGBA, l.UNSIGNED_BYTE, a), {
+			pixels: new Uint8ClampedArray(a.buffer),
+			width: r,
+			height: i
+		};
+	}
+	destroy() {
+		this._managedTextures.destroy(), this._glSamplers = null, this._boundTextures = null, this._boundSamplers = null, this._mapFormatToInternalFormat = null, this._mapFormatToType = null, this._mapFormatToFormat = null, this._uploads = null, this._renderer = null;
+	}
+	resetState() {
+		this._activeTextureLocation = -1, this._boundTextures.fill(r.EMPTY.source), this._boundSamplers = /* @__PURE__ */ Object.create(null);
+		let e = this._gl;
+		this._premultiplyAlpha = !1, e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this._premultiplyAlpha);
+	}
+};
+Q.extension = {
+	type: [g.WebGLSystem],
+	name: "texture"
+}, Q.uploadExtensions = /* @__PURE__ */ Object.create(null);
+var bt = Q;
+u.handleByMap(g.TextureUploaderWebGL, bt.uploadExtensions);
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/scene/graphics/gl/GlGraphicsAdaptor.mjs
+var xt = class {
+	contextChange(e) {
+		let t = new c({
+			uColor: {
+				value: new Float32Array([
+					1,
+					1,
+					1,
+					1
+				]),
+				type: "vec4<f32>"
+			},
+			uTransformMatrix: {
+				value: new l(),
+				type: "mat3x3<f32>"
+			},
+			uRound: {
+				value: 0,
+				type: "f32"
+			}
+		}), n = e.limits.maxBatchableTextures, r = b({
+			name: "graphics",
+			bits: [
+				le,
+				ie(n),
+				T,
+				S
+			]
+		});
+		this.shader = new _({
+			glProgram: r,
+			resources: {
+				localUniforms: t,
+				batchSamplers: oe(n)
+			}
+		});
+	}
+	execute(e, t) {
+		let n = t.context, r = n.customShader || this.shader, i = e.renderer, { batcher: a, instructions: o } = i.graphicsContext.getContextRenderData(n);
+		r.groups[0] = i.globalUniforms.bindGroup, i.state.set(e.state), i.shader.bind(r), i.geometry.bind(a.geometry, r.glProgram);
+		let s = o.instructions;
+		for (let e = 0; e < o.instructionSize; e++) {
+			let t = s[e];
+			if (t.size) {
+				for (let e = 0; e < t.textures.count; e++) i.texture.bind(t.textures.textures[e], e);
+				i.geometry.draw(t.topology, t.size, t.start);
+			}
+		}
+	}
+	destroy() {
+		this.shader.destroy(!0), this.shader = null;
+	}
+};
+xt.extension = {
+	type: [g.WebGLPipesAdaptor],
+	name: "graphics"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/scene/mesh/gl/GlMeshAdaptor.mjs
+var St = class {
+	init() {
+		let e = b({
+			name: "mesh",
+			bits: [
+				T,
+				he,
+				S
+			]
+		});
+		this._shader = new _({
+			glProgram: e,
+			resources: {
+				uTexture: r.EMPTY.source,
+				textureUniforms: { uTextureMatrix: {
+					type: "mat3x3<f32>",
+					value: new l()
+				} }
+			}
+		});
+	}
+	execute(e, t) {
+		let r = e.renderer, i = t._shader;
+		if (!i) {
+			i = this._shader;
+			let e = t.texture, n = e.source;
+			i.resources.uTexture = n, i.resources.uSampler = n.style, i.resources.textureUniforms.uniforms.uTextureMatrix = e.textureMatrix.mapCoord;
+		} else if (!i.glProgram) {
+			n("Mesh shader has no glProgram", t.shader);
+			return;
+		}
+		i.groups[100] = r.globalUniforms.bindGroup, i.groups[101] = e.localUniformsBindGroup, r.encoder.draw({
+			geometry: t._geometry,
+			shader: i,
+			state: t.state
+		});
+	}
+	destroy() {
+		this._shader.destroy(!0), this._shader = null;
+	}
+};
+St.extension = {
+	type: [g.WebGLPipesAdaptor],
+	name: "mesh"
+};
+//#endregion
+//#region node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/rendering/renderers/gl/WebGLRenderer.mjs
+var Ct = /* @__PURE__ */ e({ WebGLRenderer: () => kt }), wt = [
+	...se,
+	H,
+	Ce,
+	ve,
+	z,
+	k,
+	bt,
+	ke,
+	F,
+	We,
+	Be,
+	R,
+	$e,
+	B,
+	L
+], Tt = [...ae], Et = [
+	D,
+	St,
+	xt
+], Dt = [], Ot = [], $ = [];
+u.handleByNamedList(g.WebGLSystem, Dt), u.handleByNamedList(g.WebGLPipes, Ot), u.handleByNamedList(g.WebGLPipesAdaptor, $), u.add(...wt, ...Tt, ...Et);
+var kt = class extends ne {
+	constructor() {
+		let e = {
+			name: "webgl",
+			type: d.WEBGL,
+			systems: Dt,
+			renderPipes: Ot,
+			renderPipeAdaptors: $
+		};
+		super(e);
+	}
+};
+//#endregion
+export { j as n, Ct as t };