@sketch-hq/sketch-web-renderer 14.4.2 → 14.5.1

package/out/web-renderer/wasm/Release/web-renderer-release.mjs

@@ -208,10 +208,10 @@ var WebRendererWasmFactory = (() => {
       var info = getWasmImports();
       function receiveInstance(instance, module) {
         wasmExports = instance.exports;
-        wasmMemory = wasmExports["Uc"];
+        wasmMemory = wasmExports["od"];
         updateMemoryViews();
-        wasmTable = wasmExports["Yc"];
-        addOnInit(wasmExports["Vc"]);
+        wasmTable = wasmExports["sd"];
+        addOnInit(wasmExports["pd"]);
         removeRunDependency("wasm-instantiate");
         return wasmExports;
       }
@@ -2061,36 +2061,6 @@ var WebRendererWasmFactory = (() => {
     var _emscripten_date_now = () => Date.now();
     var _emscripten_get_now;
     _emscripten_get_now = () => performance.now();
-    var _emscripten_request_animation_frame = (cb, userData) => requestAnimationFrame(timeStamp => getWasmTableEntry(cb)(timeStamp, userData));
-    var getHeapMax = () => 2147483648;
-    var growMemory = size => {
-      var b = wasmMemory.buffer;
-      var pages = (size - b.byteLength + 65535) / 65536;
-      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;
-      }
-      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
-      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-        var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
-        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
-        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
-        var replacement = growMemory(newSize);
-        if (replacement) {
-          return true;
-        }
-      }
-      return false;
-    };
     var webgl_enable_ANGLE_instanced_arrays = ctx => {
       var ext = ctx.getExtension("ANGLE_instanced_arrays");
       if (ext) {
@@ -2247,109 +2217,24 @@ var WebRendererWasmFactory = (() => {
         });
       }
     };
-    var _emscripten_webgl_make_context_current = contextHandle => {
-      var success = GL.makeContextCurrent(contextHandle);
-      return success ? 0 : -5;
-    };
-    var ENV = {};
-    var getExecutableName = () => thisProgram || "./this.program";
-    var getEnvStrings = () => {
-      if (!getEnvStrings.strings) {
-        var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "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] === undefined) delete env[x];else env[x] = ENV[x];
-        }
-        var strings = [];
-        for (var x in env) {
-          strings.push("".concat(x, "=").concat(env[x]));
-        }
-        getEnvStrings.strings = strings;
-      }
-      return getEnvStrings.strings;
-    };
-    var stringToAscii = (str, buffer) => {
-      for (var i = 0; i < str.length; ++i) {
-        HEAP8[buffer++] = str.charCodeAt(i);
-      }
-      HEAP8[buffer] = 0;
-    };
-    var _environ_get = (__environ, environ_buf) => {
-      var bufSize = 0;
-      getEnvStrings().forEach((string, i) => {
-        var ptr = environ_buf + bufSize;
-        HEAPU32[__environ + i * 4 >> 2] = ptr;
-        stringToAscii(string, ptr);
-        bufSize += string.length + 1;
-      });
-      return 0;
-    };
-    var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
-      var strings = getEnvStrings();
-      HEAPU32[penviron_count >> 2] = strings.length;
-      var bufSize = 0;
-      strings.forEach(string => bufSize += string.length + 1);
-      HEAPU32[penviron_buf_size >> 2] = bufSize;
-      return 0;
-    };
-    var runtimeKeepaliveCounter = 0;
-    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
-    var _proc_exit = code => {
-      EXITSTATUS = code;
-      if (!keepRuntimeAlive()) {
-        ABORT = true;
-      }
-      quit_(code, new ExitStatus(code));
-    };
-    var exitJS = (status, implicit) => {
-      EXITSTATUS = status;
-      _proc_exit(status);
-    };
-    var _exit = exitJS;
-    var _fd_close = fd => 52;
-    function _fd_seek(fd, offset, whence, newOffset) {
-      offset = bigintToI53Checked(offset);
-      return 70;
-    }
-    var printCharBuffers = [null, [], []];
-    var printChar = (stream, curr) => {
-      var buffer = printCharBuffers[stream];
-      if (curr === 0 || curr === 10) {
-        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
-        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 _glActiveTexture = x0 => GLctx.activeTexture(x0);
+    var _emscripten_glActiveTexture = _glActiveTexture;
     var _glAttachShader = (program, shader) => {
       GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
     };
+    var _emscripten_glAttachShader = _glAttachShader;
+    var _glBeginQuery = (target, id) => {
+      GLctx.beginQuery(target, GL.queries[id]);
+    };
+    var _emscripten_glBeginQuery = _glBeginQuery;
+    var _glBeginQueryEXT = (target, id) => {
+      GLctx.disjointTimerQueryExt["beginQueryEXT"](target, GL.queries[id]);
+    };
+    var _emscripten_glBeginQueryEXT = _glBeginQueryEXT;
     var _glBindAttribLocation = (program, index, name) => {
       GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
     };
+    var _emscripten_glBindAttribLocation = _glBindAttribLocation;
     var _glBindBuffer = (target, buffer) => {
       if (target == 35051) {
         GLctx.currentPixelPackBufferBinding = buffer;
@@ -2358,26 +2243,37 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.bindBuffer(target, GL.buffers[buffer]);
     };
+    var _emscripten_glBindBuffer = _glBindBuffer;
     var _glBindFramebuffer = (target, framebuffer) => {
       GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
     };
+    var _emscripten_glBindFramebuffer = _glBindFramebuffer;
     var _glBindRenderbuffer = (target, renderbuffer) => {
       GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
     };
+    var _emscripten_glBindRenderbuffer = _glBindRenderbuffer;
     var _glBindSampler = (unit, sampler) => {
       GLctx.bindSampler(unit, GL.samplers[sampler]);
     };
+    var _emscripten_glBindSampler = _glBindSampler;
     var _glBindTexture = (target, texture) => {
       GLctx.bindTexture(target, GL.textures[texture]);
     };
+    var _emscripten_glBindTexture = _glBindTexture;
     var _glBindVertexArray = vao => {
       GLctx.bindVertexArray(GL.vaos[vao]);
     };
+    var _emscripten_glBindVertexArray = _glBindVertexArray;
     var _glBindVertexArrayOES = _glBindVertexArray;
+    var _emscripten_glBindVertexArrayOES = _glBindVertexArrayOES;
     var _glBlendColor = (x0, x1, x2, x3) => GLctx.blendColor(x0, x1, x2, x3);
+    var _emscripten_glBlendColor = _glBlendColor;
     var _glBlendEquation = x0 => GLctx.blendEquation(x0);
+    var _emscripten_glBlendEquation = _glBlendEquation;
     var _glBlendFunc = (x0, x1) => GLctx.blendFunc(x0, x1);
+    var _emscripten_glBlendFunc = _glBlendFunc;
     var _glBlitFramebuffer = (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) => GLctx.blitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+    var _emscripten_glBlitFramebuffer = _glBlitFramebuffer;
     var _glBufferData = (target, size, data, usage) => {
       if (GL.currentContext.version >= 2) {
         if (data && size) {
@@ -2389,6 +2285,7 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.bufferData(target, data ? HEAPU8.subarray(data, data + size) : size, usage);
     };
+    var _emscripten_glBufferData = _glBufferData;
     var _glBufferSubData = (target, offset, size, data) => {
       if (GL.currentContext.version >= 2) {
         size && GLctx.bufferSubData(target, offset, HEAPU8, data, size);
@@ -2396,20 +2293,28 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size));
     };
+    var _emscripten_glBufferSubData = _glBufferSubData;
     var _glCheckFramebufferStatus = x0 => GLctx.checkFramebufferStatus(x0);
+    var _emscripten_glCheckFramebufferStatus = _glCheckFramebufferStatus;
     var _glClear = x0 => GLctx.clear(x0);
+    var _emscripten_glClear = _glClear;
     var _glClearColor = (x0, x1, x2, x3) => GLctx.clearColor(x0, x1, x2, x3);
+    var _emscripten_glClearColor = _glClearColor;
     var _glClearStencil = x0 => GLctx.clearStencil(x0);
+    var _emscripten_glClearStencil = _glClearStencil;
     var _glClientWaitSync = (sync, flags, timeout) => {
       timeout = Number(timeout);
       return GLctx.clientWaitSync(GL.syncs[sync], flags, timeout);
     };
+    var _emscripten_glClientWaitSync = _glClientWaitSync;
     var _glColorMask = (red, green, blue, alpha) => {
       GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
     };
+    var _emscripten_glColorMask = _glColorMask;
     var _glCompileShader = shader => {
       GLctx.compileShader(GL.shaders[shader]);
     };
+    var _emscripten_glCompileShader = _glCompileShader;
     var _glCompressedTexImage2D = (target, level, internalFormat, width, height, border, imageSize, data) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
@@ -2421,6 +2326,7 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, data ? HEAPU8.subarray(data, data + imageSize) : null);
     };
+    var _emscripten_glCompressedTexImage2D = _glCompressedTexImage2D;
     var _glCompressedTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, imageSize, data) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
@@ -2432,8 +2338,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, data ? HEAPU8.subarray(data, data + imageSize) : null);
     };
+    var _emscripten_glCompressedTexSubImage2D = _glCompressedTexSubImage2D;
     var _glCopyBufferSubData = (x0, x1, x2, x3, x4) => GLctx.copyBufferSubData(x0, x1, x2, x3, x4);
+    var _emscripten_glCopyBufferSubData = _glCopyBufferSubData;
     var _glCopyTexSubImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7);
+    var _emscripten_glCopyTexSubImage2D = _glCopyTexSubImage2D;
     var _glCreateProgram = () => {
       var id = GL.getNewId(GL.programs);
       var program = GLctx.createProgram();
@@ -2443,12 +2352,15 @@ var WebRendererWasmFactory = (() => {
       GL.programs[id] = program;
       return id;
     };
+    var _emscripten_glCreateProgram = _glCreateProgram;
     var _glCreateShader = shaderType => {
       var id = GL.getNewId(GL.shaders);
       GL.shaders[id] = GLctx.createShader(shaderType);
       return id;
     };
+    var _emscripten_glCreateShader = _glCreateShader;
     var _glCullFace = x0 => GLctx.cullFace(x0);
+    var _emscripten_glCullFace = _glCullFace;
     var _glDeleteBuffers = (n, buffers) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[buffers + i * 4 >> 2];
@@ -2461,6 +2373,7 @@ var WebRendererWasmFactory = (() => {
         if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
       }
     };
+    var _emscripten_glDeleteBuffers = _glDeleteBuffers;
     var _glDeleteFramebuffers = (n, framebuffers) => {
       for (var i = 0; i < n; ++i) {
         var id = HEAP32[framebuffers + i * 4 >> 2];
@@ -2471,6 +2384,7 @@ var WebRendererWasmFactory = (() => {
         GL.framebuffers[id] = null;
       }
     };
+    var _emscripten_glDeleteFramebuffers = _glDeleteFramebuffers;
     var _glDeleteProgram = id => {
       if (!id) return;
       var program = GL.programs[id];
@@ -2482,6 +2396,27 @@ var WebRendererWasmFactory = (() => {
       program.name = 0;
       GL.programs[id] = null;
     };
+    var _emscripten_glDeleteProgram = _glDeleteProgram;
+    var _glDeleteQueries = (n, ids) => {
+      for (var i = 0; i < n; i++) {
+        var id = HEAP32[ids + i * 4 >> 2];
+        var query = GL.queries[id];
+        if (!query) continue;
+        GLctx.deleteQuery(query);
+        GL.queries[id] = null;
+      }
+    };
+    var _emscripten_glDeleteQueries = _glDeleteQueries;
+    var _glDeleteQueriesEXT = (n, ids) => {
+      for (var i = 0; i < n; i++) {
+        var id = HEAP32[ids + i * 4 >> 2];
+        var query = GL.queries[id];
+        if (!query) continue;
+        GLctx.disjointTimerQueryExt["deleteQueryEXT"](query);
+        GL.queries[id] = null;
+      }
+    };
+    var _emscripten_glDeleteQueriesEXT = _glDeleteQueriesEXT;
     var _glDeleteRenderbuffers = (n, renderbuffers) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[renderbuffers + i * 4 >> 2];
@@ -2492,6 +2427,7 @@ var WebRendererWasmFactory = (() => {
         GL.renderbuffers[id] = null;
       }
     };
+    var _emscripten_glDeleteRenderbuffers = _glDeleteRenderbuffers;
     var _glDeleteSamplers = (n, samplers) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[samplers + i * 4 >> 2];
@@ -2502,6 +2438,7 @@ var WebRendererWasmFactory = (() => {
         GL.samplers[id] = null;
       }
     };
+    var _emscripten_glDeleteSamplers = _glDeleteSamplers;
     var _glDeleteShader = id => {
       if (!id) return;
       var shader = GL.shaders[id];
@@ -2512,6 +2449,7 @@ var WebRendererWasmFactory = (() => {
       GLctx.deleteShader(shader);
       GL.shaders[id] = null;
     };
+    var _emscripten_glDeleteShader = _glDeleteShader;
     var _glDeleteSync = id => {
       if (!id) return;
       var sync = GL.syncs[id];
@@ -2523,6 +2461,7 @@ var WebRendererWasmFactory = (() => {
       sync.name = 0;
       GL.syncs[id] = null;
     };
+    var _emscripten_glDeleteSync = _glDeleteSync;
     var _glDeleteTextures = (n, textures) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[textures + i * 4 >> 2];
@@ -2533,6 +2472,7 @@ var WebRendererWasmFactory = (() => {
         GL.textures[id] = null;
       }
     };
+    var _emscripten_glDeleteTextures = _glDeleteTextures;
     var _glDeleteVertexArrays = (n, vaos) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[vaos + i * 4 >> 2];
@@ -2540,23 +2480,31 @@ var WebRendererWasmFactory = (() => {
         GL.vaos[id] = null;
       }
     };
+    var _emscripten_glDeleteVertexArrays = _glDeleteVertexArrays;
     var _glDeleteVertexArraysOES = _glDeleteVertexArrays;
+    var _emscripten_glDeleteVertexArraysOES = _glDeleteVertexArraysOES;
     var _glDepthMask = flag => {
       GLctx.depthMask(!!flag);
     };
+    var _emscripten_glDepthMask = _glDepthMask;
     var _glDisable = x0 => GLctx.disable(x0);
+    var _emscripten_glDisable = _glDisable;
     var _glDisableVertexAttribArray = index => {
       GLctx.disableVertexAttribArray(index);
     };
+    var _emscripten_glDisableVertexAttribArray = _glDisableVertexAttribArray;
     var _glDrawArrays = (mode, first, count) => {
       GLctx.drawArrays(mode, first, count);
     };
+    var _emscripten_glDrawArrays = _glDrawArrays;
     var _glDrawArraysInstanced = (mode, first, count, primcount) => {
       GLctx.drawArraysInstanced(mode, first, count, primcount);
     };
+    var _emscripten_glDrawArraysInstanced = _glDrawArraysInstanced;
     var _glDrawArraysInstancedBaseInstanceWEBGL = (mode, first, count, instanceCount, baseInstance) => {
       GLctx.dibvbi["drawArraysInstancedBaseInstanceWEBGL"](mode, first, count, instanceCount, baseInstance);
     };
+    var _emscripten_glDrawArraysInstancedBaseInstanceWEBGL = _glDrawArraysInstancedBaseInstanceWEBGL;
     var tempFixedLengthArray = [];
     var _glDrawBuffers = (n, bufs) => {
       var bufArray = tempFixedLengthArray[n];
@@ -2565,22 +2513,35 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.drawBuffers(bufArray);
     };
+    var _emscripten_glDrawBuffers = _glDrawBuffers;
     var _glDrawElements = (mode, count, type, indices) => {
       GLctx.drawElements(mode, count, type, indices);
     };
+    var _emscripten_glDrawElements = _glDrawElements;
     var _glDrawElementsInstanced = (mode, count, type, indices, primcount) => {
       GLctx.drawElementsInstanced(mode, count, type, indices, primcount);
     };
+    var _emscripten_glDrawElementsInstanced = _glDrawElementsInstanced;
     var _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL = (mode, count, type, offset, instanceCount, baseVertex, baseinstance) => {
       GLctx.dibvbi["drawElementsInstancedBaseVertexBaseInstanceWEBGL"](mode, count, type, offset, instanceCount, baseVertex, baseinstance);
     };
+    var _emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL = _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL;
     var _glDrawRangeElements = (mode, start, end, count, type, indices) => {
       _glDrawElements(mode, count, type, indices);
     };
+    var _emscripten_glDrawRangeElements = _glDrawRangeElements;
     var _glEnable = x0 => GLctx.enable(x0);
+    var _emscripten_glEnable = _glEnable;
     var _glEnableVertexAttribArray = index => {
       GLctx.enableVertexAttribArray(index);
     };
+    var _emscripten_glEnableVertexAttribArray = _glEnableVertexAttribArray;
+    var _glEndQuery = x0 => GLctx.endQuery(x0);
+    var _emscripten_glEndQuery = _glEndQuery;
+    var _glEndQueryEXT = target => {
+      GLctx.disjointTimerQueryExt["endQueryEXT"](target);
+    };
+    var _emscripten_glEndQueryEXT = _glEndQueryEXT;
     var _glFenceSync = (condition, flags) => {
       var sync = GLctx.fenceSync(condition, flags);
       if (sync) {
@@ -2591,35 +2552,68 @@ var WebRendererWasmFactory = (() => {
       }
       return 0;
     };
+    var _emscripten_glFenceSync = _glFenceSync;
     var _glFinish = () => GLctx.finish();
+    var _emscripten_glFinish = _glFinish;
     var _glFlush = () => GLctx.flush();
+    var _emscripten_glFlush = _glFlush;
     var _glFramebufferRenderbuffer = (target, attachment, renderbuffertarget, renderbuffer) => {
       GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, GL.renderbuffers[renderbuffer]);
     };
+    var _emscripten_glFramebufferRenderbuffer = _glFramebufferRenderbuffer;
     var _glFramebufferTexture2D = (target, attachment, textarget, texture, level) => {
       GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level);
     };
+    var _emscripten_glFramebufferTexture2D = _glFramebufferTexture2D;
     var _glFrontFace = x0 => GLctx.frontFace(x0);
+    var _emscripten_glFrontFace = _glFrontFace;
     var _glGenBuffers = (n, buffers) => {
       GL.genObject(n, buffers, "createBuffer", GL.buffers);
     };
+    var _emscripten_glGenBuffers = _glGenBuffers;
     var _glGenFramebuffers = (n, ids) => {
       GL.genObject(n, ids, "createFramebuffer", GL.framebuffers);
     };
+    var _emscripten_glGenFramebuffers = _glGenFramebuffers;
+    var _glGenQueries = (n, ids) => {
+      GL.genObject(n, ids, "createQuery", GL.queries);
+    };
+    var _emscripten_glGenQueries = _glGenQueries;
+    var _glGenQueriesEXT = (n, ids) => {
+      for (var i = 0; i < n; i++) {
+        var query = GLctx.disjointTimerQueryExt["createQueryEXT"]();
+        if (!query) {
+          GL.recordError(1282);
+          while (i < n) HEAP32[ids + i++ * 4 >> 2] = 0;
+          return;
+        }
+        var id = GL.getNewId(GL.queries);
+        query.name = id;
+        GL.queries[id] = query;
+        HEAP32[ids + i * 4 >> 2] = id;
+      }
+    };
+    var _emscripten_glGenQueriesEXT = _glGenQueriesEXT;
     var _glGenRenderbuffers = (n, renderbuffers) => {
       GL.genObject(n, renderbuffers, "createRenderbuffer", GL.renderbuffers);
     };
+    var _emscripten_glGenRenderbuffers = _glGenRenderbuffers;
     var _glGenSamplers = (n, samplers) => {
       GL.genObject(n, samplers, "createSampler", GL.samplers);
     };
+    var _emscripten_glGenSamplers = _glGenSamplers;
     var _glGenTextures = (n, textures) => {
       GL.genObject(n, textures, "createTexture", GL.textures);
     };
+    var _emscripten_glGenTextures = _glGenTextures;
     var _glGenVertexArrays = (n, arrays) => {
       GL.genObject(n, arrays, "createVertexArray", GL.vaos);
     };
+    var _emscripten_glGenVertexArrays = _glGenVertexArrays;
     var _glGenVertexArraysOES = _glGenVertexArrays;
+    var _emscripten_glGenVertexArraysOES = _glGenVertexArraysOES;
     var _glGenerateMipmap = x0 => GLctx.generateMipmap(x0);
+    var _emscripten_glGenerateMipmap = _glGenerateMipmap;
     var _glGetBufferParameteriv = (target, value, data) => {
       if (!data) {
         GL.recordError(1281);
@@ -2627,11 +2621,13 @@ var WebRendererWasmFactory = (() => {
       }
       HEAP32[data >> 2] = GLctx.getBufferParameter(target, value);
     };
+    var _emscripten_glGetBufferParameteriv = _glGetBufferParameteriv;
     var _glGetError = () => {
       var error = GLctx.getError() || GL.lastError;
       GL.lastError = 0;
       return error;
     };
+    var _emscripten_glGetError = _glGetError;
     var writeI53ToI64 = (ptr, num) => {
       HEAPU32[ptr >> 2] = num;
       var lower = HEAPU32[ptr >> 2];
@@ -2772,6 +2768,7 @@ var WebRendererWasmFactory = (() => {
       }
     };
     var _glGetFloatv = (name_, p) => emscriptenWebGLGet(name_, p, 2);
+    var _emscripten_glGetFloatv = _glGetFloatv;
     var _glGetFramebufferAttachmentParameteriv = (target, attachment, pname, params) => {
       var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname);
       if (result instanceof WebGLRenderbuffer || result instanceof WebGLTexture) {
@@ -2779,13 +2776,16 @@ var WebRendererWasmFactory = (() => {
       }
       HEAP32[params >> 2] = result;
     };
+    var _emscripten_glGetFramebufferAttachmentParameteriv = _glGetFramebufferAttachmentParameteriv;
     var _glGetIntegerv = (name_, p) => emscriptenWebGLGet(name_, p, 0);
+    var _emscripten_glGetIntegerv = _glGetIntegerv;
     var _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 _emscripten_glGetProgramInfoLog = _glGetProgramInfoLog;
     var _glGetProgramiv = (program, pname, p) => {
       if (!p) {
         GL.recordError(1281);
@@ -2825,6 +2825,79 @@ var WebRendererWasmFactory = (() => {
         HEAP32[p >> 2] = GLctx.getProgramParameter(program, pname);
       }
     };
+    var _emscripten_glGetProgramiv = _glGetProgramiv;
+    var _glGetQueryObjecti64vEXT = (id, pname, params) => {
+      if (!params) {
+        GL.recordError(1281);
+        return;
+      }
+      var query = GL.queries[id];
+      var param;
+      if (GL.currentContext.version < 2) {
+        param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
+      } else {
+        param = GLctx.getQueryParameter(query, pname);
+      }
+      var ret;
+      if (typeof param == "boolean") {
+        ret = param ? 1 : 0;
+      } else {
+        ret = param;
+      }
+      writeI53ToI64(params, ret);
+    };
+    var _emscripten_glGetQueryObjecti64vEXT = _glGetQueryObjecti64vEXT;
+    var _glGetQueryObjectui64vEXT = _glGetQueryObjecti64vEXT;
+    var _emscripten_glGetQueryObjectui64vEXT = _glGetQueryObjectui64vEXT;
+    var _glGetQueryObjectuiv = (id, pname, params) => {
+      if (!params) {
+        GL.recordError(1281);
+        return;
+      }
+      var query = GL.queries[id];
+      var param = GLctx.getQueryParameter(query, pname);
+      var ret;
+      if (typeof param == "boolean") {
+        ret = param ? 1 : 0;
+      } else {
+        ret = param;
+      }
+      HEAP32[params >> 2] = ret;
+    };
+    var _emscripten_glGetQueryObjectuiv = _glGetQueryObjectuiv;
+    var _glGetQueryObjectivEXT = (id, pname, params) => {
+      if (!params) {
+        GL.recordError(1281);
+        return;
+      }
+      var query = GL.queries[id];
+      var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
+      var ret;
+      if (typeof param == "boolean") {
+        ret = param ? 1 : 0;
+      } else {
+        ret = param;
+      }
+      HEAP32[params >> 2] = ret;
+    };
+    var _glGetQueryObjectuivEXT = _glGetQueryObjectivEXT;
+    var _emscripten_glGetQueryObjectuivEXT = _glGetQueryObjectuivEXT;
+    var _glGetQueryiv = (target, pname, params) => {
+      if (!params) {
+        GL.recordError(1281);
+        return;
+      }
+      HEAP32[params >> 2] = GLctx.getQuery(target, pname);
+    };
+    var _emscripten_glGetQueryiv = _glGetQueryiv;
+    var _glGetQueryivEXT = (target, pname, params) => {
+      if (!params) {
+        GL.recordError(1281);
+        return;
+      }
+      HEAP32[params >> 2] = GLctx.disjointTimerQueryExt["getQueryEXT"](target, pname);
+    };
+    var _emscripten_glGetQueryivEXT = _glGetQueryivEXT;
     var _glGetRenderbufferParameteriv = (target, pname, params) => {
       if (!params) {
         GL.recordError(1281);
@@ -2832,18 +2905,21 @@ var WebRendererWasmFactory = (() => {
       }
       HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname);
     };
+    var _emscripten_glGetRenderbufferParameteriv = _glGetRenderbufferParameteriv;
     var _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 _emscripten_glGetShaderInfoLog = _glGetShaderInfoLog;
     var _glGetShaderPrecisionFormat = (shaderType, precisionType, range, precision) => {
       var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType);
       HEAP32[range >> 2] = result.rangeMin;
       HEAP32[range + 4 >> 2] = result.rangeMax;
       HEAP32[precision >> 2] = result.precision;
     };
+    var _emscripten_glGetShaderPrecisionFormat = _glGetShaderPrecisionFormat;
     var _glGetShaderiv = (shader, pname, p) => {
       if (!p) {
         GL.recordError(1281);
@@ -2862,6 +2938,7 @@ var WebRendererWasmFactory = (() => {
         HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
       }
     };
+    var _emscripten_glGetShaderiv = _glGetShaderiv;
     var stringToNewUTF8 = str => {
       var size = lengthBytesUTF8(str) + 1;
       var ret = _malloc(size);
@@ -2909,6 +2986,7 @@ var WebRendererWasmFactory = (() => {
       }
       return ret;
     };
+    var _emscripten_glGetString = _glGetString;
     var _glGetStringi = (name, index) => {
       if (GL.currentContext.version < 2) {
         GL.recordError(1282);
@@ -2936,6 +3014,7 @@ var WebRendererWasmFactory = (() => {
           return 0;
       }
     };
+    var _emscripten_glGetStringi = _glGetStringi;
     var jstoi_q = str => parseInt(str);
     var webglGetLeftBracePos = name => name.slice(-1) == "]" && name.lastIndexOf("[");
     var webglPrepareUniformLocationsBeforeFirstUse = program => {
@@ -2986,6 +3065,7 @@ var WebRendererWasmFactory = (() => {
       }
       return -1;
     };
+    var _emscripten_glGetUniformLocation = _glGetUniformLocation;
     var _glInvalidateFramebuffer = (target, numAttachments, attachments) => {
       var list = tempFixedLengthArray[numAttachments];
       for (var i = 0; i < numAttachments; i++) {
@@ -2993,6 +3073,7 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.invalidateFramebuffer(target, list);
     };
+    var _emscripten_glInvalidateFramebuffer = _glInvalidateFramebuffer;
     var _glInvalidateSubFramebuffer = (target, numAttachments, attachments, x, y, width, height) => {
       var list = tempFixedLengthArray[numAttachments];
       for (var i = 0; i < numAttachments; i++) {
@@ -3000,32 +3081,45 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.invalidateSubFramebuffer(target, list, x, y, width, height);
     };
+    var _emscripten_glInvalidateSubFramebuffer = _glInvalidateSubFramebuffer;
     var _glIsSync = sync => GLctx.isSync(GL.syncs[sync]);
+    var _emscripten_glIsSync = _glIsSync;
     var _glIsTexture = id => {
       var texture = GL.textures[id];
       if (!texture) return 0;
       return GLctx.isTexture(texture);
     };
+    var _emscripten_glIsTexture = _glIsTexture;
     var _glLineWidth = x0 => GLctx.lineWidth(x0);
+    var _emscripten_glLineWidth = _glLineWidth;
     var _glLinkProgram = program => {
       program = GL.programs[program];
       GLctx.linkProgram(program);
       program.uniformLocsById = 0;
       program.uniformSizeAndIdsByName = {};
     };
+    var _emscripten_glLinkProgram = _glLinkProgram;
     var _glMultiDrawArraysInstancedBaseInstanceWEBGL = (mode, firsts, counts, instanceCounts, baseInstances, drawCount) => {
       GLctx.mdibvbi["multiDrawArraysInstancedBaseInstanceWEBGL"](mode, HEAP32, firsts >> 2, HEAP32, counts >> 2, HEAP32, instanceCounts >> 2, HEAPU32, baseInstances >> 2, drawCount);
     };
+    var _emscripten_glMultiDrawArraysInstancedBaseInstanceWEBGL = _glMultiDrawArraysInstancedBaseInstanceWEBGL;
     var _glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL = (mode, counts, type, offsets, instanceCounts, baseVertices, baseInstances, drawCount) => {
       GLctx.mdibvbi["multiDrawElementsInstancedBaseVertexBaseInstanceWEBGL"](mode, HEAP32, counts >> 2, type, HEAP32, offsets >> 2, HEAP32, instanceCounts >> 2, HEAP32, baseVertices >> 2, HEAPU32, baseInstances >> 2, drawCount);
     };
+    var _emscripten_glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL = _glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL;
     var _glPixelStorei = (pname, param) => {
       if (pname == 3317) {
         GL.unpackAlignment = param;
       }
       GLctx.pixelStorei(pname, param);
     };
+    var _emscripten_glPixelStorei = _glPixelStorei;
+    var _glQueryCounterEXT = (id, target) => {
+      GLctx.disjointTimerQueryExt["queryCounterEXT"](GL.queries[id], target);
+    };
+    var _emscripten_glQueryCounterEXT = _glQueryCounterEXT;
     var _glReadBuffer = x0 => GLctx.readBuffer(x0);
+    var _emscripten_glReadBuffer = _glReadBuffer;
     var computeUnpackAlignedImageSize = (width, height, sizePerPixel, alignment) => {
       function roundedToNextMultipleOf(x, y) {
         return x + y - 1 & -y;
@@ -3083,29 +3177,43 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.readPixels(x, y, width, height, format, type, pixelData);
     };
+    var _emscripten_glReadPixels = _glReadPixels;
     var _glRenderbufferStorage = (x0, x1, x2, x3) => GLctx.renderbufferStorage(x0, x1, x2, x3);
+    var _emscripten_glRenderbufferStorage = _glRenderbufferStorage;
     var _glRenderbufferStorageMultisample = (x0, x1, x2, x3, x4) => GLctx.renderbufferStorageMultisample(x0, x1, x2, x3, x4);
+    var _emscripten_glRenderbufferStorageMultisample = _glRenderbufferStorageMultisample;
     var _glSamplerParameterf = (sampler, pname, param) => {
       GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
     };
+    var _emscripten_glSamplerParameterf = _glSamplerParameterf;
     var _glSamplerParameteri = (sampler, pname, param) => {
       GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
     };
+    var _emscripten_glSamplerParameteri = _glSamplerParameteri;
     var _glSamplerParameteriv = (sampler, pname, params) => {
       var param = HEAP32[params >> 2];
       GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
     };
+    var _emscripten_glSamplerParameteriv = _glSamplerParameteriv;
     var _glScissor = (x0, x1, x2, x3) => GLctx.scissor(x0, x1, x2, x3);
+    var _emscripten_glScissor = _glScissor;
     var _glShaderSource = (shader, count, string, length) => {
       var source = GL.getSource(shader, count, string, length);
       GLctx.shaderSource(GL.shaders[shader], source);
     };
+    var _emscripten_glShaderSource = _glShaderSource;
     var _glStencilFunc = (x0, x1, x2) => GLctx.stencilFunc(x0, x1, x2);
+    var _emscripten_glStencilFunc = _glStencilFunc;
     var _glStencilFuncSeparate = (x0, x1, x2, x3) => GLctx.stencilFuncSeparate(x0, x1, x2, x3);
+    var _emscripten_glStencilFuncSeparate = _glStencilFuncSeparate;
     var _glStencilMask = x0 => GLctx.stencilMask(x0);
+    var _emscripten_glStencilMask = _glStencilMask;
     var _glStencilMaskSeparate = (x0, x1) => GLctx.stencilMaskSeparate(x0, x1);
+    var _emscripten_glStencilMaskSeparate = _glStencilMaskSeparate;
     var _glStencilOp = (x0, x1, x2) => GLctx.stencilOp(x0, x1, x2);
+    var _emscripten_glStencilOp = _glStencilOp;
     var _glStencilOpSeparate = (x0, x1, x2, x3) => GLctx.stencilOpSeparate(x0, x1, x2, x3);
+    var _emscripten_glStencilOpSeparate = _glStencilOpSeparate;
     var _glTexImage2D = (target, level, internalFormat, width, height, border, format, type, pixels) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding) {
@@ -3122,17 +3230,23 @@ var WebRendererWasmFactory = (() => {
       var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null;
       GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixelData);
     };
+    var _emscripten_glTexImage2D = _glTexImage2D;
     var _glTexParameterf = (x0, x1, x2) => GLctx.texParameterf(x0, x1, x2);
+    var _emscripten_glTexParameterf = _glTexParameterf;
     var _glTexParameterfv = (target, pname, params) => {
       var param = HEAPF32[params >> 2];
       GLctx.texParameterf(target, pname, param);
     };
+    var _emscripten_glTexParameterfv = _glTexParameterfv;
     var _glTexParameteri = (x0, x1, x2) => GLctx.texParameteri(x0, x1, x2);
+    var _emscripten_glTexParameteri = _glTexParameteri;
     var _glTexParameteriv = (target, pname, params) => {
       var param = HEAP32[params >> 2];
       GLctx.texParameteri(target, pname, param);
     };
+    var _emscripten_glTexParameteriv = _glTexParameteriv;
     var _glTexStorage2D = (x0, x1, x2, x3, x4) => GLctx.texStorage2D(x0, x1, x2, x3, x4);
+    var _emscripten_glTexStorage2D = _glTexStorage2D;
     var _glTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, type, pixels) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding) {
@@ -3148,6 +3262,7 @@ var WebRendererWasmFactory = (() => {
       var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0) : null;
       GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData);
     };
+    var _emscripten_glTexSubImage2D = _glTexSubImage2D;
     var webglGetUniformLocation = location => {
       var p = GLctx.currentProgram;
       if (p) {
@@ -3163,6 +3278,7 @@ var WebRendererWasmFactory = (() => {
     var _glUniform1f = (location, v0) => {
       GLctx.uniform1f(webglGetUniformLocation(location), v0);
     };
+    var _emscripten_glUniform1f = _glUniform1f;
     var miniTempWebGLFloatBuffers = [];
     var _glUniform1fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
@@ -3179,9 +3295,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform1fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform1fv = _glUniform1fv;
     var _glUniform1i = (location, v0) => {
       GLctx.uniform1i(webglGetUniformLocation(location), v0);
     };
+    var _emscripten_glUniform1i = _glUniform1i;
     var miniTempWebGLIntBuffers = [];
     var _glUniform1iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
@@ -3198,9 +3316,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform1iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform1iv = _glUniform1iv;
     var _glUniform2f = (location, v0, v1) => {
       GLctx.uniform2f(webglGetUniformLocation(location), v0, v1);
     };
+    var _emscripten_glUniform2f = _glUniform2f;
     var _glUniform2fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2);
@@ -3217,9 +3337,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform2fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform2fv = _glUniform2fv;
     var _glUniform2i = (location, v0, v1) => {
       GLctx.uniform2i(webglGetUniformLocation(location), v0, v1);
     };
+    var _emscripten_glUniform2i = _glUniform2i;
     var _glUniform2iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 2);
@@ -3236,9 +3358,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform2iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform2iv = _glUniform2iv;
     var _glUniform3f = (location, v0, v1, v2) => {
       GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2);
     };
+    var _emscripten_glUniform3f = _glUniform3f;
     var _glUniform3fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 3);
@@ -3256,9 +3380,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform3fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform3fv = _glUniform3fv;
     var _glUniform3i = (location, v0, v1, v2) => {
       GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2);
     };
+    var _emscripten_glUniform3i = _glUniform3i;
     var _glUniform3iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 3);
@@ -3276,9 +3402,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform3iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform3iv = _glUniform3iv;
     var _glUniform4f = (location, v0, v1, v2, v3) => {
       GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
     };
+    var _emscripten_glUniform4f = _glUniform4f;
     var _glUniform4fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4);
@@ -3300,9 +3428,11 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform4fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform4fv = _glUniform4fv;
     var _glUniform4i = (location, v0, v1, v2, v3) => {
       GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3);
     };
+    var _emscripten_glUniform4i = _glUniform4i;
     var _glUniform4iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4);
@@ -3321,6 +3451,7 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform4iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform4iv = _glUniform4iv;
     var _glUniformMatrix2fv = (location, count, transpose, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 4);
@@ -3339,6 +3470,7 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view);
     };
+    var _emscripten_glUniformMatrix2fv = _glUniformMatrix2fv;
     var _glUniformMatrix3fv = (location, count, transpose, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 9);
@@ -3362,6 +3494,7 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view);
     };
+    var _emscripten_glUniformMatrix3fv = _glUniformMatrix3fv;
     var _glUniformMatrix4fv = (location, count, transpose, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 16);
@@ -3395,35 +3528,172 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view);
     };
+    var _emscripten_glUniformMatrix4fv = _glUniformMatrix4fv;
     var _glUseProgram = program => {
       program = GL.programs[program];
       GLctx.useProgram(program);
       GLctx.currentProgram = program;
     };
+    var _emscripten_glUseProgram = _glUseProgram;
     var _glVertexAttrib1f = (x0, x1) => GLctx.vertexAttrib1f(x0, x1);
+    var _emscripten_glVertexAttrib1f = _glVertexAttrib1f;
     var _glVertexAttrib2fv = (index, v) => {
       GLctx.vertexAttrib2f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2]);
     };
+    var _emscripten_glVertexAttrib2fv = _glVertexAttrib2fv;
     var _glVertexAttrib3fv = (index, v) => {
       GLctx.vertexAttrib3f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2]);
     };
+    var _emscripten_glVertexAttrib3fv = _glVertexAttrib3fv;
     var _glVertexAttrib4fv = (index, v) => {
       GLctx.vertexAttrib4f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2], HEAPF32[v + 12 >> 2]);
     };
+    var _emscripten_glVertexAttrib4fv = _glVertexAttrib4fv;
     var _glVertexAttribDivisor = (index, divisor) => {
       GLctx.vertexAttribDivisor(index, divisor);
     };
+    var _emscripten_glVertexAttribDivisor = _glVertexAttribDivisor;
     var _glVertexAttribIPointer = (index, size, type, stride, ptr) => {
       GLctx.vertexAttribIPointer(index, size, type, stride, ptr);
     };
+    var _emscripten_glVertexAttribIPointer = _glVertexAttribIPointer;
     var _glVertexAttribPointer = (index, size, type, normalized, stride, ptr) => {
       GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
     };
+    var _emscripten_glVertexAttribPointer = _glVertexAttribPointer;
     var _glViewport = (x0, x1, x2, x3) => GLctx.viewport(x0, x1, x2, x3);
+    var _emscripten_glViewport = _glViewport;
     var _glWaitSync = (sync, flags, timeout) => {
       timeout = Number(timeout);
       GLctx.waitSync(GL.syncs[sync], flags, timeout);
     };
+    var _emscripten_glWaitSync = _glWaitSync;
+    var _emscripten_request_animation_frame = (cb, userData) => requestAnimationFrame(timeStamp => getWasmTableEntry(cb)(timeStamp, userData));
+    var getHeapMax = () => 2147483648;
+    var growMemory = size => {
+      var b = wasmMemory.buffer;
+      var pages = (size - b.byteLength + 65535) / 65536;
+      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;
+      }
+      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+        var replacement = growMemory(newSize);
+        if (replacement) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var _emscripten_webgl_make_context_current = contextHandle => {
+      var success = GL.makeContextCurrent(contextHandle);
+      return success ? 0 : -5;
+    };
+    var ENV = {};
+    var getExecutableName = () => thisProgram || "./this.program";
+    var getEnvStrings = () => {
+      if (!getEnvStrings.strings) {
+        var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "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] === undefined) delete env[x];else env[x] = ENV[x];
+        }
+        var strings = [];
+        for (var x in env) {
+          strings.push("".concat(x, "=").concat(env[x]));
+        }
+        getEnvStrings.strings = strings;
+      }
+      return getEnvStrings.strings;
+    };
+    var stringToAscii = (str, buffer) => {
+      for (var i = 0; i < str.length; ++i) {
+        HEAP8[buffer++] = str.charCodeAt(i);
+      }
+      HEAP8[buffer] = 0;
+    };
+    var _environ_get = (__environ, environ_buf) => {
+      var bufSize = 0;
+      getEnvStrings().forEach((string, i) => {
+        var ptr = environ_buf + bufSize;
+        HEAPU32[__environ + i * 4 >> 2] = ptr;
+        stringToAscii(string, ptr);
+        bufSize += string.length + 1;
+      });
+      return 0;
+    };
+    var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
+      var strings = getEnvStrings();
+      HEAPU32[penviron_count >> 2] = strings.length;
+      var bufSize = 0;
+      strings.forEach(string => bufSize += string.length + 1);
+      HEAPU32[penviron_buf_size >> 2] = bufSize;
+      return 0;
+    };
+    var runtimeKeepaliveCounter = 0;
+    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+    var _proc_exit = code => {
+      EXITSTATUS = code;
+      if (!keepRuntimeAlive()) {
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    };
+    var exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      _proc_exit(status);
+    };
+    var _exit = exitJS;
+    var _fd_close = fd => 52;
+    function _fd_seek(fd, offset, whence, newOffset) {
+      offset = bigintToI53Checked(offset);
+      return 70;
+    }
+    var printCharBuffers = [null, [], []];
+    var printChar = (stream, curr) => {
+      var buffer = printCharBuffers[stream];
+      if (curr === 0 || curr === 10) {
+        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+        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 isLeapYear = year => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
     var arraySum = (array, index) => {
       var sum = 0;
@@ -3683,224 +3953,246 @@ var WebRendererWasmFactory = (() => {
       miniTempWebGLIntBuffers[i] = miniTempWebGLIntBuffersStorage.subarray(0, i);
     }
     var wasmImports = {
-      mb: __abort_js,
+      ob: __abort_js,
       o: __embind_finalize_value_object,
-      R: __embind_register_bigint,
-      $a: __embind_register_bool,
-      f: __embind_register_class,
-      da: __embind_register_class_class_function,
-      w: __embind_register_class_constructor,
+      O: __embind_register_bigint,
+      bb: __embind_register_bool,
+      g: __embind_register_class,
+      ba: __embind_register_class_class_function,
+      u: __embind_register_class_constructor,
       a: __embind_register_class_function,
       c: __embind_register_class_property,
-      _a: __embind_register_emval,
+      ab: __embind_register_emval,
       l: __embind_register_enum,
       b: __embind_register_enum_value,
-      Q: __embind_register_float,
-      y: __embind_register_integer,
+      N: __embind_register_float,
+      z: __embind_register_integer,
       s: __embind_register_memory_view,
       x: __embind_register_optional,
-      I: __embind_register_smart_ptr,
-      P: __embind_register_std_string,
+      J: __embind_register_smart_ptr,
+      M: __embind_register_std_string,
       G: __embind_register_std_wstring,
-      Jc: __embind_register_user_type,
+      dd: __embind_register_user_type,
       p: __embind_register_value_object,
       e: __embind_register_value_object_field,
-      ab: __embind_register_void,
-      kb: __emscripten_get_now_is_monotonic,
-      cb: __emscripten_throw_longjmp,
+      cb: __embind_register_void,
+      mb: __emscripten_get_now_is_monotonic,
+      eb: __emscripten_throw_longjmp,
       E: __emval_as,
-      B: __emval_call,
+      A: __emval_call,
       m: __emval_call_method,
       d: __emval_decref,
-      S: __emval_get_global,
+      Q: __emval_get_global,
       j: __emval_get_method_caller,
       n: __emval_get_module_property,
       H: __emval_get_property,
-      q: __emval_incref,
-      Za: __emval_new_array,
+      r: __emval_incref,
+      $a: __emval_new_array,
       D: __emval_new_cstring,
-      h: __emval_run_destructors,
-      u: __emval_take_value,
-      fb: __gmtime_js,
-      eb: __tzset_js,
-      O: _emscripten_cancel_animation_frame,
-      U: _emscripten_date_now,
-      jb: _emscripten_get_now,
+      i: __emval_run_destructors,
+      t: __emval_take_value,
+      hb: __gmtime_js,
+      gb: __tzset_js,
+      L: _emscripten_cancel_animation_frame,
+      R: _emscripten_date_now,
+      lb: _emscripten_get_now,
+      ad: _emscripten_glActiveTexture,
+      bd: _emscripten_glAttachShader,
+      Gb: _emscripten_glBeginQuery,
+      Ab: _emscripten_glBeginQueryEXT,
+      cd: _emscripten_glBindAttribLocation,
+      ed: _emscripten_glBindBuffer,
+      cc: _emscripten_glBindFramebuffer,
+      dc: _emscripten_glBindRenderbuffer,
+      Mb: _emscripten_glBindSampler,
+      fd: _emscripten_glBindTexture,
+      yc: _emscripten_glBindVertexArray,
+      Bc: _emscripten_glBindVertexArrayOES,
+      gd: _emscripten_glBlendColor,
+      hd: _emscripten_glBlendEquation,
+      id: _emscripten_glBlendFunc,
+      Yb: _emscripten_glBlitFramebuffer,
+      jd: _emscripten_glBufferData,
+      kd: _emscripten_glBufferSubData,
+      ec: _emscripten_glCheckFramebufferStatus,
+      ld: _emscripten_glClear,
+      md: _emscripten_glClearColor,
+      nd: _emscripten_glClearStencil,
+      Vb: _emscripten_glClientWaitSync,
+      T: _emscripten_glColorMask,
+      U: _emscripten_glCompileShader,
+      V: _emscripten_glCompressedTexImage2D,
+      W: _emscripten_glCompressedTexSubImage2D,
+      Xb: _emscripten_glCopyBufferSubData,
+      X: _emscripten_glCopyTexSubImage2D,
+      Y: _emscripten_glCreateProgram,
+      Z: _emscripten_glCreateShader,
+      _: _emscripten_glCullFace,
+      $: _emscripten_glDeleteBuffers,
+      fc: _emscripten_glDeleteFramebuffers,
+      aa: _emscripten_glDeleteProgram,
+      Hb: _emscripten_glDeleteQueries,
+      Bb: _emscripten_glDeleteQueriesEXT,
+      gc: _emscripten_glDeleteRenderbuffers,
+      Nb: _emscripten_glDeleteSamplers,
+      ca: _emscripten_glDeleteShader,
+      Wb: _emscripten_glDeleteSync,
+      da: _emscripten_glDeleteTextures,
+      zc: _emscripten_glDeleteVertexArrays,
+      Cc: _emscripten_glDeleteVertexArraysOES,
+      ea: _emscripten_glDepthMask,
+      fa: _emscripten_glDisable,
+      ga: _emscripten_glDisableVertexAttribArray,
+      ha: _emscripten_glDrawArrays,
+      wc: _emscripten_glDrawArraysInstanced,
+      tc: _emscripten_glDrawArraysInstancedBaseInstanceWEBGL,
+      rc: _emscripten_glDrawBuffers,
+      ia: _emscripten_glDrawElements,
+      xc: _emscripten_glDrawElementsInstanced,
+      uc: _emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
+      lc: _emscripten_glDrawRangeElements,
+      ja: _emscripten_glEnable,
+      ka: _emscripten_glEnableVertexAttribArray,
+      Ib: _emscripten_glEndQuery,
+      Cb: _emscripten_glEndQueryEXT,
+      Sb: _emscripten_glFenceSync,
+      la: _emscripten_glFinish,
+      ma: _emscripten_glFlush,
+      hc: _emscripten_glFramebufferRenderbuffer,
+      ic: _emscripten_glFramebufferTexture2D,
+      na: _emscripten_glFrontFace,
+      oa: _emscripten_glGenBuffers,
+      jc: _emscripten_glGenFramebuffers,
+      Jb: _emscripten_glGenQueries,
+      Db: _emscripten_glGenQueriesEXT,
+      kc: _emscripten_glGenRenderbuffers,
+      Ob: _emscripten_glGenSamplers,
+      pa: _emscripten_glGenTextures,
+      vc: _emscripten_glGenVertexArrays,
+      Dc: _emscripten_glGenVertexArraysOES,
+      _b: _emscripten_glGenerateMipmap,
+      qa: _emscripten_glGetBufferParameteriv,
+      ra: _emscripten_glGetError,
+      sa: _emscripten_glGetFloatv,
+      $b: _emscripten_glGetFramebufferAttachmentParameteriv,
+      ta: _emscripten_glGetIntegerv,
+      ua: _emscripten_glGetProgramInfoLog,
+      va: _emscripten_glGetProgramiv,
+      xb: _emscripten_glGetQueryObjecti64vEXT,
+      yb: _emscripten_glGetQueryObjectui64vEXT,
+      Kb: _emscripten_glGetQueryObjectuiv,
+      Eb: _emscripten_glGetQueryObjectuivEXT,
+      Lb: _emscripten_glGetQueryiv,
+      Fb: _emscripten_glGetQueryivEXT,
+      ac: _emscripten_glGetRenderbufferParameteriv,
+      wa: _emscripten_glGetShaderInfoLog,
+      ub: _emscripten_glGetShaderPrecisionFormat,
+      xa: _emscripten_glGetShaderiv,
+      ya: _emscripten_glGetString,
+      Ac: _emscripten_glGetStringi,
+      za: _emscripten_glGetUniformLocation,
+      vb: _emscripten_glInvalidateFramebuffer,
+      wb: _emscripten_glInvalidateSubFramebuffer,
+      Tb: _emscripten_glIsSync,
+      Aa: _emscripten_glIsTexture,
+      Ba: _emscripten_glLineWidth,
+      Ca: _emscripten_glLinkProgram,
+      pc: _emscripten_glMultiDrawArraysInstancedBaseInstanceWEBGL,
+      qc: _emscripten_glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
+      Da: _emscripten_glPixelStorei,
+      zb: _emscripten_glQueryCounterEXT,
+      sc: _emscripten_glReadBuffer,
+      Ea: _emscripten_glReadPixels,
+      bc: _emscripten_glRenderbufferStorage,
+      Zb: _emscripten_glRenderbufferStorageMultisample,
+      Pb: _emscripten_glSamplerParameterf,
+      Qb: _emscripten_glSamplerParameteri,
+      Rb: _emscripten_glSamplerParameteriv,
+      Fa: _emscripten_glScissor,
+      Ga: _emscripten_glShaderSource,
+      Ha: _emscripten_glStencilFunc,
+      Ia: _emscripten_glStencilFuncSeparate,
+      Ja: _emscripten_glStencilMask,
+      Ka: _emscripten_glStencilMaskSeparate,
+      La: _emscripten_glStencilOp,
+      Ma: _emscripten_glStencilOpSeparate,
+      Na: _emscripten_glTexImage2D,
+      Oa: _emscripten_glTexParameterf,
+      Pa: _emscripten_glTexParameterfv,
+      Qa: _emscripten_glTexParameteri,
+      Ra: _emscripten_glTexParameteriv,
+      mc: _emscripten_glTexStorage2D,
+      Sa: _emscripten_glTexSubImage2D,
+      Ta: _emscripten_glUniform1f,
+      Ua: _emscripten_glUniform1fv,
+      Yc: _emscripten_glUniform1i,
+      Zc: _emscripten_glUniform1iv,
+      _c: _emscripten_glUniform2f,
+      $c: _emscripten_glUniform2fv,
+      Xc: _emscripten_glUniform2i,
+      Wc: _emscripten_glUniform2iv,
+      Vc: _emscripten_glUniform3f,
+      Uc: _emscripten_glUniform3fv,
+      Tc: _emscripten_glUniform3i,
+      Sc: _emscripten_glUniform3iv,
+      Rc: _emscripten_glUniform4f,
+      Qc: _emscripten_glUniform4fv,
+      Ec: _emscripten_glUniform4i,
+      Fc: _emscripten_glUniform4iv,
+      Gc: _emscripten_glUniformMatrix2fv,
+      Hc: _emscripten_glUniformMatrix3fv,
+      Ic: _emscripten_glUniformMatrix4fv,
+      Jc: _emscripten_glUseProgram,
+      Kc: _emscripten_glVertexAttrib1f,
+      Lc: _emscripten_glVertexAttrib2fv,
+      Mc: _emscripten_glVertexAttrib3fv,
+      Nc: _emscripten_glVertexAttrib4fv,
+      nc: _emscripten_glVertexAttribDivisor,
+      oc: _emscripten_glVertexAttribIPointer,
+      Oc: _emscripten_glVertexAttribPointer,
+      Pc: _emscripten_glViewport,
+      Ub: _emscripten_glWaitSync,
       C: _emscripten_request_animation_frame,
-      db: _emscripten_resize_heap,
-      Ya: _emscripten_webgl_make_context_current,
-      hb: _environ_get,
-      ib: _environ_sizes_get,
-      nb: _exit,
-      lb: _fd_close,
-      gb: _fd_seek,
-      T: _fd_write,
-      Mc: _glActiveTexture,
-      Nc: _glAttachShader,
-      Oc: _glBindAttribLocation,
-      Pc: _glBindBuffer,
-      N: _glBindFramebuffer,
-      Pb: _glBindRenderbuffer,
-      xb: _glBindSampler,
-      Qc: _glBindTexture,
-      ic: _glBindVertexArray,
-      kc: _glBindVertexArrayOES,
-      Rc: _glBlendColor,
-      Sc: _glBlendEquation,
-      Tc: _glBlendFunc,
-      Jb: _glBlitFramebuffer,
-      V: _glBufferData,
-      W: _glBufferSubData,
-      Qb: _glCheckFramebufferStatus,
-      K: _glClear,
-      M: _glClearColor,
-      L: _glClearStencil,
-      Hb: _glClientWaitSync,
-      X: _glColorMask,
-      Y: _glCompileShader,
-      Z: _glCompressedTexImage2D,
-      _: _glCompressedTexSubImage2D,
-      Gb: _glCopyBufferSubData,
-      $: _glCopyTexSubImage2D,
-      aa: _glCreateProgram,
-      ba: _glCreateShader,
-      ca: _glCullFace,
-      ea: _glDeleteBuffers,
-      Rb: _glDeleteFramebuffers,
-      fa: _glDeleteProgram,
-      Sb: _glDeleteRenderbuffers,
-      yb: _glDeleteSamplers,
-      ga: _glDeleteShader,
-      Ib: _glDeleteSync,
-      ha: _glDeleteTextures,
-      jc: _glDeleteVertexArrays,
-      lc: _glDeleteVertexArraysOES,
-      ia: _glDepthMask,
-      ja: _glDisable,
-      ka: _glDisableVertexAttribArray,
-      la: _glDrawArrays,
-      gc: _glDrawArraysInstanced,
-      dc: _glDrawArraysInstancedBaseInstanceWEBGL,
-      bc: _glDrawBuffers,
-      ma: _glDrawElements,
-      hc: _glDrawElementsInstanced,
-      ec: _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
-      Xb: _glDrawRangeElements,
-      na: _glEnable,
-      oa: _glEnableVertexAttribArray,
-      Db: _glFenceSync,
-      pa: _glFinish,
-      qa: _glFlush,
-      Tb: _glFramebufferRenderbuffer,
-      Ub: _glFramebufferTexture2D,
-      ra: _glFrontFace,
-      sa: _glGenBuffers,
-      Vb: _glGenFramebuffers,
-      Wb: _glGenRenderbuffers,
-      zb: _glGenSamplers,
-      ta: _glGenTextures,
-      fc: _glGenVertexArrays,
-      mc: _glGenVertexArraysOES,
-      Lb: _glGenerateMipmap,
-      ua: _glGetBufferParameteriv,
-      va: _glGetError,
-      wa: _glGetFloatv,
-      Mb: _glGetFramebufferAttachmentParameteriv,
+      fb: _emscripten_resize_heap,
+      _a: _emscripten_webgl_make_context_current,
+      jb: _environ_get,
+      kb: _environ_sizes_get,
+      pb: _exit,
+      nb: _fd_close,
+      ib: _fd_seek,
+      P: _fd_write,
+      Za: _glBindFramebuffer,
+      Wa: _glClear,
+      Ya: _glClearColor,
+      Xa: _glClearStencil,
       F: _glGetIntegerv,
-      xa: _glGetProgramInfoLog,
-      ya: _glGetProgramiv,
-      Nb: _glGetRenderbufferParameteriv,
-      za: _glGetShaderInfoLog,
-      ub: _glGetShaderPrecisionFormat,
-      Aa: _glGetShaderiv,
-      J: _glGetString,
-      Xa: _glGetStringi,
-      Ba: _glGetUniformLocation,
-      vb: _glInvalidateFramebuffer,
-      wb: _glInvalidateSubFramebuffer,
-      Eb: _glIsSync,
-      Ca: _glIsTexture,
-      Da: _glLineWidth,
-      Ea: _glLinkProgram,
-      $b: _glMultiDrawArraysInstancedBaseInstanceWEBGL,
-      ac: _glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
-      Fa: _glPixelStorei,
-      cc: _glReadBuffer,
-      Ga: _glReadPixels,
-      Ob: _glRenderbufferStorage,
-      Kb: _glRenderbufferStorageMultisample,
-      Ab: _glSamplerParameterf,
-      Bb: _glSamplerParameteri,
-      Cb: _glSamplerParameteriv,
-      Ha: _glScissor,
-      Ia: _glShaderSource,
-      Ja: _glStencilFunc,
-      Ka: _glStencilFuncSeparate,
-      La: _glStencilMask,
-      Ma: _glStencilMaskSeparate,
-      Na: _glStencilOp,
-      Oa: _glStencilOpSeparate,
-      Pa: _glTexImage2D,
-      Qa: _glTexParameterf,
-      Ra: _glTexParameterfv,
-      Sa: _glTexParameteri,
-      Ta: _glTexParameteriv,
-      Yb: _glTexStorage2D,
-      Ua: _glTexSubImage2D,
-      Va: _glUniform1f,
-      Wa: _glUniform1fv,
-      Hc: _glUniform1i,
-      Ic: _glUniform1iv,
-      Kc: _glUniform2f,
-      Lc: _glUniform2fv,
-      Gc: _glUniform2i,
-      Fc: _glUniform2iv,
-      Ec: _glUniform3f,
-      Dc: _glUniform3fv,
-      Cc: _glUniform3i,
-      Bc: _glUniform3iv,
-      Ac: _glUniform4f,
-      zc: _glUniform4fv,
-      nc: _glUniform4i,
-      oc: _glUniform4iv,
-      pc: _glUniformMatrix2fv,
-      qc: _glUniformMatrix3fv,
-      rc: _glUniformMatrix4fv,
-      sc: _glUseProgram,
-      tc: _glVertexAttrib1f,
-      uc: _glVertexAttrib2fv,
-      vc: _glVertexAttrib3fv,
-      wc: _glVertexAttrib4fv,
-      Zb: _glVertexAttribDivisor,
-      _b: _glVertexAttribIPointer,
-      xc: _glVertexAttribPointer,
-      yc: _glViewport,
-      Fb: _glWaitSync,
-      g: invoke_ii,
-      t: invoke_iii,
-      i: invoke_iiii,
-      z: invoke_iiiii,
+      K: _glGetString,
+      Va: _glGetStringi,
+      f: invoke_ii,
+      q: invoke_iii,
+      k: invoke_iiii,
+      B: invoke_iiiii,
       qb: invoke_iiiiii,
-      pb: invoke_iiiiiii,
-      sb: invoke_v,
-      k: invoke_vi,
-      A: invoke_vii,
+      tb: invoke_iiiiiii,
+      S: invoke_iiiiiiii,
+      I: invoke_v,
+      h: invoke_vi,
+      y: invoke_vii,
       v: invoke_viii,
-      r: invoke_viiii,
-      ob: invoke_viiiii,
+      w: invoke_viiii,
       rb: invoke_viiiiii,
-      tb: invoke_viiiiiiiii,
-      bb: _strftime_l
+      sb: invoke_viiiiiiiii,
+      db: _strftime_l
     };
     var wasmExports = createWasm();
-    var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["Vc"])();
-    var ___getTypeName = a0 => (___getTypeName = wasmExports["Wc"])(a0);
-    var _malloc = Module["_malloc"] = a0 => (_malloc = Module["_malloc"] = wasmExports["Xc"])(a0);
-    var _free = Module["_free"] = a0 => (_free = Module["_free"] = wasmExports["Zc"])(a0);
-    var _setThrew = (a0, a1) => (_setThrew = wasmExports["_c"])(a0, a1);
-    var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["$c"])(a0);
+    var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["pd"])();
+    var ___getTypeName = a0 => (___getTypeName = wasmExports["qd"])(a0);
+    var _malloc = Module["_malloc"] = a0 => (_malloc = Module["_malloc"] = wasmExports["rd"])(a0);
+    var _free = Module["_free"] = a0 => (_free = Module["_free"] = wasmExports["td"])(a0);
+    var _setThrew = (a0, a1) => (_setThrew = wasmExports["ud"])(a0, a1);
+    var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["vd"])(a0);
     var __emscripten_stack_alloc = a0 => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);
-    var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["ad"])();
+    var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["wd"])();
     function invoke_ii(index, a1) {
       var sp = stackSave();
       try {
@@ -3981,60 +4273,60 @@ var WebRendererWasmFactory = (() => {
         _setThrew(1, 0);
       }
     }
-    function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    function invoke_v(index) {
       var sp = stackSave();
       try {
-        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        getWasmTableEntry(index)();
       } catch (e) {
         stackRestore(sp);
         if (e !== e + 0) throw e;
         _setThrew(1, 0);
       }
     }
-    function invoke_v(index) {
+    function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
       var sp = stackSave();
       try {
-        getWasmTableEntry(index)();
+        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
       } catch (e) {
         stackRestore(sp);
         if (e !== e + 0) throw e;
         _setThrew(1, 0);
       }
     }
-    function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
+    function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
       var sp = stackSave();
       try {
-        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
+        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
       } catch (e) {
         stackRestore(sp);
         if (e !== e + 0) throw e;
         _setThrew(1, 0);
       }
     }
-    function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
+    function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
       var sp = stackSave();
       try {
-        return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
       } catch (e) {
         stackRestore(sp);
         if (e !== e + 0) throw e;
         _setThrew(1, 0);
       }
     }
-    function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
+    function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
       var sp = stackSave();
       try {
-        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
+        return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
       } catch (e) {
         stackRestore(sp);
         if (e !== e + 0) throw e;
         _setThrew(1, 0);
       }
     }
-    function invoke_viiiii(index, a1, a2, a3, a4, a5) {
+    function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
       var sp = stackSave();
       try {
-        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7);
       } catch (e) {
         stackRestore(sp);
         if (e !== e + 0) throw e;