lecodes-web-host 2.0.0

package/dist/chunks/creator-2d-D13oxDsX.js

@@ -0,0 +1,2807 @@
+async function createCreatorWeb(moduleArg = {}) {
+  var Module = moduleArg;
+  var thisProgram = "./this.program";
+  var _scriptName = import.meta.url;
+  var scriptDirectory = "";
+  function locateFile(path) {
+    if (Module["locateFile"]) {
+      return Module["locateFile"](path, scriptDirectory);
+    }
+    return scriptDirectory + path;
+  }
+  var readAsync;
+  {
+    try {
+      scriptDirectory = new URL(".", _scriptName).href;
+    } catch {
+    }
+    {
+      readAsync = async (url) => {
+        var response = await fetch(url, { credentials: "same-origin" });
+        if (response.ok) {
+          return response.arrayBuffer();
+        }
+        throw new Error(response.status + " : " + response.url);
+      };
+    }
+  }
+  var out = console.log.bind(console);
+  var err = console.error.bind(console);
+  var wasmBinary;
+  var ABORT = false;
+  class EmscriptenEH {
+  }
+  function updateMemoryViews() {
+    var b = wasmMemory.buffer;
+    HEAP8 = new Int8Array(b);
+    HEAP16 = new Int16Array(b);
+    Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+    Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
+    Module["HEAP32"] = HEAP32 = new Int32Array(b);
+    Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+    Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
+    Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
+    HEAP64 = new BigInt64Array(b);
+    new BigUint64Array(b);
+  }
+  function preRun() {
+    if (Module["preRun"]) {
+      if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+      while (Module["preRun"].length) {
+        addOnPreRun(Module["preRun"].shift());
+      }
+    }
+    callRuntimeCallbacks(onPreRuns);
+  }
+  function initRuntime() {
+    wasmExports["te"]();
+  }
+  function postRun() {
+    if (Module["postRun"]) {
+      if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+      while (Module["postRun"].length) {
+        addOnPostRun(Module["postRun"].shift());
+      }
+    }
+    callRuntimeCallbacks(onPostRuns);
+  }
+  function abort(what) {
+    Module["onAbort"]?.(what);
+    what = `Aborted(${what})`;
+    err(what);
+    ABORT = true;
+    what += ". Build with -sASSERTIONS for more info.";
+    var e = new WebAssembly.RuntimeError(what);
+    throw e;
+  }
+  var wasmBinaryFile;
+  function findWasmBinary() {
+    if (Module["locateFile"]) {
+      return locateFile("creator-2d.wasm");
+    }
+    return new URL("" + new URL("../assets/creator-2d-ukvEmNEp.wasm", import.meta.url).href, import.meta.url).href;
+  }
+  function getBinarySync(file) {
+    if (file == wasmBinaryFile && wasmBinary) {
+      return new Uint8Array(wasmBinary);
+    }
+    throw "both async and sync fetching of the wasm failed";
+  }
+  async function getWasmBinary(binaryFile) {
+    if (!wasmBinary) {
+      try {
+        var response = await readAsync(binaryFile);
+        return new Uint8Array(response);
+      } catch {
+      }
+    }
+    return getBinarySync(binaryFile);
+  }
+  async function instantiateArrayBuffer(binaryFile, imports) {
+    try {
+      var binary = await getWasmBinary(binaryFile);
+      var instance = await WebAssembly.instantiate(binary, imports);
+      return instance;
+    } catch (reason) {
+      err(`failed to asynchronously prepare wasm: ${reason}`);
+      abort(reason);
+    }
+  }
+  async function instantiateAsync(binary, binaryFile, imports) {
+    if (!binary) {
+      try {
+        var response = fetch(binaryFile, { credentials: "same-origin" });
+        var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
+        return instantiationResult;
+      } catch (reason) {
+        err(`wasm streaming compile failed: ${reason}`);
+        err("falling back to ArrayBuffer instantiation");
+      }
+    }
+    return instantiateArrayBuffer(binaryFile, imports);
+  }
+  function getWasmImports() {
+    var imports = { a: wasmImports };
+    return imports;
+  }
+  async function createWasm() {
+    function receiveInstance(instance, module) {
+      wasmExports = instance.exports;
+      assignWasmExports(wasmExports);
+      updateMemoryViews();
+      return wasmExports;
+    }
+    function receiveInstantiationResult(result2) {
+      return receiveInstance(result2["instance"]);
+    }
+    var info = getWasmImports();
+    if (Module["instantiateWasm"]) {
+      return new Promise((resolve, reject) => {
+        Module["instantiateWasm"](info, (inst, mod) => {
+          resolve(receiveInstance(inst));
+        });
+      });
+    }
+    wasmBinaryFile ??= findWasmBinary();
+    var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+    var exports = receiveInstantiationResult(result);
+    return exports;
+  }
+  var HEAP16;
+  var HEAP32;
+  var HEAP64;
+  var HEAP8;
+  var HEAPF32;
+  var HEAPF64;
+  var HEAPU16;
+  var HEAPU32;
+  var HEAPU8;
+  var callRuntimeCallbacks = (callbacks) => {
+    while (callbacks.length > 0) {
+      callbacks.shift()(Module);
+    }
+  };
+  var onPostRuns = [];
+  var addOnPostRun = (cb) => onPostRuns.push(cb);
+  var onPreRuns = [];
+  var addOnPreRun = (cb) => onPreRuns.push(cb);
+  var stackRestore = (val) => __emscripten_stack_restore(val);
+  var stackSave = () => _emscripten_stack_get_current();
+  var exceptionCaught = [];
+  var ___cxa_begin_catch = (ptr) => {
+    var info = new ExceptionInfo(ptr);
+    if (!info.get_caught()) {
+      info.set_caught(true);
+    }
+    info.set_rethrown(false);
+    exceptionCaught.push(info);
+    return ___cxa_get_exception_ptr(ptr);
+  };
+  var ___cxa_end_catch = () => {
+    _setThrew(0, 0);
+    var info = exceptionCaught.pop();
+    ___cxa_decrement_exception_refcount(info.excPtr);
+  };
+  var findMatchingCatch = (args) => {
+    setTempRet0(0);
+    return 0;
+  };
+  var ___cxa_find_matching_catch_2 = () => findMatchingCatch();
+  var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch();
+  var ___cxa_rethrow = () => {
+    if (!exceptionCaught.length) {
+      abort("no exception to throw");
+    }
+    var info = exceptionCaught.at(-1);
+    info.excPtr;
+    info.set_rethrown(true);
+    info.set_caught(false);
+    abort();
+  };
+  class ExceptionInfo {
+    constructor(excPtr) {
+      this.excPtr = excPtr;
+      this.ptr = excPtr - 24;
+    }
+    set_type(type) {
+      HEAPU32[this.ptr + 4 >> 2] = type;
+    }
+    get_type() {
+      return HEAPU32[this.ptr + 4 >> 2];
+    }
+    set_destructor(destructor) {
+      HEAPU32[this.ptr + 8 >> 2] = destructor;
+    }
+    get_destructor() {
+      return HEAPU32[this.ptr + 8 >> 2];
+    }
+    set_caught(caught) {
+      caught = caught ? 1 : 0;
+      HEAP8[this.ptr + 12] = caught;
+    }
+    get_caught() {
+      return HEAP8[this.ptr + 12] != 0;
+    }
+    set_rethrown(rethrown) {
+      rethrown = rethrown ? 1 : 0;
+      HEAP8[this.ptr + 13] = rethrown;
+    }
+    get_rethrown() {
+      return HEAP8[this.ptr + 13] != 0;
+    }
+    init(type, destructor) {
+      this.set_adjusted_ptr(0);
+      this.set_type(type);
+      this.set_destructor(destructor);
+    }
+    set_adjusted_ptr(adjustedPtr) {
+      HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
+    }
+    get_adjusted_ptr() {
+      return HEAPU32[this.ptr + 16 >> 2];
+    }
+  }
+  var ___cxa_throw = (ptr, type, destructor) => {
+    var info = new ExceptionInfo(ptr);
+    info.init(type, destructor);
+    abort();
+  };
+  var ___resumeException = (ptr) => {
+    abort();
+  };
+  var __abort_js = () => abort("");
+  var _emscripten_get_now = () => performance.now();
+  var _emscripten_date_now = () => Date.now();
+  var checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
+  function _clock_time_get(clk_id, ignored_precision, ptime) {
+    if (!checkWasiClock(clk_id)) {
+      return 28;
+    }
+    var now;
+    if (clk_id === 0) {
+      now = _emscripten_date_now();
+    } else {
+      now = _emscripten_get_now();
+    }
+    var nsec = Math.round(now * 1e3 * 1e3);
+    HEAP64[ptime >> 3] = BigInt(nsec);
+    return 0;
+  }
+  var readEmAsmArgsArray = [];
+  var readEmAsmArgs = (sigPtr, buf) => {
+    readEmAsmArgsArray.length = 0;
+    var ch;
+    while (ch = HEAPU8[sigPtr++]) {
+      var wide = ch != 105;
+      wide &= ch != 112;
+      buf += wide && buf % 8 ? 4 : 0;
+      readEmAsmArgsArray.push(ch == 112 ? HEAPU32[buf >> 2] : ch == 106 ? HEAP64[buf >> 3] : ch == 105 ? HEAP32[buf >> 2] : HEAPF64[buf >> 3]);
+      buf += wide ? 8 : 4;
+    }
+    return readEmAsmArgsArray;
+  };
+  var runEmAsmFunction = (code, sigPtr, argbuf) => {
+    var args = readEmAsmArgs(sigPtr, argbuf);
+    return ASM_CONSTS[code](...args);
+  };
+  var _emscripten_asm_const_int = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf);
+  var getHeapMax = () => 2147483648;
+  var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+  var growMemory = (size) => {
+    var oldHeapSize = wasmMemory.buffer.byteLength;
+    var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+    try {
+      wasmMemory.grow(pages);
+      updateMemoryViews();
+      return 1;
+    } catch (e) {
+    }
+  };
+  var _emscripten_resize_heap = (requestedSize) => {
+    var oldSize = HEAPU8.length;
+    requestedSize >>>= 0;
+    var maxHeapSize = getHeapMax();
+    if (requestedSize > maxHeapSize) {
+      return false;
+    }
+    for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+      var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+      overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+      var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+      var replacement = growMemory(newSize);
+      if (replacement) {
+        return true;
+      }
+    }
+    return false;
+  };
+  var GLctx;
+  var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance = (ctx) => !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"));
+  var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance = (ctx) => !!(ctx.mdibvbi = ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));
+  var webgl_enable_EXT_polygon_offset_clamp = (ctx) => !!(ctx.extPolygonOffsetClamp = ctx.getExtension("EXT_polygon_offset_clamp"));
+  var webgl_enable_EXT_clip_control = (ctx) => !!(ctx.extClipControl = ctx.getExtension("EXT_clip_control"));
+  var webgl_enable_WEBGL_polygon_mode = (ctx) => !!(ctx.webglPolygonMode = ctx.getExtension("WEBGL_polygon_mode"));
+  var webgl_enable_WEBGL_multi_draw = (ctx) => !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw"));
+  var getEmscriptenSupportedExtensions = (ctx) => {
+    var supportedExtensions = ["EXT_color_buffer_float", "EXT_conservative_depth", "EXT_disjoint_timer_query_webgl2", "EXT_texture_norm16", "NV_shader_noperspective_interpolation", "WEBGL_clip_cull_distance", "EXT_clip_control", "EXT_color_buffer_half_float", "EXT_depth_clamp", "EXT_float_blend", "EXT_polygon_offset_clamp", "EXT_texture_compression_bptc", "EXT_texture_compression_rgtc", "EXT_texture_filter_anisotropic", "KHR_parallel_shader_compile", "OES_texture_float_linear", "WEBGL_blend_func_extended", "WEBGL_compressed_texture_astc", "WEBGL_compressed_texture_etc", "WEBGL_compressed_texture_etc1", "WEBGL_compressed_texture_s3tc", "WEBGL_compressed_texture_s3tc_srgb", "WEBGL_debug_renderer_info", "WEBGL_debug_shaders", "WEBGL_lose_context", "WEBGL_multi_draw", "WEBGL_polygon_mode"];
+    return ctx.getSupportedExtensions()?.filter((ext) => supportedExtensions.includes(ext)) ?? [];
+  };
+  var registerPreMainLoop = (f) => {
+    typeof MainLoop != "undefined" && MainLoop.preMainLoop.push(f);
+  };
+  var webglBufferSubData = (target, offset, size, data, src = HEAPU8) => {
+    {
+      size && GLctx.bufferSubData(target, offset, src, data, size);
+      return;
+    }
+  };
+  var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
+  var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+    var maxIdx = idx + maxBytesToRead;
+    if (ignoreNul) return maxIdx;
+    while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
+    return idx;
+  };
+  var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
+    var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+    }
+    var str = "";
+    while (idx < endPtr) {
+      var u0 = heapOrArray[idx++];
+      if (!(u0 & 128)) {
+        str += String.fromCharCode(u0);
+        continue;
+      }
+      var u1 = heapOrArray[idx++] & 63;
+      if ((u0 & 224) == 192) {
+        str += String.fromCharCode((u0 & 31) << 6 | u1);
+        continue;
+      }
+      var u2 = heapOrArray[idx++] & 63;
+      if ((u0 & 240) == 224) {
+        u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+      } else {
+        u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
+      }
+      if (u0 < 65536) {
+        str += String.fromCharCode(u0);
+      } else {
+        var ch = u0 - 65536;
+        str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+      }
+    }
+    return str;
+  };
+  var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
+  var GL = { counter: 1, buffers: [], mappedBuffers: {}, programs: [], framebuffers: [], renderbuffers: [], textures: [], shaders: [], vaos: [], contexts: [], offscreenCanvases: {}, queries: [], samplers: [], transformFeedbacks: [], syncs: [], byteSizeByTypeRoot: 5120, byteSizeByType: [1, 1, 2, 2, 4, 4, 4, 2, 3, 4, 8], stringCache: {}, stringiCache: {}, unpackAlignment: 4, unpackRowLength: 0, recordError: (errorCode) => {
+    if (!GL.lastError) {
+      GL.lastError = errorCode;
+    }
+  }, getNewId: (table) => {
+    var ret = GL.counter++;
+    for (var i = table.length; i < ret; i++) {
+      table[i] = null;
+    }
+    while (table[ret]) {
+      ret = GL.counter++;
+    }
+    return ret;
+  }, genObject: (n, buffers, createFunction, objectTable) => {
+    for (var i = 0; i < n; i++) {
+      var buffer = GLctx[createFunction]();
+      var id = buffer && GL.getNewId(objectTable);
+      if (buffer) {
+        buffer.name = id;
+        objectTable[id] = buffer;
+      } else {
+        GL.recordError(1282);
+      }
+      HEAP32[buffers + i * 4 >> 2] = id;
+    }
+  }, MAX_TEMP_BUFFER_SIZE: 2097152, numTempVertexBuffersPerSize: 64, log2ceilLookup: (i) => 32 - Math.clz32(i === 0 ? 0 : i - 1), generateTempBuffers: (quads, context) => {
+    var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);
+    context.tempVertexBufferCounters1 = [];
+    context.tempVertexBufferCounters2 = [];
+    context.tempVertexBufferCounters1.length = context.tempVertexBufferCounters2.length = largestIndex + 1;
+    context.tempVertexBuffers1 = [];
+    context.tempVertexBuffers2 = [];
+    context.tempVertexBuffers1.length = context.tempVertexBuffers2.length = largestIndex + 1;
+    context.tempIndexBuffers = [];
+    context.tempIndexBuffers.length = largestIndex + 1;
+    for (var i = 0; i <= largestIndex; ++i) {
+      context.tempIndexBuffers[i] = null;
+      context.tempVertexBufferCounters1[i] = context.tempVertexBufferCounters2[i] = 0;
+      var ringbufferLength = GL.numTempVertexBuffersPerSize;
+      context.tempVertexBuffers1[i] = [];
+      context.tempVertexBuffers2[i] = [];
+      var ringbuffer1 = context.tempVertexBuffers1[i];
+      var ringbuffer2 = context.tempVertexBuffers2[i];
+      ringbuffer1.length = ringbuffer2.length = ringbufferLength;
+      for (var j = 0; j < ringbufferLength; ++j) {
+        ringbuffer1[j] = ringbuffer2[j] = null;
+      }
+    }
+    if (quads) {
+      context.tempQuadIndexBuffer = GLctx.createBuffer();
+      context.GLctx.bindBuffer(34963, context.tempQuadIndexBuffer);
+      var numIndexes = GL.MAX_TEMP_BUFFER_SIZE >> 1;
+      var quadIndexes = new Uint16Array(numIndexes);
+      var i = 0, v = 0;
+      while (1) {
+        quadIndexes[i++] = v;
+        if (i >= numIndexes) break;
+        quadIndexes[i++] = v + 1;
+        if (i >= numIndexes) break;
+        quadIndexes[i++] = v + 2;
+        if (i >= numIndexes) break;
+        quadIndexes[i++] = v;
+        if (i >= numIndexes) break;
+        quadIndexes[i++] = v + 2;
+        if (i >= numIndexes) break;
+        quadIndexes[i++] = v + 3;
+        if (i >= numIndexes) break;
+        v += 4;
+      }
+      context.GLctx.bufferData(34963, quadIndexes, 35044);
+      context.GLctx.bindBuffer(34963, null);
+    }
+  }, getTempVertexBuffer: (sizeBytes) => {
+    var idx = GL.log2ceilLookup(sizeBytes);
+    var ringbuffer = GL.currentContext.tempVertexBuffers1[idx];
+    var nextFreeBufferIndex = GL.currentContext.tempVertexBufferCounters1[idx];
+    GL.currentContext.tempVertexBufferCounters1[idx] = GL.currentContext.tempVertexBufferCounters1[idx] + 1 & GL.numTempVertexBuffersPerSize - 1;
+    var vbo = ringbuffer[nextFreeBufferIndex];
+    if (vbo) {
+      return vbo;
+    }
+    var prevVBO = GLctx.getParameter(34964);
+    ringbuffer[nextFreeBufferIndex] = GLctx.createBuffer();
+    GLctx.bindBuffer(34962, ringbuffer[nextFreeBufferIndex]);
+    GLctx.bufferData(34962, 1 << idx, 35048);
+    GLctx.bindBuffer(34962, prevVBO);
+    return ringbuffer[nextFreeBufferIndex];
+  }, getTempIndexBuffer: (sizeBytes) => {
+    var idx = GL.log2ceilLookup(sizeBytes);
+    var ibo = GL.currentContext.tempIndexBuffers[idx];
+    if (ibo) {
+      return ibo;
+    }
+    var prevIBO = GLctx.getParameter(34965);
+    GL.currentContext.tempIndexBuffers[idx] = GLctx.createBuffer();
+    GLctx.bindBuffer(34963, GL.currentContext.tempIndexBuffers[idx]);
+    GLctx.bufferData(34963, 1 << idx, 35048);
+    GLctx.bindBuffer(34963, prevIBO);
+    return GL.currentContext.tempIndexBuffers[idx];
+  }, newRenderingFrameStarted: () => {
+    if (!GL.currentContext) {
+      return;
+    }
+    var vb = GL.currentContext.tempVertexBuffers1;
+    GL.currentContext.tempVertexBuffers1 = GL.currentContext.tempVertexBuffers2;
+    GL.currentContext.tempVertexBuffers2 = vb;
+    vb = GL.currentContext.tempVertexBufferCounters1;
+    GL.currentContext.tempVertexBufferCounters1 = GL.currentContext.tempVertexBufferCounters2;
+    GL.currentContext.tempVertexBufferCounters2 = vb;
+    var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);
+    for (var i = 0; i <= largestIndex; ++i) {
+      GL.currentContext.tempVertexBufferCounters1[i] = 0;
+    }
+  }, getSource: (shader, count, string, length) => {
+    var source = "";
+    for (var i = 0; i < count; ++i) {
+      var len = length ? HEAPU32[length + i * 4 >> 2] : void 0;
+      source += UTF8ToString(HEAPU32[string + i * 4 >> 2], len);
+    }
+    return source;
+  }, calcBufLength: (size, type, stride, count) => {
+    if (stride > 0) {
+      return count * stride;
+    }
+    var typeSize = GL.byteSizeByType[type - GL.byteSizeByTypeRoot];
+    return size * typeSize * count;
+  }, usedTempBuffers: [], preDrawHandleClientVertexAttribBindings: (count) => {
+    GL.resetBufferBinding = false;
+    for (var i = 0; i < GL.currentContext.maxVertexAttribs; ++i) {
+      var cb = GL.currentContext.clientBuffers[i];
+      if (!cb.clientside || !cb.enabled) continue;
+      GL.resetBufferBinding = true;
+      var size = GL.calcBufLength(cb.size, cb.type, cb.stride, count);
+      var buf = GL.getTempVertexBuffer(size);
+      GLctx.bindBuffer(34962, buf);
+      webglBufferSubData(34962, 0, size, cb.ptr);
+      cb.vertexAttribPointerAdaptor.call(GLctx, i, cb.size, cb.type, cb.normalized, cb.stride, 0);
+    }
+  }, postDrawHandleClientVertexAttribBindings: () => {
+    if (GL.resetBufferBinding) {
+      GLctx.bindBuffer(34962, GL.buffers[GLctx.currentArrayBufferBinding]);
+    }
+  }, createContext: (canvas, webGLContextAttributes) => {
+    if (!canvas.getContextSafariWebGL2Fixed) {
+      let fixedGetContext = function(ver, attrs) {
+        var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
+        return ver == "webgl" == gl instanceof WebGLRenderingContext ? gl : null;
+      };
+      canvas.getContextSafariWebGL2Fixed = canvas.getContext;
+      canvas.getContext = fixedGetContext;
+    }
+    var ctx = canvas.getContext("webgl2", webGLContextAttributes);
+    if (!ctx) return 0;
+    var handle = GL.registerContext(ctx, webGLContextAttributes);
+    return handle;
+  }, registerContext: (ctx, webGLContextAttributes) => {
+    var handle = GL.getNewId(GL.contexts);
+    var context = { handle, attributes: webGLContextAttributes, version: webGLContextAttributes.majorVersion, GLctx: ctx };
+    if (ctx.canvas) ctx.canvas.GLctxObject = context;
+    GL.contexts[handle] = context;
+    if (typeof webGLContextAttributes.enableExtensionsByDefault == "undefined" || webGLContextAttributes.enableExtensionsByDefault) {
+      GL.initExtensions(context);
+    }
+    context.maxVertexAttribs = context.GLctx.getParameter(34921);
+    context.clientBuffers = [];
+    for (var i = 0; i < context.maxVertexAttribs; i++) {
+      context.clientBuffers[i] = { enabled: false, clientside: false, size: 0, type: 0, normalized: 0, stride: 0, ptr: 0, vertexAttribPointerAdaptor: null };
+    }
+    GL.generateTempBuffers(false, context);
+    return handle;
+  }, makeContextCurrent: (contextHandle) => {
+    GL.currentContext = GL.contexts[contextHandle];
+    Module["ctx"] = GLctx = GL.currentContext?.GLctx;
+    return !(contextHandle && !GLctx);
+  }, getContext: (contextHandle) => GL.contexts[contextHandle], deleteContext: (contextHandle) => {
+    if (GL.currentContext === GL.contexts[contextHandle]) {
+      GL.currentContext = null;
+    }
+    if (typeof JSEvents == "object") {
+      JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
+    }
+    if (GL.contexts[contextHandle]?.GLctx.canvas) {
+      GL.contexts[contextHandle].GLctx.canvas.GLctxObject = void 0;
+    }
+    GL.contexts[contextHandle] = null;
+  }, initExtensions: (context) => {
+    context ||= GL.currentContext;
+    if (context.initExtensionsDone) return;
+    context.initExtensionsDone = true;
+    var GLctx2 = context.GLctx;
+    webgl_enable_WEBGL_multi_draw(GLctx2);
+    webgl_enable_EXT_polygon_offset_clamp(GLctx2);
+    webgl_enable_EXT_clip_control(GLctx2);
+    webgl_enable_WEBGL_polygon_mode(GLctx2);
+    webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx2);
+    webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx2);
+    if (context.version >= 2) {
+      GLctx2.disjointTimerQueryExt = GLctx2.getExtension("EXT_disjoint_timer_query_webgl2");
+    }
+    if (context.version < 2 || !GLctx2.disjointTimerQueryExt) {
+      GLctx2.disjointTimerQueryExt = GLctx2.getExtension("EXT_disjoint_timer_query");
+    }
+    for (var ext of getEmscriptenSupportedExtensions(GLctx2)) {
+      if (!ext.includes("lose_context") && !ext.includes("debug")) {
+        GLctx2.getExtension(ext);
+      }
+    }
+  } };
+  var _emscripten_webgl_make_context_current = (contextHandle) => {
+    var success = GL.makeContextCurrent(contextHandle);
+    return success ? 0 : -5;
+  };
+  var ENV = {};
+  var getExecutableName = () => thisProgram;
+  var getEnvStrings = () => {
+    if (!getEnvStrings.strings) {
+      var lang = (globalThis.navigator?.language ?? "C").replace("-", "_") + ".UTF-8";
+      var env = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: lang, _: getExecutableName() };
+      for (var x in ENV) {
+        if (ENV[x] === void 0) delete env[x];
+        else env[x] = ENV[x];
+      }
+      var strings = [];
+      for (var x in env) {
+        strings.push(`${x}=${env[x]}`);
+      }
+      getEnvStrings.strings = strings;
+    }
+    return getEnvStrings.strings;
+  };
+  var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+    if (!(maxBytesToWrite > 0)) return 0;
+    var startIdx = outIdx;
+    var endIdx = outIdx + maxBytesToWrite - 1;
+    for (var i = 0; i < str.length; ++i) {
+      var u = str.codePointAt(i);
+      if (u <= 127) {
+        if (outIdx >= endIdx) break;
+        heap[outIdx++] = u;
+      } else if (u <= 2047) {
+        if (outIdx + 1 >= endIdx) break;
+        heap[outIdx++] = 192 | u >> 6;
+        heap[outIdx++] = 128 | u & 63;
+      } else if (u <= 65535) {
+        if (outIdx + 2 >= endIdx) break;
+        heap[outIdx++] = 224 | u >> 12;
+        heap[outIdx++] = 128 | u >> 6 & 63;
+        heap[outIdx++] = 128 | u & 63;
+      } else {
+        if (outIdx + 3 >= endIdx) break;
+        heap[outIdx++] = 240 | u >> 18;
+        heap[outIdx++] = 128 | u >> 12 & 63;
+        heap[outIdx++] = 128 | u >> 6 & 63;
+        heap[outIdx++] = 128 | u & 63;
+        i++;
+      }
+    }
+    heap[outIdx] = 0;
+    return outIdx - startIdx;
+  };
+  var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+  var _environ_get = (__environ, environ_buf) => {
+    var bufSize = 0;
+    var envp = 0;
+    for (var string of getEnvStrings()) {
+      var ptr = environ_buf + bufSize;
+      HEAPU32[__environ + envp >> 2] = ptr;
+      bufSize += stringToUTF8(string, ptr, Infinity) + 1;
+      envp += 4;
+    }
+    return 0;
+  };
+  var lengthBytesUTF8 = (str) => {
+    var len = 0;
+    for (var i = 0; i < str.length; ++i) {
+      var c = str.charCodeAt(i);
+      if (c <= 127) {
+        len++;
+      } else if (c <= 2047) {
+        len += 2;
+      } else if (c >= 55296 && c <= 57343) {
+        len += 4;
+        ++i;
+      } else {
+        len += 3;
+      }
+    }
+    return len;
+  };
+  var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
+    var strings = getEnvStrings();
+    HEAPU32[penviron_count >> 2] = strings.length;
+    var bufSize = 0;
+    for (var string of strings) {
+      bufSize += lengthBytesUTF8(string) + 1;
+    }
+    HEAPU32[penviron_buf_size >> 2] = bufSize;
+    return 0;
+  };
+  var _fd_close = (fd) => 52;
+  function _fd_seek(fd, offset, whence, newOffset) {
+    return 70;
+  }
+  var printCharBuffers = [null, [], []];
+  var printChar = (stream, curr) => {
+    var buffer = printCharBuffers[stream];
+    if (curr === 0 || curr === 10) {
+      (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
+      buffer.length = 0;
+    } else {
+      buffer.push(curr);
+    }
+  };
+  var _fd_write = (fd, iov, iovcnt, pnum) => {
+    var num = 0;
+    for (var i = 0; i < iovcnt; i++) {
+      var ptr = HEAPU32[iov >> 2];
+      var len = HEAPU32[iov + 4 >> 2];
+      iov += 8;
+      for (var j = 0; j < len; j++) {
+        printChar(fd, HEAPU8[ptr + j]);
+      }
+      num += len;
+    }
+    HEAPU32[pnum >> 2] = num;
+    return 0;
+  };
+  var _emscripten_glActiveTexture = (x0) => GLctx.activeTexture(x0);
+  var _glActiveTexture = _emscripten_glActiveTexture;
+  var _emscripten_glAttachShader = (program, shader) => {
+    GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
+  };
+  var _glAttachShader = _emscripten_glAttachShader;
+  var _emscripten_glBindBuffer = (target, buffer) => {
+    if (buffer && !GL.buffers[buffer]) {
+      var b = GLctx.createBuffer();
+      b.name = buffer;
+      GL.buffers[buffer] = b;
+    }
+    if (target == 34962) {
+      GLctx.currentArrayBufferBinding = buffer;
+    } else if (target == 34963) {
+      GLctx.currentElementArrayBufferBinding = buffer;
+    }
+    if (target == 35051) {
+      GLctx.currentPixelPackBufferBinding = buffer;
+    } else if (target == 35052) {
+      GLctx.currentPixelUnpackBufferBinding = buffer;
+    }
+    GLctx.bindBuffer(target, GL.buffers[buffer]);
+  };
+  var _glBindBuffer = _emscripten_glBindBuffer;
+  var _emscripten_glBindBufferBase = (target, index, buffer) => {
+    GLctx.bindBufferBase(target, index, GL.buffers[buffer]);
+  };
+  var _glBindBufferBase = _emscripten_glBindBufferBase;
+  var _emscripten_glBindBufferRange = (target, index, buffer, offset, ptrsize) => {
+    GLctx.bindBufferRange(target, index, GL.buffers[buffer], offset, ptrsize);
+  };
+  var _glBindBufferRange = _emscripten_glBindBufferRange;
+  var _emscripten_glBindFramebuffer = (target, framebuffer) => {
+    GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
+  };
+  var _glBindFramebuffer = _emscripten_glBindFramebuffer;
+  var _emscripten_glBindRenderbuffer = (target, renderbuffer) => {
+    GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
+  };
+  var _glBindRenderbuffer = _emscripten_glBindRenderbuffer;
+  var _emscripten_glBindSampler = (unit, sampler) => {
+    GLctx.bindSampler(unit, GL.samplers[sampler]);
+  };
+  var _glBindSampler = _emscripten_glBindSampler;
+  var _emscripten_glBindTexture = (target, texture) => {
+    GLctx.bindTexture(target, GL.textures[texture]);
+  };
+  var _glBindTexture = _emscripten_glBindTexture;
+  var _emscripten_glBindVertexArray = (vao) => {
+    GLctx.bindVertexArray(GL.vaos[vao]);
+    var ibo = GLctx.getParameter(34965);
+    GLctx.currentElementArrayBufferBinding = ibo ? ibo.name | 0 : 0;
+  };
+  var _glBindVertexArray = _emscripten_glBindVertexArray;
+  var _emscripten_glBlendColor = (x0, x1, x2, x3) => GLctx.blendColor(x0, x1, x2, x3);
+  var _glBlendColor = _emscripten_glBlendColor;
+  var _emscripten_glBlendEquationSeparate = (x0, x1) => GLctx.blendEquationSeparate(x0, x1);
+  var _glBlendEquationSeparate = _emscripten_glBlendEquationSeparate;
+  var _emscripten_glBlendFuncSeparate = (x0, x1, x2, x3) => GLctx.blendFuncSeparate(x0, x1, x2, x3);
+  var _glBlendFuncSeparate = _emscripten_glBlendFuncSeparate;
+  var _emscripten_glBlitFramebuffer = (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) => GLctx.blitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+  var _glBlitFramebuffer = _emscripten_glBlitFramebuffer;
+  var _emscripten_glBufferData = (target, size, data, usage) => {
+    {
+      if (data && size) {
+        GLctx.bufferData(target, HEAPU8, usage, data, size);
+      } else {
+        GLctx.bufferData(target, size, usage);
+      }
+      return;
+    }
+  };
+  var _glBufferData = _emscripten_glBufferData;
+  var _emscripten_glBufferSubData = (target, offset, size, data) => webglBufferSubData(target, offset, size, data);
+  var _glBufferSubData = _emscripten_glBufferSubData;
+  var _emscripten_glCheckFramebufferStatus = (x0) => GLctx.checkFramebufferStatus(x0);
+  var _glCheckFramebufferStatus = _emscripten_glCheckFramebufferStatus;
+  var _emscripten_glClearBufferfi = (x0, x1, x2, x3) => GLctx.clearBufferfi(x0, x1, x2, x3);
+  var _glClearBufferfi = _emscripten_glClearBufferfi;
+  var _emscripten_glClearBufferfv = (buffer, drawbuffer, value) => {
+    GLctx.clearBufferfv(buffer, drawbuffer, HEAPF32, value >> 2);
+  };
+  var _glClearBufferfv = _emscripten_glClearBufferfv;
+  var _emscripten_glClearBufferiv = (buffer, drawbuffer, value) => {
+    GLctx.clearBufferiv(buffer, drawbuffer, HEAP32, value >> 2);
+  };
+  var _glClearBufferiv = _emscripten_glClearBufferiv;
+  var _emscripten_glColorMask = (red, green, blue, alpha) => {
+    GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
+  };
+  var _glColorMask = _emscripten_glColorMask;
+  var _emscripten_glCompileShader = (shader) => {
+    GLctx.compileShader(GL.shaders[shader]);
+  };
+  var _glCompileShader = _emscripten_glCompileShader;
+  var _emscripten_glCompressedTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, imageSize, data) => {
+    {
+      if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
+        GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+        return;
+      }
+      GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize);
+      return;
+    }
+  };
+  var _glCompressedTexSubImage2D = _emscripten_glCompressedTexSubImage2D;
+  var _emscripten_glCompressedTexSubImage3D = (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) => {
+    if (GLctx.currentPixelUnpackBufferBinding) {
+      GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    } else {
+      GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize);
+    }
+  };
+  var _glCompressedTexSubImage3D = _emscripten_glCompressedTexSubImage3D;
+  var _emscripten_glCreateProgram = () => {
+    var id = GL.getNewId(GL.programs);
+    var program = GLctx.createProgram();
+    program.name = id;
+    program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0;
+    program.uniformIdCounter = 1;
+    GL.programs[id] = program;
+    return id;
+  };
+  var _glCreateProgram = _emscripten_glCreateProgram;
+  var _emscripten_glCreateShader = (shaderType) => {
+    var id = GL.getNewId(GL.shaders);
+    GL.shaders[id] = GLctx.createShader(shaderType);
+    return id;
+  };
+  var _glCreateShader = _emscripten_glCreateShader;
+  var _emscripten_glCullFace = (x0) => GLctx.cullFace(x0);
+  var _glCullFace = _emscripten_glCullFace;
+  var _emscripten_glDeleteBuffers = (n, buffers) => {
+    for (var i = 0; i < n; i++) {
+      var id = HEAP32[buffers + i * 4 >> 2];
+      var buffer = GL.buffers[id];
+      if (!buffer) continue;
+      GLctx.deleteBuffer(buffer);
+      buffer.name = 0;
+      GL.buffers[id] = null;
+      if (id == GLctx.currentArrayBufferBinding) GLctx.currentArrayBufferBinding = 0;
+      if (id == GLctx.currentElementArrayBufferBinding) GLctx.currentElementArrayBufferBinding = 0;
+      if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0;
+      if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
+    }
+  };
+  var _glDeleteBuffers = _emscripten_glDeleteBuffers;
+  var _emscripten_glDeleteFramebuffers = (n, framebuffers) => {
+    for (var i = 0; i < n; ++i) {
+      var id = HEAP32[framebuffers + i * 4 >> 2];
+      var framebuffer = GL.framebuffers[id];
+      if (!framebuffer) continue;
+      GLctx.deleteFramebuffer(framebuffer);
+      framebuffer.name = 0;
+      GL.framebuffers[id] = null;
+    }
+  };
+  var _glDeleteFramebuffers = _emscripten_glDeleteFramebuffers;
+  var _emscripten_glDeleteProgram = (id) => {
+    if (!id) return;
+    var program = GL.programs[id];
+    if (!program) {
+      GL.recordError(1281);
+      return;
+    }
+    GLctx.deleteProgram(program);
+    program.name = 0;
+    GL.programs[id] = null;
+  };
+  var _glDeleteProgram = _emscripten_glDeleteProgram;
+  var _emscripten_glDeleteRenderbuffers = (n, renderbuffers) => {
+    for (var i = 0; i < n; i++) {
+      var id = HEAP32[renderbuffers + i * 4 >> 2];
+      var renderbuffer = GL.renderbuffers[id];
+      if (!renderbuffer) continue;
+      GLctx.deleteRenderbuffer(renderbuffer);
+      renderbuffer.name = 0;
+      GL.renderbuffers[id] = null;
+    }
+  };
+  var _glDeleteRenderbuffers = _emscripten_glDeleteRenderbuffers;
+  var _emscripten_glDeleteSamplers = (n, samplers) => {
+    for (var i = 0; i < n; i++) {
+      var id = HEAP32[samplers + i * 4 >> 2];
+      var sampler = GL.samplers[id];
+      if (!sampler) continue;
+      GLctx.deleteSampler(sampler);
+      sampler.name = 0;
+      GL.samplers[id] = null;
+    }
+  };
+  var _glDeleteSamplers = _emscripten_glDeleteSamplers;
+  var _emscripten_glDeleteShader = (id) => {
+    if (!id) return;
+    var shader = GL.shaders[id];
+    if (!shader) {
+      GL.recordError(1281);
+      return;
+    }
+    GLctx.deleteShader(shader);
+    GL.shaders[id] = null;
+  };
+  var _glDeleteShader = _emscripten_glDeleteShader;
+  var _emscripten_glDeleteTextures = (n, textures) => {
+    for (var i = 0; i < n; i++) {
+      var id = HEAP32[textures + i * 4 >> 2];
+      var texture = GL.textures[id];
+      if (!texture) continue;
+      GLctx.deleteTexture(texture);
+      texture.name = 0;
+      GL.textures[id] = null;
+    }
+  };
+  var _glDeleteTextures = _emscripten_glDeleteTextures;
+  var _emscripten_glDeleteVertexArrays = (n, vaos) => {
+    for (var i = 0; i < n; i++) {
+      var id = HEAP32[vaos + i * 4 >> 2];
+      GLctx.deleteVertexArray(GL.vaos[id]);
+      GL.vaos[id] = null;
+    }
+  };
+  var _glDeleteVertexArrays = _emscripten_glDeleteVertexArrays;
+  var _emscripten_glDepthFunc = (x0) => GLctx.depthFunc(x0);
+  var _glDepthFunc = _emscripten_glDepthFunc;
+  var _emscripten_glDepthMask = (flag) => {
+    GLctx.depthMask(!!flag);
+  };
+  var _glDepthMask = _emscripten_glDepthMask;
+  var _emscripten_glDisable = (x0) => GLctx.disable(x0);
+  var _glDisable = _emscripten_glDisable;
+  var _emscripten_glDisableVertexAttribArray = (index) => {
+    var cb = GL.currentContext.clientBuffers[index];
+    cb.enabled = false;
+    GLctx.disableVertexAttribArray(index);
+  };
+  var _glDisableVertexAttribArray = _emscripten_glDisableVertexAttribArray;
+  var _emscripten_glDrawArrays = (mode, first, count) => {
+    GL.preDrawHandleClientVertexAttribBindings(first + count);
+    GLctx.drawArrays(mode, first, count);
+    GL.postDrawHandleClientVertexAttribBindings();
+  };
+  var _glDrawArrays = _emscripten_glDrawArrays;
+  var _emscripten_glDrawArraysInstanced = (mode, first, count, primcount) => {
+    GLctx.drawArraysInstanced(mode, first, count, primcount);
+  };
+  var _glDrawArraysInstanced = _emscripten_glDrawArraysInstanced;
+  var tempFixedLengthArray = [];
+  var _emscripten_glDrawBuffers = (n, bufs) => {
+    var bufArray = tempFixedLengthArray[n];
+    for (var i = 0; i < n; i++) {
+      bufArray[i] = HEAP32[bufs + i * 4 >> 2];
+    }
+    GLctx.drawBuffers(bufArray);
+  };
+  var _glDrawBuffers = _emscripten_glDrawBuffers;
+  var _emscripten_glDrawElements = (mode, count, type, indices) => {
+    var buf;
+    var vertexes = 0;
+    if (!GLctx.currentElementArrayBufferBinding) {
+      var size = GL.calcBufLength(1, type, 0, count);
+      buf = GL.getTempIndexBuffer(size);
+      GLctx.bindBuffer(34963, buf);
+      webglBufferSubData(34963, 0, size, indices);
+      if (count > 0) {
+        for (var i = 0; i < GL.currentContext.maxVertexAttribs; ++i) {
+          var cb = GL.currentContext.clientBuffers[i];
+          if (cb.clientside && cb.enabled) {
+            let arrayClass;
+            switch (type) {
+              case 5121:
+                arrayClass = Uint8Array;
+                break;
+              case 5123:
+                arrayClass = Uint16Array;
+                break;
+              case 5125:
+                arrayClass = Uint32Array;
+                break;
+              default:
+                GL.recordError(1282);
+                return;
+            }
+            vertexes = new arrayClass(HEAPU8.buffer, indices, count).reduce((max, current) => Math.max(max, current)) + 1;
+            break;
+          }
+        }
+      }
+      indices = 0;
+    }
+    GL.preDrawHandleClientVertexAttribBindings(vertexes);
+    GLctx.drawElements(mode, count, type, indices);
+    GL.postDrawHandleClientVertexAttribBindings(count);
+    if (!GLctx.currentElementArrayBufferBinding) {
+      GLctx.bindBuffer(34963, null);
+    }
+  };
+  var _glDrawElements = _emscripten_glDrawElements;
+  var _emscripten_glDrawElementsInstanced = (mode, count, type, indices, primcount) => {
+    GLctx.drawElementsInstanced(mode, count, type, indices, primcount);
+  };
+  var _glDrawElementsInstanced = _emscripten_glDrawElementsInstanced;
+  var _emscripten_glEnable = (x0) => GLctx.enable(x0);
+  var _glEnable = _emscripten_glEnable;
+  var _emscripten_glEnableVertexAttribArray = (index) => {
+    var cb = GL.currentContext.clientBuffers[index];
+    cb.enabled = true;
+    GLctx.enableVertexAttribArray(index);
+  };
+  var _glEnableVertexAttribArray = _emscripten_glEnableVertexAttribArray;
+  var _emscripten_glFramebufferRenderbuffer = (target, attachment, renderbuffertarget, renderbuffer) => {
+    GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, GL.renderbuffers[renderbuffer]);
+  };
+  var _glFramebufferRenderbuffer = _emscripten_glFramebufferRenderbuffer;
+  var _emscripten_glFramebufferTexture2D = (target, attachment, textarget, texture, level) => {
+    GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level);
+  };
+  var _glFramebufferTexture2D = _emscripten_glFramebufferTexture2D;
+  var _emscripten_glFramebufferTextureLayer = (target, attachment, texture, level, layer) => {
+    GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer);
+  };
+  var _glFramebufferTextureLayer = _emscripten_glFramebufferTextureLayer;
+  var _emscripten_glFrontFace = (x0) => GLctx.frontFace(x0);
+  var _glFrontFace = _emscripten_glFrontFace;
+  var _emscripten_glGenBuffers = (n, buffers) => {
+    GL.genObject(n, buffers, "createBuffer", GL.buffers);
+  };
+  var _glGenBuffers = _emscripten_glGenBuffers;
+  var _emscripten_glGenFramebuffers = (n, ids) => {
+    GL.genObject(n, ids, "createFramebuffer", GL.framebuffers);
+  };
+  var _glGenFramebuffers = _emscripten_glGenFramebuffers;
+  var _emscripten_glGenRenderbuffers = (n, renderbuffers) => {
+    GL.genObject(n, renderbuffers, "createRenderbuffer", GL.renderbuffers);
+  };
+  var _glGenRenderbuffers = _emscripten_glGenRenderbuffers;
+  var _emscripten_glGenSamplers = (n, samplers) => {
+    GL.genObject(n, samplers, "createSampler", GL.samplers);
+  };
+  var _glGenSamplers = _emscripten_glGenSamplers;
+  var _emscripten_glGenTextures = (n, textures) => {
+    GL.genObject(n, textures, "createTexture", GL.textures);
+  };
+  var _glGenTextures = _emscripten_glGenTextures;
+  var _emscripten_glGenVertexArrays = (n, arrays) => {
+    GL.genObject(n, arrays, "createVertexArray", GL.vaos);
+  };
+  var _glGenVertexArrays = _emscripten_glGenVertexArrays;
+  var _emscripten_glGetAttribLocation = (program, name) => GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
+  var _glGetAttribLocation = _emscripten_glGetAttribLocation;
+  var writeI53ToI64 = (ptr, num) => {
+    HEAPU32[ptr >> 2] = num;
+    var lower = HEAPU32[ptr >> 2];
+    HEAPU32[ptr + 4 >> 2] = (num - lower) / 4294967296;
+  };
+  var webglGetExtensions = () => {
+    var exts = getEmscriptenSupportedExtensions(GLctx);
+    exts = exts.concat(exts.map((e) => "GL_" + e));
+    return exts;
+  };
+  var emscriptenWebGLGet = (name_, p, type) => {
+    if (!p) {
+      GL.recordError(1281);
+      return;
+    }
+    var ret = void 0;
+    switch (name_) {
+      case 36346:
+        ret = 1;
+        break;
+      case 36344:
+        return;
+      case 34814:
+      case 36345:
+        ret = 0;
+        break;
+      case 34466:
+        var formats = GLctx.getParameter(34467);
+        ret = formats ? formats.length : 0;
+        break;
+      case 33309:
+        if (GL.currentContext.version < 2) {
+          GL.recordError(1282);
+          return;
+        }
+        ret = webglGetExtensions().length;
+        break;
+      case 33307:
+      case 33308:
+        if (GL.currentContext.version < 2) {
+          GL.recordError(1280);
+          return;
+        }
+        ret = name_ == 33307 ? 3 : 0;
+        break;
+    }
+    if (ret === void 0) {
+      var result = GLctx.getParameter(name_);
+      switch (typeof result) {
+        case "number":
+          ret = result;
+          break;
+        case "boolean":
+          ret = result ? 1 : 0;
+          break;
+        case "string":
+          GL.recordError(1280);
+          return;
+        case "object":
+          if (result === null) {
+            switch (name_) {
+              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: {
+                ret = 0;
+                break;
+              }
+              default: {
+                GL.recordError(1280);
+                return;
+              }
+            }
+          } else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) {
+            for (var i = 0; i < result.length; ++i) {
+              switch (type) {
+                case 0:
+                  HEAP32[p + i * 4 >> 2] = result[i];
+                  break;
+                case 2:
+                  HEAPF32[p + i * 4 >> 2] = result[i];
+                  break;
+                case 4:
+                  HEAP8[p + i] = result[i] ? 1 : 0;
+                  break;
+              }
+            }
+            return;
+          } else {
+            try {
+              ret = result.name | 0;
+            } catch (e) {
+              GL.recordError(1280);
+              err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`);
+              return;
+            }
+          }
+          break;
+        default:
+          GL.recordError(1280);
+          err(`GL_INVALID_ENUM in glGet${type}v: Native code calling glGet${type}v(${name_}) and it returns ${result} of type ${typeof result}!`);
+          return;
+      }
+    }
+    switch (type) {
+      case 1:
+        writeI53ToI64(p, ret);
+        break;
+      case 0:
+        HEAP32[p >> 2] = ret;
+        break;
+      case 2:
+        HEAPF32[p >> 2] = ret;
+        break;
+      case 4:
+        HEAP8[p] = ret ? 1 : 0;
+        break;
+    }
+  };
+  var _emscripten_glGetIntegerv = (name_, p) => emscriptenWebGLGet(name_, p, 0);
+  var _glGetIntegerv = _emscripten_glGetIntegerv;
+  var _emscripten_glGetProgramInfoLog = (program, maxLength, length, infoLog) => {
+    var log = GLctx.getProgramInfoLog(GL.programs[program]);
+    if (log === null) log = "(unknown error)";
+    var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
+    if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
+  };
+  var _glGetProgramInfoLog = _emscripten_glGetProgramInfoLog;
+  var _emscripten_glGetProgramiv = (program, pname, p) => {
+    if (!p) {
+      GL.recordError(1281);
+      return;
+    }
+    if (program >= GL.counter) {
+      GL.recordError(1281);
+      return;
+    }
+    program = GL.programs[program];
+    if (pname == 35716) {
+      var log = GLctx.getProgramInfoLog(program);
+      if (log === null) log = "(unknown error)";
+      HEAP32[p >> 2] = log.length + 1;
+    } else if (pname == 35719) {
+      if (!program.maxUniformLength) {
+        var numActiveUniforms = GLctx.getProgramParameter(program, 35718);
+        for (var i = 0; i < numActiveUniforms; ++i) {
+          program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length + 1);
+        }
+      }
+      HEAP32[p >> 2] = program.maxUniformLength;
+    } else if (pname == 35722) {
+      if (!program.maxAttributeLength) {
+        var numActiveAttributes = GLctx.getProgramParameter(program, 35721);
+        for (var i = 0; i < numActiveAttributes; ++i) {
+          program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length + 1);
+        }
+      }
+      HEAP32[p >> 2] = program.maxAttributeLength;
+    } else if (pname == 35381) {
+      if (!program.maxUniformBlockNameLength) {
+        var numActiveUniformBlocks = GLctx.getProgramParameter(program, 35382);
+        for (var i = 0; i < numActiveUniformBlocks; ++i) {
+          program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length + 1);
+        }
+      }
+      HEAP32[p >> 2] = program.maxUniformBlockNameLength;
+    } else {
+      HEAP32[p >> 2] = GLctx.getProgramParameter(program, pname);
+    }
+  };
+  var _glGetProgramiv = _emscripten_glGetProgramiv;
+  var _emscripten_glGetShaderInfoLog = (shader, maxLength, length, infoLog) => {
+    var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
+    if (log === null) log = "(unknown error)";
+    var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
+    if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
+  };
+  var _glGetShaderInfoLog = _emscripten_glGetShaderInfoLog;
+  var _emscripten_glGetShaderiv = (shader, pname, p) => {
+    if (!p) {
+      GL.recordError(1281);
+      return;
+    }
+    if (pname == 35716) {
+      var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
+      if (log === null) log = "(unknown error)";
+      var logLength = log ? log.length + 1 : 0;
+      HEAP32[p >> 2] = logLength;
+    } else if (pname == 35720) {
+      var source = GLctx.getShaderSource(GL.shaders[shader]);
+      var sourceLength = source ? source.length + 1 : 0;
+      HEAP32[p >> 2] = sourceLength;
+    } else {
+      HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
+    }
+  };
+  var _glGetShaderiv = _emscripten_glGetShaderiv;
+  var stringToNewUTF8 = (str) => {
+    var size = lengthBytesUTF8(str) + 1;
+    var ret = _malloc(size);
+    if (ret) stringToUTF8(str, ret, size);
+    return ret;
+  };
+  var _emscripten_glGetStringi = (name, index) => {
+    if (GL.currentContext.version < 2) {
+      GL.recordError(1282);
+      return 0;
+    }
+    var stringiCache = GL.stringiCache[name];
+    if (stringiCache) {
+      if (index < 0 || index >= stringiCache.length) {
+        GL.recordError(1281);
+        return 0;
+      }
+      return stringiCache[index];
+    }
+    switch (name) {
+      case 7939:
+        var exts = webglGetExtensions().map(stringToNewUTF8);
+        stringiCache = GL.stringiCache[name] = exts;
+        if (index < 0 || index >= stringiCache.length) {
+          GL.recordError(1281);
+          return 0;
+        }
+        return stringiCache[index];
+      default:
+        GL.recordError(1280);
+        return 0;
+    }
+  };
+  var _glGetStringi = _emscripten_glGetStringi;
+  var jstoi_q = (str) => parseInt(str);
+  var webglGetLeftBracePos = (name) => name.slice(-1) == "]" && name.lastIndexOf("[");
+  var webglPrepareUniformLocationsBeforeFirstUse = (program) => {
+    var uniformLocsById = program.uniformLocsById, uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, i, j;
+    if (!uniformLocsById) {
+      program.uniformLocsById = uniformLocsById = {};
+      program.uniformArrayNamesById = {};
+      var numActiveUniforms = GLctx.getProgramParameter(program, 35718);
+      for (i = 0; i < numActiveUniforms; ++i) {
+        var u = GLctx.getActiveUniform(program, i);
+        var nm = u.name;
+        var sz = u.size;
+        var lb = webglGetLeftBracePos(nm);
+        var arrayName = lb > 0 ? nm.slice(0, lb) : nm;
+        var id = program.uniformIdCounter;
+        program.uniformIdCounter += sz;
+        uniformSizeAndIdsByName[arrayName] = [sz, id];
+        for (j = 0; j < sz; ++j) {
+          uniformLocsById[id] = j;
+          program.uniformArrayNamesById[id++] = arrayName;
+        }
+      }
+    }
+  };
+  var _emscripten_glGetUniformLocation = (program, name) => {
+    name = UTF8ToString(name);
+    if (program = GL.programs[program]) {
+      webglPrepareUniformLocationsBeforeFirstUse(program);
+      var uniformLocsById = program.uniformLocsById;
+      var arrayIndex = 0;
+      var uniformBaseName = name;
+      var leftBrace = webglGetLeftBracePos(name);
+      if (leftBrace > 0) {
+        arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0;
+        uniformBaseName = name.slice(0, leftBrace);
+      }
+      var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName];
+      if (sizeAndId && arrayIndex < sizeAndId[0]) {
+        arrayIndex += sizeAndId[1];
+        if (uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) {
+          return arrayIndex;
+        }
+      }
+    } else {
+      GL.recordError(1281);
+    }
+    return -1;
+  };
+  var _glGetUniformLocation = _emscripten_glGetUniformLocation;
+  var _emscripten_glInvalidateFramebuffer = (target, numAttachments, attachments) => {
+    var list = tempFixedLengthArray[numAttachments];
+    for (var i = 0; i < numAttachments; i++) {
+      list[i] = HEAP32[attachments + i * 4 >> 2];
+    }
+    GLctx.invalidateFramebuffer(target, list);
+  };
+  var _glInvalidateFramebuffer = _emscripten_glInvalidateFramebuffer;
+  var _emscripten_glLinkProgram = (program) => {
+    program = GL.programs[program];
+    GLctx.linkProgram(program);
+    program.uniformLocsById = 0;
+    program.uniformSizeAndIdsByName = {};
+  };
+  var _glLinkProgram = _emscripten_glLinkProgram;
+  var _emscripten_glPixelStorei = (pname, param) => {
+    if (pname == 3317) {
+      GL.unpackAlignment = param;
+    } else if (pname == 3314) {
+      GL.unpackRowLength = param;
+    }
+    GLctx.pixelStorei(pname, param);
+  };
+  var _glPixelStorei = _emscripten_glPixelStorei;
+  var _emscripten_glPolygonOffset = (x0, x1) => GLctx.polygonOffset(x0, x1);
+  var _glPolygonOffset = _emscripten_glPolygonOffset;
+  var _emscripten_glReadBuffer = (x0) => GLctx.readBuffer(x0);
+  var _glReadBuffer = _emscripten_glReadBuffer;
+  var _emscripten_glRenderbufferStorageMultisample = (x0, x1, x2, x3, x4) => GLctx.renderbufferStorageMultisample(x0, x1, x2, x3, x4);
+  var _glRenderbufferStorageMultisample = _emscripten_glRenderbufferStorageMultisample;
+  var _emscripten_glSamplerParameterf = (sampler, pname, param) => {
+    GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
+  };
+  var _glSamplerParameterf = _emscripten_glSamplerParameterf;
+  var _emscripten_glSamplerParameteri = (sampler, pname, param) => {
+    GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
+  };
+  var _glSamplerParameteri = _emscripten_glSamplerParameteri;
+  var _emscripten_glScissor = (x0, x1, x2, x3) => GLctx.scissor(x0, x1, x2, x3);
+  var _glScissor = _emscripten_glScissor;
+  var _emscripten_glShaderSource = (shader, count, string, length) => {
+    var source = GL.getSource(shader, count, string, length);
+    GLctx.shaderSource(GL.shaders[shader], source);
+  };
+  var _glShaderSource = _emscripten_glShaderSource;
+  var _emscripten_glStencilFunc = (x0, x1, x2) => GLctx.stencilFunc(x0, x1, x2);
+  var _glStencilFunc = _emscripten_glStencilFunc;
+  var _emscripten_glStencilFuncSeparate = (x0, x1, x2, x3) => GLctx.stencilFuncSeparate(x0, x1, x2, x3);
+  var _glStencilFuncSeparate = _emscripten_glStencilFuncSeparate;
+  var _emscripten_glStencilMask = (x0) => GLctx.stencilMask(x0);
+  var _glStencilMask = _emscripten_glStencilMask;
+  var _emscripten_glStencilOp = (x0, x1, x2) => GLctx.stencilOp(x0, x1, x2);
+  var _glStencilOp = _emscripten_glStencilOp;
+  var _emscripten_glStencilOpSeparate = (x0, x1, x2, x3) => GLctx.stencilOpSeparate(x0, x1, x2, x3);
+  var _glStencilOpSeparate = _emscripten_glStencilOpSeparate;
+  var _emscripten_glTexStorage2D = (x0, x1, x2, x3, x4) => GLctx.texStorage2D(x0, x1, x2, x3, x4);
+  var _glTexStorage2D = _emscripten_glTexStorage2D;
+  var _emscripten_glTexStorage3D = (x0, x1, x2, x3, x4, x5) => GLctx.texStorage3D(x0, x1, x2, x3, x4, x5);
+  var _glTexStorage3D = _emscripten_glTexStorage3D;
+  var computeUnpackAlignedImageSize = (width, height, sizePerPixel) => {
+    function roundedToNextMultipleOf(x, y) {
+      return x + y - 1 & -y;
+    }
+    var plainRowSize = (GL.unpackRowLength || width) * sizePerPixel;
+    var alignedRowSize = roundedToNextMultipleOf(plainRowSize, GL.unpackAlignment);
+    return height * alignedRowSize;
+  };
+  var colorChannelsInGlTextureFormat = (format) => {
+    var colorChannels = { 5: 3, 6: 4, 8: 2, 29502: 3, 29504: 4, 26917: 2, 26918: 2, 29846: 3, 29847: 4 };
+    return colorChannels[format - 6402] || 1;
+  };
+  var heapObjectForWebGLType = (type) => {
+    type -= 5120;
+    if (type == 0) return HEAP8;
+    if (type == 1) return HEAPU8;
+    if (type == 2) return HEAP16;
+    if (type == 4) return HEAP32;
+    if (type == 6) return HEAPF32;
+    if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) return HEAPU32;
+    return HEAPU16;
+  };
+  var toTypedArrayIndex = (pointer, heap) => pointer >>> 31 - Math.clz32(heap.BYTES_PER_ELEMENT);
+  var emscriptenWebGLGetTexPixelData = (type, format, width, height, pixels) => {
+    var heap = heapObjectForWebGLType(type);
+    var sizePerPixel = colorChannelsInGlTextureFormat(format) * heap.BYTES_PER_ELEMENT;
+    var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel);
+    return heap.subarray(toTypedArrayIndex(pixels, heap), toTypedArrayIndex(pixels + bytes, heap));
+  };
+  var _emscripten_glTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, type, pixels) => {
+    {
+      if (GLctx.currentPixelUnpackBufferBinding) {
+        GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+        return;
+      }
+      if (pixels) {
+        var heap = heapObjectForWebGLType(type);
+        GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, toTypedArrayIndex(pixels, heap));
+        return;
+      }
+    }
+    var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels) : null;
+    GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData);
+  };
+  var _glTexSubImage2D = _emscripten_glTexSubImage2D;
+  var _emscripten_glTexSubImage3D = (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) => {
+    if (GLctx.currentPixelUnpackBufferBinding) {
+      GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    } else if (pixels) {
+      var heap = heapObjectForWebGLType(type);
+      GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, heap, toTypedArrayIndex(pixels, heap));
+    } else {
+      GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null);
+    }
+  };
+  var _glTexSubImage3D = _emscripten_glTexSubImage3D;
+  var webglGetProgramUniformLocation = (program, location) => {
+    if (program) {
+      var webglLoc = program.uniformLocsById[location];
+      if (typeof webglLoc == "number") {
+        program.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(program, program.uniformArrayNamesById[location] + (webglLoc > 0 ? `[${webglLoc}]` : ""));
+      }
+      return webglLoc;
+    } else {
+      GL.recordError(1282);
+    }
+  };
+  var webglGetUniformLocation = (location) => webglGetProgramUniformLocation(GLctx.currentProgram, location);
+  var _emscripten_glUniform1fv = (location, count, value) => {
+    count && GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count);
+  };
+  var _glUniform1fv = _emscripten_glUniform1fv;
+  var _emscripten_glUniform1i = (location, v0) => {
+    GLctx.uniform1i(webglGetUniformLocation(location), v0);
+  };
+  var _glUniform1i = _emscripten_glUniform1i;
+  var _emscripten_glUniform1iv = (location, count, value) => {
+    count && GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, value >> 2, count);
+  };
+  var _glUniform1iv = _emscripten_glUniform1iv;
+  var _emscripten_glUniform2fv = (location, count, value) => {
+    count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2);
+  };
+  var _glUniform2fv = _emscripten_glUniform2fv;
+  var _emscripten_glUniform2iv = (location, count, value) => {
+    count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 2);
+  };
+  var _glUniform2iv = _emscripten_glUniform2iv;
+  var _emscripten_glUniform3fv = (location, count, value) => {
+    count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 3);
+  };
+  var _glUniform3fv = _emscripten_glUniform3fv;
+  var _emscripten_glUniform3iv = (location, count, value) => {
+    count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 3);
+  };
+  var _glUniform3iv = _emscripten_glUniform3iv;
+  var _emscripten_glUniform4fv = (location, count, value) => {
+    count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4);
+  };
+  var _glUniform4fv = _emscripten_glUniform4fv;
+  var _emscripten_glUniform4iv = (location, count, value) => {
+    count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4);
+  };
+  var _glUniform4iv = _emscripten_glUniform4iv;
+  var _emscripten_glUniformMatrix4fv = (location, count, transpose, value) => {
+    count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 16);
+  };
+  var _glUniformMatrix4fv = _emscripten_glUniformMatrix4fv;
+  var _emscripten_glUseProgram = (program) => {
+    program = GL.programs[program];
+    GLctx.useProgram(program);
+    GLctx.currentProgram = program;
+  };
+  var _glUseProgram = _emscripten_glUseProgram;
+  var _emscripten_glVertexAttribDivisor = (index, divisor) => {
+    GLctx.vertexAttribDivisor(index, divisor);
+  };
+  var _glVertexAttribDivisor = _emscripten_glVertexAttribDivisor;
+  var _emscripten_glVertexAttribIPointer = (index, size, type, stride, ptr) => {
+    var cb = GL.currentContext.clientBuffers[index];
+    if (!GLctx.currentArrayBufferBinding) {
+      cb.size = size;
+      cb.type = type;
+      cb.normalized = false;
+      cb.stride = stride;
+      cb.ptr = ptr;
+      cb.clientside = true;
+      cb.vertexAttribPointerAdaptor = function(index2, size2, type2, normalized, stride2, ptr2) {
+        this.vertexAttribIPointer(index2, size2, type2, stride2, ptr2);
+      };
+      return;
+    }
+    cb.clientside = false;
+    GLctx.vertexAttribIPointer(index, size, type, stride, ptr);
+  };
+  var _glVertexAttribIPointer = _emscripten_glVertexAttribIPointer;
+  var _emscripten_glVertexAttribPointer = (index, size, type, normalized, stride, ptr) => {
+    var cb = GL.currentContext.clientBuffers[index];
+    if (!GLctx.currentArrayBufferBinding) {
+      cb.size = size;
+      cb.type = type;
+      cb.normalized = normalized;
+      cb.stride = stride;
+      cb.ptr = ptr;
+      cb.clientside = true;
+      cb.vertexAttribPointerAdaptor = function(index2, size2, type2, normalized2, stride2, ptr2) {
+        this.vertexAttribPointer(index2, size2, type2, normalized2, stride2, ptr2);
+      };
+      return;
+    }
+    cb.clientside = false;
+    GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
+  };
+  var _glVertexAttribPointer = _emscripten_glVertexAttribPointer;
+  var _emscripten_glViewport = (x0, x1, x2, x3) => GLctx.viewport(x0, x1, x2, x3);
+  var _glViewport = _emscripten_glViewport;
+  var getWasmTableEntry = (funcPtr) => wasmTable.get(funcPtr);
+  var updateTableMap = (offset, count) => {
+    if (functionsInTableMap) {
+      for (var i = offset; i < offset + count; i++) {
+        var item = getWasmTableEntry(i);
+        if (item) {
+          functionsInTableMap.set(item, i);
+        }
+      }
+    }
+  };
+  var functionsInTableMap;
+  var getFunctionAddress = (func) => {
+    if (!functionsInTableMap) {
+      functionsInTableMap = /* @__PURE__ */ new WeakMap();
+      updateTableMap(0, wasmTable.length);
+    }
+    return functionsInTableMap.get(func) || 0;
+  };
+  var freeTableIndexes = [];
+  var getEmptyTableSlot = () => {
+    if (freeTableIndexes.length) {
+      return freeTableIndexes.pop();
+    }
+    return wasmTable["grow"](1);
+  };
+  var setWasmTableEntry = (idx, func) => wasmTable.set(idx, func);
+  var uleb128EncodeWithLen = (arr) => {
+    const n = arr.length;
+    return [n % 128 | 128, n >> 7, ...arr];
+  };
+  var wasmTypeCodes = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+  var generateTypePack = (types) => uleb128EncodeWithLen(Array.from(types, (type) => {
+    var code = wasmTypeCodes[type];
+    return code;
+  }));
+  var convertJsFunctionToWasm = (func, sig) => {
+    var bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...uleb128EncodeWithLen([1, 96, ...generateTypePack(sig.slice(1)), ...generateTypePack(sig[0] === "v" ? "" : sig[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+    var module = new WebAssembly.Module(bytes);
+    var instance = new WebAssembly.Instance(module, { e: { f: func } });
+    var wrappedFunc = instance.exports["f"];
+    return wrappedFunc;
+  };
+  var addFunction = (func, sig) => {
+    var rtn = getFunctionAddress(func);
+    if (rtn) {
+      return rtn;
+    }
+    var ret = getEmptyTableSlot();
+    try {
+      setWasmTableEntry(ret, func);
+    } catch (err2) {
+      if (!(err2 instanceof TypeError)) {
+        throw err2;
+      }
+      var wrapped = convertJsFunctionToWasm(func, sig);
+      setWasmTableEntry(ret, wrapped);
+    }
+    functionsInTableMap.set(func, ret);
+    return ret;
+  };
+  var removeFunction = (index) => {
+    functionsInTableMap.delete(getWasmTableEntry(index));
+    setWasmTableEntry(index, null);
+    freeTableIndexes.push(index);
+  };
+  registerPreMainLoop(() => GL.newRenderingFrameStarted());
+  for (let i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));
+  {
+    if (Module["noExitRuntime"]) Module["noExitRuntime"];
+    if (Module["print"]) out = Module["print"];
+    if (Module["printErr"]) err = Module["printErr"];
+    if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+    if (Module["arguments"]) Module["arguments"];
+    if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+    if (Module["preInit"]) {
+      if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+      while (Module["preInit"].length > 0) {
+        Module["preInit"].shift()();
+      }
+    }
+  }
+  Module["ENV"] = ENV;
+  Module["addFunction"] = addFunction;
+  Module["removeFunction"] = removeFunction;
+  Module["UTF8ToString"] = UTF8ToString;
+  Module["stringToUTF8"] = stringToUTF8;
+  Module["lengthBytesUTF8"] = lengthBytesUTF8;
+  Module["stringToNewUTF8"] = stringToNewUTF8;
+  Module["GL"] = GL;
+  var ASM_CONSTS = { 86553: () => {
+    const ctx = Module.creator2d_glContext || typeof window !== "undefined" && window.creator2d_glContext;
+    const opts = Module.creator2d_glOptions || typeof window !== "undefined" && window.creator2d_glOptions || {};
+    const handle = GL.registerContext(ctx, opts);
+    GL.makeContextCurrent(handle);
+    return handle;
+  } };
+  function jsb_init(out2) {
+    Module.jsb._init(out2);
+  }
+  function jsb_dup(idx) {
+    Module.jsb.dup(idx);
+  }
+  function jsb_release(idx) {
+    Module.jsb.release(idx);
+  }
+  function jsb_global(ctx) {
+    Module.jsb.global(ctx);
+  }
+  function jsb_get(lo, hi, key) {
+    Module.jsb.get(lo, hi, UTF8ToString(key));
+  }
+  function jsb_getIndex(lo, hi, i) {
+    Module.jsb.getIndex(lo, hi, i);
+  }
+  function jsb_has(lo, hi, key) {
+    return Module.jsb.has(lo, hi, UTF8ToString(key)) ? 1 : 0;
+  }
+  function jsb_set(obj, key, lo, hi) {
+    Module.jsb.set(obj, UTF8ToString(key), lo, hi);
+  }
+  function jsb_setIndex(obj, i, lo, hi) {
+    Module.jsb.setIndex(obj, i, lo, hi);
+  }
+  function jsb_keys(lo, hi, countOut) {
+    return Module.jsb.keys(lo, hi, countOut);
+  }
+  function jsb_newObject(classId, opaque) {
+    Module.jsb.newObject(classId, opaque);
+  }
+  function jsb_newArray() {
+    Module.jsb.newArray();
+  }
+  function jsb_newString(s, len) {
+    Module.jsb.newString(UTF8ToString(s, len));
+  }
+  function jsb_str(lo, hi, lenOut) {
+    return Module.jsb.str(lo, hi, lenOut);
+  }
+  function jsb_logString(lo, hi) {
+    return Module.jsb.logString(lo, hi);
+  }
+  function jsb_toNumber(idx) {
+    return Module.jsb.toNumber(idx);
+  }
+  function jsb_truthy(idx) {
+    return Module.jsb.truthy(idx) ? 1 : 0;
+  }
+  function jsb_newError(msg) {
+    Module.jsb.newError(UTF8ToString(msg));
+  }
+  function jsb_throw(kind, msg) {
+    Module.jsb.throwNew(kind, UTF8ToString(msg));
+  }
+  function jsb_takeException() {
+    Module.jsb.takeException();
+  }
+  function jsb_call(ctx, fn, thisLo, thisHi, argc, argv) {
+    Module.jsb.call(ctx, fn, thisLo, thisHi, argc, argv);
+  }
+  function jsb_eval(ctx, code, len, filename) {
+    Module.jsb.eval(ctx, UTF8ToString(code, len), UTF8ToString(filename));
+  }
+  function jsb_newContext() {
+    return Module.jsb.newContext();
+  }
+  function jsb_freeContext(ctx) {
+    Module.jsb.freeContext(ctx);
+  }
+  function jsb_parseJson(text, len) {
+    Module.jsb.parseJson(UTF8ToString(text, len));
+  }
+  function jsb_typedArray(kind, data, bytes) {
+    Module.jsb.typedArray(kind, data, bytes);
+  }
+  function jsb_arrayIn(idx, elem, mode, sizeOut) {
+    return Module.jsb.arrayIn(idx, elem, mode, sizeOut);
+  }
+  function jsb_arrayOut(idx, data, bytes) {
+    Module.jsb.arrayOut(idx, data, bytes);
+  }
+  function jsb_makeFunction(ctx, k, name, length) {
+    Module.jsb.makeFunction(ctx, k, name ? UTF8ToString(name) : "", length);
+  }
+  function jsb_defineMethod(ctx, obj, name, fnIndex, length, getter) {
+    Module.jsb.defineMethod(ctx, obj, UTF8ToString(name), fnIndex, length, getter);
+  }
+  function jsb_gc() {
+    Module.jsb.gc();
+  }
+  function jshost_table(table) {
+    return Module.jsb.host[UTF8ToString(table)] ? 1 : 0;
+  }
+  function jshost_has(table, slot) {
+    const t = Module.jsb.host[UTF8ToString(table)];
+    return t && typeof t[UTF8ToString(slot)] === "function" ? 1 : 0;
+  }
+  function jshost_fieldString(table, field) {
+    const t = Module.jsb.host[UTF8ToString(table)];
+    const v = t ? t[UTF8ToString(field)] : void 0;
+    return v == null ? 0 : stringToNewUTF8(String(v));
+  }
+  function jshost_fieldNumber(table, field) {
+    const t = Module.jsb.host[UTF8ToString(table)];
+    const v = t ? Number(t[UTF8ToString(field)]) : 0;
+    return v === v ? v : 0;
+  }
+  function jshost_gl_getGLContext() {
+    return Module.jsb.host.gl.getGLContext() | 0;
+  }
+  function jshost_gl_engineCreated() {
+    Module.jsb.host.gl.engineCreated();
+  }
+  function jshost_gl_createGLView() {
+    Module.jsb.host.gl.createGLView();
+  }
+  function jshost_gl_closeScene() {
+    Module.jsb.host.gl.closeScene();
+  }
+  function jshost_gl_createTexture(systemId, flags, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.gl.createTexture(systemId, flags, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_gl_createMediaPlayerTexture(playerId) {
+    return Module.jsb.host.gl.createMediaPlayerTexture(playerId) || 0;
+  }
+  function jshost_gl_launchAR(sceneId, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.gl.launchAR(sceneId, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_gl_stopAR() {
+    Module.jsb.host.gl.stopAR();
+  }
+  function jshost_gl_launchVR(sceneId, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.gl.launchVR(sceneId, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_gl_stopVR() {
+    Module.jsb.host.gl.stopVR();
+  }
+  function jshost_gl_createARController(sceneId, cameraId, mode) {
+    Module.jsb.host.gl.createARController(sceneId, cameraId, mode ? UTF8ToString(mode) : null);
+  }
+  function jshost_gl_createRootAnchor(sceneId, entityId) {
+    Module.jsb.host.gl.createRootAnchor(sceneId, entityId);
+  }
+  function jshost_gl_createAnchor(sceneId, entityId, physicalWidth, systemId) {
+    Module.jsb.host.gl.createAnchor(sceneId, entityId, physicalWidth, systemId);
+  }
+  function jshost_scene2d_open2DScene(sceneId) {
+    Module.jsb.host.scene2d.open2DScene(sceneId);
+  }
+  function jshost_scene2d_close2DScene() {
+    Module.jsb.host.scene2d.close2DScene();
+  }
+  function jshost_scene2d_init2D() {
+    Module.jsb.host.scene2d.init2D();
+  }
+  function jshost_ui_nodeFactory(id, type, parent, index) {
+    Module.jsb.host.ui.nodeFactory(id, type ? UTF8ToString(type) : null, parent, index);
+  }
+  function jshost_ui_setPropertyString(id, prop, value) {
+    Module.jsb.host.ui.setPropertyString(id, prop ? UTF8ToString(prop) : null, value ? UTF8ToString(value) : null);
+  }
+  function jshost_ui_setPropertyInt(id, prop, value) {
+    Module.jsb.host.ui.setPropertyInt(id, prop ? UTF8ToString(prop) : null, value);
+  }
+  function jshost_ui_setFlags(id, mask) {
+    Module.jsb.host.ui.setFlags(id, mask);
+  }
+  function jshost_ui_insertNode(parent, child, index) {
+    Module.jsb.host.ui.insertNode(parent, child, index);
+  }
+  function jshost_ui_removeNode(parent, child) {
+    Module.jsb.host.ui.removeNode(parent, child);
+  }
+  function jshost_ui_releaseNode(id) {
+    Module.jsb.host.ui.releaseNode(id);
+  }
+  function jshost_ui_openView(kind, node, id, viewName, paramsJson, above) {
+    Module.jsb.host.ui.openView(kind, node, id, viewName ? UTF8ToString(viewName) : null, paramsJson ? UTF8ToString(paramsJson) : null, !!above);
+  }
+  function jshost_ui_dropView(kind, node, id) {
+    Module.jsb.host.ui.dropView(kind, node, id);
+  }
+  function jshost_ui_closeView() {
+    Module.jsb.host.ui.closeView();
+  }
+  function jshost_ui_isViewSupported(name) {
+    return Module.jsb.host.ui.isViewSupported(name ? UTF8ToString(name) : null) ? 1 : 0;
+  }
+  function jshost_ui_viewVersion(name) {
+    return Module.jsb.host.ui.viewVersion(name ? UTF8ToString(name) : null) || 0;
+  }
+  function jshost_ui_viewCall_js(viewId, method, args, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.ui.viewCall(viewId, method ? UTF8ToString(method) : null, Module.jsb.valueAt(args), Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_ui_widgetOpen(node, ownerKind, ownerId, ownerNode) {
+    Module.jsb.host.ui.widgetOpen(node, ownerKind, ownerId, ownerNode);
+  }
+  function jshost_ui_widgetClose(node) {
+    Module.jsb.host.ui.widgetClose(node);
+  }
+  function jshost_ui_registerFont(url, fontFamily, weight, style, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.ui.registerFont(url ? UTF8ToString(url) : null, fontFamily ? UTF8ToString(fontFamily) : null, weight, style, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_ui_showToast(message, duration) {
+    Module.jsb.host.ui.showToast(message ? UTF8ToString(message) : null, duration);
+  }
+  function jshost_ui_getButtonPressed(node) {
+    return Module.jsb.host.ui.getButtonPressed(node) ? 1 : 0;
+  }
+  function jshost_ui_getTextValue(node) {
+    const $r = Module.jsb.host.ui.getTextValue(node);
+    return $r == null ? 0 : stringToNewUTF8(String($r));
+  }
+  function jshost_ui_getBoundingRect(node, out2) {
+    const $r = Module.jsb.host.ui.getBoundingRect(node);
+    if (!$r) return 0;
+    for (let $i = 0; $i < 4; $i++) HEAPF32[(out2 >> 2) + $i] = $r[$i] || 0;
+    return 1;
+  }
+  function jshost_ui_touchHandler(pointerId, hasMove, claim, node) {
+    Module.jsb.host.ui.touchHandler(pointerId, !!hasMove, claim, node);
+  }
+  function jshost_ui_longPressHandler(pointerId, node) {
+    Module.jsb.host.ui.longPressHandler(pointerId, node);
+  }
+  function jshost_ui_vlistScroll(node, scrollY, animated) {
+    Module.jsb.host.ui.vlistScroll(node, scrollY, !!animated);
+  }
+  function jshost_ui_pagerCommand(node, cmd, animated) {
+    Module.jsb.host.ui.pagerCommand(node, cmd ? UTF8ToString(cmd) : null, !!animated);
+  }
+  function jshost_ui_pagerShowPage(node, page, above) {
+    Module.jsb.host.ui.pagerShowPage(node, page, !!above);
+  }
+  function jshost_ui_pagerDropPage(node, page) {
+    Module.jsb.host.ui.pagerDropPage(node, page);
+  }
+  function jshost_ui_pagerPageMounted(page, mounted) {
+    Module.jsb.host.ui.pagerPageMounted(page, !!mounted);
+  }
+  function jshost_ui_tweenClaim(node, prop, lanes, samples, samplesCount, durationMs, delayMs, iterations, pingPong, rate) {
+    return Module.jsb.host.ui.tweenClaim(node, prop ? UTF8ToString(prop) : null, lanes, HEAPF32.subarray(samples >> 2, (samples >> 2) + samplesCount), durationMs, delayMs, iterations, !!pingPong, rate) ? 1 : 0;
+  }
+  function jshost_ui_tweenRelease(node, prop, reason) {
+    Module.jsb.host.ui.tweenRelease(node, prop ? UTF8ToString(prop) : null, reason);
+  }
+  function jshost_canvas_paint(surfaceId, pw, ph, scale, words, wordsCount, strings, stringsCount) {
+    Module.jsb.host.canvas.paint(surfaceId, pw, ph, scale, HEAPF32.subarray(words >> 2, (words >> 2) + wordsCount), Module.jsb.strings(strings, stringsCount));
+  }
+  function jshost_canvas_measureText(text, family, size, weight, italic, out2) {
+    Module.jsb.host.canvas.measureText(text ? UTF8ToString(text) : null, family ? UTF8ToString(family) : null, size, weight, !!italic, HEAPF32.subarray(out2 >> 2, (out2 >> 2) + 16));
+  }
+  function jshost_canvas_decodeImage(bufferId, surfaceId, size) {
+    return Module.jsb.host.canvas.decodeImage(bufferId, surfaceId, HEAP32.subarray(size >> 2, (size >> 2) + 16)) ? 1 : 0;
+  }
+  function jshost_canvas_readPixels(surfaceId, size) {
+    const $r = Module.jsb.host.canvas.readPixels(surfaceId, HEAP32.subarray(size >> 2, (size >> 2) + 16));
+    return Module.jsb.bytesOut($r, 0);
+  }
+  function jshost_canvas_releaseSurface(surfaceId) {
+    Module.jsb.host.canvas.releaseSurface(surfaceId);
+  }
+  function jshost_app_state() {
+    const $r = Module.jsb.host.app.state();
+    return $r == null ? 0 : stringToNewUTF8(String($r));
+  }
+  function jshost_app_isOnline() {
+    return Module.jsb.host.app.isOnline() ? 1 : 0;
+  }
+  function jshost_app_openUrl(url) {
+    Module.jsb.host.app.openUrl(url ? UTF8ToString(url) : null);
+  }
+  function jshost_app_setOrientation(mode) {
+    Module.jsb.host.app.setOrientation(mode ? UTF8ToString(mode) : null);
+  }
+  function jshost_app_worldChange(projectUuid, trusted) {
+    Module.jsb.host.app.worldChange(projectUuid ? UTF8ToString(projectUuid) : null, !!trusted);
+  }
+  function jshost_app_exit() {
+    Module.jsb.host.app.exit();
+  }
+  function jshost_device_setPreciseTouch(enabled) {
+    Module.jsb.host.device.setPreciseTouch(!!enabled);
+  }
+  function jshost_device_vibrate(style) {
+    Module.jsb.host.device.vibrate(style ? UTF8ToString(style) : null);
+  }
+  function jshost_device_motionAvailable() {
+    return Module.jsb.host.device.motionAvailable() ? 1 : 0;
+  }
+  function jshost_device_motionStart(interval) {
+    return Module.jsb.host.device.motionStart(interval) ? 1 : 0;
+  }
+  function jshost_device_motionStop() {
+    Module.jsb.host.device.motionStop();
+  }
+  function jshost_device_motionSample(out2) {
+    const $r = Module.jsb.host.device.motionSample();
+    if (!$r) return 0;
+    for (let $i = 0; $i < 8; $i++) HEAPF32[(out2 >> 2) + $i] = $r[$i] || 0;
+    return 1;
+  }
+  function jshost_device_clipboardWrite(text) {
+    Module.jsb.host.device.clipboardWrite(text ? UTF8ToString(text) : null);
+  }
+  function jshost_device_clipboardRead(onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.device.clipboardRead(Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_device_share(systemId, text) {
+    Module.jsb.host.device.share(systemId, text ? UTF8ToString(text) : null);
+  }
+  function jshost_device_openFilePicker(onComplete, onReject, multiple, accept) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.device.openFilePicker(Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g), !!multiple, accept ? UTF8ToString(accept) : null);
+  }
+  function jshost_device_requestCamera(onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.device.requestCamera(Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_fetch_local(path) {
+    return Module.jsb.host.fetch.local(path ? UTF8ToString(path) : null) || 0;
+  }
+  function jshost_fetch_dispose(systemId) {
+    Module.jsb.host.fetch.dispose(systemId);
+  }
+  function jshost_fetch_request(url, method, headers, headersCount, body, form, formCount, onComplete, onReject, onProgress) {
+    const $g = Module.jsb.group(onComplete, onReject, onProgress);
+    Module.jsb.host.fetch.request(url ? UTF8ToString(url) : null, method ? UTF8ToString(method) : null, Module.jsb.strings(headers, headersCount), body ? UTF8ToString(body) : null, Array.from({ length: formCount }, (_, $i) => ({ key: HEAPU32[form + $i * 16 + 0 >> 2] ? UTF8ToString(HEAPU32[form + $i * 16 + 0 >> 2]) : null, value: HEAPU32[form + $i * 16 + 4 >> 2] ? UTF8ToString(HEAPU32[form + $i * 16 + 4 >> 2]) : null, bufferId: HEAP32[form + $i * 16 + 8 >> 2], filename: HEAPU32[form + $i * 16 + 12 >> 2] ? UTF8ToString(HEAPU32[form + $i * 16 + 12 >> 2]) : null })), Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g), Module.jsb.callback(onProgress, $g));
+  }
+  function jshost_fetch_buffer(id, addByte, outSize) {
+    const $r = Module.jsb.host.fetch.buffer(id, !!addByte);
+    return Module.jsb.bytesOut($r, outSize);
+  }
+  function jshost_fetch_bufferSlice(id, start, end, addByte, outSize) {
+    const $r = Module.jsb.host.fetch.bufferSlice(id, start, end, !!addByte);
+    return Module.jsb.bytesOut($r, outSize);
+  }
+  function jshost_fetch_systemBuffer(id, outSize) {
+    const $r = Module.jsb.host.fetch.systemBuffer(id);
+    return Module.jsb.bytesOut($r, outSize);
+  }
+  function jshost_fetch_putBuffer(bytes, bytesSize) {
+    return Module.jsb.host.fetch.putBuffer(HEAPU8.subarray(bytes, bytes + bytesSize)) || 0;
+  }
+  function jshost_files_readBytes(path, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.files.readBytes(path ? UTF8ToString(path) : null, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_files_readText(path, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.files.readText(path ? UTF8ToString(path) : null, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_files_remove(path, recursive, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.files.remove(path ? UTF8ToString(path) : null, !!recursive, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_files_mkdir(path, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.files.mkdir(path ? UTF8ToString(path) : null, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_files_list(path, recursive, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.files.list(path ? UTF8ToString(path) : null, !!recursive, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_files_stat(path, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.files.stat(path ? UTF8ToString(path) : null, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_files_write(path, data, dataSize, append, onComplete, onReject) {
+    const $g = Module.jsb.group(onComplete, onReject);
+    Module.jsb.host.files.write(path ? UTF8ToString(path) : null, HEAPU8.subarray(data, data + dataSize), !!append, Module.jsb.callback(onComplete, $g), Module.jsb.callback(onReject, $g));
+  }
+  function jshost_storage_load(name) {
+    const $r = Module.jsb.host.storage.load(name ? UTF8ToString(name) : null);
+    return $r == null ? 0 : stringToNewUTF8(String($r));
+  }
+  function jshost_storage_save(name, json) {
+    Module.jsb.host.storage.save(name ? UTF8ToString(name) : null, json ? UTF8ToString(json) : null);
+  }
+  function jshost_socket_send(id, message) {
+    Module.jsb.host.socket.send(id, message ? UTF8ToString(message) : null);
+  }
+  function jshost_socket_open(url, onMessage) {
+    const $g = null;
+    return Module.jsb.host.socket.open(url ? UTF8ToString(url) : null, Module.jsb.callback(onMessage, $g)) || 0;
+  }
+  function jshost_socket_close(id) {
+    Module.jsb.host.socket.close(id);
+  }
+  function jshost_service_supported(name) {
+    return Module.jsb.host.service.supported(name ? UTF8ToString(name) : null) ? 1 : 0;
+  }
+  function jshost_service_open(name, params, onEvent) {
+    const $g = null;
+    return Module.jsb.host.service.open(name ? UTF8ToString(name) : null, params ? UTF8ToString(params) : null, Module.jsb.callback(onEvent, $g)) || 0;
+  }
+  function jshost_service_close(serviceId) {
+    Module.jsb.host.service.close(serviceId);
+  }
+  function jshost_service_version(name) {
+    return Module.jsb.host.service.version(name ? UTF8ToString(name) : null) || 0;
+  }
+  function jshost_service_call_js(serviceId, method, args, onComplete, onError) {
+    const $g = Module.jsb.group(onComplete, onError);
+    Module.jsb.host.service.call(serviceId, method ? UTF8ToString(method) : null, Module.jsb.valueAt(args), Module.jsb.callback(onComplete, $g), Module.jsb.callback(onError, $g));
+  }
+  function jshost_input_key(code, gamepad) {
+    return Module.jsb.host.input.key(code ? UTF8ToString(code) : null, gamepad) ? 1 : 0;
+  }
+  function jshost_input_read(channel) {
+    return Module.jsb.host.input.read(channel) || 0;
+  }
+  function jshost_input_setPointerLock(on) {
+    return Module.jsb.host.input.setPointerLock(!!on) ? 1 : 0;
+  }
+  function jshost_input_rumble(gamepad, strong, weak, durationMs) {
+    return Module.jsb.host.input.rumble(gamepad, strong, weak, durationMs) ? 1 : 0;
+  }
+  function jshost_input_keyboardHeight() {
+    return Module.jsb.host.input.keyboardHeight() || 0;
+  }
+  function jshost_media_setVolume(id, volume) {
+    Module.jsb.host.media.setVolume(id, volume);
+  }
+  function jshost_media_time(id) {
+    return Module.jsb.host.media.time(id) || 0;
+  }
+  function jshost_media_setTime(id, time) {
+    Module.jsb.host.media.setTime(id, time);
+  }
+  function jshost_media_duration(id) {
+    return Module.jsb.host.media.duration(id) || 0;
+  }
+  function jshost_media_createAudio(src, onFinished) {
+    const $g = null;
+    return Module.jsb.host.media.createAudio(src ? UTF8ToString(src) : null, Module.jsb.callback(onFinished, $g)) || 0;
+  }
+  function jshost_media_createVideo(src, onFinished) {
+    const $g = null;
+    return Module.jsb.host.media.createVideo(src ? UTF8ToString(src) : null, Module.jsb.callback(onFinished, $g)) || 0;
+  }
+  function jshost_media_setLoop(id, loop) {
+    Module.jsb.host.media.setLoop(id, !!loop);
+  }
+  function jshost_media_setPlaying(id, playing) {
+    Module.jsb.host.media.setPlaying(id, !!playing);
+  }
+  function jshost_media_remove(id) {
+    Module.jsb.host.media.remove(id);
+  }
+  function slog_js_log(level, c_str) {
+    const str = UTF8ToString(c_str);
+    switch (level) {
+      case 0:
+        console.error(str);
+        break;
+      case 1:
+        console.error(str);
+        break;
+      case 2:
+        console.warn(str);
+        break;
+      default:
+        console.info(str);
+        break;
+    }
+  }
+  function cuiConsoleError(msg) {
+    console.error(UTF8ToString(msg));
+  }
+  function jshost_refreshDone(node) {
+    const ui = Module.jsb.host.ui;
+    if (ui.refreshDone) ui.refreshDone(node);
+  }
+  var _malloc, _setThrew, __emscripten_stack_restore, _emscripten_stack_get_current, ___cxa_decrement_exception_refcount, ___cxa_get_exception_ptr, wasmMemory, wasmTable;
+  function assignWasmExports(wasmExports2) {
+    Module["_free"] = wasmExports2["ve"];
+    Module["_setNodeClass"] = wasmExports2["we"];
+    Module["_setThemeValue"] = wasmExports2["xe"];
+    Module["_applyTheme"] = wasmExports2["ye"];
+    Module["_getScreenId"] = wasmExports2["ze"];
+    Module["_getParentNode"] = wasmExports2["Ae"];
+    Module["_c2dGetLocalTransform"] = wasmExports2["Be"];
+    Module["_c2dSetPosition"] = wasmExports2["Ce"];
+    Module["_c2dSetRotation"] = wasmExports2["De"];
+    Module["_c2dSetScale"] = wasmExports2["Ee"];
+    Module["_c2dSetSpriteOpacity"] = wasmExports2["Fe"];
+    Module["_c2dSetSpriteColor"] = wasmExports2["Ge"];
+    Module["_c2dGetSpriteOpacity"] = wasmExports2["He"];
+    Module["_c2dGetSpriteColor"] = wasmExports2["Ie"];
+    _malloc = Module["_malloc"] = wasmExports2["Je"];
+    Module["_jsbInvoke"] = wasmExports2["Ke"];
+    Module["_jsbInvokeGetter"] = wasmExports2["Le"];
+    Module["_jsbInvokeData"] = wasmExports2["Me"];
+    Module["_jsbFunctionGone"] = wasmExports2["Ne"];
+    Module["_jsbFinalize"] = wasmExports2["Oe"];
+    Module["_jsbHostCall"] = wasmExports2["Pe"];
+    Module["_jsbRejection"] = wasmExports2["Qe"];
+    Module["_calculate"] = wasmExports2["Re"];
+    Module["_widgetDetach"] = wasmExports2["Se"];
+    Module["_recalculate"] = wasmExports2["Te"];
+    Module["_calculateRoot"] = wasmExports2["Ue"];
+    Module["_calculateWidget"] = wasmExports2["Ve"];
+    Module["_collectBegin"] = wasmExports2["We"];
+    Module["_collectRoot"] = wasmExports2["Xe"];
+    Module["_collectCount"] = wasmExports2["Ye"];
+    Module["_jsbViewEvent"] = wasmExports2["Ze"];
+    Module["_getNodeOwner"] = wasmExports2["_e"];
+    Module["_createNodeRoot"] = wasmExports2["$e"];
+    Module["_setNodeMeasure"] = wasmExports2["af"];
+    Module["_setNodeOwner"] = wasmExports2["bf"];
+    Module["_forEachNode"] = wasmExports2["cf"];
+    Module["_freeNode"] = wasmExports2["df"];
+    Module["_vlistExists"] = wasmExports2["ef"];
+    Module["_adoptNode"] = wasmExports2["ff"];
+    Module["_detachNode"] = wasmExports2["gf"];
+    Module["_cuiChildCount"] = wasmExports2["hf"];
+    Module["_cuiChildAt"] = wasmExports2["jf"];
+    Module["_setStringExt"] = wasmExports2["kf"];
+    Module["_resetPropExt"] = wasmExports2["lf"];
+    Module["_nodeHasMeasure"] = wasmExports2["mf"];
+    Module["_nodeHasFixedSize"] = wasmExports2["nf"];
+    Module["_markNodeDirty"] = wasmExports2["of"];
+    Module["_setNodeInteractive"] = wasmExports2["pf"];
+    Module["_setFloatExt"] = wasmExports2["qf"];
+    Module["_getLayer"] = wasmExports2["rf"];
+    Module["_setNodeHovered"] = wasmExports2["sf"];
+    Module["_cuiPaintJson"] = wasmExports2["tf"];
+    Module["_setVListHandlers"] = wasmExports2["uf"];
+    Module["_vlistInit"] = wasmExports2["vf"];
+    Module["_vlistFree"] = wasmExports2["wf"];
+    Module["_vlistSetKeys"] = wasmExports2["xf"];
+    Module["_vlistInsertKeys"] = wasmExports2["yf"];
+    Module["_vlistRemoveKeys"] = wasmExports2["zf"];
+    Module["_vlistInvalidate"] = wasmExports2["Af"];
+    Module["_vlistCreateItemRoot"] = wasmExports2["Bf"];
+    Module["_vlistItemMounted"] = wasmExports2["Cf"];
+    Module["_vlistItemUnmounted"] = wasmExports2["Df"];
+    Module["_vlistToPhysical"] = wasmExports2["Ef"];
+    Module["_getContentHeight"] = wasmExports2["Ff"];
+    Module["_vlistOffsetOf"] = wasmExports2["Gf"];
+    Module["_c2dInit"] = wasmExports2["Hf"];
+    Module["_c2dOpenScene"] = wasmExports2["If"];
+    Module["_c2dSetUpdateCallbacks"] = wasmExports2["Jf"];
+    Module["_c2dSetAnimEventCallback"] = wasmExports2["Kf"];
+    Module["_c2dSetPhysicsEventCallback"] = wasmExports2["Lf"];
+    Module["_c2dCloseScene"] = wasmExports2["Mf"];
+    Module["_c2dEntityIsOwned"] = wasmExports2["Nf"];
+    Module["_c2dDestroyEntity"] = wasmExports2["Of"];
+    Module["_c2dResetStateCache"] = wasmExports2["Pf"];
+    Module["_c2dRender"] = wasmExports2["Qf"];
+    Module["_c2dTick"] = wasmExports2["Rf"];
+    Module["_c2dGetChildCount"] = wasmExports2["Sf"];
+    Module["_c2dGetChild"] = wasmExports2["Tf"];
+    Module["_c2dCreateTexture"] = wasmExports2["Uf"];
+    Module["_c2dGetTextureWidth"] = wasmExports2["Vf"];
+    Module["_c2dGetTextureHeight"] = wasmExports2["Wf"];
+    Module["_c2dCreateTextureFromRGBA"] = wasmExports2["Xf"];
+    Module["_c2dUpdateTextureFromRGBA"] = wasmExports2["Yf"];
+    Module["_creator2dVersion"] = wasmExports2["Zf"];
+    Module["_c2dSetTimeScale"] = wasmExports2["_f"];
+    Module["_c2dSetClearColor"] = wasmExports2["$f"];
+    Module["_c2dCreateScene"] = wasmExports2["ag"];
+    Module["_c2dDestroyScene"] = wasmExports2["bg"];
+    Module["_c2dSceneSetClearColor"] = wasmExports2["cg"];
+    Module["_c2dAddEntityToScene"] = wasmExports2["dg"];
+    Module["_c2dRemoveEntityFromScene"] = wasmExports2["eg"];
+    Module["_c2dSetLayerYSort"] = wasmExports2["fg"];
+    Module["_c2dCameraSetPosition"] = wasmExports2["gg"];
+    Module["_c2dCameraSetZoom"] = wasmExports2["hg"];
+    Module["_c2dCameraSetRotation"] = wasmExports2["ig"];
+    Module["_c2dCameraScreenToWorld"] = wasmExports2["jg"];
+    Module["_c2dCameraWorldToScreen"] = wasmExports2["kg"];
+    Module["_c2dCreateEntity"] = wasmExports2["lg"];
+    Module["_c2dSetLayer"] = wasmExports2["mg"];
+    Module["_c2dSetZ"] = wasmExports2["ng"];
+    Module["_c2dSetVisible"] = wasmExports2["og"];
+    Module["_c2dGetPosition"] = wasmExports2["pg"];
+    Module["_c2dSetParent"] = wasmExports2["qg"];
+    Module["_c2dGetParent"] = wasmExports2["rg"];
+    Module["_c2dGetWorldPosition"] = wasmExports2["sg"];
+    Module["_c2dGetWorldMatrix"] = wasmExports2["tg"];
+    Module["_c2dWorldToLocal"] = wasmExports2["ug"];
+    Module["_c2dLocalToWorld"] = wasmExports2["vg"];
+    Module["_c2dSetSprite"] = wasmExports2["wg"];
+    Module["_c2dSetSpriteFrame"] = wasmExports2["xg"];
+    Module["_c2dSetSpriteFramePx"] = wasmExports2["yg"];
+    Module["_c2dSetSpriteSize"] = wasmExports2["zg"];
+    Module["_c2dSetSpriteAnchor"] = wasmExports2["Ag"];
+    Module["_c2dSetSpriteFlip"] = wasmExports2["Bg"];
+    Module["_c2dDestroyTexture"] = wasmExports2["Cg"];
+    Module["_c2dSetDefaultFilter"] = wasmExports2["Dg"];
+    Module["_c2dDefineAnimation"] = wasmExports2["Eg"];
+    Module["_c2dPlayAnimation"] = wasmExports2["Fg"];
+    Module["_c2dStopAnimation"] = wasmExports2["Gg"];
+    Module["_c2dSetAnimationSpeed"] = wasmExports2["Hg"];
+    Module["_c2dGetAnimationFrame"] = wasmExports2["Ig"];
+    Module["_c2dCreateTilemap"] = wasmExports2["Jg"];
+    Module["_c2dSetTile"] = wasmExports2["Kg"];
+    Module["_c2dBulkSetPositions"] = wasmExports2["Lg"];
+    Module["_c2dPhysicsHasSupport"] = wasmExports2["Mg"];
+    Module["_c2dPhysicsConfigure"] = wasmExports2["Ng"];
+    Module["_c2dSetInterpolation"] = wasmExports2["Og"];
+    Module["_c2dPhysicsCreateBody"] = wasmExports2["Pg"];
+    Module["_c2dPhysicsRemoveBody"] = wasmExports2["Qg"];
+    Module["_c2dPhysicsAddBox"] = wasmExports2["Rg"];
+    Module["_c2dPhysicsAddCircle"] = wasmExports2["Sg"];
+    Module["_c2dPhysicsAddCapsule"] = wasmExports2["Tg"];
+    Module["_c2dPhysicsAddSegment"] = wasmExports2["Ug"];
+    Module["_c2dPhysicsAddPolygon"] = wasmExports2["Vg"];
+    Module["_c2dPhysicsAddChain"] = wasmExports2["Wg"];
+    Module["_c2dPhysicsClearShapes"] = wasmExports2["Xg"];
+    Module["_c2dPhysicsSetContactEvents"] = wasmExports2["Yg"];
+    Module["_c2dPhysicsSetLinearVelocity"] = wasmExports2["Zg"];
+    Module["_c2dPhysicsGetLinearVelocity"] = wasmExports2["_g"];
+    Module["_c2dPhysicsSetAngularVelocity"] = wasmExports2["$g"];
+    Module["_c2dPhysicsGetAngularVelocity"] = wasmExports2["ah"];
+    Module["_c2dPhysicsApplyLinearImpulse"] = wasmExports2["bh"];
+    Module["_c2dPhysicsApplyImpulseAt"] = wasmExports2["ch"];
+    Module["_c2dPhysicsApplyForce"] = wasmExports2["dh"];
+    Module["_c2dPhysicsSetFromEntity"] = wasmExports2["eh"];
+    Module["_c2dPhysicsSetFixedRotation"] = wasmExports2["fh"];
+    Module["_c2dPhysicsSetGravityScale"] = wasmExports2["gh"];
+    Module["_c2dPhysicsSetLinearDamping"] = wasmExports2["hh"];
+    Module["_c2dPhysicsSetAngularDamping"] = wasmExports2["ih"];
+    Module["_c2dPhysicsSetBullet"] = wasmExports2["jh"];
+    Module["_c2dPhysicsSetEnabled"] = wasmExports2["kh"];
+    Module["_c2dPhysicsSetAwake"] = wasmExports2["lh"];
+    Module["_c2dPhysicsSetMass"] = wasmExports2["mh"];
+    Module["_c2dPhysicsGetMass"] = wasmExports2["nh"];
+    Module["_c2dPhysicsSetMotionType"] = wasmExports2["oh"];
+    Module["_c2dPhysicsSetFriction"] = wasmExports2["ph"];
+    Module["_c2dPhysicsSetBounce"] = wasmExports2["qh"];
+    Module["_c2dPhysicsSetFilter"] = wasmExports2["rh"];
+    Module["_c2dPhysicsRaycastClosest"] = wasmExports2["sh"];
+    Module["_c2dPhysicsRaycastAll"] = wasmExports2["th"];
+    Module["_c2dPhysicsOverlap"] = wasmExports2["uh"];
+    Module["_c2dPhysicsOverlapPoint"] = wasmExports2["vh"];
+    Module["_c2dCharacterCreate"] = wasmExports2["wh"];
+    Module["_c2dCharacterDestroy"] = wasmExports2["xh"];
+    Module["_c2dCharacterMove"] = wasmExports2["yh"];
+    Module["_c2dCharacterMoveFree"] = wasmExports2["zh"];
+    Module["_c2dCharacterSetVerticalVelocity"] = wasmExports2["Ah"];
+    Module["_c2dCharacterSetVelocity"] = wasmExports2["Bh"];
+    Module["_c2dCharacterSetGravityScale"] = wasmExports2["Ch"];
+    Module["_c2dCharacterSetMaxSlope"] = wasmExports2["Dh"];
+    Module["_c2dCharacterSetFilter"] = wasmExports2["Eh"];
+    Module["_c2dCharacterSetDropThrough"] = wasmExports2["Fh"];
+    Module["_c2dCharacterSetCapsule"] = wasmExports2["Gh"];
+    Module["_c2dCharacterSetFromEntity"] = wasmExports2["Hh"];
+    Module["_c2dCharacterGetState"] = wasmExports2["Ih"];
+    Module["_c2dCharacterGetCollisions"] = wasmExports2["Jh"];
+    Module["_c2dPhysicsSetOneWay"] = wasmExports2["Kh"];
+    Module["_c2dPickSprite"] = wasmExports2["Lh"];
+    Module["_cnavUnloadAll"] = wasmExports2["Mh"];
+    Module["_cnavLastError"] = wasmExports2["Nh"];
+    Module["_cnavLoad"] = wasmExports2["Oh"];
+    Module["_cnavUnload"] = wasmExports2["Ph"];
+    Module["_cnavHeader"] = wasmExports2["Qh"];
+    Module["_cnavPolyCount"] = wasmExports2["Rh"];
+    Module["_cnavSetAreaCost"] = wasmExports2["Sh"];
+    Module["_cnavPath"] = wasmExports2["Th"];
+    Module["_cnavNearestPoint"] = wasmExports2["Uh"];
+    Module["_cnavRay"] = wasmExports2["Vh"];
+    Module["_cnavRandom"] = wasmExports2["Wh"];
+    Module["_cnavTriangles"] = wasmExports2["Xh"];
+    Module["_cnavCrowdNew"] = wasmExports2["Yh"];
+    Module["_cnavCrowdFree"] = wasmExports2["Zh"];
+    Module["_cnavAgentAdd"] = wasmExports2["_h"];
+    Module["_cnavAgentRemove"] = wasmExports2["$h"];
+    Module["_cnavAgentSetParams"] = wasmExports2["ai"];
+    Module["_cnavAgentSetTarget"] = wasmExports2["bi"];
+    Module["_cnavAgentSetVelocity"] = wasmExports2["ci"];
+    Module["_cnavAgentResetTarget"] = wasmExports2["di"];
+    Module["_cnavAgentWarp"] = wasmExports2["ei"];
+    Module["_cnavCrowdStep"] = wasmExports2["fi"];
+    Module["_cnavCrowdReadAll"] = wasmExports2["gi"];
+    Module["_c2dInitMetal"] = wasmExports2["hi"];
+    Module["_c2dInitVulkan"] = wasmExports2["ii"];
+    Module["_c2dInitHeadless"] = wasmExports2["ji"];
+    Module["_c2dTickHeadless"] = wasmExports2["ki"];
+    Module["_c2dReadDrawList"] = wasmExports2["li"];
+    Module["_c2dShutdown"] = wasmExports2["mi"];
+    Module["_c2dSetViewport"] = wasmExports2["ni"];
+    Module["_c2dSetDensity"] = wasmExports2["oi"];
+    Module["_c2dSetGLFramebuffer"] = wasmExports2["pi"];
+    Module["_c2dDrawSceneGL"] = wasmExports2["qi"];
+    Module["_c2dTargetCreate"] = wasmExports2["ri"];
+    Module["_c2dTargetCreateMetal"] = wasmExports2["si"];
+    Module["_c2dTargetDestroy"] = wasmExports2["ti"];
+    Module["_c2dSetPresentTarget"] = wasmExports2["ui"];
+    Module["_c2dDrawSceneTarget"] = wasmExports2["vi"];
+    Module["_c2dTargetVkImage"] = wasmExports2["wi"];
+    Module["_c2dTargetMtlTexture"] = wasmExports2["xi"];
+    Module["_c2dRenderMetal"] = wasmExports2["yi"];
+    Module["_setMeasureFunc"] = wasmExports2["zi"];
+    Module["_createNode"] = wasmExports2["Ai"];
+    Module["_cuiStringOf"] = wasmExports2["Bi"];
+    Module["_removeNode"] = wasmExports2["Ci"];
+    Module["_paintCollect"] = wasmExports2["Di"];
+    Module["_paintNodes"] = wasmExports2["Ei"];
+    Module["_paintRecords"] = wasmExports2["Fi"];
+    Module["_cuiPaintOf"] = wasmExports2["Gi"];
+    Module["_cuiGradientOf"] = wasmExports2["Hi"];
+    Module["_getColor"] = wasmExports2["Ii"];
+    Module["_setFloat"] = wasmExports2["Ji"];
+    Module["_setString"] = wasmExports2["Ki"];
+    Module["_getThemeValue"] = wasmExports2["Li"];
+    Module["_resetProp"] = wasmExports2["Mi"];
+    Module["_enableNodeLayer"] = wasmExports2["Ni"];
+    Module["_disableNodeLayer"] = wasmExports2["Oi"];
+    Module["_resetNodeLayer"] = wasmExports2["Pi"];
+    Module["_mergeNodeLayer"] = wasmExports2["Qi"];
+    Module["_setNodePressed"] = wasmExports2["Ri"];
+    Module["_setNodeFocused"] = wasmExports2["Si"];
+    Module["_setConditionValue"] = wasmExports2["Ti"];
+    Module["_freeWidget"] = wasmExports2["Ui"];
+    Module["_setSafePaddings"] = wasmExports2["Vi"];
+    Module["_overrideRootSafeBottom"] = wasmExports2["Wi"];
+    Module["_setSafeAreaBars"] = wasmExports2["Xi"];
+    Module["_consumeNeedsLayout"] = wasmExports2["Yi"];
+    Module["_getCachedRoot"] = wasmExports2["Zi"];
+    Module["_collectNodes"] = wasmExports2["_i"];
+    Module["_collectRects"] = wasmExports2["$i"];
+    Module["_getOffset"] = wasmExports2["aj"];
+    Module["_getContentWidth"] = wasmExports2["bj"];
+    Module["_getLayoutPointer"] = wasmExports2["cj"];
+    Module["_getLayoutDOMPointer"] = wasmExports2["dj"];
+    Module["_getPaddingPointer"] = wasmExports2["ej"];
+    Module["_vlistOnScroll"] = wasmExports2["fj"];
+    Module["_vlistUpdateLayout"] = wasmExports2["gj"];
+    Module["_vlistItemOffsetOf"] = wasmExports2["hj"];
+    Module["_cnavBuildDefaults"] = wasmExports2["ij"];
+    Module["_cnavBuildCreate"] = wasmExports2["jj"];
+    Module["_cnavBuildDestroy"] = wasmExports2["kj"];
+    Module["_cnavBuildAddTriangles"] = wasmExports2["lj"];
+    Module["_cnavBuildAddVolume"] = wasmExports2["mj"];
+    Module["_cnavBuildAddLink"] = wasmExports2["nj"];
+    Module["_cnavBuildRun"] = wasmExports2["oj"];
+    Module["_cnavBuildData"] = wasmExports2["pj"];
+    Module["_cnavBuildTileCount"] = wasmExports2["qj"];
+    Module["_cnavBuildPolyCount"] = wasmExports2["rj"];
+    Module["_cnavBuildBounds"] = wasmExports2["sj"];
+    Module["_cnavMeshLoad"] = wasmExports2["tj"];
+    Module["_cnavMeshDestroy"] = wasmExports2["uj"];
+    Module["_cnavMeshHeader"] = wasmExports2["vj"];
+    Module["_cnavMeshTileCount"] = wasmExports2["wj"];
+    Module["_cnavMeshPolyCount"] = wasmExports2["xj"];
+    Module["_cnavMeshSetAreaCost"] = wasmExports2["yj"];
+    Module["_cnavFindPath"] = wasmExports2["zj"];
+    Module["_cnavNearest"] = wasmExports2["Aj"];
+    Module["_cnavRaycast"] = wasmExports2["Bj"];
+    Module["_cnavRandomPoint"] = wasmExports2["Cj"];
+    Module["_cnavDebugTriangles"] = wasmExports2["Dj"];
+    Module["_cnavAgentDefaults"] = wasmExports2["Ej"];
+    Module["_cnavCrowdCreate"] = wasmExports2["Fj"];
+    Module["_cnavCrowdDestroy"] = wasmExports2["Gj"];
+    Module["_cnavCrowdMaxAgents"] = wasmExports2["Hj"];
+    Module["_cnavCrowdAdd"] = wasmExports2["Ij"];
+    Module["_cnavCrowdRemove"] = wasmExports2["Jj"];
+    Module["_cnavCrowdSetParams"] = wasmExports2["Kj"];
+    Module["_cnavCrowdSetTarget"] = wasmExports2["Lj"];
+    Module["_cnavCrowdSetVelocity"] = wasmExports2["Mj"];
+    Module["_cnavCrowdResetTarget"] = wasmExports2["Nj"];
+    Module["_cnavCrowdWarp"] = wasmExports2["Oj"];
+    Module["_cnavCrowdUpdate"] = wasmExports2["Pj"];
+    Module["_cnavCrowdRead"] = wasmExports2["Qj"];
+    Module["_creatorWebVersion"] = wasmExports2["Rj"];
+    Module["_creatorWebInit"] = wasmExports2["Sj"];
+    Module["_creatorWebRun"] = wasmExports2["Tj"];
+    Module["_creatorWebTick"] = wasmExports2["Uj"];
+    Module["_creatorWebTickCore"] = wasmExports2["Vj"];
+    Module["_creatorWebResize"] = wasmExports2["Wj"];
+    Module["_creatorWebLayoutFrame"] = wasmExports2["Xj"];
+    Module["_creatorWebDebugDump"] = wasmExports2["Yj"];
+    Module["_creatorWebBackPressed"] = wasmExports2["Zj"];
+    Module["_creatorWebSetStepEveryTick"] = wasmExports2["_j"];
+    Module["_creatorWebSceneOpen"] = wasmExports2["$j"];
+    Module["_creatorWebFrameRendered"] = wasmExports2["ak"];
+    Module["_creatorWebSetViewport"] = wasmExports2["bk"];
+    Module["_creatorWebSceneRenderScale"] = wasmExports2["ck"];
+    Module["_creatorWebAppEvent"] = wasmExports2["dk"];
+    Module["_creatorWebInputEvent"] = wasmExports2["ek"];
+    Module["_creatorWebKeyboardEvent"] = wasmExports2["fk"];
+    Module["_creatorWebSetLaunchUrl"] = wasmExports2["gk"];
+    Module["_creatorWebSetBootProjectUuid"] = wasmExports2["hk"];
+    Module["_creatorWebQuitToLauncher"] = wasmExports2["ik"];
+    Module["_creatorWebViewEvent"] = wasmExports2["jk"];
+    Module["_creatorWebNodeEvent"] = wasmExports2["kk"];
+    Module["_creatorWebNodeEventNum"] = wasmExports2["lk"];
+    Module["_creatorWebNodeEventStr"] = wasmExports2["mk"];
+    Module["_creatorWebNodeLayout"] = wasmExports2["nk"];
+    Module["_creatorWebNodeScroll"] = wasmExports2["ok"];
+    Module["_creatorWebNodeTouchStart"] = wasmExports2["pk"];
+    Module["_creatorWebNodeLongPress"] = wasmExports2["qk"];
+    Module["_creatorWebNodeClick"] = wasmExports2["rk"];
+    Module["_creatorWebTouchMove"] = wasmExports2["sk"];
+    Module["_creatorWebTouchEnd"] = wasmExports2["tk"];
+    Module["_creatorWebTouchCancel"] = wasmExports2["uk"];
+    Module["_creatorWebRefresh"] = wasmExports2["vk"];
+    Module["_creatorWebHover"] = wasmExports2["wk"];
+    Module["_creatorWebSceneTouchStart"] = wasmExports2["xk"];
+    Module["_creatorWebSceneTouchClick"] = wasmExports2["yk"];
+    Module["_creatorWebSetShrunkRoot"] = wasmExports2["zk"];
+    Module["_creatorWebSetWidgetBox"] = wasmExports2["Ak"];
+    Module["_creatorWebRootLayoutHeight"] = wasmExports2["Bk"];
+    Module["_creatorWebPagerLayoutPages"] = wasmExports2["Ck"];
+    Module["_creatorWebPagerDidSelect"] = wasmExports2["Dk"];
+    Module["_creatorWebPagerTabCount"] = wasmExports2["Ek"];
+    Module["_creatorWebPagerSelectedIndex"] = wasmExports2["Fk"];
+    Module["_creatorWebPagerStackLen"] = wasmExports2["Gk"];
+    Module["_creatorWebPagerPageNode"] = wasmExports2["Hk"];
+    Module["_creatorWeb2dEnsureInited"] = wasmExports2["Ik"];
+    Module["_creatorWeb2dSceneOpen"] = wasmExports2["Jk"];
+    Module["_creatorWeb2dRenderFrame"] = wasmExports2["Kk"];
+    Module["_creatorWeb2dEmitPointer"] = wasmExports2["Lk"];
+    _setThrew = wasmExports2["Mk"];
+    __emscripten_stack_restore = wasmExports2["Nk"];
+    _emscripten_stack_get_current = wasmExports2["Ok"];
+    ___cxa_decrement_exception_refcount = wasmExports2["Pk"];
+    ___cxa_get_exception_ptr = wasmExports2["Qk"];
+    wasmMemory = wasmExports2["se"];
+    wasmTable = wasmExports2["ue"];
+  }
+  var wasmImports = { S: ___cxa_begin_catch, hc: ___cxa_end_catch, a: ___cxa_find_matching_catch_2, n: ___cxa_find_matching_catch_3, ic: ___cxa_rethrow, F: ___cxa_throw, c: ___resumeException, $b: __abort_js, Zb: _clock_time_get, fc: cuiConsoleError, zd: _emscripten_asm_const_int, Vb: _emscripten_get_now, Tb: _emscripten_resize_heap, K: _emscripten_webgl_make_context_current, Wb: _environ_get, Xb: _environ_sizes_get, Yb: _fd_close, Ub: _fd_seek, aa: _fd_write, U: _glActiveTexture, Y: _glAttachShader, u: _glBindBuffer, fa: _glBindBufferBase, Xc: _glBindBufferRange, C: _glBindFramebuffer, gd: _glBindRenderbuffer, T: _glBindSampler, B: _glBindTexture, ya: _glBindVertexArray, ka: _glBlendColor, la: _glBlendEquationSeparate, ma: _glBlendFuncSeparate, Dc: _glBlitFramebuffer, sd: _glBufferData, ua: _glBufferSubData, oc: _glCheckFramebufferStatus, bd: _glClearBufferfi, oa: _glClearBufferfv, ad: _glClearBufferiv, P: _glColorMask, rc: _glCompileShader, xc: _glCompressedTexSubImage2D, vc: _glCompressedTexSubImage3D, md: _glCreateProgram, tc: _glCreateShader, ja: _glCullFace, yc: _glDeleteBuffers, Z: _glDeleteFramebuffers, I: _glDeleteProgram, va: _glDeleteRenderbuffers, wa: _glDeleteSamplers, H: _glDeleteShader, Q: _glDeleteTextures, ud: _glDeleteVertexArrays, W: _glDepthFunc, X: _glDepthMask, v: _glDisable, ha: _glDisableVertexAttribArray, Fc: _glDrawArrays, Gc: _glDrawArraysInstanced, pa: _glDrawBuffers, Hc: _glDrawElements, Ic: _glDrawElementsInstanced, y: _glEnable, Tc: _glEnableVertexAttribArray, E: _glFramebufferRenderbuffer, D: _glFramebufferTexture2D, pc: _glFramebufferTextureLayer, ia: _glFrontFace, td: _glGenBuffers, xa: _glGenFramebuffers, hd: _glGenRenderbuffers, nd: _glGenSamplers, rd: _glGenTextures, xd: _glGenVertexArrays, id: _glGetAttribLocation, p: _glGetIntegerv, kd: _glGetProgramInfoLog, ra: _glGetProgramiv, qc: _glGetShaderInfoLog, ea: _glGetShaderiv, yd: _glGetStringi, qa: _glGetUniformLocation, Cc: _glInvalidateFramebuffer, sa: _glLinkProgram, wd: _glPixelStorei, na: _glPolygonOffset, Ec: _glReadBuffer, fd: _glRenderbufferStorageMultisample, ta: _glSamplerParameterf, x: _glSamplerParameteri, cd: _glScissor, sc: _glShaderSource, Bc: _glStencilFunc, _c: _glStencilFuncSeparate, O: _glStencilMask, Ac: _glStencilOp, Zc: _glStencilOpSeparate, pd: _glTexStorage2D, od: _glTexStorage3D, wc: _glTexSubImage2D, uc: _glTexSubImage3D, Sc: _glUniform1fv, jd: _glUniform1i, Nc: _glUniform1iv, Rc: _glUniform2fv, Mc: _glUniform2iv, Qc: _glUniform3fv, Lc: _glUniform3iv, Oc: _glUniform4fv, Kc: _glUniform4iv, Jc: _glUniformMatrix4fv, J: _glUseProgram, Uc: _glVertexAttribDivisor, Vc: _glVertexAttribIPointer, Wc: _glVertexAttribPointer, dd: _glViewport, q: invoke_fi, m: invoke_fiif, j: invoke_fiiif, i: invoke_fiiiff, ba: invoke_fiiifff, d: invoke_ii, M: invoke_iiffiiiffiiiii, g: invoke_iii, G: invoke_iiii, w: invoke_iiiii, dc: invoke_iiiiii, ca: invoke_iiiiiiiiffff, ec: invoke_iiiiiiiiii, f: invoke_v, k: invoke_vi, t: invoke_vif, cc: invoke_viffi, o: invoke_vifi, e: invoke_vii, A: invoke_viif, lc: invoke_viiff, l: invoke_viii, jc: invoke_viiiffffii, mc: invoke_viiiffiiiii, h: invoke_viiii, bc: invoke_viiiif, N: invoke_viiiii, z: invoke_viiiiii, L: invoke_viiiiiiii, Bd: jsb_arrayIn, vd: jsb_arrayOut, zc: jsb_call, kc: jsb_defineMethod, R: jsb_dup, Pb: jsb_eval, Qb: jsb_freeContext, Rb: jsb_gc, qd: jsb_get, ld: jsb_getIndex, Yc: jsb_global, ed: jsb_has, _b: jsb_init, $c: jsb_keys, nc: jsb_logString, gc: jsb_makeFunction, re: jsb_newArray, Sb: jsb_newContext, Ta: jsb_newError, _: jsb_newObject, cb: jsb_newString, Pc: jsb_parseJson, r: jsb_release, ge: jsb_set, Xd: jsb_setIndex, nb: jsb_str, da: jsb_takeException, V: jsb_throw, Jb: jsb_toNumber, yb: jsb_truthy, Md: jsb_typedArray, Ia: jshost_app_exit, Ma: jshost_app_isOnline, La: jshost_app_openUrl, Ka: jshost_app_setOrientation, Na: jshost_app_state, Ja: jshost_app_worldChange, Qa: jshost_canvas_decodeImage, Ra: jshost_canvas_measureText, Sa: jshost_canvas_paint, Pa: jshost_canvas_readPixels, Oa: jshost_canvas_releaseSurface, Aa: jshost_device_clipboardRead, Ba: jshost_device_clipboardWrite, Fa: jshost_device_motionAvailable, Ca: jshost_device_motionSample, Ea: jshost_device_motionStart, Da: jshost_device_motionStop, qe: jshost_device_openFilePicker, pe: jshost_device_requestCamera, Ha: jshost_device_setPreciseTouch, za: jshost_device_share, Ga: jshost_device_vibrate, le: jshost_fetch_buffer, ke: jshost_fetch_bufferSlice, ne: jshost_fetch_dispose, oe: jshost_fetch_local, ie: jshost_fetch_putBuffer, me: jshost_fetch_request, je: jshost_fetch_systemBuffer, Ob: jshost_fieldNumber, $: jshost_fieldString, ce: jshost_files_list, de: jshost_files_mkdir, he: jshost_files_readBytes, fe: jshost_files_readText, ee: jshost_files_remove, be: jshost_files_stat, ae: jshost_files_write, Kb: jshost_gl_closeScene, Cb: jshost_gl_createARController, Ab: jshost_gl_createAnchor, Lb: jshost_gl_createGLView, Hb: jshost_gl_createMediaPlayerTexture, Bb: jshost_gl_createRootAnchor, Ib: jshost_gl_createTexture, Mb: jshost_gl_engineCreated, Nb: jshost_gl_getGLContext, Gb: jshost_gl_launchAR, Eb: jshost_gl_launchVR, Fb: jshost_gl_stopAR, Db: jshost_gl_stopVR, b: jshost_has, Rd: jshost_input_key, Nd: jshost_input_keyboardHeight, Qd: jshost_input_read, Od: jshost_input_rumble, Pd: jshost_input_setPointerLock, Hd: jshost_media_createAudio, Gd: jshost_media_createVideo, Id: jshost_media_duration, Dd: jshost_media_remove, Fd: jshost_media_setLoop, Ed: jshost_media_setPlaying, Jd: jshost_media_setTime, Ld: jshost_media_setVolume, Kd: jshost_media_time, ac: jshost_refreshDone, xb: jshost_scene2d_close2DScene, wb: jshost_scene2d_init2D, zb: jshost_scene2d_open2DScene, Ad: jshost_service_call_js, Td: jshost_service_close, Ud: jshost_service_open, Vd: jshost_service_supported, Sd: jshost_service_version, Wd: jshost_socket_close, Yd: jshost_socket_open, Zd: jshost_socket_send, $d: jshost_storage_load, _d: jshost_storage_save, s: jshost_table, lb: jshost_ui_closeView, mb: jshost_ui_dropView, bb: jshost_ui_getBoundingRect, eb: jshost_ui_getButtonPressed, db: jshost_ui_getTextValue, rb: jshost_ui_insertNode, kb: jshost_ui_isViewSupported, $a: jshost_ui_longPressHandler, vb: jshost_ui_nodeFactory, ob: jshost_ui_openView, Za: jshost_ui_pagerCommand, Xa: jshost_ui_pagerDropPage, Wa: jshost_ui_pagerPageMounted, Ya: jshost_ui_pagerShowPage, gb: jshost_ui_registerFont, pb: jshost_ui_releaseNode, qb: jshost_ui_removeNode, sb: jshost_ui_setFlags, tb: jshost_ui_setPropertyInt, ub: jshost_ui_setPropertyString, fb: jshost_ui_showToast, ab: jshost_ui_touchHandler, Va: jshost_ui_tweenClaim, Ua: jshost_ui_tweenRelease, Cd: jshost_ui_viewCall_js, jb: jshost_ui_viewVersion, _a: jshost_ui_vlistScroll, hb: jshost_ui_widgetClose, ib: jshost_ui_widgetOpen, ga: slog_js_log };
+  function invoke_iii(index, a1, a2) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_v(index) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)();
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_ii(index, a1) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiii(index, a1, a2, a3, a4) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_vi(index, a1) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiiii(index, a1, a2, a3, a4, a5) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_iiiiiiiiffff(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiiffiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_vifi(index, a1, a2, a3) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_fi(index, a1) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_vii(index, a1, a2) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiff(index, a1, a2, a3, a4) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_vif(index, a1, a2) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_fiiiff(index, a1, a2, a3, a4, a5) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_fiiif(index, a1, a2, a3, a4) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_fiif(index, a1, a2, a3) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_iiffiiiffiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiiffffii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_iiiii(index, a1, a2, a3, a4) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viii(index, a1, a2, a3) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_fiiifff(index, a1, a2, a3, a4, a5, a6) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_iiii(index, a1, a2, a3) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viif(index, a1, a2, a3) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
+    var sp = stackSave();
+    try {
+      return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viffi(index, a1, a2, a3, a4) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  function invoke_viiiif(index, a1, a2, a3, a4, a5) {
+    var sp = stackSave();
+    try {
+      getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+    } catch (e) {
+      stackRestore(sp);
+      if (!(e instanceof EmscriptenEH)) throw e;
+      _setThrew(1, 0);
+    }
+  }
+  async function run() {
+    preRun();
+    var setStatus = Module["setStatus"];
+    if (setStatus) {
+      setStatus("Running...");
+      await new Promise((resolve) => setTimeout(resolve, 1));
+      setTimeout(setStatus, 1, "");
+    }
+    if (ABORT) return;
+    initRuntime();
+    Module["onRuntimeInitialized"]?.();
+    postRun();
+  }
+  var wasmExports;
+  wasmExports = await createWasm();
+  await run();
+  return Module;
+}
+export {
+  createCreatorWeb as default
+};
+//# sourceMappingURL=creator-2d-D13oxDsX.js.map