@orbit-software/sdk 1.10.0

package/dist/esm/ui-C32u2WA-.mjs

@@ -0,0 +1,2678 @@
+var Xr = ((Pt) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(Pt, { get: (vt, te) => (typeof require < "u" ? require : vt)[te] }) : Pt)(function(Pt) {
+  if (typeof require < "u") return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + Pt + '" is not supported');
+}), zn = (Pt, vt) => () => (vt || Pt((vt = { exports: {} }).exports, vt), vt.exports), qn = zn((Pt, vt) => {
+  var te = (() => {
+    var ee = typeof document < "u" && document.currentScript ? document.currentScript.src : void 0;
+    return typeof __filename < "u" && (ee = ee || __filename), function(Je = {}) {
+      var g = Je, Ke, re;
+      g.ready = new Promise((t, e) => {
+        Ke = t, re = e;
+      }), function(t) {
+        t.Id = t.Id || [], t.Id.push(function() {
+          t.MakeSWCanvasSurface = function(e) {
+            var r = e, o = typeof OffscreenCanvas < "u" && r instanceof OffscreenCanvas;
+            if (!(typeof HTMLCanvasElement < "u" && r instanceof HTMLCanvasElement || o || (r = document.getElementById(e), r))) throw "Canvas with id " + e + " was not found";
+            return (e = t.MakeSurface(r.width, r.height)) && (e.ie = r), e;
+          }, t.MakeCanvasSurface || (t.MakeCanvasSurface = t.MakeSWCanvasSurface), t.MakeSurface = function(e, r) {
+            var o = { width: e, height: r, colorType: t.ColorType.RGBA_8888, alphaType: t.AlphaType.Unpremul, colorSpace: t.ColorSpace.SRGB }, i = e * r * 4, c = t._malloc(i);
+            return (o = t.Surface._makeRasterDirect(o, c, 4 * e)) && (o.ie = null, o.Pe = e, o.Me = r, o.Ne = i, o.re = c, o.getCanvas().clear(t.TRANSPARENT)), o;
+          }, t.MakeRasterDirectSurface = function(e, r, o) {
+            return t.Surface._makeRasterDirect(e, r.byteOffset, o);
+          }, t.Surface.prototype.flush = function(e) {
+            if (t.Fd(this.Ed), this._flush(), this.ie) {
+              var r = new Uint8ClampedArray(t.HEAPU8.buffer, this.re, this.Ne);
+              r = new ImageData(r, this.Pe, this.Me), e ? this.ie.getContext("2d").putImageData(r, 0, 0, e[0], e[1], e[2] - e[0], e[3] - e[1]) : this.ie.getContext("2d").putImageData(r, 0, 0);
+            }
+          }, t.Surface.prototype.dispose = function() {
+            this.re && t._free(this.re), this.delete();
+          }, t.Fd = t.Fd || function() {
+          }, t.je = t.je || function() {
+            return null;
+          };
+        });
+      }(g), function(t) {
+        t.Id = t.Id || [], t.Id.push(function() {
+          function e(l, h, b) {
+            return l && l.hasOwnProperty(h) ? l[h] : b;
+          }
+          function r(l) {
+            var h = Gt(rt);
+            return rt[h] = l, h;
+          }
+          function o(l) {
+            return l.naturalHeight || l.videoHeight || l.displayHeight || l.height;
+          }
+          function i(l) {
+            return l.naturalWidth || l.videoWidth || l.displayWidth || l.width;
+          }
+          function c(l, h, b, _) {
+            return l.bindTexture(l.TEXTURE_2D, h), _ || b.alphaType !== t.AlphaType.Premul || l.pixelStorei(l.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !0), h;
+          }
+          function s(l, h, b) {
+            b || h.alphaType !== t.AlphaType.Premul || l.pixelStorei(l.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), l.bindTexture(l.TEXTURE_2D, null);
+          }
+          t.GetWebGLContext = function(l, h) {
+            if (!l) throw "null canvas passed into makeWebGLContext";
+            var b = { alpha: e(h, "alpha", 1), depth: e(h, "depth", 1), stencil: e(h, "stencil", 8), antialias: e(h, "antialias", 0), premultipliedAlpha: e(h, "premultipliedAlpha", 1), preserveDrawingBuffer: e(h, "preserveDrawingBuffer", 0), preferLowPowerToHighPerformance: e(h, "preferLowPowerToHighPerformance", 0), failIfMajorPerformanceCaveat: e(h, "failIfMajorPerformanceCaveat", 0), enableExtensionsByDefault: e(h, "enableExtensionsByDefault", 1), explicitSwapControl: e(h, "explicitSwapControl", 0), renderViaOffscreenBackBuffer: e(h, "renderViaOffscreenBackBuffer", 0) };
+            if (b.majorVersion = h && h.majorVersion ? h.majorVersion : typeof WebGL2RenderingContext < "u" ? 2 : 1, b.explicitSwapControl) throw "explicitSwapControl is not supported";
+            return l = Tn(l, b), l ? (Mr(l), R.Qd.getExtension("WEBGL_debug_renderer_info"), l) : 0;
+          }, t.deleteContext = function(l) {
+            R === mt[l] && (R = null), typeof JSEvents == "object" && JSEvents.tf(mt[l].Qd.canvas), mt[l] && mt[l].Qd.canvas && (mt[l].Qd.canvas.Ke = void 0), mt[l] = null;
+          }, t._setTextureCleanup({ deleteTexture: function(l, h) {
+            var b = rt[h];
+            b && mt[l].Qd.deleteTexture(b), rt[h] = null;
+          } }), t.MakeWebGLContext = function(l) {
+            if (!this.Fd(l)) return null;
+            var h = this._MakeGrContext();
+            if (!h) return null;
+            h.Ed = l;
+            var b = h.delete.bind(h);
+            return h.delete = (function() {
+              t.Fd(this.Ed), b();
+            }).bind(h), R.te = h;
+          }, t.MakeGrContext = t.MakeWebGLContext, t.GrDirectContext.prototype.getResourceCacheLimitBytes = function() {
+            t.Fd(this.Ed), this._getResourceCacheLimitBytes();
+          }, t.GrDirectContext.prototype.getResourceCacheUsageBytes = function() {
+            t.Fd(this.Ed), this._getResourceCacheUsageBytes();
+          }, t.GrDirectContext.prototype.releaseResourcesAndAbandonContext = function() {
+            t.Fd(this.Ed), this._releaseResourcesAndAbandonContext();
+          }, t.GrDirectContext.prototype.setResourceCacheLimitBytes = function(l) {
+            t.Fd(this.Ed), this._setResourceCacheLimitBytes(l);
+          }, t.MakeOnScreenGLSurface = function(l, h, b, _, A, C) {
+            return !this.Fd(l.Ed) || (h = A === void 0 || C === void 0 ? this._MakeOnScreenGLSurface(l, h, b, _) : this._MakeOnScreenGLSurface(l, h, b, _, A, C), !h) ? null : (h.Ed = l.Ed, h);
+          }, t.MakeRenderTarget = function() {
+            var l = arguments[0];
+            if (!this.Fd(l.Ed)) return null;
+            if (arguments.length === 3) {
+              var h = this._MakeRenderTargetWH(l, arguments[1], arguments[2]);
+              if (!h) return null;
+            } else if (arguments.length === 2) {
+              if (h = this._MakeRenderTargetII(l, arguments[1]), !h) return null;
+            } else return null;
+            return h.Ed = l.Ed, h;
+          }, t.MakeWebGLCanvasSurface = function(l, h, b) {
+            h = h || null;
+            var _ = l, A = typeof OffscreenCanvas < "u" && _ instanceof OffscreenCanvas;
+            if (!(typeof HTMLCanvasElement < "u" && _ instanceof HTMLCanvasElement || A || (_ = document.getElementById(l), _))) throw "Canvas with id " + l + " was not found";
+            if (l = this.GetWebGLContext(_, b), !l || 0 > l) throw "failed to create webgl context: err " + l;
+            return l = this.MakeWebGLContext(l), h = this.MakeOnScreenGLSurface(l, _.width, _.height, h), h || (h = _.cloneNode(!0), _.parentNode.replaceChild(h, _), h.classList.add("ck-replaced"), t.MakeSWCanvasSurface(h));
+          }, t.MakeCanvasSurface = t.MakeWebGLCanvasSurface, t.Surface.prototype.makeImageFromTexture = function(l, h) {
+            return t.Fd(this.Ed), l = r(l), (h = this._makeImageFromTexture(this.Ed, l, h)) && (h.de = l), h;
+          }, t.Surface.prototype.makeImageFromTextureSource = function(l, h, b) {
+            h || (h = { height: o(l), width: i(l), colorType: t.ColorType.RGBA_8888, alphaType: b ? t.AlphaType.Premul : t.AlphaType.Unpremul }), h.colorSpace || (h.colorSpace = t.ColorSpace.SRGB), t.Fd(this.Ed);
+            var _ = R.Qd;
+            return b = c(_, _.createTexture(), h, b), R.version === 2 ? _.texImage2D(_.TEXTURE_2D, 0, _.RGBA, h.width, h.height, 0, _.RGBA, _.UNSIGNED_BYTE, l) : _.texImage2D(_.TEXTURE_2D, 0, _.RGBA, _.RGBA, _.UNSIGNED_BYTE, l), s(_, h), this._resetContext(), this.makeImageFromTexture(b, h);
+          }, t.Surface.prototype.updateTextureFromSource = function(l, h, b) {
+            if (l.de) {
+              t.Fd(this.Ed);
+              var _ = l.getImageInfo(), A = R.Qd, C = c(A, rt[l.de], _, b);
+              R.version === 2 ? A.texImage2D(A.TEXTURE_2D, 0, A.RGBA, i(h), o(h), 0, A.RGBA, A.UNSIGNED_BYTE, h) : A.texImage2D(A.TEXTURE_2D, 0, A.RGBA, A.RGBA, A.UNSIGNED_BYTE, h), s(A, _, b), this._resetContext(), rt[l.de] = null, l.de = r(C), _.colorSpace = l.getColorSpace(), h = this._makeImageFromTexture(this.Ed, l.de, _), b = l.Dd.Hd, A = l.Dd.Ld, l.Dd.Hd = h.Dd.Hd, l.Dd.Ld = h.Dd.Ld, h.Dd.Hd = b, h.Dd.Ld = A, h.delete(), _.colorSpace.delete();
+            }
+          }, t.MakeLazyImageFromTextureSource = function(l, h, b) {
+            h || (h = { height: o(l), width: i(l), colorType: t.ColorType.RGBA_8888, alphaType: b ? t.AlphaType.Premul : t.AlphaType.Unpremul }), h.colorSpace || (h.colorSpace = t.ColorSpace.SRGB);
+            var _ = { makeTexture: function() {
+              var A = R, C = A.Qd, m = c(C, C.createTexture(), h, b);
+              return A.version === 2 ? C.texImage2D(C.TEXTURE_2D, 0, C.RGBA, h.width, h.height, 0, C.RGBA, C.UNSIGNED_BYTE, l) : C.texImage2D(C.TEXTURE_2D, 0, C.RGBA, C.RGBA, C.UNSIGNED_BYTE, l), s(C, h, b), r(m);
+            }, freeSrc: function() {
+            } };
+            return l.constructor.name === "VideoFrame" && (_.freeSrc = function() {
+              l.close();
+            }), t.Image._makeFromGenerator(h, _);
+          }, t.Fd = function(l) {
+            return l ? Mr(l) : !1;
+          }, t.je = function() {
+            return R && R.te && !R.te.isDeleted() ? R.te : null;
+          };
+        });
+      }(g), function(t) {
+        function e(a) {
+          return (i(255 * a[3]) << 24 | i(255 * a[0]) << 16 | i(255 * a[1]) << 8 | i(255 * a[2]) << 0) >>> 0;
+        }
+        function r(a) {
+          if (a && a._ck) return a;
+          if (a instanceof Float32Array) {
+            for (var n = Math.floor(a.length / 4), u = new Uint32Array(n), f = 0; f < n; f++) u[f] = e(a.slice(4 * f, 4 * (f + 1)));
+            return u;
+          }
+          if (a instanceof Uint32Array) return a;
+          if (a instanceof Array && a[0] instanceof Float32Array) return a.map(e);
+        }
+        function o(a) {
+          if (a === void 0) return 1;
+          var n = parseFloat(a);
+          return a && a.indexOf("%") !== -1 ? n / 100 : n;
+        }
+        function i(a) {
+          return Math.round(Math.max(0, Math.min(a || 0, 255)));
+        }
+        function c(a, n) {
+          n && n._ck || t._free(a);
+        }
+        function s(a, n, u) {
+          if (!a || !a.length) return B;
+          if (a && a._ck) return a.byteOffset;
+          var f = t[n].BYTES_PER_ELEMENT;
+          return u || (u = t._malloc(a.length * f)), t[n].set(a, u / f), u;
+        }
+        function l(a) {
+          var n = { Nd: B, count: a.length, colorType: t.ColorType.RGBA_F32 };
+          if (a instanceof Float32Array) n.Nd = s(a, "HEAPF32"), n.count = a.length / 4;
+          else if (a instanceof Uint32Array) n.Nd = s(a, "HEAPU32"), n.colorType = t.ColorType.RGBA_8888;
+          else if (a instanceof Array) {
+            if (a && a.length) {
+              for (var u = t._malloc(16 * a.length), f = 0, y = u / 4, v = 0; v < a.length; v++) for (var P = 0; 4 > P; P++) t.HEAPF32[y + f] = a[v][P], f++;
+              a = u;
+            } else a = B;
+            n.Nd = a;
+          } else throw "Invalid argument to copyFlexibleColorArray, Not a color array " + typeof a;
+          return n;
+        }
+        function h(a) {
+          if (!a) return B;
+          var n = U.toTypedArray();
+          if (a.length) {
+            if (a.length === 6 || a.length === 9) return s(a, "HEAPF32", k), a.length === 6 && t.HEAPF32.set(Yn, 6 + k / 4), k;
+            if (a.length === 16) return n[0] = a[0], n[1] = a[1], n[2] = a[3], n[3] = a[4], n[4] = a[5], n[5] = a[7], n[6] = a[12], n[7] = a[13], n[8] = a[15], k;
+            throw "invalid matrix size";
+          }
+          if (a.m11 === void 0) throw "invalid matrix argument";
+          return n[0] = a.m11, n[1] = a.m21, n[2] = a.m41, n[3] = a.m12, n[4] = a.m22, n[5] = a.m42, n[6] = a.m14, n[7] = a.m24, n[8] = a.m44, k;
+        }
+        function b(a) {
+          if (!a) return B;
+          var n = Y.toTypedArray();
+          if (a.length) {
+            if (a.length !== 16 && a.length !== 6 && a.length !== 9) throw "invalid matrix size";
+            return a.length === 16 ? s(a, "HEAPF32", J) : (n.fill(0), n[0] = a[0], n[1] = a[1], n[3] = a[2], n[4] = a[3], n[5] = a[4], n[7] = a[5], n[10] = 1, n[12] = a[6], n[13] = a[7], n[15] = a[8], a.length === 6 && (n[12] = 0, n[13] = 0, n[15] = 1), J);
+          }
+          if (a.m11 === void 0) throw "invalid matrix argument";
+          return n[0] = a.m11, n[1] = a.m21, n[2] = a.m31, n[3] = a.m41, n[4] = a.m12, n[5] = a.m22, n[6] = a.m32, n[7] = a.m42, n[8] = a.m13, n[9] = a.m23, n[10] = a.m33, n[11] = a.m43, n[12] = a.m14, n[13] = a.m24, n[14] = a.m34, n[15] = a.m44, J;
+        }
+        function _(a, n) {
+          return s(a, "HEAPF32", n || gt);
+        }
+        function A(a, n, u, f) {
+          var y = Ht.toTypedArray();
+          return y[0] = a, y[1] = n, y[2] = u, y[3] = f, gt;
+        }
+        function C(a) {
+          for (var n = new Float32Array(4), u = 0; 4 > u; u++) n[u] = t.HEAPF32[a / 4 + u];
+          return n;
+        }
+        function m(a, n) {
+          return s(a, "HEAPF32", n || N);
+        }
+        function S(a, n) {
+          return s(a, "HEAPF32", n || Ye);
+        }
+        t.Color = function(a, n, u, f) {
+          return f === void 0 && (f = 1), t.Color4f(i(a) / 255, i(n) / 255, i(u) / 255, f);
+        }, t.ColorAsInt = function(a, n, u, f) {
+          return f === void 0 && (f = 255), (i(f) << 24 | i(a) << 16 | i(n) << 8 | i(u) << 0 & 268435455) >>> 0;
+        }, t.Color4f = function(a, n, u, f) {
+          return f === void 0 && (f = 1), Float32Array.of(a, n, u, f);
+        }, Object.defineProperty(t, "TRANSPARENT", { get: function() {
+          return t.Color4f(0, 0, 0, 0);
+        } }), Object.defineProperty(t, "BLACK", { get: function() {
+          return t.Color4f(0, 0, 0, 1);
+        } }), Object.defineProperty(t, "WHITE", { get: function() {
+          return t.Color4f(1, 1, 1, 1);
+        } }), Object.defineProperty(t, "RED", { get: function() {
+          return t.Color4f(1, 0, 0, 1);
+        } }), Object.defineProperty(t, "GREEN", { get: function() {
+          return t.Color4f(0, 1, 0, 1);
+        } }), Object.defineProperty(t, "BLUE", { get: function() {
+          return t.Color4f(0, 0, 1, 1);
+        } }), Object.defineProperty(t, "YELLOW", { get: function() {
+          return t.Color4f(1, 1, 0, 1);
+        } }), Object.defineProperty(t, "CYAN", { get: function() {
+          return t.Color4f(0, 1, 1, 1);
+        } }), Object.defineProperty(t, "MAGENTA", { get: function() {
+          return t.Color4f(1, 0, 1, 1);
+        } }), t.getColorComponents = function(a) {
+          return [Math.floor(255 * a[0]), Math.floor(255 * a[1]), Math.floor(255 * a[2]), a[3]];
+        }, t.parseColorString = function(a, n) {
+          if (a = a.toLowerCase(), a.startsWith("#")) {
+            switch (n = 255, a.length) {
+              case 9:
+                n = parseInt(a.slice(7, 9), 16);
+              case 7:
+                var u = parseInt(a.slice(1, 3), 16), f = parseInt(a.slice(3, 5), 16), y = parseInt(a.slice(5, 7), 16);
+                break;
+              case 5:
+                n = 17 * parseInt(a.slice(4, 5), 16);
+              case 4:
+                u = 17 * parseInt(a.slice(1, 2), 16), f = 17 * parseInt(a.slice(2, 3), 16), y = 17 * parseInt(a.slice(3, 4), 16);
+            }
+            return t.Color(u, f, y, n / 255);
+          }
+          return a.startsWith("rgba") ? (a = a.slice(5, -1), a = a.split(","), t.Color(+a[0], +a[1], +a[2], o(a[3]))) : a.startsWith("rgb") ? (a = a.slice(4, -1), a = a.split(","), t.Color(+a[0], +a[1], +a[2], o(a[3]))) : a.startsWith("gray(") || a.startsWith("hsl") || !n || (a = n[a], a === void 0) ? t.BLACK : a;
+        }, t.multiplyByAlpha = function(a, n) {
+          return a = a.slice(), a[3] = Math.max(0, Math.min(a[3] * n, 1)), a;
+        }, t.Malloc = function(a, n) {
+          var u = t._malloc(n * a.BYTES_PER_ELEMENT);
+          return { _ck: !0, length: n, byteOffset: u, Xd: null, subarray: function(f, y) {
+            return f = this.toTypedArray().subarray(f, y), f._ck = !0, f;
+          }, toTypedArray: function() {
+            return this.Xd && this.Xd.length ? this.Xd : (this.Xd = new a(t.HEAPU8.buffer, u, n), this.Xd._ck = !0, this.Xd);
+          } };
+        }, t.Free = function(a) {
+          t._free(a.byteOffset), a.byteOffset = B, a.toTypedArray = null, a.Xd = null;
+        };
+        var k = B, U, J = B, Y, gt = B, Ht, ft, N = B, Vr, Tt = B, Nr, Ve = B, Yr, Ne = B, Ce, Qt = B, zr, Ye = B, qr, Jr = B, Yn = Float32Array.of(0, 0, 1), B = 0;
+        t.onRuntimeInitialized = function() {
+          function a(n, u, f, y, v, P, T) {
+            P || (P = 4 * y.width, y.colorType === t.ColorType.RGBA_F16 ? P *= 2 : y.colorType === t.ColorType.RGBA_F32 && (P *= 4));
+            var M = P * y.height, x = v ? v.byteOffset : t._malloc(M);
+            if (T ? !n._readPixels(y, x, P, u, f, T) : !n._readPixels(y, x, P, u, f)) return v || t._free(x), null;
+            if (v) return v.toTypedArray();
+            switch (y.colorType) {
+              case t.ColorType.RGBA_8888:
+              case t.ColorType.RGBA_F16:
+                n = new Uint8Array(t.HEAPU8.buffer, x, M).slice();
+                break;
+              case t.ColorType.RGBA_F32:
+                n = new Float32Array(t.HEAPU8.buffer, x, M).slice();
+                break;
+              default:
+                return null;
+            }
+            return t._free(x), n;
+          }
+          Ht = t.Malloc(Float32Array, 4), gt = Ht.byteOffset, Y = t.Malloc(Float32Array, 16), J = Y.byteOffset, U = t.Malloc(Float32Array, 9), k = U.byteOffset, zr = t.Malloc(Float32Array, 12), Ye = zr.byteOffset, qr = t.Malloc(Float32Array, 12), Jr = qr.byteOffset, ft = t.Malloc(Float32Array, 4), N = ft.byteOffset, Vr = t.Malloc(Float32Array, 4), Tt = Vr.byteOffset, Nr = t.Malloc(Float32Array, 3), Ve = Nr.byteOffset, Yr = t.Malloc(Float32Array, 3), Ne = Yr.byteOffset, Ce = t.Malloc(Int32Array, 4), Qt = Ce.byteOffset, t.ColorSpace.SRGB = t.ColorSpace._MakeSRGB(), t.ColorSpace.DISPLAY_P3 = t.ColorSpace._MakeDisplayP3(), t.ColorSpace.ADOBE_RGB = t.ColorSpace._MakeAdobeRGB(), t.GlyphRunFlags = { IsWhiteSpace: t._GlyphRunFlags_isWhiteSpace }, t.Path.MakeFromCmds = function(n) {
+            var u = s(n, "HEAPF32"), f = t.Path._MakeFromCmds(u, n.length);
+            return c(u, n), f;
+          }, t.Path.MakeFromVerbsPointsWeights = function(n, u, f) {
+            var y = s(n, "HEAPU8"), v = s(u, "HEAPF32"), P = s(f, "HEAPF32"), T = t.Path._MakeFromVerbsPointsWeights(y, n.length, v, u.length, P, f && f.length || 0);
+            return c(y, n), c(v, u), c(P, f), T;
+          }, t.Path.prototype.addArc = function(n, u, f) {
+            return n = m(n), this._addArc(n, u, f), this;
+          }, t.Path.prototype.addCircle = function(n, u, f, y) {
+            return this._addCircle(n, u, f, !!y), this;
+          }, t.Path.prototype.addOval = function(n, u, f) {
+            return f === void 0 && (f = 1), n = m(n), this._addOval(n, !!u, f), this;
+          }, t.Path.prototype.addPath = function() {
+            var n = Array.prototype.slice.call(arguments), u = n[0], f = !1;
+            if (typeof n[n.length - 1] == "boolean" && (f = n.pop()), n.length === 1) this._addPath(u, 1, 0, 0, 0, 1, 0, 0, 0, 1, f);
+            else if (n.length === 2) n = n[1], this._addPath(u, n[0], n[1], n[2], n[3], n[4], n[5], n[6] || 0, n[7] || 0, n[8] || 1, f);
+            else if (n.length === 7 || n.length === 10) this._addPath(u, n[1], n[2], n[3], n[4], n[5], n[6], n[7] || 0, n[8] || 0, n[9] || 1, f);
+            else return null;
+            return this;
+          }, t.Path.prototype.addPoly = function(n, u) {
+            var f = s(n, "HEAPF32");
+            return this._addPoly(f, n.length / 2, u), c(f, n), this;
+          }, t.Path.prototype.addRect = function(n, u) {
+            return n = m(n), this._addRect(n, !!u), this;
+          }, t.Path.prototype.addRRect = function(n, u) {
+            return n = S(n), this._addRRect(n, !!u), this;
+          }, t.Path.prototype.addVerbsPointsWeights = function(n, u, f) {
+            var y = s(n, "HEAPU8"), v = s(u, "HEAPF32"), P = s(f, "HEAPF32");
+            this._addVerbsPointsWeights(y, n.length, v, u.length, P, f && f.length || 0), c(y, n), c(v, u), c(P, f);
+          }, t.Path.prototype.arc = function(n, u, f, y, v, P) {
+            return n = t.LTRBRect(n - f, u - f, n + f, u + f), v = (v - y) / Math.PI * 180 - 360 * !!P, P = new t.Path(), P.addArc(n, y / Math.PI * 180, v), this.addPath(P, !0), P.delete(), this;
+          }, t.Path.prototype.arcToOval = function(n, u, f, y) {
+            return n = m(n), this._arcToOval(n, u, f, y), this;
+          }, t.Path.prototype.arcToRotated = function(n, u, f, y, v, P, T) {
+            return this._arcToRotated(n, u, f, !!y, !!v, P, T), this;
+          }, t.Path.prototype.arcToTangent = function(n, u, f, y, v) {
+            return this._arcToTangent(n, u, f, y, v), this;
+          }, t.Path.prototype.close = function() {
+            return this._close(), this;
+          }, t.Path.prototype.conicTo = function(n, u, f, y, v) {
+            return this._conicTo(n, u, f, y, v), this;
+          }, t.Path.prototype.computeTightBounds = function(n) {
+            this._computeTightBounds(N);
+            var u = ft.toTypedArray();
+            return n ? (n.set(u), n) : u.slice();
+          }, t.Path.prototype.cubicTo = function(n, u, f, y, v, P) {
+            return this._cubicTo(n, u, f, y, v, P), this;
+          }, t.Path.prototype.dash = function(n, u, f) {
+            return this._dash(n, u, f) ? this : null;
+          }, t.Path.prototype.getBounds = function(n) {
+            this._getBounds(N);
+            var u = ft.toTypedArray();
+            return n ? (n.set(u), n) : u.slice();
+          }, t.Path.prototype.lineTo = function(n, u) {
+            return this._lineTo(n, u), this;
+          }, t.Path.prototype.moveTo = function(n, u) {
+            return this._moveTo(n, u), this;
+          }, t.Path.prototype.offset = function(n, u) {
+            return this._transform(1, 0, n, 0, 1, u, 0, 0, 1), this;
+          }, t.Path.prototype.quadTo = function(n, u, f, y) {
+            return this._quadTo(n, u, f, y), this;
+          }, t.Path.prototype.rArcTo = function(n, u, f, y, v, P, T) {
+            return this._rArcTo(n, u, f, y, v, P, T), this;
+          }, t.Path.prototype.rConicTo = function(n, u, f, y, v) {
+            return this._rConicTo(n, u, f, y, v), this;
+          }, t.Path.prototype.rCubicTo = function(n, u, f, y, v, P) {
+            return this._rCubicTo(n, u, f, y, v, P), this;
+          }, t.Path.prototype.rLineTo = function(n, u) {
+            return this._rLineTo(n, u), this;
+          }, t.Path.prototype.rMoveTo = function(n, u) {
+            return this._rMoveTo(n, u), this;
+          }, t.Path.prototype.rQuadTo = function(n, u, f, y) {
+            return this._rQuadTo(n, u, f, y), this;
+          }, t.Path.prototype.stroke = function(n) {
+            return n = n || {}, n.width = n.width || 1, n.miter_limit = n.miter_limit || 4, n.cap = n.cap || t.StrokeCap.Butt, n.join = n.join || t.StrokeJoin.Miter, n.precision = n.precision || 1, this._stroke(n) ? this : null;
+          }, t.Path.prototype.transform = function() {
+            if (arguments.length === 1) {
+              var n = arguments[0];
+              this._transform(n[0], n[1], n[2], n[3], n[4], n[5], n[6] || 0, n[7] || 0, n[8] || 1);
+            } else if (arguments.length === 6 || arguments.length === 9) n = arguments, this._transform(n[0], n[1], n[2], n[3], n[4], n[5], n[6] || 0, n[7] || 0, n[8] || 1);
+            else throw "transform expected to take 1 or 9 arguments. Got " + arguments.length;
+            return this;
+          }, t.Path.prototype.trim = function(n, u, f) {
+            return this._trim(n, u, !!f) ? this : null;
+          }, t.Image.prototype.encodeToBytes = function(n, u) {
+            var f = t.je();
+            return n = n || t.ImageFormat.PNG, u = u || 100, f ? this._encodeToBytes(n, u, f) : this._encodeToBytes(n, u);
+          }, t.Image.prototype.makeShaderCubic = function(n, u, f, y, v) {
+            return v = h(v), this._makeShaderCubic(n, u, f, y, v);
+          }, t.Image.prototype.makeShaderOptions = function(n, u, f, y, v) {
+            return v = h(v), this._makeShaderOptions(n, u, f, y, v);
+          }, t.Image.prototype.readPixels = function(n, u, f, y, v) {
+            var P = t.je();
+            return a(this, n, u, f, y, v, P);
+          }, t.Canvas.prototype.clear = function(n) {
+            t.Fd(this.Ed), n = _(n), this._clear(n);
+          }, t.Canvas.prototype.clipRRect = function(n, u, f) {
+            t.Fd(this.Ed), n = S(n), this._clipRRect(n, u, f);
+          }, t.Canvas.prototype.clipRect = function(n, u, f) {
+            t.Fd(this.Ed), n = m(n), this._clipRect(n, u, f);
+          }, t.Canvas.prototype.concat = function(n) {
+            t.Fd(this.Ed), n = b(n), this._concat(n);
+          }, t.Canvas.prototype.drawArc = function(n, u, f, y, v) {
+            t.Fd(this.Ed), n = m(n), this._drawArc(n, u, f, y, v);
+          }, t.Canvas.prototype.drawAtlas = function(n, u, f, y, v, P, T) {
+            if (n && y && u && f && u.length === f.length) {
+              t.Fd(this.Ed), v || (v = t.BlendMode.SrcOver);
+              var M = s(u, "HEAPF32"), x = s(f, "HEAPF32"), W = f.length / 4, V = s(r(P), "HEAPU32");
+              if (T && "B" in T && "C" in T) this._drawAtlasCubic(n, x, M, V, W, v, T.B, T.C, y);
+              else {
+                let d = t.FilterMode.Linear, w = t.MipmapMode.None;
+                T && (d = T.filter, "mipmap" in T && (w = T.mipmap)), this._drawAtlasOptions(n, x, M, V, W, v, d, w, y);
+              }
+              c(M, u), c(x, f), c(V, P);
+            }
+          }, t.Canvas.prototype.drawCircle = function(n, u, f, y) {
+            t.Fd(this.Ed), this._drawCircle(n, u, f, y);
+          }, t.Canvas.prototype.drawColor = function(n, u) {
+            t.Fd(this.Ed), n = _(n), u !== void 0 ? this._drawColor(n, u) : this._drawColor(n);
+          }, t.Canvas.prototype.drawColorInt = function(n, u) {
+            t.Fd(this.Ed), this._drawColorInt(n, u || t.BlendMode.SrcOver);
+          }, t.Canvas.prototype.drawColorComponents = function(n, u, f, y, v) {
+            t.Fd(this.Ed), n = A(n, u, f, y), v !== void 0 ? this._drawColor(n, v) : this._drawColor(n);
+          }, t.Canvas.prototype.drawDRRect = function(n, u, f) {
+            t.Fd(this.Ed), n = S(n, Ye), u = S(u, Jr), this._drawDRRect(n, u, f);
+          }, t.Canvas.prototype.drawImage = function(n, u, f, y) {
+            t.Fd(this.Ed), this._drawImage(n, u, f, y || null);
+          }, t.Canvas.prototype.drawImageCubic = function(n, u, f, y, v, P) {
+            t.Fd(this.Ed), this._drawImageCubic(n, u, f, y, v, P || null);
+          }, t.Canvas.prototype.drawImageOptions = function(n, u, f, y, v, P) {
+            t.Fd(this.Ed), this._drawImageOptions(n, u, f, y, v, P || null);
+          }, t.Canvas.prototype.drawImageNine = function(n, u, f, y, v) {
+            t.Fd(this.Ed), u = s(u, "HEAP32", Qt), f = m(f), this._drawImageNine(n, u, f, y, v || null);
+          }, t.Canvas.prototype.drawImageRect = function(n, u, f, y, v) {
+            t.Fd(this.Ed), m(u, N), m(f, Tt), this._drawImageRect(n, N, Tt, y, !!v);
+          }, t.Canvas.prototype.drawImageRectCubic = function(n, u, f, y, v, P) {
+            t.Fd(this.Ed), m(u, N), m(f, Tt), this._drawImageRectCubic(n, N, Tt, y, v, P || null);
+          }, t.Canvas.prototype.drawImageRectOptions = function(n, u, f, y, v, P) {
+            t.Fd(this.Ed), m(u, N), m(f, Tt), this._drawImageRectOptions(n, N, Tt, y, v, P || null);
+          }, t.Canvas.prototype.drawLine = function(n, u, f, y, v) {
+            t.Fd(this.Ed), this._drawLine(n, u, f, y, v);
+          }, t.Canvas.prototype.drawOval = function(n, u) {
+            t.Fd(this.Ed), n = m(n), this._drawOval(n, u);
+          }, t.Canvas.prototype.drawPaint = function(n) {
+            t.Fd(this.Ed), this._drawPaint(n);
+          }, t.Canvas.prototype.drawParagraph = function(n, u, f) {
+            t.Fd(this.Ed), this._drawParagraph(n, u, f);
+          }, t.Canvas.prototype.drawPatch = function(n, u, f, y, v) {
+            if (24 > n.length) throw "Need 12 cubic points";
+            if (u && 4 > u.length) throw "Need 4 colors";
+            if (f && 8 > f.length) throw "Need 4 shader coordinates";
+            t.Fd(this.Ed);
+            let P = s(n, "HEAPF32"), T = u ? s(r(u), "HEAPU32") : B, M = f ? s(f, "HEAPF32") : B;
+            y || (y = t.BlendMode.Modulate), this._drawPatch(P, T, M, y, v), c(M, f), c(T, u), c(P, n);
+          }, t.Canvas.prototype.drawPath = function(n, u) {
+            t.Fd(this.Ed), this._drawPath(n, u);
+          }, t.Canvas.prototype.drawPicture = function(n) {
+            t.Fd(this.Ed), this._drawPicture(n);
+          }, t.Canvas.prototype.drawPoints = function(n, u, f) {
+            t.Fd(this.Ed);
+            var y = s(u, "HEAPF32");
+            this._drawPoints(n, y, u.length / 2, f), c(y, u);
+          }, t.Canvas.prototype.drawRRect = function(n, u) {
+            t.Fd(this.Ed), n = S(n), this._drawRRect(n, u);
+          }, t.Canvas.prototype.drawRect = function(n, u) {
+            t.Fd(this.Ed), n = m(n), this._drawRect(n, u);
+          }, t.Canvas.prototype.drawRect4f = function(n, u, f, y, v) {
+            t.Fd(this.Ed), this._drawRect4f(n, u, f, y, v);
+          }, t.Canvas.prototype.drawShadow = function(n, u, f, y, v, P, T) {
+            t.Fd(this.Ed);
+            var M = s(v, "HEAPF32"), x = s(P, "HEAPF32");
+            u = s(u, "HEAPF32", Ve), f = s(f, "HEAPF32", Ne), this._drawShadow(n, u, f, y, M, x, T), c(M, v), c(x, P);
+          }, t.getShadowLocalBounds = function(n, u, f, y, v, P, T) {
+            return n = h(n), f = s(f, "HEAPF32", Ve), y = s(y, "HEAPF32", Ne), this._getShadowLocalBounds(n, u, f, y, v, P, N) ? (u = ft.toTypedArray(), T ? (T.set(u), T) : u.slice()) : null;
+          }, t.Canvas.prototype.drawTextBlob = function(n, u, f, y) {
+            t.Fd(this.Ed), this._drawTextBlob(n, u, f, y);
+          }, t.Canvas.prototype.drawVertices = function(n, u, f) {
+            t.Fd(this.Ed), this._drawVertices(n, u, f);
+          }, t.Canvas.prototype.getDeviceClipBounds = function(n) {
+            this._getDeviceClipBounds(Qt);
+            var u = Ce.toTypedArray();
+            return n ? n.set(u) : n = u.slice(), n;
+          }, t.Canvas.prototype.getLocalToDevice = function() {
+            this._getLocalToDevice(J);
+            for (var n = J, u = Array(16), f = 0; 16 > f; f++) u[f] = t.HEAPF32[n / 4 + f];
+            return u;
+          }, t.Canvas.prototype.getTotalMatrix = function() {
+            this._getTotalMatrix(k);
+            for (var n = Array(9), u = 0; 9 > u; u++) n[u] = t.HEAPF32[k / 4 + u];
+            return n;
+          }, t.Canvas.prototype.makeSurface = function(n) {
+            return n = this._makeSurface(n), n.Ed = this.Ed, n;
+          }, t.Canvas.prototype.readPixels = function(n, u, f, y, v) {
+            return t.Fd(this.Ed), a(this, n, u, f, y, v);
+          }, t.Canvas.prototype.saveLayer = function(n, u, f, y) {
+            return u = m(u), this._saveLayer(n || null, u, f || null, y || 0);
+          }, t.Canvas.prototype.writePixels = function(n, u, f, y, v, P, T, M) {
+            if (n.byteLength % (u * f)) throw "pixels length must be a multiple of the srcWidth * srcHeight";
+            t.Fd(this.Ed);
+            var x = n.byteLength / (u * f);
+            P = P || t.AlphaType.Unpremul, T = T || t.ColorType.RGBA_8888, M = M || t.ColorSpace.SRGB;
+            var W = x * u;
+            return x = s(n, "HEAPU8"), u = this._writePixels({ width: u, height: f, colorType: T, alphaType: P, colorSpace: M }, x, W, y, v), c(x, n), u;
+          }, t.ColorFilter.MakeBlend = function(n, u, f) {
+            return n = _(n), f = f || t.ColorSpace.SRGB, t.ColorFilter._MakeBlend(n, u, f);
+          }, t.ColorFilter.MakeMatrix = function(n) {
+            if (!n || n.length !== 20) throw "invalid color matrix";
+            var u = s(n, "HEAPF32"), f = t.ColorFilter._makeMatrix(u);
+            return c(u, n), f;
+          }, t.ContourMeasure.prototype.getPosTan = function(n, u) {
+            return this._getPosTan(n, N), n = ft.toTypedArray(), u ? (u.set(n), u) : n.slice();
+          }, t.ImageFilter.prototype.getOutputBounds = function(n, u, f) {
+            return n = m(n, N), u = h(u), this._getOutputBounds(n, u, Qt), u = Ce.toTypedArray(), f ? (f.set(u), f) : u.slice();
+          }, t.ImageFilter.MakeDropShadow = function(n, u, f, y, v, P) {
+            return v = _(v, gt), t.ImageFilter._MakeDropShadow(n, u, f, y, v, P);
+          }, t.ImageFilter.MakeDropShadowOnly = function(n, u, f, y, v, P) {
+            return v = _(v, gt), t.ImageFilter._MakeDropShadowOnly(n, u, f, y, v, P);
+          }, t.ImageFilter.MakeImage = function(n, u, f, y) {
+            if (f = m(f, N), y = m(y, Tt), "B" in u && "C" in u) return t.ImageFilter._MakeImageCubic(n, u.B, u.C, f, y);
+            let v = u.filter, P = t.MipmapMode.None;
+            return "mipmap" in u && (P = u.mipmap), t.ImageFilter._MakeImageOptions(n, v, P, f, y);
+          }, t.ImageFilter.MakeMatrixTransform = function(n, u, f) {
+            if (n = h(n), "B" in u && "C" in u) return t.ImageFilter._MakeMatrixTransformCubic(n, u.B, u.C, f);
+            let y = u.filter, v = t.MipmapMode.None;
+            return "mipmap" in u && (v = u.mipmap), t.ImageFilter._MakeMatrixTransformOptions(n, y, v, f);
+          }, t.Paint.prototype.getColor = function() {
+            return this._getColor(gt), C(gt);
+          }, t.Paint.prototype.setColor = function(n, u) {
+            u = u || null, n = _(n), this._setColor(n, u);
+          }, t.Paint.prototype.setColorComponents = function(n, u, f, y, v) {
+            v = v || null, n = A(n, u, f, y), this._setColor(n, v);
+          }, t.Path.prototype.getPoint = function(n, u) {
+            return this._getPoint(n, N), n = ft.toTypedArray(), u ? (u[0] = n[0], u[1] = n[1], u) : n.slice(0, 2);
+          }, t.Picture.prototype.makeShader = function(n, u, f, y, v) {
+            return y = h(y), v = m(v), this._makeShader(n, u, f, y, v);
+          }, t.Picture.prototype.cullRect = function(n) {
+            this._cullRect(N);
+            var u = ft.toTypedArray();
+            return n ? (n.set(u), n) : u.slice();
+          }, t.PictureRecorder.prototype.beginRecording = function(n, u) {
+            return n = m(n), this._beginRecording(n, !!u);
+          }, t.Surface.prototype.getCanvas = function() {
+            var n = this._getCanvas();
+            return n.Ed = this.Ed, n;
+          }, t.Surface.prototype.makeImageSnapshot = function(n) {
+            return t.Fd(this.Ed), n = s(n, "HEAP32", Qt), this._makeImageSnapshot(n);
+          }, t.Surface.prototype.makeSurface = function(n) {
+            return t.Fd(this.Ed), n = this._makeSurface(n), n.Ed = this.Ed, n;
+          }, t.Surface.prototype.Oe = function(n, u) {
+            return this.ce || (this.ce = this.getCanvas()), requestAnimationFrame((function() {
+              t.Fd(this.Ed), n(this.ce), this.flush(u);
+            }).bind(this));
+          }, t.Surface.prototype.requestAnimationFrame || (t.Surface.prototype.requestAnimationFrame = t.Surface.prototype.Oe), t.Surface.prototype.Le = function(n, u) {
+            this.ce || (this.ce = this.getCanvas()), requestAnimationFrame((function() {
+              t.Fd(this.Ed), n(this.ce), this.flush(u), this.dispose();
+            }).bind(this));
+          }, t.Surface.prototype.drawOnce || (t.Surface.prototype.drawOnce = t.Surface.prototype.Le), t.PathEffect.MakeDash = function(n, u) {
+            if (u || (u = 0), !n.length || n.length % 2 === 1) throw "Intervals array must have even length";
+            var f = s(n, "HEAPF32");
+            return u = t.PathEffect._MakeDash(f, n.length, u), c(f, n), u;
+          }, t.PathEffect.MakeLine2D = function(n, u) {
+            return u = h(u), t.PathEffect._MakeLine2D(n, u);
+          }, t.PathEffect.MakePath2D = function(n, u) {
+            return n = h(n), t.PathEffect._MakePath2D(n, u);
+          }, t.Shader.MakeColor = function(n, u) {
+            return u = u || null, n = _(n), t.Shader._MakeColor(n, u);
+          }, t.Shader.Blend = t.Shader.MakeBlend, t.Shader.Color = t.Shader.MakeColor, t.Shader.MakeLinearGradient = function(n, u, f, y, v, P, T, M) {
+            M = M || null;
+            var x = l(f), W = s(y, "HEAPF32");
+            T = T || 0, P = h(P);
+            var V = ft.toTypedArray();
+            return V.set(n), V.set(u, 2), n = t.Shader._MakeLinearGradient(N, x.Nd, x.colorType, W, x.count, v, T, P, M), c(x.Nd, f), y && c(W, y), n;
+          }, t.Shader.MakeRadialGradient = function(n, u, f, y, v, P, T, M) {
+            M = M || null;
+            var x = l(f), W = s(y, "HEAPF32");
+            return T = T || 0, P = h(P), n = t.Shader._MakeRadialGradient(n[0], n[1], u, x.Nd, x.colorType, W, x.count, v, T, P, M), c(x.Nd, f), y && c(W, y), n;
+          }, t.Shader.MakeSweepGradient = function(n, u, f, y, v, P, T, M, x, W) {
+            W = W || null;
+            var V = l(f), d = s(y, "HEAPF32");
+            return T = T || 0, M = M || 0, x = x || 360, P = h(P), n = t.Shader._MakeSweepGradient(n, u, V.Nd, V.colorType, d, V.count, v, M, x, T, P, W), c(V.Nd, f), y && c(d, y), n;
+          }, t.Shader.MakeTwoPointConicalGradient = function(n, u, f, y, v, P, T, M, x, W) {
+            W = W || null;
+            var V = l(v), d = s(P, "HEAPF32");
+            x = x || 0, M = h(M);
+            var w = ft.toTypedArray();
+            return w.set(n), w.set(f, 2), n = t.Shader._MakeTwoPointConicalGradient(N, u, y, V.Nd, V.colorType, d, V.count, T, x, M, W), c(V.Nd, v), P && c(d, P), n;
+          }, t.Vertices.prototype.bounds = function(n) {
+            this._bounds(N);
+            var u = ft.toTypedArray();
+            return n ? (n.set(u), n) : u.slice();
+          }, t.Id && t.Id.forEach(function(n) {
+            n();
+          });
+        }, t.computeTonalColors = function(a) {
+          var n = s(a.ambient, "HEAPF32"), u = s(a.spot, "HEAPF32");
+          this._computeTonalColors(n, u);
+          var f = { ambient: C(n), spot: C(u) };
+          return c(n, a.ambient), c(u, a.spot), f;
+        }, t.LTRBRect = function(a, n, u, f) {
+          return Float32Array.of(a, n, u, f);
+        }, t.XYWHRect = function(a, n, u, f) {
+          return Float32Array.of(a, n, a + u, n + f);
+        }, t.LTRBiRect = function(a, n, u, f) {
+          return Int32Array.of(a, n, u, f);
+        }, t.XYWHiRect = function(a, n, u, f) {
+          return Int32Array.of(a, n, a + u, n + f);
+        }, t.RRectXY = function(a, n, u) {
+          return Float32Array.of(a[0], a[1], a[2], a[3], n, u, n, u, n, u, n, u);
+        }, t.MakeAnimatedImageFromEncoded = function(a) {
+          a = new Uint8Array(a);
+          var n = t._malloc(a.byteLength);
+          return t.HEAPU8.set(a, n), (a = t._decodeAnimatedImage(n, a.byteLength)) ? a : null;
+        }, t.MakeImageFromEncoded = function(a) {
+          a = new Uint8Array(a);
+          var n = t._malloc(a.byteLength);
+          return t.HEAPU8.set(a, n), (a = t._decodeImage(n, a.byteLength)) ? a : null;
+        };
+        var Zt = null;
+        t.MakeImageFromCanvasImageSource = function(a) {
+          var n = a.width, u = a.height;
+          Zt || (Zt = document.createElement("canvas")), Zt.width = n, Zt.height = u;
+          var f = Zt.getContext("2d", { willReadFrequently: !0 });
+          return f.drawImage(a, 0, 0), a = f.getImageData(0, 0, n, u), t.MakeImage({ width: n, height: u, alphaType: t.AlphaType.Unpremul, colorType: t.ColorType.RGBA_8888, colorSpace: t.ColorSpace.SRGB }, a.data, 4 * n);
+        }, t.MakeImage = function(a, n, u) {
+          var f = t._malloc(n.length);
+          return t.HEAPU8.set(n, f), t._MakeImage(a, f, n.length, u);
+        }, t.MakeVertices = function(a, n, u, f, y, v) {
+          var P = y && y.length || 0, T = 0;
+          return u && u.length && (T |= 1), f && f.length && (T |= 2), v === void 0 || v || (T |= 4), a = new t._VerticesBuilder(a, n.length / 2, P, T), s(n, "HEAPF32", a.positions()), a.texCoords() && s(u, "HEAPF32", a.texCoords()), a.colors() && s(r(f), "HEAPU32", a.colors()), a.indices() && s(y, "HEAPU16", a.indices()), a.detach();
+        }, function(a) {
+          a.Id = a.Id || [], a.Id.push(function() {
+            function n(d) {
+              return d && (d.dir = d.dir === 0 ? a.TextDirection.RTL : a.TextDirection.LTR), d;
+            }
+            function u(d) {
+              if (!d || !d.length) return [];
+              for (var w = [], H = 0; H < d.length; H += 5) {
+                var z = a.LTRBRect(d[H], d[H + 1], d[H + 2], d[H + 3]), _t = a.TextDirection.LTR;
+                d[H + 4] === 0 && (_t = a.TextDirection.RTL), w.push({ rect: z, dir: _t });
+              }
+              return a._free(d.byteOffset), w;
+            }
+            function f(d) {
+              return d = d || {}, d.weight === void 0 && (d.weight = a.FontWeight.Normal), d.width = d.width || a.FontWidth.Normal, d.slant = d.slant || a.FontSlant.Upright, d;
+            }
+            function y(d) {
+              if (!d || !d.length) return B;
+              for (var w = [], H = 0; H < d.length; H++) {
+                var z = v(d[H]);
+                w.push(z);
+              }
+              return s(w, "HEAPU32");
+            }
+            function v(d) {
+              if (M[d]) return M[d];
+              var w = ct(d) + 1, H = a._malloc(w);
+              return ut(d, I, H, w), M[d] = H;
+            }
+            function P(d) {
+              if (d._colorPtr = _(d.color), d._foregroundColorPtr = B, d._backgroundColorPtr = B, d._decorationColorPtr = B, d.foregroundColor && (d._foregroundColorPtr = _(d.foregroundColor, x)), d.backgroundColor && (d._backgroundColorPtr = _(d.backgroundColor, W)), d.decorationColor && (d._decorationColorPtr = _(d.decorationColor, V)), Array.isArray(d.fontFamilies) && d.fontFamilies.length ? (d._fontFamiliesPtr = y(d.fontFamilies), d._fontFamiliesLen = d.fontFamilies.length) : (d._fontFamiliesPtr = B, d._fontFamiliesLen = 0), d.locale) {
+                var w = d.locale;
+                d._localePtr = v(w), d._localeLen = ct(w) + 1;
+              } else d._localePtr = B, d._localeLen = 0;
+              if (Array.isArray(d.shadows) && d.shadows.length) {
+                w = d.shadows;
+                var H = w.map(function(dt) {
+                  return dt.color || a.BLACK;
+                }), z = w.map(function(dt) {
+                  return dt.blurRadius || 0;
+                });
+                d._shadowLen = w.length;
+                for (var _t = a._malloc(8 * w.length), ze = _t / 4, qe = 0; qe < w.length; qe++) {
+                  var Kr = w[qe].offset || [0, 0];
+                  a.HEAPF32[ze] = Kr[0], a.HEAPF32[ze + 1] = Kr[1], ze += 2;
+                }
+                d._shadowColorsPtr = l(H).Nd, d._shadowOffsetsPtr = _t, d._shadowBlurRadiiPtr = s(z, "HEAPF32");
+              } else d._shadowLen = 0, d._shadowColorsPtr = B, d._shadowOffsetsPtr = B, d._shadowBlurRadiiPtr = B;
+              Array.isArray(d.fontFeatures) && d.fontFeatures.length ? (w = d.fontFeatures, H = w.map(function(dt) {
+                return dt.name;
+              }), z = w.map(function(dt) {
+                return dt.value;
+              }), d._fontFeatureLen = w.length, d._fontFeatureNamesPtr = y(H), d._fontFeatureValuesPtr = s(z, "HEAPU32")) : (d._fontFeatureLen = 0, d._fontFeatureNamesPtr = B, d._fontFeatureValuesPtr = B), Array.isArray(d.fontVariations) && d.fontVariations.length ? (w = d.fontVariations, H = w.map(function(dt) {
+                return dt.axis;
+              }), z = w.map(function(dt) {
+                return dt.value;
+              }), d._fontVariationLen = w.length, d._fontVariationAxesPtr = y(H), d._fontVariationValuesPtr = s(z, "HEAPF32")) : (d._fontVariationLen = 0, d._fontVariationAxesPtr = B, d._fontVariationValuesPtr = B);
+            }
+            function T(d) {
+              a._free(d._fontFamiliesPtr), a._free(d._shadowColorsPtr), a._free(d._shadowOffsetsPtr), a._free(d._shadowBlurRadiiPtr), a._free(d._fontFeatureNamesPtr), a._free(d._fontFeatureValuesPtr), a._free(d._fontVariationAxesPtr), a._free(d._fontVariationValuesPtr);
+            }
+            a.Paragraph.prototype.getRectsForRange = function(d, w, H, z) {
+              return d = this._getRectsForRange(d, w, H, z), u(d);
+            }, a.Paragraph.prototype.getRectsForPlaceholders = function() {
+              var d = this._getRectsForPlaceholders();
+              return u(d);
+            }, a.Paragraph.prototype.getGlyphInfoAt = function(d) {
+              return n(this._getGlyphInfoAt(d));
+            }, a.Paragraph.prototype.getClosestGlyphInfoAtCoordinate = function(d, w) {
+              return n(this._getClosestGlyphInfoAtCoordinate(d, w));
+            }, a.TypefaceFontProvider.prototype.registerFont = function(d, w) {
+              if (d = a.Typeface.MakeFreeTypeFaceFromData(d), !d) return null;
+              w = v(w), this._registerFont(d, w);
+            }, a.ParagraphStyle = function(d) {
+              if (d.disableHinting = d.disableHinting || !1, d.ellipsis) {
+                var w = d.ellipsis;
+                d._ellipsisPtr = v(w), d._ellipsisLen = ct(w) + 1;
+              } else d._ellipsisPtr = B, d._ellipsisLen = 0;
+              return d.heightMultiplier == null && (d.heightMultiplier = -1), d.maxLines = d.maxLines || 0, d.replaceTabCharacters = d.replaceTabCharacters || !1, w = (w = d.strutStyle) || {}, w.strutEnabled = w.strutEnabled || !1, w.strutEnabled && Array.isArray(w.fontFamilies) && w.fontFamilies.length ? (w._fontFamiliesPtr = y(w.fontFamilies), w._fontFamiliesLen = w.fontFamilies.length) : (w._fontFamiliesPtr = B, w._fontFamiliesLen = 0), w.fontStyle = f(w.fontStyle), w.fontSize == null && (w.fontSize = -1), w.heightMultiplier == null && (w.heightMultiplier = -1), w.halfLeading = w.halfLeading || !1, w.leading = w.leading || 0, w.forceStrutHeight = w.forceStrutHeight || !1, d.strutStyle = w, d.textAlign = d.textAlign || a.TextAlign.Start, d.textDirection = d.textDirection || a.TextDirection.LTR, d.textHeightBehavior = d.textHeightBehavior || a.TextHeightBehavior.All, d.textStyle = a.TextStyle(d.textStyle), d.applyRoundingHack = d.applyRoundingHack !== !1, d;
+            }, a.TextStyle = function(d) {
+              return d.color || (d.color = a.BLACK), d.decoration = d.decoration || 0, d.decorationThickness = d.decorationThickness || 0, d.decorationStyle = d.decorationStyle || a.DecorationStyle.Solid, d.textBaseline = d.textBaseline || a.TextBaseline.Alphabetic, d.fontSize == null && (d.fontSize = -1), d.letterSpacing = d.letterSpacing || 0, d.wordSpacing = d.wordSpacing || 0, d.heightMultiplier == null && (d.heightMultiplier = -1), d.halfLeading = d.halfLeading || !1, d.fontStyle = f(d.fontStyle), d;
+            };
+            var M = {}, x = a._malloc(16), W = a._malloc(16), V = a._malloc(16);
+            a.ParagraphBuilder.Make = function(d, w) {
+              return P(d.textStyle), w = a.ParagraphBuilder._Make(d, w), T(d.textStyle), w;
+            }, a.ParagraphBuilder.MakeFromFontProvider = function(d, w) {
+              return P(d.textStyle), w = a.ParagraphBuilder._MakeFromFontProvider(d, w), T(d.textStyle), w;
+            }, a.ParagraphBuilder.MakeFromFontCollection = function(d, w) {
+              return P(d.textStyle), w = a.ParagraphBuilder._MakeFromFontCollection(d, w), T(d.textStyle), w;
+            }, a.ParagraphBuilder.ShapeText = function(d, w, H) {
+              let z = 0;
+              for (let _t of w) z += _t.length;
+              if (z !== d.length) throw "Accumulated block lengths must equal text.length";
+              return a.ParagraphBuilder._ShapeText(d, w, H);
+            }, a.ParagraphBuilder.prototype.pushStyle = function(d) {
+              P(d), this._pushStyle(d), T(d);
+            }, a.ParagraphBuilder.prototype.pushPaintStyle = function(d, w, H) {
+              P(d), this._pushPaintStyle(d, w, H), T(d);
+            }, a.ParagraphBuilder.prototype.addPlaceholder = function(d, w, H, z, _t) {
+              H = H || a.PlaceholderAlignment.Baseline, z = z || a.TextBaseline.Alphabetic, this._addPlaceholder(d || 0, w || 0, H, z, _t || 0);
+            }, a.ParagraphBuilder.prototype.setWordsUtf8 = function(d) {
+              var w = s(d, "HEAPU32");
+              this._setWordsUtf8(w, d && d.length || 0), c(w, d);
+            }, a.ParagraphBuilder.prototype.setWordsUtf16 = function(d) {
+              var w = s(d, "HEAPU32");
+              this._setWordsUtf16(w, d && d.length || 0), c(w, d);
+            }, a.ParagraphBuilder.prototype.setGraphemeBreaksUtf8 = function(d) {
+              var w = s(d, "HEAPU32");
+              this._setGraphemeBreaksUtf8(w, d && d.length || 0), c(w, d);
+            }, a.ParagraphBuilder.prototype.setGraphemeBreaksUtf16 = function(d) {
+              var w = s(d, "HEAPU32");
+              this._setGraphemeBreaksUtf16(w, d && d.length || 0), c(w, d);
+            }, a.ParagraphBuilder.prototype.setLineBreaksUtf8 = function(d) {
+              var w = s(d, "HEAPU32");
+              this._setLineBreaksUtf8(w, d && d.length || 0), c(w, d);
+            }, a.ParagraphBuilder.prototype.setLineBreaksUtf16 = function(d) {
+              var w = s(d, "HEAPU32");
+              this._setLineBreaksUtf16(w, d && d.length || 0), c(w, d);
+            };
+          });
+        }(g), t.Id = t.Id || [], t.Id.push(function() {
+          t.Path.prototype.op = function(a, n) {
+            return this._op(a, n) ? this : null;
+          }, t.Path.prototype.simplify = function() {
+            return this._simplify() ? this : null;
+          };
+        }), t.Id = t.Id || [], t.Id.push(function() {
+          t.Canvas.prototype.drawText = function(a, n, u, f, y) {
+            var v = ct(a), P = t._malloc(v + 1);
+            ut(a, I, P, v + 1), this._drawSimpleText(P, v, n, u, y, f), t._free(P);
+          }, t.Canvas.prototype.drawGlyphs = function(a, n, u, f, y, v) {
+            if (!(2 * a.length <= n.length)) throw "Not enough positions for the array of gyphs";
+            t.Fd(this.Ed);
+            let P = s(a, "HEAPU16"), T = s(n, "HEAPF32");
+            this._drawGlyphs(a.length, P, T, u, f, y, v), c(T, n), c(P, a);
+          }, t.Font.prototype.getGlyphBounds = function(a, n, u) {
+            var f = s(a, "HEAPU16"), y = t._malloc(16 * a.length);
+            return this._getGlyphWidthBounds(f, a.length, B, y, n || null), n = new Float32Array(t.HEAPU8.buffer, y, 4 * a.length), c(f, a), u ? (u.set(n), t._free(y), u) : (a = Float32Array.from(n), t._free(y), a);
+          }, t.Font.prototype.getGlyphIDs = function(a, n, u) {
+            n || (n = a.length);
+            var f = ct(a) + 1, y = t._malloc(f);
+            return ut(a, I, y, f), a = t._malloc(2 * n), n = this._getGlyphIDs(y, f - 1, n, a), t._free(y), 0 > n ? (t._free(a), null) : (y = new Uint16Array(t.HEAPU8.buffer, a, n), u ? (u.set(y), t._free(a), u) : (u = Uint16Array.from(y), t._free(a), u));
+          }, t.Font.prototype.getGlyphIntercepts = function(a, n, u, f) {
+            var y = s(a, "HEAPU16"), v = s(n, "HEAPF32");
+            return this._getGlyphIntercepts(y, a.length, !(a && a._ck), v, n.length, !(n && n._ck), u, f);
+          }, t.Font.prototype.getGlyphWidths = function(a, n, u) {
+            var f = s(a, "HEAPU16"), y = t._malloc(4 * a.length);
+            return this._getGlyphWidthBounds(f, a.length, y, B, n || null), n = new Float32Array(t.HEAPU8.buffer, y, a.length), c(f, a), u ? (u.set(n), t._free(y), u) : (a = Float32Array.from(n), t._free(y), a);
+          }, t.FontMgr.FromData = function() {
+            if (!arguments.length) return null;
+            var a = arguments;
+            if (a.length === 1 && Array.isArray(a[0]) && (a = arguments[0]), !a.length) return null;
+            for (var n = [], u = [], f = 0; f < a.length; f++) {
+              var y = new Uint8Array(a[f]), v = s(y, "HEAPU8");
+              n.push(v), u.push(y.byteLength);
+            }
+            return n = s(n, "HEAPU32"), u = s(u, "HEAPU32"), a = t.FontMgr._fromData(n, u, a.length), t._free(n), t._free(u), a;
+          }, t.Typeface.MakeFreeTypeFaceFromData = function(a) {
+            a = new Uint8Array(a);
+            var n = s(a, "HEAPU8");
+            return (a = t.Typeface._MakeFreeTypeFaceFromData(n, a.byteLength)) ? a : null;
+          }, t.Typeface.prototype.getGlyphIDs = function(a, n, u) {
+            n || (n = a.length);
+            var f = ct(a) + 1, y = t._malloc(f);
+            return ut(a, I, y, f), a = t._malloc(2 * n), n = this._getGlyphIDs(y, f - 1, n, a), t._free(y), 0 > n ? (t._free(a), null) : (y = new Uint16Array(t.HEAPU8.buffer, a, n), u ? (u.set(y), t._free(a), u) : (u = Uint16Array.from(y), t._free(a), u));
+          }, t.TextBlob.MakeOnPath = function(a, n, u, f) {
+            if (a && a.length && n && n.countPoints()) {
+              if (n.countPoints() === 1) return this.MakeFromText(a, u);
+              f || (f = 0);
+              var y = u.getGlyphIDs(a);
+              y = u.getGlyphWidths(y);
+              var v = [];
+              n = new t.ContourMeasureIter(n, !1, 1);
+              for (var P = n.next(), T = new Float32Array(4), M = 0; M < a.length && P; M++) {
+                var x = y[M];
+                if (f += x / 2, f > P.length()) {
+                  if (P.delete(), P = n.next(), !P) {
+                    a = a.substring(0, M);
+                    break;
+                  }
+                  f = x / 2;
+                }
+                P.getPosTan(f, T);
+                var W = T[2], V = T[3];
+                v.push(W, V, T[0] - x / 2 * W, T[1] - x / 2 * V), f += x / 2;
+              }
+              return a = this.MakeFromRSXform(a, v, u), P && P.delete(), n.delete(), a;
+            }
+          }, t.TextBlob.MakeFromRSXform = function(a, n, u) {
+            var f = ct(a) + 1, y = t._malloc(f);
+            return ut(a, I, y, f), a = s(n, "HEAPF32"), u = t.TextBlob._MakeFromRSXform(y, f - 1, a, u), t._free(y), u || null;
+          }, t.TextBlob.MakeFromRSXformGlyphs = function(a, n, u) {
+            var f = s(a, "HEAPU16");
+            return n = s(n, "HEAPF32"), u = t.TextBlob._MakeFromRSXformGlyphs(f, 2 * a.length, n, u), c(f, a), u || null;
+          }, t.TextBlob.MakeFromGlyphs = function(a, n) {
+            var u = s(a, "HEAPU16");
+            return n = t.TextBlob._MakeFromGlyphs(u, 2 * a.length, n), c(u, a), n || null;
+          }, t.TextBlob.MakeFromText = function(a, n) {
+            var u = ct(a) + 1, f = t._malloc(u);
+            return ut(a, I, f, u), a = t.TextBlob._MakeFromText(f, u - 1, n), t._free(f), a || null;
+          }, t.MallocGlyphIDs = function(a) {
+            return t.Malloc(Uint16Array, a);
+          };
+        }), t.Id = t.Id || [], t.Id.push(function() {
+          t.MakePicture = function(a) {
+            a = new Uint8Array(a);
+            var n = t._malloc(a.byteLength);
+            return t.HEAPU8.set(a, n), (a = t._MakePicture(n, a.byteLength)) ? a : null;
+          };
+        }), t.Id = t.Id || [], t.Id.push(function() {
+          t.RuntimeEffect.Make = function(a, n) {
+            return t.RuntimeEffect._Make(a, { onError: n || function(u) {
+              console.log("RuntimeEffect error", u);
+            } });
+          }, t.RuntimeEffect.MakeForBlender = function(a, n) {
+            return t.RuntimeEffect._MakeForBlender(a, { onError: n || function(u) {
+              console.log("RuntimeEffect error", u);
+            } });
+          }, t.RuntimeEffect.prototype.makeShader = function(a, n) {
+            var u = !a._ck, f = s(a, "HEAPF32");
+            return n = h(n), this._makeShader(f, 4 * a.length, u, n);
+          }, t.RuntimeEffect.prototype.makeShaderWithChildren = function(a, n, u) {
+            var f = !a._ck, y = s(a, "HEAPF32");
+            u = h(u);
+            for (var v = [], P = 0; P < n.length; P++) v.push(n[P].Dd.Hd);
+            return n = s(v, "HEAPU32"), this._makeShaderWithChildren(y, 4 * a.length, f, n, v.length, u);
+          }, t.RuntimeEffect.prototype.makeBlender = function(a) {
+            var n = !a._ck, u = s(a, "HEAPF32");
+            return this._makeBlender(u, 4 * a.length, n);
+          };
+        });
+      }(g);
+      var Xe = Object.assign({}, g), Te = "./this.program", Qe = typeof window == "object", Ot = typeof importScripts == "function", Ze = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string", Q = "", Se, ne, oe;
+      if (Ze) {
+        var tr = Xr("fs"), Fe = Xr("path");
+        Q = Ot ? Fe.dirname(Q) + "/" : __dirname + "/", Se = (t, e) => (t = t.startsWith("file://") ? new URL(t) : Fe.normalize(t), tr.readFileSync(t, e ? void 0 : "utf8")), oe = (t) => (t = Se(t, !0), t.buffer || (t = new Uint8Array(t)), t), ne = (t, e, r, o = !0) => {
+          t = t.startsWith("file://") ? new URL(t) : Fe.normalize(t), tr.readFile(t, o ? void 0 : "utf8", (i, c) => {
+            i ? r(i) : e(o ? c.buffer : c);
+          });
+        }, !g.thisProgram && 1 < process.argv.length && (Te = process.argv[1].replace(/\\/g, "/")), process.argv.slice(2), g.inspect = () => "[Emscripten Module object]";
+      } else (Qe || Ot) && (Ot ? Q = self.location.href : typeof document < "u" && document.currentScript && (Q = document.currentScript.src), ee && (Q = ee), Q.indexOf("blob:") !== 0 ? Q = Q.substr(0, Q.replace(/[?#].*/, "").lastIndexOf("/") + 1) : Q = "", Se = (t) => {
+        var e = new XMLHttpRequest();
+        return e.open("GET", t, !1), e.send(null), e.responseText;
+      }, Ot && (oe = (t) => {
+        var e = new XMLHttpRequest();
+        return e.open("GET", t, !1), e.responseType = "arraybuffer", e.send(null), new Uint8Array(e.response);
+      }), ne = (t, e, r) => {
+        var o = new XMLHttpRequest();
+        o.open("GET", t, !0), o.responseType = "arraybuffer", o.onload = () => {
+          o.status == 200 || o.status == 0 && o.response ? e(o.response) : r();
+        }, o.onerror = r, o.send(null);
+      });
+      var Qr = g.print || console.log.bind(console), wt = g.printErr || console.error.bind(console);
+      Object.assign(g, Xe), Xe = null, g.thisProgram && (Te = g.thisProgram);
+      var jt;
+      g.wasmBinary && (jt = g.wasmBinary), g.noExitRuntime, typeof WebAssembly != "object" && ke("no native wasm support detected");
+      var ie, D, er = !1, ht, I, At, Rt, E, O, F, rr;
+      function nr() {
+        var t = ie.buffer;
+        g.HEAP8 = ht = new Int8Array(t), g.HEAP16 = At = new Int16Array(t), g.HEAP32 = E = new Int32Array(t), g.HEAPU8 = I = new Uint8Array(t), g.HEAPU16 = Rt = new Uint16Array(t), g.HEAPU32 = O = new Uint32Array(t), g.HEAPF32 = F = new Float32Array(t), g.HEAPF64 = rr = new Float64Array(t);
+      }
+      var K, or = [], ir = [], ar = [];
+      function Zr() {
+        var t = g.preRun.shift();
+        or.unshift(t);
+      }
+      var St = 0, Ut = null;
+      function ke(t) {
+        throw g.onAbort && g.onAbort(t), t = "Aborted(" + t + ")", wt(t), er = !0, t = new WebAssembly.RuntimeError(t + ". Build with -sASSERTIONS for more info."), re(t), t;
+      }
+      function ur(t) {
+        return t.startsWith("data:application/octet-stream;base64,");
+      }
+      var It;
+      if (It = "canvaskit.wasm", !ur(It)) {
+        var cr = It;
+        It = g.locateFile ? g.locateFile(cr, Q) : Q + cr;
+      }
+      function sr(t) {
+        if (t == It && jt) return new Uint8Array(jt);
+        if (oe) return oe(t);
+        throw "both async and sync fetching of the wasm failed";
+      }
+      function tn(t) {
+        if (!jt && (Qe || Ot)) {
+          if (typeof fetch == "function" && !t.startsWith("file://")) return fetch(t, { credentials: "same-origin" }).then((e) => {
+            if (!e.ok) throw "failed to load wasm binary file at '" + t + "'";
+            return e.arrayBuffer();
+          }).catch(() => sr(t));
+          if (ne) return new Promise((e, r) => {
+            ne(t, (o) => e(new Uint8Array(o)), r);
+          });
+        }
+        return Promise.resolve().then(() => sr(t));
+      }
+      function lr(t, e, r) {
+        return tn(t).then((o) => WebAssembly.instantiate(o, e)).then((o) => o).then(r, (o) => {
+          wt("failed to asynchronously prepare wasm: " + o), ke(o);
+        });
+      }
+      function en(t, e) {
+        var r = It;
+        return jt || typeof WebAssembly.instantiateStreaming != "function" || ur(r) || r.startsWith("file://") || Ze || typeof fetch != "function" ? lr(r, t, e) : fetch(r, { credentials: "same-origin" }).then((o) => WebAssembly.instantiateStreaming(o, t).then(e, function(i) {
+          return wt("wasm streaming compile failed: " + i), wt("falling back to ArrayBuffer instantiation"), lr(r, t, e);
+        }));
+      }
+      var xe = (t) => {
+        for (; 0 < t.length; ) t.shift()(g);
+      }, fr = typeof TextDecoder < "u" ? new TextDecoder("utf8") : void 0, Ft = (t, e, r) => {
+        var o = e + r;
+        for (r = e; t[r] && !(r >= o); ) ++r;
+        if (16 < r - e && t.buffer && fr) return fr.decode(t.subarray(e, r));
+        for (o = ""; e < r; ) {
+          var i = t[e++];
+          if (i & 128) {
+            var c = t[e++] & 63;
+            if ((i & 224) == 192) o += String.fromCharCode((i & 31) << 6 | c);
+            else {
+              var s = t[e++] & 63;
+              i = (i & 240) == 224 ? (i & 15) << 12 | c << 6 | s : (i & 7) << 18 | c << 12 | s << 6 | t[e++] & 63, 65536 > i ? o += String.fromCharCode(i) : (i -= 65536, o += String.fromCharCode(55296 | i >> 10, 56320 | i & 1023));
+            }
+          } else o += String.fromCharCode(i);
+        }
+        return o;
+      }, ae = {};
+      function Me(t) {
+        for (; t.length; ) {
+          var e = t.pop();
+          t.pop()(e);
+        }
+      }
+      function Wt(t) {
+        return this.fromWireType(E[t >> 2]);
+      }
+      var Bt = {}, kt = {}, ue = {}, dr = void 0;
+      function ce(t) {
+        throw new dr(t);
+      }
+      function at(t, e, r) {
+        function o(l) {
+          l = r(l), l.length !== t.length && ce("Mismatched type converter count");
+          for (var h = 0; h < t.length; ++h) pt(t[h], l[h]);
+        }
+        t.forEach(function(l) {
+          ue[l] = e;
+        });
+        var i = Array(e.length), c = [], s = 0;
+        e.forEach((l, h) => {
+          kt.hasOwnProperty(l) ? i[h] = kt[l] : (c.push(l), Bt.hasOwnProperty(l) || (Bt[l] = []), Bt[l].push(() => {
+            i[h] = kt[l], ++s, s === c.length && o(i);
+          }));
+        }), c.length === 0 && o(i);
+      }
+      function se(t) {
+        switch (t) {
+          case 1:
+            return 0;
+          case 2:
+            return 1;
+          case 4:
+            return 2;
+          case 8:
+            return 3;
+          default:
+            throw new TypeError(`Unknown type size: ${t}`);
+        }
+      }
+      var hr = void 0;
+      function $(t) {
+        for (var e = ""; I[t]; ) e += hr[I[t++]];
+        return e;
+      }
+      var Dt = void 0;
+      function G(t) {
+        throw new Dt(t);
+      }
+      function rn(t, e, r = {}) {
+        var o = e.name;
+        if (t || G(`type "${o}" must have a positive integer typeid pointer`), kt.hasOwnProperty(t)) {
+          if (r.af) return;
+          G(`Cannot register type '${o}' twice`);
+        }
+        kt[t] = e, delete ue[t], Bt.hasOwnProperty(t) && (e = Bt[t], delete Bt[t], e.forEach((i) => i()));
+      }
+      function pt(t, e, r = {}) {
+        if (!("argPackAdvance" in e)) throw new TypeError("registerType registeredInstance requires argPackAdvance");
+        rn(t, e, r);
+      }
+      function Re(t) {
+        G(t.Dd.Jd.Gd.name + " instance already deleted");
+      }
+      var Ie = !1;
+      function pr() {
+      }
+      function yr(t) {
+        --t.count.value, t.count.value === 0 && (t.Ld ? t.Pd.Td(t.Ld) : t.Jd.Gd.Td(t.Hd));
+      }
+      function mr(t, e, r) {
+        return e === r ? t : r.Md === void 0 ? null : (t = mr(t, e, r.Md), t === null ? null : r.Te(t));
+      }
+      var gr = {}, $t = [];
+      function Be() {
+        for (; $t.length; ) {
+          var t = $t.pop();
+          t.Dd.$d = !1, t.delete();
+        }
+      }
+      var Vt = void 0, Nt = {};
+      function nn(t, e) {
+        for (e === void 0 && G("ptr should not be undefined"); t.Md; ) e = t.ge(e), t = t.Md;
+        return Nt[e];
+      }
+      function le(t, e) {
+        return e.Jd && e.Hd || ce("makeClassHandle requires ptr and ptrType"), !!e.Pd != !!e.Ld && ce("Both smartPtrType and smartPtr must be specified"), e.count = { value: 1 }, Yt(Object.create(t, { Dd: { value: e } }));
+      }
+      function Yt(t) {
+        return typeof FinalizationRegistry > "u" ? (Yt = (e) => e, t) : (Ie = new FinalizationRegistry((e) => {
+          yr(e.Dd);
+        }), Yt = (e) => {
+          var r = e.Dd;
+          return r.Ld && Ie.register(e, { Dd: r }, e), e;
+        }, pr = (e) => {
+          Ie.unregister(e);
+        }, Yt(t));
+      }
+      function Et() {
+      }
+      function vr(t) {
+        if (t === void 0) return "_unknown";
+        t = t.replace(/[^a-zA-Z0-9_]/g, "$");
+        var e = t.charCodeAt(0);
+        return 48 <= e && 57 >= e ? `_${t}` : t;
+      }
+      function De(t, e) {
+        return t = vr(t), { [t]: function() {
+          return e.apply(this, arguments);
+        } }[t];
+      }
+      function Ge(t, e, r) {
+        if (t[e].Kd === void 0) {
+          var o = t[e];
+          t[e] = function() {
+            return t[e].Kd.hasOwnProperty(arguments.length) || G(`Function '${r}' called with an invalid number of arguments (${arguments.length}) - expects one of (${t[e].Kd})!`), t[e].Kd[arguments.length].apply(this, arguments);
+          }, t[e].Kd = [], t[e].Kd[o.Yd] = o;
+        }
+      }
+      function Le(t, e, r) {
+        g.hasOwnProperty(t) ? ((r === void 0 || g[t].Kd !== void 0 && g[t].Kd[r] !== void 0) && G(`Cannot register public name '${t}' twice`), Ge(g, t, t), g.hasOwnProperty(r) && G(`Cannot register multiple overloads of a function with the same number of arguments (${r})!`), g[t].Kd[r] = e) : (g[t] = e, r !== void 0 && (g[t].sf = r));
+      }
+      function on(t, e, r, o, i, c, s, l) {
+        this.name = t, this.constructor = e, this.ae = r, this.Td = o, this.Md = i, this.We = c, this.ge = s, this.Te = l, this.ef = [];
+      }
+      function He(t, e, r) {
+        for (; e !== r; ) e.ge || G(`Expected null or instance of ${r.name}, got an instance of ${e.name}`), t = e.ge(t), e = e.Md;
+        return t;
+      }
+      function an(t, e) {
+        return e === null ? (this.ue && G(`null is not a valid ${this.name}`), 0) : (e.Dd || G(`Cannot pass "${je(e)}" as a ${this.name}`), e.Dd.Hd || G(`Cannot pass deleted object as a pointer of type ${this.name}`), He(e.Dd.Hd, e.Dd.Jd.Gd, this.Gd));
+      }
+      function un(t, e) {
+        if (e === null) {
+          if (this.ue && G(`null is not a valid ${this.name}`), this.le) {
+            var r = this.ve();
+            return t !== null && t.push(this.Td, r), r;
+          }
+          return 0;
+        }
+        if (e.Dd || G(`Cannot pass "${je(e)}" as a ${this.name}`), e.Dd.Hd || G(`Cannot pass deleted object as a pointer of type ${this.name}`), !this.ke && e.Dd.Jd.ke && G(`Cannot convert argument of type ${e.Dd.Pd ? e.Dd.Pd.name : e.Dd.Jd.name} to parameter type ${this.name}`), r = He(e.Dd.Hd, e.Dd.Jd.Gd, this.Gd), this.le) switch (e.Dd.Ld === void 0 && G("Passing raw pointer to smart pointer is illegal"), this.kf) {
+          case 0:
+            e.Dd.Pd === this ? r = e.Dd.Ld : G(`Cannot convert argument of type ${e.Dd.Pd ? e.Dd.Pd.name : e.Dd.Jd.name} to parameter type ${this.name}`);
+            break;
+          case 1:
+            r = e.Dd.Ld;
+            break;
+          case 2:
+            if (e.Dd.Pd === this) r = e.Dd.Ld;
+            else {
+              var o = e.clone();
+              r = this.ff(r, et(function() {
+                o.delete();
+              })), t !== null && t.push(this.Td, r);
+            }
+            break;
+          default:
+            G("Unsupporting sharing policy");
+        }
+        return r;
+      }
+      function cn(t, e) {
+        return e === null ? (this.ue && G(`null is not a valid ${this.name}`), 0) : (e.Dd || G(`Cannot pass "${je(e)}" as a ${this.name}`), e.Dd.Hd || G(`Cannot pass deleted object as a pointer of type ${this.name}`), e.Dd.Jd.ke && G(`Cannot convert argument of type ${e.Dd.Jd.name} to parameter type ${this.name}`), He(e.Dd.Hd, e.Dd.Jd.Gd, this.Gd));
+      }
+      function yt(t, e, r, o, i, c, s, l, h, b, _) {
+        this.name = t, this.Gd = e, this.ue = r, this.ke = o, this.le = i, this.df = c, this.kf = s, this.Ee = l, this.ve = h, this.ff = b, this.Td = _, i || e.Md !== void 0 ? this.toWireType = un : (this.toWireType = o ? an : cn, this.Od = null);
+      }
+      function br(t, e, r) {
+        g.hasOwnProperty(t) || ce("Replacing nonexistant public symbol"), g[t].Kd !== void 0 && r !== void 0 ? g[t].Kd[r] = e : (g[t] = e, g[t].Yd = r);
+      }
+      var sn = (t, e) => {
+        var r = [];
+        return function() {
+          if (r.length = 0, Object.assign(r, arguments), t.includes("j")) {
+            var o = g["dynCall_" + t];
+            o = r.length ? o.apply(null, [e].concat(r)) : o.call(null, e);
+          } else o = K.get(e).apply(null, r);
+          return o;
+        };
+      };
+      function q(t, e) {
+        t = $(t);
+        var r = t.includes("j") ? sn(t, e) : K.get(e);
+        return typeof r != "function" && G(`unknown function pointer with signature ${t}: ${e}`), r;
+      }
+      var _r = void 0;
+      function Pr(t) {
+        t = Wr(t);
+        var e = $(t);
+        return bt(t), e;
+      }
+      function zt(t, e) {
+        function r(c) {
+          i[c] || kt[c] || (ue[c] ? ue[c].forEach(r) : (o.push(c), i[c] = !0));
+        }
+        var o = [], i = {};
+        throw e.forEach(r), new _r(`${t}: ` + o.map(Pr).join([", "]));
+      }
+      function fe(t, e, r, o, i) {
+        var c = e.length;
+        2 > c && G("argTypes array size mismatch! Must at least get return value and 'this' types!");
+        var s = e[1] !== null && r !== null, l = !1;
+        for (r = 1; r < e.length; ++r) if (e[r] !== null && e[r].Od === void 0) {
+          l = !0;
+          break;
+        }
+        var h = e[0].name !== "void", b = c - 2, _ = Array(b), A = [], C = [];
+        return function() {
+          if (arguments.length !== b && G(`function ${t} called with ${arguments.length} arguments, expected ${b} args!`), C.length = 0, A.length = s ? 2 : 1, A[0] = i, s) {
+            var m = e[1].toWireType(C, this);
+            A[1] = m;
+          }
+          for (var S = 0; S < b; ++S) _[S] = e[S + 2].toWireType(C, arguments[S]), A.push(_[S]);
+          if (S = o.apply(null, A), l) Me(C);
+          else for (var k = s ? 1 : 2; k < e.length; k++) {
+            var U = k === 1 ? m : _[k - 2];
+            e[k].Od !== null && e[k].Od(U);
+          }
+          return m = h ? e[0].fromWireType(S) : void 0, m;
+        };
+      }
+      function de(t, e) {
+        for (var r = [], o = 0; o < t; o++) r.push(O[e + 4 * o >> 2]);
+        return r;
+      }
+      function wr() {
+        this.Sd = [void 0], this.Ce = [];
+      }
+      var Z = new wr();
+      function Oe(t) {
+        t >= Z.be && --Z.get(t).Fe === 0 && Z.Je(t);
+      }
+      var tt = (t) => (t || G("Cannot use deleted val. handle = " + t), Z.get(t).value), et = (t) => {
+        switch (t) {
+          case void 0:
+            return 1;
+          case null:
+            return 2;
+          case !0:
+            return 3;
+          case !1:
+            return 4;
+          default:
+            return Z.Ie({ Fe: 1, value: t });
+        }
+      };
+      function ln(t, e, r) {
+        switch (e) {
+          case 0:
+            return function(o) {
+              return this.fromWireType((r ? ht : I)[o]);
+            };
+          case 1:
+            return function(o) {
+              return this.fromWireType((r ? At : Rt)[o >> 1]);
+            };
+          case 2:
+            return function(o) {
+              return this.fromWireType((r ? E : O)[o >> 2]);
+            };
+          default:
+            throw new TypeError("Unknown integer type: " + t);
+        }
+      }
+      function qt(t, e) {
+        var r = kt[t];
+        return r === void 0 && G(e + " has unknown type " + Pr(t)), r;
+      }
+      function je(t) {
+        if (t === null) return "null";
+        var e = typeof t;
+        return e === "object" || e === "array" || e === "function" ? t.toString() : "" + t;
+      }
+      function fn(t, e) {
+        switch (e) {
+          case 2:
+            return function(r) {
+              return this.fromWireType(F[r >> 2]);
+            };
+          case 3:
+            return function(r) {
+              return this.fromWireType(rr[r >> 3]);
+            };
+          default:
+            throw new TypeError("Unknown float type: " + t);
+        }
+      }
+      function dn(t, e, r) {
+        switch (e) {
+          case 0:
+            return r ? function(o) {
+              return ht[o];
+            } : function(o) {
+              return I[o];
+            };
+          case 1:
+            return r ? function(o) {
+              return At[o >> 1];
+            } : function(o) {
+              return Rt[o >> 1];
+            };
+          case 2:
+            return r ? function(o) {
+              return E[o >> 2];
+            } : function(o) {
+              return O[o >> 2];
+            };
+          default:
+            throw new TypeError("Unknown integer type: " + t);
+        }
+      }
+      var ut = (t, e, r, o) => {
+        if (!(0 < o)) return 0;
+        var i = r;
+        o = r + o - 1;
+        for (var c = 0; c < t.length; ++c) {
+          var s = t.charCodeAt(c);
+          if (55296 <= s && 57343 >= s) {
+            var l = t.charCodeAt(++c);
+            s = 65536 + ((s & 1023) << 10) | l & 1023;
+          }
+          if (127 >= s) {
+            if (r >= o) break;
+            e[r++] = s;
+          } else {
+            if (2047 >= s) {
+              if (r + 1 >= o) break;
+              e[r++] = 192 | s >> 6;
+            } else {
+              if (65535 >= s) {
+                if (r + 2 >= o) break;
+                e[r++] = 224 | s >> 12;
+              } else {
+                if (r + 3 >= o) break;
+                e[r++] = 240 | s >> 18, e[r++] = 128 | s >> 12 & 63;
+              }
+              e[r++] = 128 | s >> 6 & 63;
+            }
+            e[r++] = 128 | s & 63;
+          }
+        }
+        return e[r] = 0, r - i;
+      }, ct = (t) => {
+        for (var e = 0, r = 0; r < t.length; ++r) {
+          var o = t.charCodeAt(r);
+          127 >= o ? e++ : 2047 >= o ? e += 2 : 55296 <= o && 57343 >= o ? (e += 4, ++r) : e += 3;
+        }
+        return e;
+      }, Ar = typeof TextDecoder < "u" ? new TextDecoder("utf-16le") : void 0, hn = (t, e) => {
+        for (var r = t >> 1, o = r + e / 2; !(r >= o) && Rt[r]; ) ++r;
+        if (r <<= 1, 32 < r - t && Ar) return Ar.decode(I.subarray(t, r));
+        for (r = "", o = 0; !(o >= e / 2); ++o) {
+          var i = At[t + 2 * o >> 1];
+          if (i == 0) break;
+          r += String.fromCharCode(i);
+        }
+        return r;
+      }, pn = (t, e, r) => {
+        if (r === void 0 && (r = 2147483647), 2 > r) return 0;
+        r -= 2;
+        var o = e;
+        r = r < 2 * t.length ? r / 2 : t.length;
+        for (var i = 0; i < r; ++i) At[e >> 1] = t.charCodeAt(i), e += 2;
+        return At[e >> 1] = 0, e - o;
+      }, yn = (t) => 2 * t.length, mn = (t, e) => {
+        for (var r = 0, o = ""; !(r >= e / 4); ) {
+          var i = E[t + 4 * r >> 2];
+          if (i == 0) break;
+          ++r, 65536 <= i ? (i -= 65536, o += String.fromCharCode(55296 | i >> 10, 56320 | i & 1023)) : o += String.fromCharCode(i);
+        }
+        return o;
+      }, gn = (t, e, r) => {
+        if (r === void 0 && (r = 2147483647), 4 > r) return 0;
+        var o = e;
+        r = o + r - 4;
+        for (var i = 0; i < t.length; ++i) {
+          var c = t.charCodeAt(i);
+          if (55296 <= c && 57343 >= c) {
+            var s = t.charCodeAt(++i);
+            c = 65536 + ((c & 1023) << 10) | s & 1023;
+          }
+          if (E[e >> 2] = c, e += 4, e + 4 > r) break;
+        }
+        return E[e >> 2] = 0, e - o;
+      }, vn = (t) => {
+        for (var e = 0, r = 0; r < t.length; ++r) {
+          var o = t.charCodeAt(r);
+          55296 <= o && 57343 >= o && ++r, e += 4;
+        }
+        return e;
+      }, bn = {};
+      function he(t) {
+        var e = bn[t];
+        return e === void 0 ? $(t) : e;
+      }
+      var pe = [];
+      function Er() {
+        function t(e) {
+          e.$$$embind_global$$$ = e;
+          var r = typeof $$$embind_global$$$ == "object" && e.$$$embind_global$$$ == e;
+          return r || delete e.$$$embind_global$$$, r;
+        }
+        if (typeof globalThis == "object") return globalThis;
+        if (typeof $$$embind_global$$$ == "object" || (typeof global == "object" && t(global) ? $$$embind_global$$$ = global : typeof self == "object" && t(self) && ($$$embind_global$$$ = self), typeof $$$embind_global$$$ == "object")) return $$$embind_global$$$;
+        throw Error("unable to get global object.");
+      }
+      function _n(t) {
+        var e = pe.length;
+        return pe.push(t), e;
+      }
+      function Pn(t, e) {
+        for (var r = Array(t), o = 0; o < t; ++o) r[o] = qt(O[e + 4 * o >> 2], "parameter " + o);
+        return r;
+      }
+      var Cr = [];
+      function wn(t) {
+        var e = Array(t + 1);
+        return function(r, o, i) {
+          e[0] = r;
+          for (var c = 0; c < t; ++c) {
+            var s = qt(O[o + 4 * c >> 2], "parameter " + c);
+            e[c + 1] = s.readValueFromPointer(i), i += s.argPackAdvance;
+          }
+          return r = new (r.bind.apply(r, e))(), et(r);
+        };
+      }
+      var Tr = {};
+      function An(t) {
+        var e = t.getExtension("ANGLE_instanced_arrays");
+        e && (t.vertexAttribDivisor = function(r, o) {
+          e.vertexAttribDivisorANGLE(r, o);
+        }, t.drawArraysInstanced = function(r, o, i, c) {
+          e.drawArraysInstancedANGLE(r, o, i, c);
+        }, t.drawElementsInstanced = function(r, o, i, c, s) {
+          e.drawElementsInstancedANGLE(r, o, i, c, s);
+        });
+      }
+      function En(t) {
+        var e = t.getExtension("OES_vertex_array_object");
+        e && (t.createVertexArray = function() {
+          return e.createVertexArrayOES();
+        }, t.deleteVertexArray = function(r) {
+          e.deleteVertexArrayOES(r);
+        }, t.bindVertexArray = function(r) {
+          e.bindVertexArrayOES(r);
+        }, t.isVertexArray = function(r) {
+          return e.isVertexArrayOES(r);
+        });
+      }
+      function Cn(t) {
+        var e = t.getExtension("WEBGL_draw_buffers");
+        e && (t.drawBuffers = function(r, o) {
+          e.drawBuffersWEBGL(r, o);
+        });
+      }
+      var Sr = 1, ye = [], st = [], me = [], Jt = [], rt = [], lt = [], ge = [], mt = [], xt = [], Mt = [], Fr = {}, kr = {}, xr = 4;
+      function j(t) {
+        ve || (ve = t);
+      }
+      function Gt(t) {
+        for (var e = Sr++, r = t.length; r < e; r++) t[r] = null;
+        return e;
+      }
+      function Tn(t, e) {
+        t.be || (t.be = t.getContext, t.getContext = function(o, i) {
+          return i = t.be(o, i), o == "webgl" == i instanceof WebGLRenderingContext ? i : null;
+        });
+        var r = 1 < e.majorVersion ? t.getContext("webgl2", e) : t.getContext("webgl", e);
+        return r ? Sn(r, e) : 0;
+      }
+      function Sn(t, e) {
+        var r = Gt(mt), o = { handle: r, attributes: e, version: e.majorVersion, Qd: t };
+        return t.canvas && (t.canvas.Ke = o), mt[r] = o, (typeof e.Ue > "u" || e.Ue) && Fn(o), r;
+      }
+      function Mr(t) {
+        return R = mt[t], g.qf = p = R && R.Qd, !(t && !p);
+      }
+      function Fn(t) {
+        if (!t.bf) {
+          t.bf = !0;
+          var e = t.Qd;
+          An(e), En(e), Cn(e), e.ze = e.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"), e.De = e.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"), 2 <= t.version && (e.Ae = e.getExtension("EXT_disjoint_timer_query_webgl2")), (2 > t.version || !e.Ae) && (e.Ae = e.getExtension("EXT_disjoint_timer_query")), e.rf = e.getExtension("WEBGL_multi_draw"), (e.getSupportedExtensions() || []).forEach(function(r) {
+            r.includes("lose_context") || r.includes("debug") || e.getExtension(r);
+          });
+        }
+      }
+      var R, ve, Ue = {}, Rr = () => {
+        if (!We) {
+          var t = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: Te || "./this.program" }, e;
+          for (e in Ue) Ue[e] === void 0 ? delete t[e] : t[e] = Ue[e];
+          var r = [];
+          for (e in t) r.push(`${e}=${t[e]}`);
+          We = r;
+        }
+        return We;
+      }, We, kn = [null, [], []];
+      function Ir(t) {
+        p.bindVertexArray(ge[t]);
+      }
+      function Br(t, e) {
+        for (var r = 0; r < t; r++) {
+          var o = E[e + 4 * r >> 2];
+          p.deleteVertexArray(ge[o]), ge[o] = null;
+        }
+      }
+      var be = [];
+      function Dr(t, e, r, o) {
+        p.drawElements(t, e, r, o);
+      }
+      function Lt(t, e, r, o) {
+        for (var i = 0; i < t; i++) {
+          var c = p[r](), s = c && Gt(o);
+          c ? (c.name = s, o[s] = c) : j(1282), E[e + 4 * i >> 2] = s;
+        }
+      }
+      function Gr(t, e) {
+        Lt(t, e, "createVertexArray", ge);
+      }
+      function Lr(t, e, r) {
+        if (e) {
+          var o = void 0;
+          switch (t) {
+            case 36346:
+              o = 1;
+              break;
+            case 36344:
+              r != 0 && r != 1 && j(1280);
+              return;
+            case 34814:
+            case 36345:
+              o = 0;
+              break;
+            case 34466:
+              var i = p.getParameter(34467);
+              o = i ? i.length : 0;
+              break;
+            case 33309:
+              if (2 > R.version) {
+                j(1282);
+                return;
+              }
+              o = 2 * (p.getSupportedExtensions() || []).length;
+              break;
+            case 33307:
+            case 33308:
+              if (2 > R.version) {
+                j(1280);
+                return;
+              }
+              o = t == 33307 ? 3 : 0;
+          }
+          if (o === void 0) switch (i = p.getParameter(t), typeof i) {
+            case "number":
+              o = i;
+              break;
+            case "boolean":
+              o = i ? 1 : 0;
+              break;
+            case "string":
+              j(1280);
+              return;
+            case "object":
+              if (i === null) switch (t) {
+                case 34964:
+                case 35725:
+                case 34965:
+                case 36006:
+                case 36007:
+                case 32873:
+                case 34229:
+                case 36662:
+                case 36663:
+                case 35053:
+                case 35055:
+                case 36010:
+                case 35097:
+                case 35869:
+                case 32874:
+                case 36389:
+                case 35983:
+                case 35368:
+                case 34068:
+                  o = 0;
+                  break;
+                default:
+                  j(1280);
+                  return;
+              }
+              else {
+                if (i instanceof Float32Array || i instanceof Uint32Array || i instanceof Int32Array || i instanceof Array) {
+                  for (t = 0; t < i.length; ++t) switch (r) {
+                    case 0:
+                      E[e + 4 * t >> 2] = i[t];
+                      break;
+                    case 2:
+                      F[e + 4 * t >> 2] = i[t];
+                      break;
+                    case 4:
+                      ht[e + t >> 0] = i[t] ? 1 : 0;
+                  }
+                  return;
+                }
+                try {
+                  o = i.name | 0;
+                } catch (c) {
+                  j(1280), wt("GL_INVALID_ENUM in glGet" + r + "v: Unknown object returned from WebGL getParameter(" + t + ")! (error: " + c + ")");
+                  return;
+                }
+              }
+              break;
+            default:
+              j(1280), wt("GL_INVALID_ENUM in glGet" + r + "v: Native code calling glGet" + r + "v(" + t + ") and it returns " + i + " of type " + typeof i + "!");
+              return;
+          }
+          switch (r) {
+            case 1:
+              r = o, O[e >> 2] = r, O[e + 4 >> 2] = (r - O[e >> 2]) / 4294967296;
+              break;
+            case 0:
+              E[e >> 2] = o;
+              break;
+            case 2:
+              F[e >> 2] = o;
+              break;
+            case 4:
+              ht[e >> 0] = o ? 1 : 0;
+          }
+        } else j(1281);
+      }
+      var Kt = (t) => {
+        var e = ct(t) + 1, r = Ae(e);
+        return r && ut(t, I, r, e), r;
+      };
+      function Hr(t) {
+        return t.slice(-1) == "]" && t.lastIndexOf("[");
+      }
+      function _e(t) {
+        return t -= 5120, t == 0 ? ht : t == 1 ? I : t == 2 ? At : t == 4 ? E : t == 6 ? F : t == 5 || t == 28922 || t == 28520 || t == 30779 || t == 30782 ? O : Rt;
+      }
+      function $e(t, e, r, o, i) {
+        t = _e(t);
+        var c = 31 - Math.clz32(t.BYTES_PER_ELEMENT), s = xr;
+        return t.subarray(i >> c, i + o * (r * ({ 5: 3, 6: 4, 8: 2, 29502: 3, 29504: 4, 26917: 2, 26918: 2, 29846: 3, 29847: 4 }[e - 6402] || 1) * (1 << c) + s - 1 & -s) >> c);
+      }
+      function L(t) {
+        var e = p.Re;
+        if (e) {
+          var r = e.fe[t];
+          return typeof r == "number" && (e.fe[t] = r = p.getUniformLocation(e, e.Ge[t] + (0 < r ? "[" + r + "]" : ""))), r;
+        }
+        j(1282);
+      }
+      var Ct = [], Xt = [], Pe = (t) => t % 4 === 0 && (t % 100 !== 0 || t % 400 === 0), Or = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], jr = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+      function xn(t) {
+        var e = Array(ct(t) + 1);
+        return ut(t, e, 0, e.length), e;
+      }
+      var Mn = (t, e, r, o) => {
+        function i(m, S, k) {
+          for (m = typeof m == "number" ? m.toString() : m || ""; m.length < S; ) m = k[0] + m;
+          return m;
+        }
+        function c(m, S) {
+          return i(m, S, "0");
+        }
+        function s(m, S) {
+          function k(J) {
+            return 0 > J ? -1 : 0 < J ? 1 : 0;
+          }
+          var U;
+          return (U = k(m.getFullYear() - S.getFullYear())) === 0 && (U = k(m.getMonth() - S.getMonth())) === 0 && (U = k(m.getDate() - S.getDate())), U;
+        }
+        function l(m) {
+          switch (m.getDay()) {
+            case 0:
+              return new Date(m.getFullYear() - 1, 11, 29);
+            case 1:
+              return m;
+            case 2:
+              return new Date(m.getFullYear(), 0, 3);
+            case 3:
+              return new Date(m.getFullYear(), 0, 2);
+            case 4:
+              return new Date(m.getFullYear(), 0, 1);
+            case 5:
+              return new Date(m.getFullYear() - 1, 11, 31);
+            case 6:
+              return new Date(m.getFullYear() - 1, 11, 30);
+          }
+        }
+        function h(m) {
+          var S = m.Vd;
+          for (m = new Date(new Date(m.Wd + 1900, 0, 1).getTime()); 0 < S; ) {
+            var k = m.getMonth(), U = (Pe(m.getFullYear()) ? Or : jr)[k];
+            if (S > U - m.getDate()) S -= U - m.getDate() + 1, m.setDate(1), 11 > k ? m.setMonth(k + 1) : (m.setMonth(0), m.setFullYear(m.getFullYear() + 1));
+            else {
+              m.setDate(m.getDate() + S);
+              break;
+            }
+          }
+          return k = new Date(m.getFullYear() + 1, 0, 4), S = l(new Date(m.getFullYear(), 0, 4)), k = l(k), 0 >= s(S, m) ? 0 >= s(k, m) ? m.getFullYear() + 1 : m.getFullYear() : m.getFullYear() - 1;
+        }
+        var b = E[o + 40 >> 2];
+        o = { nf: E[o >> 2], mf: E[o + 4 >> 2], pe: E[o + 8 >> 2], we: E[o + 12 >> 2], qe: E[o + 16 >> 2], Wd: E[o + 20 >> 2], Rd: E[o + 24 >> 2], Vd: E[o + 28 >> 2], uf: E[o + 32 >> 2], lf: E[o + 36 >> 2], pf: b && b ? Ft(I, b) : "" }, r = r ? Ft(I, r) : "", b = { "%c": "%a %b %d %H:%M:%S %Y", "%D": "%m/%d/%y", "%F": "%Y-%m-%d", "%h": "%b", "%r": "%I:%M:%S %p", "%R": "%H:%M", "%T": "%H:%M:%S", "%x": "%m/%d/%y", "%X": "%H:%M:%S", "%Ec": "%c", "%EC": "%C", "%Ex": "%m/%d/%y", "%EX": "%H:%M:%S", "%Ey": "%y", "%EY": "%Y", "%Od": "%d", "%Oe": "%e", "%OH": "%H", "%OI": "%I", "%Om": "%m", "%OM": "%M", "%OS": "%S", "%Ou": "%u", "%OU": "%U", "%OV": "%V", "%Ow": "%w", "%OW": "%W", "%Oy": "%y" };
+        for (var _ in b) r = r.replace(new RegExp(_, "g"), b[_]);
+        var A = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "), C = "January February March April May June July August September October November December".split(" ");
+        b = { "%a": (m) => A[m.Rd].substring(0, 3), "%A": (m) => A[m.Rd], "%b": (m) => C[m.qe].substring(0, 3), "%B": (m) => C[m.qe], "%C": (m) => c((m.Wd + 1900) / 100 | 0, 2), "%d": (m) => c(m.we, 2), "%e": (m) => i(m.we, 2, " "), "%g": (m) => h(m).toString().substring(2), "%G": (m) => h(m), "%H": (m) => c(m.pe, 2), "%I": (m) => (m = m.pe, m == 0 ? m = 12 : 12 < m && (m -= 12), c(m, 2)), "%j": (m) => {
+          for (var S = 0, k = 0; k <= m.qe - 1; S += (Pe(m.Wd + 1900) ? Or : jr)[k++]) ;
+          return c(m.we + S, 3);
+        }, "%m": (m) => c(m.qe + 1, 2), "%M": (m) => c(m.mf, 2), "%n": () => `
+`, "%p": (m) => 0 <= m.pe && 12 > m.pe ? "AM" : "PM", "%S": (m) => c(m.nf, 2), "%t": () => "	", "%u": (m) => m.Rd || 7, "%U": (m) => c(Math.floor((m.Vd + 7 - m.Rd) / 7), 2), "%V": (m) => {
+          var S = Math.floor((m.Vd + 7 - (m.Rd + 6) % 7) / 7);
+          if (2 >= (m.Rd + 371 - m.Vd - 2) % 7 && S++, S) S == 53 && (k = (m.Rd + 371 - m.Vd) % 7, k == 4 || k == 3 && Pe(m.Wd) || (S = 1));
+          else {
+            S = 52;
+            var k = (m.Rd + 7 - m.Vd - 1) % 7;
+            (k == 4 || k == 5 && Pe(m.Wd % 400 - 1)) && S++;
+          }
+          return c(S, 2);
+        }, "%w": (m) => m.Rd, "%W": (m) => c(Math.floor((m.Vd + 7 - (m.Rd + 6) % 7) / 7), 2), "%y": (m) => (m.Wd + 1900).toString().substring(2), "%Y": (m) => m.Wd + 1900, "%z": (m) => {
+          m = m.lf;
+          var S = 0 <= m;
+          return m = Math.abs(m) / 60, (S ? "+" : "-") + ("0000" + (m / 60 * 100 + m % 60)).slice(-4);
+        }, "%Z": (m) => m.pf, "%%": () => "%" }, r = r.replace(/%%/g, "\0\0");
+        for (_ in b) r.includes(_) && (r = r.replace(new RegExp(_, "g"), b[_](o)));
+        return r = r.replace(/\0\0/g, "%"), _ = xn(r), _.length > e ? 0 : (ht.set(_, t), _.length - 1);
+      };
+      dr = g.InternalError = class extends Error {
+        constructor(t) {
+          super(t), this.name = "InternalError";
+        }
+      };
+      for (var Ur = Array(256), we = 0; 256 > we; ++we) Ur[we] = String.fromCharCode(we);
+      hr = Ur, Dt = g.BindingError = class extends Error {
+        constructor(t) {
+          super(t), this.name = "BindingError";
+        }
+      }, Et.prototype.isAliasOf = function(t) {
+        if (!(this instanceof Et && t instanceof Et)) return !1;
+        var e = this.Dd.Jd.Gd, r = this.Dd.Hd, o = t.Dd.Jd.Gd;
+        for (t = t.Dd.Hd; e.Md; ) r = e.ge(r), e = e.Md;
+        for (; o.Md; ) t = o.ge(t), o = o.Md;
+        return e === o && r === t;
+      }, Et.prototype.clone = function() {
+        if (this.Dd.Hd || Re(this), this.Dd.ee) return this.Dd.count.value += 1, this;
+        var t = Yt, e = Object, r = e.create, o = Object.getPrototypeOf(this), i = this.Dd;
+        return t = t(r.call(e, o, { Dd: { value: { count: i.count, $d: i.$d, ee: i.ee, Hd: i.Hd, Jd: i.Jd, Ld: i.Ld, Pd: i.Pd } } })), t.Dd.count.value += 1, t.Dd.$d = !1, t;
+      }, Et.prototype.delete = function() {
+        this.Dd.Hd || Re(this), this.Dd.$d && !this.Dd.ee && G("Object already scheduled for deletion"), pr(this), yr(this.Dd), this.Dd.ee || (this.Dd.Ld = void 0, this.Dd.Hd = void 0);
+      }, Et.prototype.isDeleted = function() {
+        return !this.Dd.Hd;
+      }, Et.prototype.deleteLater = function() {
+        return this.Dd.Hd || Re(this), this.Dd.$d && !this.Dd.ee && G("Object already scheduled for deletion"), $t.push(this), $t.length === 1 && Vt && Vt(Be), this.Dd.$d = !0, this;
+      }, g.getInheritedInstanceCount = function() {
+        return Object.keys(Nt).length;
+      }, g.getLiveInheritedInstances = function() {
+        var t = [], e;
+        for (e in Nt) Nt.hasOwnProperty(e) && t.push(Nt[e]);
+        return t;
+      }, g.flushPendingDeletes = Be, g.setDelayFunction = function(t) {
+        Vt = t, $t.length && Vt && Vt(Be);
+      }, yt.prototype.Xe = function(t) {
+        return this.Ee && (t = this.Ee(t)), t;
+      }, yt.prototype.ye = function(t) {
+        this.Td && this.Td(t);
+      }, yt.prototype.argPackAdvance = 8, yt.prototype.readValueFromPointer = Wt, yt.prototype.deleteObject = function(t) {
+        t !== null && t.delete();
+      }, yt.prototype.fromWireType = function(t) {
+        function e() {
+          return this.le ? le(this.Gd.ae, { Jd: this.df, Hd: r, Pd: this, Ld: t }) : le(this.Gd.ae, { Jd: this, Hd: t });
+        }
+        var r = this.Xe(t);
+        if (!r) return this.ye(t), null;
+        var o = nn(this.Gd, r);
+        if (o !== void 0) return o.Dd.count.value === 0 ? (o.Dd.Hd = r, o.Dd.Ld = t, o.clone()) : (o = o.clone(), this.ye(t), o);
+        if (o = this.Gd.We(r), o = gr[o], !o) return e.call(this);
+        o = this.ke ? o.Qe : o.pointerType;
+        var i = mr(r, this.Gd, o.Gd);
+        return i === null ? e.call(this) : this.le ? le(o.Gd.ae, { Jd: o, Hd: i, Pd: this, Ld: t }) : le(o.Gd.ae, { Jd: o, Hd: i });
+      }, _r = g.UnboundTypeError = function(t, e) {
+        var r = De(e, function(o) {
+          this.name = e, this.message = o, o = Error(o).stack, o !== void 0 && (this.stack = this.toString() + `
+` + o.replace(/^Error(:[^\n]*)?\n/, ""));
+        });
+        return r.prototype = Object.create(t.prototype), r.prototype.constructor = r, r.prototype.toString = function() {
+          return this.message === void 0 ? this.name : `${this.name}: ${this.message}`;
+        }, r;
+      }(Error, "UnboundTypeError"), Object.assign(wr.prototype, { get(t) {
+        return this.Sd[t];
+      }, has(t) {
+        return this.Sd[t] !== void 0;
+      }, Ie(t) {
+        var e = this.Ce.pop() || this.Sd.length;
+        return this.Sd[e] = t, e;
+      }, Je(t) {
+        this.Sd[t] = void 0, this.Ce.push(t);
+      } }), Z.Sd.push({ value: void 0 }, { value: null }, { value: !0 }, { value: !1 }), Z.be = Z.Sd.length, g.count_emval_handles = function() {
+        for (var t = 0, e = Z.be; e < Z.Sd.length; ++e) Z.Sd[e] !== void 0 && ++t;
+        return t;
+      };
+      for (var p, X = 0; 32 > X; ++X) be.push(Array(X));
+      var Rn = new Float32Array(288);
+      for (X = 0; 288 > X; ++X) Ct[X] = Rn.subarray(0, X + 1);
+      var In = new Int32Array(288);
+      for (X = 0; 288 > X; ++X) Xt[X] = In.subarray(0, X + 1);
+      var Bn = { Q: function() {
+        return 0;
+      }, Ab: () => {
+      }, Cb: function() {
+        return 0;
+      }, xb: () => {
+      }, yb: () => {
+      }, R: function() {
+      }, zb: () => {
+      }, v: function(t) {
+        var e = ae[t];
+        delete ae[t];
+        var r = e.ve, o = e.Td, i = e.Be, c = i.map((s) => s.$e).concat(i.map((s) => s.hf));
+        at([t], c, (s) => {
+          var l = {};
+          return i.forEach((h, b) => {
+            var _ = s[b], A = h.Ye, C = h.Ze, m = s[b + i.length], S = h.gf, k = h.jf;
+            l[h.Ve] = { read: (U) => _.fromWireType(A(C, U)), write: (U, J) => {
+              var Y = [];
+              S(k, U, m.toWireType(Y, J)), Me(Y);
+            } };
+          }), [{ name: e.name, fromWireType: function(h) {
+            var b = {}, _;
+            for (_ in l) b[_] = l[_].read(h);
+            return o(h), b;
+          }, toWireType: function(h, b) {
+            for (var _ in l) if (!(_ in b)) throw new TypeError(`Missing field: "${_}"`);
+            var A = r();
+            for (_ in l) l[_].write(A, b[_]);
+            return h !== null && h.push(o, A), A;
+          }, argPackAdvance: 8, readValueFromPointer: Wt, Od: o }];
+        });
+      }, pb: function() {
+      }, Gb: function(t, e, r, o, i) {
+        var c = se(r);
+        e = $(e), pt(t, { name: e, fromWireType: function(s) {
+          return !!s;
+        }, toWireType: function(s, l) {
+          return l ? o : i;
+        }, argPackAdvance: 8, readValueFromPointer: function(s) {
+          if (r === 1) var l = ht;
+          else if (r === 2) l = At;
+          else if (r === 4) l = E;
+          else throw new TypeError("Unknown boolean type size: " + e);
+          return this.fromWireType(l[s >> c]);
+        }, Od: null });
+      }, k: function(t, e, r, o, i, c, s, l, h, b, _, A, C) {
+        _ = $(_), c = q(i, c), l && (l = q(s, l)), b && (b = q(h, b)), C = q(A, C);
+        var m = vr(_);
+        Le(m, function() {
+          zt(`Cannot construct ${_} due to unbound types`, [o]);
+        }), at([t, e, r], o ? [o] : [], function(S) {
+          if (S = S[0], o) var k = S.Gd, U = k.ae;
+          else U = Et.prototype;
+          S = De(m, function() {
+            if (Object.getPrototypeOf(this) !== J) throw new Dt("Use 'new' to construct " + _);
+            if (Y.Ud === void 0) throw new Dt(_ + " has no accessible constructor");
+            var Ht = Y.Ud[arguments.length];
+            if (Ht === void 0) throw new Dt(`Tried to invoke ctor of ${_} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(Y.Ud).toString()}) parameters instead!`);
+            return Ht.apply(this, arguments);
+          });
+          var J = Object.create(U, { constructor: { value: S } });
+          S.prototype = J;
+          var Y = new on(_, S, J, C, k, c, l, b);
+          Y.Md && (Y.Md.he === void 0 && (Y.Md.he = []), Y.Md.he.push(Y)), k = new yt(_, Y, !0, !1, !1), U = new yt(_ + "*", Y, !1, !1, !1);
+          var gt = new yt(_ + " const*", Y, !1, !0, !1);
+          return gr[t] = { pointerType: U, Qe: gt }, br(m, S), [k, U, gt];
+        });
+      }, f: function(t, e, r, o, i, c, s) {
+        var l = de(r, o);
+        e = $(e), c = q(i, c), at([], [t], function(h) {
+          function b() {
+            zt(`Cannot call ${_} due to unbound types`, l);
+          }
+          h = h[0];
+          var _ = `${h.name}.${e}`;
+          e.startsWith("@@") && (e = Symbol[e.substring(2)]);
+          var A = h.Gd.constructor;
+          return A[e] === void 0 ? (b.Yd = r - 1, A[e] = b) : (Ge(A, e, _), A[e].Kd[r - 1] = b), at([], l, function(C) {
+            if (C = [C[0], null].concat(C.slice(1)), C = fe(_, C, null, c, s), A[e].Kd === void 0 ? (C.Yd = r - 1, A[e] = C) : A[e].Kd[r - 1] = C, h.Gd.he) for (let m of h.Gd.he) m.constructor.hasOwnProperty(e) || (m.constructor[e] = C);
+            return [];
+          }), [];
+        });
+      }, t: function(t, e, r, o, i, c) {
+        var s = de(e, r);
+        i = q(o, i), at([], [t], function(l) {
+          l = l[0];
+          var h = `constructor ${l.name}`;
+          if (l.Gd.Ud === void 0 && (l.Gd.Ud = []), l.Gd.Ud[e - 1] !== void 0) throw new Dt(`Cannot register multiple constructors with identical number of parameters (${e - 1}) for class '${l.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
+          return l.Gd.Ud[e - 1] = () => {
+            zt(`Cannot construct ${l.name} due to unbound types`, s);
+          }, at([], s, function(b) {
+            return b.splice(1, 0, null), l.Gd.Ud[e - 1] = fe(h, b, null, i, c), [];
+          }), [];
+        });
+      }, b: function(t, e, r, o, i, c, s, l) {
+        var h = de(r, o);
+        e = $(e), c = q(i, c), at([], [t], function(b) {
+          function _() {
+            zt(`Cannot call ${A} due to unbound types`, h);
+          }
+          b = b[0];
+          var A = `${b.name}.${e}`;
+          e.startsWith("@@") && (e = Symbol[e.substring(2)]), l && b.Gd.ef.push(e);
+          var C = b.Gd.ae, m = C[e];
+          return m === void 0 || m.Kd === void 0 && m.className !== b.name && m.Yd === r - 2 ? (_.Yd = r - 2, _.className = b.name, C[e] = _) : (Ge(C, e, A), C[e].Kd[r - 2] = _), at([], h, function(S) {
+            return S = fe(A, S, b, c, s), C[e].Kd === void 0 ? (S.Yd = r - 2, C[e] = S) : C[e].Kd[r - 2] = S, [];
+          }), [];
+        });
+      }, o: function(t, e, r) {
+        t = $(t), at([], [e], function(o) {
+          return o = o[0], g[t] = o.fromWireType(r), [];
+        });
+      }, Fb: function(t, e) {
+        e = $(e), pt(t, { name: e, fromWireType: function(r) {
+          var o = tt(r);
+          return Oe(r), o;
+        }, toWireType: function(r, o) {
+          return et(o);
+        }, argPackAdvance: 8, readValueFromPointer: Wt, Od: null });
+      }, j: function(t, e, r, o) {
+        function i() {
+        }
+        r = se(r), e = $(e), i.values = {}, pt(t, { name: e, constructor: i, fromWireType: function(c) {
+          return this.constructor.values[c];
+        }, toWireType: function(c, s) {
+          return s.value;
+        }, argPackAdvance: 8, readValueFromPointer: ln(e, r, o), Od: null }), Le(e, i);
+      }, c: function(t, e, r) {
+        var o = qt(t, "enum");
+        e = $(e), t = o.constructor, o = Object.create(o.constructor.prototype, { value: { value: r }, constructor: { value: De(`${o.name}_${e}`, function() {
+        }) } }), t.values[r] = o, t[e] = o;
+      }, T: function(t, e, r) {
+        r = se(r), e = $(e), pt(t, { name: e, fromWireType: function(o) {
+          return o;
+        }, toWireType: function(o, i) {
+          return i;
+        }, argPackAdvance: 8, readValueFromPointer: fn(e, r), Od: null });
+      }, r: function(t, e, r, o, i, c) {
+        var s = de(e, r);
+        t = $(t), i = q(o, i), Le(t, function() {
+          zt(`Cannot call ${t} due to unbound types`, s);
+        }, e - 1), at([], s, function(l) {
+          return l = [l[0], null].concat(l.slice(1)), br(t, fe(t, l, null, i, c), e - 1), [];
+        });
+      }, x: function(t, e, r, o, i) {
+        e = $(e), i === -1 && (i = 4294967295), i = se(r);
+        var c = (l) => l;
+        if (o === 0) {
+          var s = 32 - 8 * r;
+          c = (l) => l << s >>> s;
+        }
+        r = e.includes("unsigned") ? function(l, h) {
+          return h >>> 0;
+        } : function(l, h) {
+          return h;
+        }, pt(t, { name: e, fromWireType: c, toWireType: r, argPackAdvance: 8, readValueFromPointer: dn(e, i, o !== 0), Od: null });
+      }, n: function(t, e, r) {
+        function o(c) {
+          c >>= 2;
+          var s = O;
+          return new i(s.buffer, s[c + 1], s[c]);
+        }
+        var i = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array][e];
+        r = $(r), pt(t, { name: r, fromWireType: o, argPackAdvance: 8, readValueFromPointer: o }, { af: !0 });
+      }, m: function(t, e, r, o, i, c, s, l, h, b, _, A) {
+        r = $(r), c = q(i, c), l = q(s, l), b = q(h, b), A = q(_, A), at([t], [e], function(C) {
+          return C = C[0], [new yt(r, C.Gd, !1, !1, !0, C, o, c, l, b, A)];
+        });
+      }, S: function(t, e) {
+        e = $(e);
+        var r = e === "std::string";
+        pt(t, { name: e, fromWireType: function(o) {
+          var i = O[o >> 2], c = o + 4;
+          if (r) for (var s = c, l = 0; l <= i; ++l) {
+            var h = c + l;
+            if (l == i || I[h] == 0) {
+              if (s = s ? Ft(I, s, h - s) : "", b === void 0) var b = s;
+              else b += "\0", b += s;
+              s = h + 1;
+            }
+          }
+          else {
+            for (b = Array(i), l = 0; l < i; ++l) b[l] = String.fromCharCode(I[c + l]);
+            b = b.join("");
+          }
+          return bt(o), b;
+        }, toWireType: function(o, i) {
+          i instanceof ArrayBuffer && (i = new Uint8Array(i));
+          var c = typeof i == "string";
+          c || i instanceof Uint8Array || i instanceof Uint8ClampedArray || i instanceof Int8Array || G("Cannot pass non-string to std::string");
+          var s = r && c ? ct(i) : i.length, l = Ae(4 + s + 1), h = l + 4;
+          if (O[l >> 2] = s, r && c) ut(i, I, h, s + 1);
+          else if (c) for (c = 0; c < s; ++c) {
+            var b = i.charCodeAt(c);
+            255 < b && (bt(h), G("String has UTF-16 code units that do not fit in 8 bits")), I[h + c] = b;
+          }
+          else for (c = 0; c < s; ++c) I[h + c] = i[c];
+          return o !== null && o.push(bt, l), l;
+        }, argPackAdvance: 8, readValueFromPointer: Wt, Od: function(o) {
+          bt(o);
+        } });
+      }, K: function(t, e, r) {
+        if (r = $(r), e === 2) var o = hn, i = pn, c = yn, s = () => Rt, l = 1;
+        else e === 4 && (o = mn, i = gn, c = vn, s = () => O, l = 2);
+        pt(t, { name: r, fromWireType: function(h) {
+          for (var b = O[h >> 2], _ = s(), A, C = h + 4, m = 0; m <= b; ++m) {
+            var S = h + 4 + m * e;
+            (m == b || _[S >> l] == 0) && (C = o(C, S - C), A === void 0 ? A = C : (A += "\0", A += C), C = S + e);
+          }
+          return bt(h), A;
+        }, toWireType: function(h, b) {
+          typeof b != "string" && G(`Cannot pass non-string to C++ string type ${r}`);
+          var _ = c(b), A = Ae(4 + _ + e);
+          return O[A >> 2] = _ >> l, i(b, A + 4, _ + e), h !== null && h.push(bt, A), A;
+        }, argPackAdvance: 8, readValueFromPointer: Wt, Od: function(h) {
+          bt(h);
+        } });
+      }, w: function(t, e, r, o, i, c) {
+        ae[t] = { name: $(e), ve: q(r, o), Td: q(i, c), Be: [] };
+      }, e: function(t, e, r, o, i, c, s, l, h, b) {
+        ae[t].Be.push({ Ve: $(e), $e: r, Ye: q(o, i), Ze: c, hf: s, gf: q(l, h), jf: b });
+      }, Hb: function(t, e) {
+        e = $(e), pt(t, { cf: !0, name: e, argPackAdvance: 0, fromWireType: function() {
+        }, toWireType: function() {
+        } });
+      }, Eb: () => !0, tb: () => {
+        throw 1 / 0;
+      }, y: function(t, e, r) {
+        t = tt(t), e = qt(e, "emval::as");
+        var o = [], i = et(o);
+        return O[r >> 2] = i, e.toWireType(o, t);
+      }, Y: function(t, e, r, o, i) {
+        t = pe[t], e = tt(e), r = he(r);
+        var c = [];
+        return O[o >> 2] = et(c), t(e, r, c, i);
+      }, q: function(t, e, r, o) {
+        t = pe[t], e = tt(e), r = he(r), t(e, r, null, o);
+      }, d: Oe, H: function(t) {
+        return t === 0 ? et(Er()) : (t = he(t), et(Er()[t]));
+      }, p: function(t, e) {
+        var r = Pn(t, e), o = r[0];
+        e = o.name + "_$" + r.slice(1).map(function(s) {
+          return s.name;
+        }).join("_") + "$";
+        var i = Cr[e];
+        if (i !== void 0) return i;
+        var c = Array(t - 1);
+        return i = _n((s, l, h, b) => {
+          for (var _ = 0, A = 0; A < t - 1; ++A) c[A] = r[A + 1].readValueFromPointer(b + _), _ += r[A + 1].argPackAdvance;
+          for (s = s[l].apply(s, c), A = 0; A < t - 1; ++A) r[A + 1].Se && r[A + 1].Se(c[A]);
+          if (!o.cf) return o.toWireType(h, s);
+        }), Cr[e] = i;
+      }, s: function(t, e) {
+        return t = tt(t), e = tt(e), et(t[e]);
+      }, l: function(t) {
+        4 < t && (Z.get(t).Fe += 1);
+      }, G: function(t, e, r, o) {
+        t = tt(t);
+        var i = Tr[e];
+        return i || (i = wn(e), Tr[e] = i), i(t, r, o);
+      }, C: function() {
+        return et([]);
+      }, g: function(t) {
+        return et(he(t));
+      }, z: function() {
+        return et({});
+      }, jb: function(t) {
+        return t = tt(t), !t;
+      }, u: function(t) {
+        var e = tt(t);
+        Me(e), Oe(t);
+      }, i: function(t, e, r) {
+        t = tt(t), e = tt(e), r = tt(r), t[e] = r;
+      }, h: function(t, e) {
+        return t = qt(t, "_emval_take_value"), t = t.readValueFromPointer(e), et(t);
+      }, mb: function() {
+        return -52;
+      }, nb: function() {
+      }, a: () => {
+        ke("");
+      }, Db: () => performance.now(), ub: (t) => {
+        var e = I.length;
+        if (t >>>= 0, 2147483648 < t) return !1;
+        for (var r = 1; 4 >= r; r *= 2) {
+          var o = e * (1 + 0.2 / r);
+          o = Math.min(o, t + 100663296);
+          var i = Math;
+          o = Math.max(t, o);
+          t: {
+            i = i.min.call(i, 2147483648, o + (65536 - o % 65536) % 65536) - ie.buffer.byteLength + 65535 >>> 16;
+            try {
+              ie.grow(i), nr();
+              var c = 1;
+              break t;
+            } catch {
+            }
+            c = void 0;
+          }
+          if (c) return !0;
+        }
+        return !1;
+      }, kb: function() {
+        return R ? R.handle : 0;
+      }, vb: (t, e) => {
+        var r = 0;
+        return Rr().forEach(function(o, i) {
+          var c = e + r;
+          for (i = O[t + 4 * i >> 2] = c, c = 0; c < o.length; ++c) ht[i++ >> 0] = o.charCodeAt(c);
+          ht[i >> 0] = 0, r += o.length + 1;
+        }), 0;
+      }, wb: (t, e) => {
+        var r = Rr();
+        O[t >> 2] = r.length;
+        var o = 0;
+        return r.forEach(function(i) {
+          o += i.length + 1;
+        }), O[e >> 2] = o, 0;
+      }, J: () => 52, lb: function() {
+        return 52;
+      }, Bb: () => 52, ob: function() {
+        return 70;
+      }, P: (t, e, r, o) => {
+        for (var i = 0, c = 0; c < r; c++) {
+          var s = O[e >> 2], l = O[e + 4 >> 2];
+          e += 8;
+          for (var h = 0; h < l; h++) {
+            var b = I[s + h], _ = kn[t];
+            b === 0 || b === 10 ? ((t === 1 ? Qr : wt)(Ft(_, 0)), _.length = 0) : _.push(b);
+          }
+          i += l;
+        }
+        return O[o >> 2] = i, 0;
+      }, $: function(t) {
+        p.activeTexture(t);
+      }, aa: function(t, e) {
+        p.attachShader(st[t], lt[e]);
+      }, ba: function(t, e, r) {
+        p.bindAttribLocation(st[t], e, r ? Ft(I, r) : "");
+      }, ca: function(t, e) {
+        t == 35051 ? p.se = e : t == 35052 && (p.Zd = e), p.bindBuffer(t, ye[e]);
+      }, _: function(t, e) {
+        p.bindFramebuffer(t, me[e]);
+      }, ac: function(t, e) {
+        p.bindRenderbuffer(t, Jt[e]);
+      }, Mb: function(t, e) {
+        p.bindSampler(t, xt[e]);
+      }, da: function(t, e) {
+        p.bindTexture(t, rt[e]);
+      }, uc: Ir, xc: Ir, ea: function(t, e, r, o) {
+        p.blendColor(t, e, r, o);
+      }, fa: function(t) {
+        p.blendEquation(t);
+      }, ga: function(t, e) {
+        p.blendFunc(t, e);
+      }, Wb: function(t, e, r, o, i, c, s, l, h, b) {
+        p.blitFramebuffer(t, e, r, o, i, c, s, l, h, b);
+      }, ha: function(t, e, r, o) {
+        2 <= R.version ? r && e ? p.bufferData(t, I, o, r, e) : p.bufferData(t, e, o) : p.bufferData(t, r ? I.subarray(r, r + e) : e, o);
+      }, ia: function(t, e, r, o) {
+        2 <= R.version ? r && p.bufferSubData(t, e, I, o, r) : p.bufferSubData(t, e, I.subarray(o, o + r));
+      }, bc: function(t) {
+        return p.checkFramebufferStatus(t);
+      }, N: function(t) {
+        p.clear(t);
+      }, Z: function(t, e, r, o) {
+        p.clearColor(t, e, r, o);
+      }, O: function(t) {
+        p.clearStencil(t);
+      }, rb: function(t, e, r, o) {
+        return p.clientWaitSync(Mt[t], e, (r >>> 0) + 4294967296 * o);
+      }, ja: function(t, e, r, o) {
+        p.colorMask(!!t, !!e, !!r, !!o);
+      }, ka: function(t) {
+        p.compileShader(lt[t]);
+      }, la: function(t, e, r, o, i, c, s, l) {
+        2 <= R.version ? p.Zd || !s ? p.compressedTexImage2D(t, e, r, o, i, c, s, l) : p.compressedTexImage2D(t, e, r, o, i, c, I, l, s) : p.compressedTexImage2D(t, e, r, o, i, c, l ? I.subarray(l, l + s) : null);
+      }, ma: function(t, e, r, o, i, c, s, l, h) {
+        2 <= R.version ? p.Zd || !l ? p.compressedTexSubImage2D(t, e, r, o, i, c, s, l, h) : p.compressedTexSubImage2D(t, e, r, o, i, c, s, I, h, l) : p.compressedTexSubImage2D(t, e, r, o, i, c, s, h ? I.subarray(h, h + l) : null);
+      }, Ub: function(t, e, r, o, i) {
+        p.copyBufferSubData(t, e, r, o, i);
+      }, na: function(t, e, r, o, i, c, s, l) {
+        p.copyTexSubImage2D(t, e, r, o, i, c, s, l);
+      }, oa: function() {
+        var t = Gt(st), e = p.createProgram();
+        return e.name = t, e.oe = e.me = e.ne = 0, e.xe = 1, st[t] = e, t;
+      }, pa: function(t) {
+        var e = Gt(lt);
+        return lt[e] = p.createShader(t), e;
+      }, qa: function(t) {
+        p.cullFace(t);
+      }, ra: function(t, e) {
+        for (var r = 0; r < t; r++) {
+          var o = E[e + 4 * r >> 2], i = ye[o];
+          i && (p.deleteBuffer(i), i.name = 0, ye[o] = null, o == p.se && (p.se = 0), o == p.Zd && (p.Zd = 0));
+        }
+      }, cc: function(t, e) {
+        for (var r = 0; r < t; ++r) {
+          var o = E[e + 4 * r >> 2], i = me[o];
+          i && (p.deleteFramebuffer(i), i.name = 0, me[o] = null);
+        }
+      }, sa: function(t) {
+        if (t) {
+          var e = st[t];
+          e ? (p.deleteProgram(e), e.name = 0, st[t] = null) : j(1281);
+        }
+      }, dc: function(t, e) {
+        for (var r = 0; r < t; r++) {
+          var o = E[e + 4 * r >> 2], i = Jt[o];
+          i && (p.deleteRenderbuffer(i), i.name = 0, Jt[o] = null);
+        }
+      }, Nb: function(t, e) {
+        for (var r = 0; r < t; r++) {
+          var o = E[e + 4 * r >> 2], i = xt[o];
+          i && (p.deleteSampler(i), i.name = 0, xt[o] = null);
+        }
+      }, ta: function(t) {
+        if (t) {
+          var e = lt[t];
+          e ? (p.deleteShader(e), lt[t] = null) : j(1281);
+        }
+      }, Vb: function(t) {
+        if (t) {
+          var e = Mt[t];
+          e ? (p.deleteSync(e), e.name = 0, Mt[t] = null) : j(1281);
+        }
+      }, ua: function(t, e) {
+        for (var r = 0; r < t; r++) {
+          var o = E[e + 4 * r >> 2], i = rt[o];
+          i && (p.deleteTexture(i), i.name = 0, rt[o] = null);
+        }
+      }, vc: Br, yc: Br, va: function(t) {
+        p.depthMask(!!t);
+      }, wa: function(t) {
+        p.disable(t);
+      }, xa: function(t) {
+        p.disableVertexAttribArray(t);
+      }, ya: function(t, e, r) {
+        p.drawArrays(t, e, r);
+      }, sc: function(t, e, r, o) {
+        p.drawArraysInstanced(t, e, r, o);
+      }, qc: function(t, e, r, o, i) {
+        p.ze.drawArraysInstancedBaseInstanceWEBGL(t, e, r, o, i);
+      }, oc: function(t, e) {
+        for (var r = be[t], o = 0; o < t; o++) r[o] = E[e + 4 * o >> 2];
+        p.drawBuffers(r);
+      }, za: Dr, tc: function(t, e, r, o, i) {
+        p.drawElementsInstanced(t, e, r, o, i);
+      }, rc: function(t, e, r, o, i, c, s) {
+        p.ze.drawElementsInstancedBaseVertexBaseInstanceWEBGL(t, e, r, o, i, c, s);
+      }, ic: function(t, e, r, o, i, c) {
+        Dr(t, o, i, c);
+      }, Aa: function(t) {
+        p.enable(t);
+      }, Ba: function(t) {
+        p.enableVertexAttribArray(t);
+      }, Sb: function(t, e) {
+        return (t = p.fenceSync(t, e)) ? (e = Gt(Mt), t.name = e, Mt[e] = t, e) : 0;
+      }, Ca: function() {
+        p.finish();
+      }, Da: function() {
+        p.flush();
+      }, ec: function(t, e, r, o) {
+        p.framebufferRenderbuffer(t, e, r, Jt[o]);
+      }, fc: function(t, e, r, o, i) {
+        p.framebufferTexture2D(t, e, r, rt[o], i);
+      }, Ea: function(t) {
+        p.frontFace(t);
+      }, Fa: function(t, e) {
+        Lt(t, e, "createBuffer", ye);
+      }, gc: function(t, e) {
+        Lt(t, e, "createFramebuffer", me);
+      }, hc: function(t, e) {
+        Lt(t, e, "createRenderbuffer", Jt);
+      }, Ob: function(t, e) {
+        Lt(t, e, "createSampler", xt);
+      }, Ga: function(t, e) {
+        Lt(t, e, "createTexture", rt);
+      }, wc: Gr, zc: Gr, Yb: function(t) {
+        p.generateMipmap(t);
+      }, Ha: function(t, e, r) {
+        r ? E[r >> 2] = p.getBufferParameter(t, e) : j(1281);
+      }, Ia: function() {
+        var t = p.getError() || ve;
+        return ve = 0, t;
+      }, Ja: function(t, e) {
+        Lr(t, e, 2);
+      }, Zb: function(t, e, r, o) {
+        t = p.getFramebufferAttachmentParameter(t, e, r), (t instanceof WebGLRenderbuffer || t instanceof WebGLTexture) && (t = t.name | 0), E[o >> 2] = t;
+      }, I: function(t, e) {
+        Lr(t, e, 0);
+      }, Ka: function(t, e, r, o) {
+        t = p.getProgramInfoLog(st[t]), t === null && (t = "(unknown error)"), e = 0 < e && o ? ut(t, I, o, e) : 0, r && (E[r >> 2] = e);
+      }, La: function(t, e, r) {
+        if (r) if (t >= Sr) j(1281);
+        else if (t = st[t], e == 35716) t = p.getProgramInfoLog(t), t === null && (t = "(unknown error)"), E[r >> 2] = t.length + 1;
+        else if (e == 35719) {
+          if (!t.oe) for (e = 0; e < p.getProgramParameter(t, 35718); ++e) t.oe = Math.max(t.oe, p.getActiveUniform(t, e).name.length + 1);
+          E[r >> 2] = t.oe;
+        } else if (e == 35722) {
+          if (!t.me) for (e = 0; e < p.getProgramParameter(t, 35721); ++e) t.me = Math.max(t.me, p.getActiveAttrib(t, e).name.length + 1);
+          E[r >> 2] = t.me;
+        } else if (e == 35381) {
+          if (!t.ne) for (e = 0; e < p.getProgramParameter(t, 35382); ++e) t.ne = Math.max(t.ne, p.getActiveUniformBlockName(t, e).length + 1);
+          E[r >> 2] = t.ne;
+        } else E[r >> 2] = p.getProgramParameter(t, e);
+        else j(1281);
+      }, _b: function(t, e, r) {
+        r ? E[r >> 2] = p.getRenderbufferParameter(t, e) : j(1281);
+      }, Ma: function(t, e, r, o) {
+        t = p.getShaderInfoLog(lt[t]), t === null && (t = "(unknown error)"), e = 0 < e && o ? ut(t, I, o, e) : 0, r && (E[r >> 2] = e);
+      }, Jb: function(t, e, r, o) {
+        t = p.getShaderPrecisionFormat(t, e), E[r >> 2] = t.rangeMin, E[r + 4 >> 2] = t.rangeMax, E[o >> 2] = t.precision;
+      }, Na: function(t, e, r) {
+        r ? e == 35716 ? (t = p.getShaderInfoLog(lt[t]), t === null && (t = "(unknown error)"), E[r >> 2] = t ? t.length + 1 : 0) : e == 35720 ? (t = p.getShaderSource(lt[t]), E[r >> 2] = t ? t.length + 1 : 0) : E[r >> 2] = p.getShaderParameter(lt[t], e) : j(1281);
+      }, M: function(t) {
+        var e = Fr[t];
+        if (!e) {
+          switch (t) {
+            case 7939:
+              e = p.getSupportedExtensions() || [], e = e.concat(e.map(function(o) {
+                return "GL_" + o;
+              })), e = Kt(e.join(" "));
+              break;
+            case 7936:
+            case 7937:
+            case 37445:
+            case 37446:
+              (e = p.getParameter(t)) || j(1280), e = e && Kt(e);
+              break;
+            case 7938:
+              e = p.getParameter(7938), e = 2 <= R.version ? "OpenGL ES 3.0 (" + e + ")" : "OpenGL ES 2.0 (" + e + ")", e = Kt(e);
+              break;
+            case 35724:
+              e = p.getParameter(35724);
+              var r = e.match(/^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/);
+              r !== null && (r[1].length == 3 && (r[1] += "0"), e = "OpenGL ES GLSL ES " + r[1] + " (" + e + ")"), e = Kt(e);
+              break;
+            default:
+              j(1280);
+          }
+          Fr[t] = e;
+        }
+        return e;
+      }, ib: function(t, e) {
+        if (2 > R.version) return j(1282), 0;
+        var r = kr[t];
+        if (r) return 0 > e || e >= r.length ? (j(1281), 0) : r[e];
+        switch (t) {
+          case 7939:
+            return r = p.getSupportedExtensions() || [], r = r.concat(r.map(function(o) {
+              return "GL_" + o;
+            })), r = r.map(function(o) {
+              return Kt(o);
+            }), r = kr[t] = r, 0 > e || e >= r.length ? (j(1281), 0) : r[e];
+          default:
+            return j(1280), 0;
+        }
+      }, Oa: function(t, e) {
+        if (e = e ? Ft(I, e) : "", t = st[t]) {
+          var r = t, o = r.fe, i = r.He, c;
+          if (!o) for (r.fe = o = {}, r.Ge = {}, c = 0; c < p.getProgramParameter(r, 35718); ++c) {
+            var s = p.getActiveUniform(r, c), l = s.name;
+            s = s.size;
+            var h = Hr(l);
+            h = 0 < h ? l.slice(0, h) : l;
+            var b = r.xe;
+            for (r.xe += s, i[h] = [s, b], l = 0; l < s; ++l) o[b] = l, r.Ge[b++] = h;
+          }
+          if (r = t.fe, o = 0, i = e, c = Hr(e), 0 < c && (o = parseInt(e.slice(c + 1)) >>> 0, i = e.slice(0, c)), (i = t.He[i]) && o < i[0] && (o += i[1], r[o] = r[o] || p.getUniformLocation(t, e))) return o;
+        } else j(1281);
+        return -1;
+      }, Kb: function(t, e, r) {
+        for (var o = be[e], i = 0; i < e; i++) o[i] = E[r + 4 * i >> 2];
+        p.invalidateFramebuffer(t, o);
+      }, Lb: function(t, e, r, o, i, c, s) {
+        for (var l = be[e], h = 0; h < e; h++) l[h] = E[r + 4 * h >> 2];
+        p.invalidateSubFramebuffer(t, l, o, i, c, s);
+      }, Tb: function(t) {
+        return p.isSync(Mt[t]);
+      }, Pa: function(t) {
+        return (t = rt[t]) ? p.isTexture(t) : 0;
+      }, Qa: function(t) {
+        p.lineWidth(t);
+      }, Ra: function(t) {
+        t = st[t], p.linkProgram(t), t.fe = 0, t.He = {};
+      }, mc: function(t, e, r, o, i, c) {
+        p.De.multiDrawArraysInstancedBaseInstanceWEBGL(t, E, e >> 2, E, r >> 2, E, o >> 2, O, i >> 2, c);
+      }, nc: function(t, e, r, o, i, c, s, l) {
+        p.De.multiDrawElementsInstancedBaseVertexBaseInstanceWEBGL(t, E, e >> 2, r, E, o >> 2, E, i >> 2, E, c >> 2, O, s >> 2, l);
+      }, Sa: function(t, e) {
+        t == 3317 && (xr = e), p.pixelStorei(t, e);
+      }, pc: function(t) {
+        p.readBuffer(t);
+      }, Ta: function(t, e, r, o, i, c, s) {
+        if (2 <= R.version) if (p.se) p.readPixels(t, e, r, o, i, c, s);
+        else {
+          var l = _e(c);
+          p.readPixels(t, e, r, o, i, c, l, s >> 31 - Math.clz32(l.BYTES_PER_ELEMENT));
+        }
+        else (s = $e(c, i, r, o, s)) ? p.readPixels(t, e, r, o, i, c, s) : j(1280);
+      }, $b: function(t, e, r, o) {
+        p.renderbufferStorage(t, e, r, o);
+      }, Xb: function(t, e, r, o, i) {
+        p.renderbufferStorageMultisample(t, e, r, o, i);
+      }, Pb: function(t, e, r) {
+        p.samplerParameterf(xt[t], e, r);
+      }, Qb: function(t, e, r) {
+        p.samplerParameteri(xt[t], e, r);
+      }, Rb: function(t, e, r) {
+        p.samplerParameteri(xt[t], e, E[r >> 2]);
+      }, Ua: function(t, e, r, o) {
+        p.scissor(t, e, r, o);
+      }, Va: function(t, e, r, o) {
+        for (var i = "", c = 0; c < e; ++c) {
+          var s = o ? E[o + 4 * c >> 2] : -1, l = E[r + 4 * c >> 2];
+          s = l ? Ft(I, l, 0 > s ? void 0 : s) : "", i += s;
+        }
+        p.shaderSource(lt[t], i);
+      }, Wa: function(t, e, r) {
+        p.stencilFunc(t, e, r);
+      }, Xa: function(t, e, r, o) {
+        p.stencilFuncSeparate(t, e, r, o);
+      }, Ya: function(t) {
+        p.stencilMask(t);
+      }, Za: function(t, e) {
+        p.stencilMaskSeparate(t, e);
+      }, _a: function(t, e, r) {
+        p.stencilOp(t, e, r);
+      }, $a: function(t, e, r, o) {
+        p.stencilOpSeparate(t, e, r, o);
+      }, ab: function(t, e, r, o, i, c, s, l, h) {
+        if (2 <= R.version) if (p.Zd) p.texImage2D(t, e, r, o, i, c, s, l, h);
+        else if (h) {
+          var b = _e(l);
+          p.texImage2D(t, e, r, o, i, c, s, l, b, h >> 31 - Math.clz32(b.BYTES_PER_ELEMENT));
+        } else p.texImage2D(t, e, r, o, i, c, s, l, null);
+        else p.texImage2D(t, e, r, o, i, c, s, l, h ? $e(l, s, o, i, h) : null);
+      }, bb: function(t, e, r) {
+        p.texParameterf(t, e, r);
+      }, cb: function(t, e, r) {
+        p.texParameterf(t, e, F[r >> 2]);
+      }, db: function(t, e, r) {
+        p.texParameteri(t, e, r);
+      }, eb: function(t, e, r) {
+        p.texParameteri(t, e, E[r >> 2]);
+      }, jc: function(t, e, r, o, i) {
+        p.texStorage2D(t, e, r, o, i);
+      }, fb: function(t, e, r, o, i, c, s, l, h) {
+        if (2 <= R.version) if (p.Zd) p.texSubImage2D(t, e, r, o, i, c, s, l, h);
+        else if (h) {
+          var b = _e(l);
+          p.texSubImage2D(t, e, r, o, i, c, s, l, b, h >> 31 - Math.clz32(b.BYTES_PER_ELEMENT));
+        } else p.texSubImage2D(t, e, r, o, i, c, s, l, null);
+        else b = null, h && (b = $e(l, s, i, c, h)), p.texSubImage2D(t, e, r, o, i, c, s, l, b);
+      }, gb: function(t, e) {
+        p.uniform1f(L(t), e);
+      }, hb: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform1fv(L(t), F, r >> 2, e);
+        else {
+          if (288 >= e) for (var o = Ct[e - 1], i = 0; i < e; ++i) o[i] = F[r + 4 * i >> 2];
+          else o = F.subarray(r >> 2, r + 4 * e >> 2);
+          p.uniform1fv(L(t), o);
+        }
+      }, Uc: function(t, e) {
+        p.uniform1i(L(t), e);
+      }, Vc: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform1iv(L(t), E, r >> 2, e);
+        else {
+          if (288 >= e) for (var o = Xt[e - 1], i = 0; i < e; ++i) o[i] = E[r + 4 * i >> 2];
+          else o = E.subarray(r >> 2, r + 4 * e >> 2);
+          p.uniform1iv(L(t), o);
+        }
+      }, Wc: function(t, e, r) {
+        p.uniform2f(L(t), e, r);
+      }, Xc: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform2fv(L(t), F, r >> 2, 2 * e);
+        else {
+          if (144 >= e) for (var o = Ct[2 * e - 1], i = 0; i < 2 * e; i += 2) o[i] = F[r + 4 * i >> 2], o[i + 1] = F[r + (4 * i + 4) >> 2];
+          else o = F.subarray(r >> 2, r + 8 * e >> 2);
+          p.uniform2fv(L(t), o);
+        }
+      }, Tc: function(t, e, r) {
+        p.uniform2i(L(t), e, r);
+      }, Sc: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform2iv(L(t), E, r >> 2, 2 * e);
+        else {
+          if (144 >= e) for (var o = Xt[2 * e - 1], i = 0; i < 2 * e; i += 2) o[i] = E[r + 4 * i >> 2], o[i + 1] = E[r + (4 * i + 4) >> 2];
+          else o = E.subarray(r >> 2, r + 8 * e >> 2);
+          p.uniform2iv(L(t), o);
+        }
+      }, Rc: function(t, e, r, o) {
+        p.uniform3f(L(t), e, r, o);
+      }, Qc: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform3fv(L(t), F, r >> 2, 3 * e);
+        else {
+          if (96 >= e) for (var o = Ct[3 * e - 1], i = 0; i < 3 * e; i += 3) o[i] = F[r + 4 * i >> 2], o[i + 1] = F[r + (4 * i + 4) >> 2], o[i + 2] = F[r + (4 * i + 8) >> 2];
+          else o = F.subarray(r >> 2, r + 12 * e >> 2);
+          p.uniform3fv(L(t), o);
+        }
+      }, Pc: function(t, e, r, o) {
+        p.uniform3i(L(t), e, r, o);
+      }, Oc: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform3iv(L(t), E, r >> 2, 3 * e);
+        else {
+          if (96 >= e) for (var o = Xt[3 * e - 1], i = 0; i < 3 * e; i += 3) o[i] = E[r + 4 * i >> 2], o[i + 1] = E[r + (4 * i + 4) >> 2], o[i + 2] = E[r + (4 * i + 8) >> 2];
+          else o = E.subarray(r >> 2, r + 12 * e >> 2);
+          p.uniform3iv(L(t), o);
+        }
+      }, Nc: function(t, e, r, o, i) {
+        p.uniform4f(L(t), e, r, o, i);
+      }, Mc: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform4fv(L(t), F, r >> 2, 4 * e);
+        else {
+          if (72 >= e) {
+            var o = Ct[4 * e - 1], i = F;
+            r >>= 2;
+            for (var c = 0; c < 4 * e; c += 4) {
+              var s = r + c;
+              o[c] = i[s], o[c + 1] = i[s + 1], o[c + 2] = i[s + 2], o[c + 3] = i[s + 3];
+            }
+          } else o = F.subarray(r >> 2, r + 16 * e >> 2);
+          p.uniform4fv(L(t), o);
+        }
+      }, Ac: function(t, e, r, o, i) {
+        p.uniform4i(L(t), e, r, o, i);
+      }, Bc: function(t, e, r) {
+        if (2 <= R.version) e && p.uniform4iv(L(t), E, r >> 2, 4 * e);
+        else {
+          if (72 >= e) for (var o = Xt[4 * e - 1], i = 0; i < 4 * e; i += 4) o[i] = E[r + 4 * i >> 2], o[i + 1] = E[r + (4 * i + 4) >> 2], o[i + 2] = E[r + (4 * i + 8) >> 2], o[i + 3] = E[r + (4 * i + 12) >> 2];
+          else o = E.subarray(r >> 2, r + 16 * e >> 2);
+          p.uniform4iv(L(t), o);
+        }
+      }, Cc: function(t, e, r, o) {
+        if (2 <= R.version) e && p.uniformMatrix2fv(L(t), !!r, F, o >> 2, 4 * e);
+        else {
+          if (72 >= e) for (var i = Ct[4 * e - 1], c = 0; c < 4 * e; c += 4) i[c] = F[o + 4 * c >> 2], i[c + 1] = F[o + (4 * c + 4) >> 2], i[c + 2] = F[o + (4 * c + 8) >> 2], i[c + 3] = F[o + (4 * c + 12) >> 2];
+          else i = F.subarray(o >> 2, o + 16 * e >> 2);
+          p.uniformMatrix2fv(L(t), !!r, i);
+        }
+      }, Dc: function(t, e, r, o) {
+        if (2 <= R.version) e && p.uniformMatrix3fv(L(t), !!r, F, o >> 2, 9 * e);
+        else {
+          if (32 >= e) for (var i = Ct[9 * e - 1], c = 0; c < 9 * e; c += 9) i[c] = F[o + 4 * c >> 2], i[c + 1] = F[o + (4 * c + 4) >> 2], i[c + 2] = F[o + (4 * c + 8) >> 2], i[c + 3] = F[o + (4 * c + 12) >> 2], i[c + 4] = F[o + (4 * c + 16) >> 2], i[c + 5] = F[o + (4 * c + 20) >> 2], i[c + 6] = F[o + (4 * c + 24) >> 2], i[c + 7] = F[o + (4 * c + 28) >> 2], i[c + 8] = F[o + (4 * c + 32) >> 2];
+          else i = F.subarray(o >> 2, o + 36 * e >> 2);
+          p.uniformMatrix3fv(L(t), !!r, i);
+        }
+      }, Ec: function(t, e, r, o) {
+        if (2 <= R.version) e && p.uniformMatrix4fv(L(t), !!r, F, o >> 2, 16 * e);
+        else {
+          if (18 >= e) {
+            var i = Ct[16 * e - 1], c = F;
+            o >>= 2;
+            for (var s = 0; s < 16 * e; s += 16) {
+              var l = o + s;
+              i[s] = c[l], i[s + 1] = c[l + 1], i[s + 2] = c[l + 2], i[s + 3] = c[l + 3], i[s + 4] = c[l + 4], i[s + 5] = c[l + 5], i[s + 6] = c[l + 6], i[s + 7] = c[l + 7], i[s + 8] = c[l + 8], i[s + 9] = c[l + 9], i[s + 10] = c[l + 10], i[s + 11] = c[l + 11], i[s + 12] = c[l + 12], i[s + 13] = c[l + 13], i[s + 14] = c[l + 14], i[s + 15] = c[l + 15];
+            }
+          } else i = F.subarray(o >> 2, o + 64 * e >> 2);
+          p.uniformMatrix4fv(L(t), !!r, i);
+        }
+      }, Fc: function(t) {
+        t = st[t], p.useProgram(t), p.Re = t;
+      }, Gc: function(t, e) {
+        p.vertexAttrib1f(t, e);
+      }, Hc: function(t, e) {
+        p.vertexAttrib2f(t, F[e >> 2], F[e + 4 >> 2]);
+      }, Ic: function(t, e) {
+        p.vertexAttrib3f(t, F[e >> 2], F[e + 4 >> 2], F[e + 8 >> 2]);
+      }, Jc: function(t, e) {
+        p.vertexAttrib4f(t, F[e >> 2], F[e + 4 >> 2], F[e + 8 >> 2], F[e + 12 >> 2]);
+      }, kc: function(t, e) {
+        p.vertexAttribDivisor(t, e);
+      }, lc: function(t, e, r, o, i) {
+        p.vertexAttribIPointer(t, e, r, o, i);
+      }, Kc: function(t, e, r, o, i, c) {
+        p.vertexAttribPointer(t, e, r, !!o, i, c);
+      }, Lc: function(t, e, r, o) {
+        p.viewport(t, e, r, o);
+      }, qb: function(t, e, r, o) {
+        p.waitSync(Mt[t], e, (r >>> 0) + 4294967296 * o);
+      }, W: On, F: Gn, E: jn, X: Ln, Ib: Vn, V: Wn, U: Nn, A: $n, B: Un, D: Hn, L: Dn, sb: (t, e, r, o) => Mn(t, e, r, o) };
+      (function() {
+        function t(r) {
+          if (D = r = r.exports, ie = D.Yc, nr(), K = D._c, ir.unshift(D.Zc), St--, g.monitorRunDependencies && g.monitorRunDependencies(St), St == 0 && Ut) {
+            var o = Ut;
+            Ut = null, o();
+          }
+          return r;
+        }
+        var e = { a: Bn };
+        if (St++, g.monitorRunDependencies && g.monitorRunDependencies(St), g.instantiateWasm) try {
+          return g.instantiateWasm(e, t);
+        } catch (r) {
+          wt("Module.instantiateWasm callback failed with error: " + r), re(r);
+        }
+        return en(e, function(r) {
+          t(r.instance);
+        }).catch(re), {};
+      })();
+      var bt = g._free = (t) => (bt = g._free = D.$c)(t), Ae = g._malloc = (t) => (Ae = g._malloc = D.ad)(t), Wr = (t) => (Wr = D.bd)(t);
+      g.__embind_initialize_bindings = () => (g.__embind_initialize_bindings = D.cd)();
+      var nt = (t, e) => (nt = D.dd)(t, e), ot = () => (ot = D.ed)(), it = (t) => (it = D.fd)(t);
+      g.dynCall_viji = (t, e, r, o, i) => (g.dynCall_viji = D.gd)(t, e, r, o, i), g.dynCall_vijiii = (t, e, r, o, i, c, s) => (g.dynCall_vijiii = D.hd)(t, e, r, o, i, c, s), g.dynCall_viiiiij = (t, e, r, o, i, c, s, l) => (g.dynCall_viiiiij = D.id)(t, e, r, o, i, c, s, l), g.dynCall_jii = (t, e, r) => (g.dynCall_jii = D.jd)(t, e, r), g.dynCall_vij = (t, e, r, o) => (g.dynCall_vij = D.kd)(t, e, r, o), g.dynCall_iiij = (t, e, r, o, i) => (g.dynCall_iiij = D.ld)(t, e, r, o, i), g.dynCall_iiiij = (t, e, r, o, i, c) => (g.dynCall_iiiij = D.md)(t, e, r, o, i, c), g.dynCall_viij = (t, e, r, o, i) => (g.dynCall_viij = D.nd)(t, e, r, o, i), g.dynCall_viiij = (t, e, r, o, i, c) => (g.dynCall_viiij = D.od)(t, e, r, o, i, c), g.dynCall_ji = (t, e) => (g.dynCall_ji = D.pd)(t, e), g.dynCall_iij = (t, e, r, o) => (g.dynCall_iij = D.qd)(t, e, r, o), g.dynCall_jiiiiii = (t, e, r, o, i, c, s) => (g.dynCall_jiiiiii = D.rd)(t, e, r, o, i, c, s), g.dynCall_jiiiiji = (t, e, r, o, i, c, s, l) => (g.dynCall_jiiiiji = D.sd)(t, e, r, o, i, c, s, l), g.dynCall_iijj = (t, e, r, o, i, c) => (g.dynCall_iijj = D.td)(t, e, r, o, i, c), g.dynCall_iiiji = (t, e, r, o, i, c) => (g.dynCall_iiiji = D.ud)(t, e, r, o, i, c), g.dynCall_iiji = (t, e, r, o, i) => (g.dynCall_iiji = D.vd)(t, e, r, o, i), g.dynCall_iijjiii = (t, e, r, o, i, c, s, l, h) => (g.dynCall_iijjiii = D.wd)(t, e, r, o, i, c, s, l, h), g.dynCall_vijjjii = (t, e, r, o, i, c, s, l, h, b) => (g.dynCall_vijjjii = D.xd)(t, e, r, o, i, c, s, l, h, b), g.dynCall_jiji = (t, e, r, o, i) => (g.dynCall_jiji = D.yd)(t, e, r, o, i), g.dynCall_viijii = (t, e, r, o, i, c, s) => (g.dynCall_viijii = D.zd)(t, e, r, o, i, c, s), g.dynCall_iiiiij = (t, e, r, o, i, c, s) => (g.dynCall_iiiiij = D.Ad)(t, e, r, o, i, c, s), g.dynCall_iiiiijj = (t, e, r, o, i, c, s, l, h) => (g.dynCall_iiiiijj = D.Bd)(t, e, r, o, i, c, s, l, h), g.dynCall_iiiiiijj = (t, e, r, o, i, c, s, l, h, b) => (g.dynCall_iiiiiijj = D.Cd)(t, e, r, o, i, c, s, l, h, b);
+      function Dn(t, e, r, o, i) {
+        var c = ot();
+        try {
+          K.get(t)(e, r, o, i);
+        } catch (s) {
+          if (it(c), s !== s + 0) throw s;
+          nt(1, 0);
+        }
+      }
+      function Gn(t, e, r) {
+        var o = ot();
+        try {
+          return K.get(t)(e, r);
+        } catch (i) {
+          if (it(o), i !== i + 0) throw i;
+          nt(1, 0);
+        }
+      }
+      function Ln(t, e, r, o, i) {
+        var c = ot();
+        try {
+          return K.get(t)(e, r, o, i);
+        } catch (s) {
+          if (it(c), s !== s + 0) throw s;
+          nt(1, 0);
+        }
+      }
+      function Hn(t, e, r, o) {
+        var i = ot();
+        try {
+          K.get(t)(e, r, o);
+        } catch (c) {
+          if (it(i), c !== c + 0) throw c;
+          nt(1, 0);
+        }
+      }
+      function On(t, e) {
+        var r = ot();
+        try {
+          return K.get(t)(e);
+        } catch (o) {
+          if (it(r), o !== o + 0) throw o;
+          nt(1, 0);
+        }
+      }
+      function jn(t, e, r, o) {
+        var i = ot();
+        try {
+          return K.get(t)(e, r, o);
+        } catch (c) {
+          if (it(i), c !== c + 0) throw c;
+          nt(1, 0);
+        }
+      }
+      function Un(t, e, r) {
+        var o = ot();
+        try {
+          K.get(t)(e, r);
+        } catch (i) {
+          if (it(o), i !== i + 0) throw i;
+          nt(1, 0);
+        }
+      }
+      function Wn(t, e, r, o, i, c, s, l, h, b) {
+        var _ = ot();
+        try {
+          return K.get(t)(e, r, o, i, c, s, l, h, b);
+        } catch (A) {
+          if (it(_), A !== A + 0) throw A;
+          nt(1, 0);
+        }
+      }
+      function $n(t, e) {
+        var r = ot();
+        try {
+          K.get(t)(e);
+        } catch (o) {
+          if (it(r), o !== o + 0) throw o;
+          nt(1, 0);
+        }
+      }
+      function Vn(t, e, r, o, i, c, s) {
+        var l = ot();
+        try {
+          return K.get(t)(e, r, o, i, c, s);
+        } catch (h) {
+          if (it(l), h !== h + 0) throw h;
+          nt(1, 0);
+        }
+      }
+      function Nn(t) {
+        var e = ot();
+        try {
+          K.get(t)();
+        } catch (r) {
+          if (it(e), r !== r + 0) throw r;
+          nt(1, 0);
+        }
+      }
+      var Ee;
+      Ut = function t() {
+        Ee || $r(), Ee || (Ut = t);
+      };
+      function $r() {
+        function t() {
+          if (!Ee && (Ee = !0, g.calledRun = !0, !er)) {
+            if (xe(ir), Ke(g), g.onRuntimeInitialized && g.onRuntimeInitialized(), g.postRun) for (typeof g.postRun == "function" && (g.postRun = [g.postRun]); g.postRun.length; ) {
+              var e = g.postRun.shift();
+              ar.unshift(e);
+            }
+            xe(ar);
+          }
+        }
+        if (!(0 < St)) {
+          if (g.preRun) for (typeof g.preRun == "function" && (g.preRun = [g.preRun]); g.preRun.length; ) Zr();
+          xe(or), 0 < St || (g.setStatus ? (g.setStatus("Running..."), setTimeout(function() {
+            setTimeout(function() {
+              g.setStatus("");
+            }, 1), t();
+          }, 1)) : t());
+        }
+      }
+      if (g.preInit) for (typeof g.preInit == "function" && (g.preInit = [g.preInit]); 0 < g.preInit.length; ) g.preInit.pop()();
+      return $r(), Je.ready;
+    };
+  })();
+  typeof Pt == "object" && typeof vt == "object" ? vt.exports = te : typeof define == "function" && define.amd && define([], () => te);
+});
+const Jn = qn();
+export {
+  Jn as default
+};