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

package/out/web-renderer/wasm/Debug/web-renderer-debug.mjs

@@ -3012,77 +3012,6 @@ var WebRendererWasmFactory = (() => {
     // unfortunately not allowed even in current browsers (e.g. FF Nightly 75).
     _emscripten_get_now = () => performance.now();
     ;
-    var _emscripten_request_animation_frame = (cb, userData) => requestAnimationFrame(timeStamp => getWasmTableEntry(cb)(timeStamp, userData));
-    var getHeapMax = () =>
-    // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
-    // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
-    // for any code that deals with heap sizes, which would require special
-    // casing all heap size related code to treat 0 specially.
-    2147483648;
-    var growMemory = size => {
-      var b = wasmMemory.buffer;
-      var pages = (size - b.byteLength + 65535) / 65536;
-      try {
-        // round size grow request up to wasm page size (fixed 64KB per spec)
-        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
-        updateMemoryViews();
-        return 1 /*success*/;
-      } catch (e) {
-        err("growMemory: Attempted to grow heap from ".concat(b.byteLength, " bytes to ").concat(size, " bytes, but got error: ").concat(e));
-      }
-      // implicit 0 return to save code size (caller will cast "undefined" into 0
-      // anyhow)
-    };
-    var _emscripten_resize_heap = requestedSize => {
-      var oldSize = HEAPU8.length;
-      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
-      requestedSize >>>= 0;
-      // With multithreaded builds, races can happen (another thread might increase the size
-      // in between), so return a failure, and let the caller retry.
-      assert(requestedSize > oldSize);
-
-      // Memory resize rules:
-      // 1.  Always increase heap size to at least the requested size, rounded up
-      //     to next page multiple.
-      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
-      //     geometrically: increase the heap size according to
-      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
-      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
-      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
-      //     linearly: increase the heap size by at least
-      //     MEMORY_GROWTH_LINEAR_STEP bytes.
-      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
-      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
-      // 4.  If we were unable to allocate as much memory, it may be due to
-      //     over-eager decision to excessively reserve due to (3) above.
-      //     Hence if an allocation fails, cut down on the amount of excess
-      //     growth, in an attempt to succeed to perform a smaller allocation.
-
-      // A limit is set for how much we can grow. We should not exceed that
-      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
-      var maxHeapSize = getHeapMax();
-      if (requestedSize > maxHeapSize) {
-        err("Cannot enlarge memory, requested ".concat(requestedSize, " bytes, but the limit is ").concat(maxHeapSize, " bytes!"));
-        return false;
-      }
-      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
-
-      // Loop through potential heap size increases. If we attempt a too eager
-      // reservation that fails, cut down on the attempted size and reserve a
-      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
-      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
-        // but limit overreserving (default to capping at +96MB overgrowth at most)
-        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;
-        }
-      }
-      err("Failed to grow the heap from ".concat(oldSize, " bytes to ").concat(newSize, " bytes, not enough memory!"));
-      return false;
-    };
     var webgl_enable_ANGLE_instanced_arrays = ctx => {
       // Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2.
       var ext = ctx.getExtension('ANGLE_instanced_arrays');
@@ -3303,148 +3232,35 @@ var WebRendererWasmFactory = (() => {
         });
       }
     };
-    var _emscripten_webgl_make_context_current = contextHandle => {
-      var success = GL.makeContextCurrent(contextHandle);
-      return success ? 0 : -5;
-    };
-    var ENV = {};
-    var getExecutableName = () => {
-      return thisProgram || './this.program';
-    };
-    var getEnvStrings = () => {
-      if (!getEnvStrings.strings) {
-        // Default values.
-        // Browser language detection #8751
-        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()
-        };
-        // Apply the user-provided values, if any.
-        for (var x in ENV) {
-          // x is a key in ENV; if ENV[x] is undefined, that means it was
-          // explicitly set to be so. We allow user code to do that to
-          // force variables with default values to remain unset.
-          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) {
-        assert(str.charCodeAt(i) === (str.charCodeAt(i) & 0xff));
-        HEAP8[buffer++] = str.charCodeAt(i);
-      }
-      // Null-terminate the string
-      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));
-    };
-
     /** @suppress {duplicate } */
-    /** @param {boolean|number=} implicit */
-    var exitJS = (status, implicit) => {
-      EXITSTATUS = status;
-      checkUnflushedContent();
-
-      // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
-      if (keepRuntimeAlive() && !implicit) {
-        var msg = "program exited (with status: ".concat(status, "), but keepRuntimeAlive() is set (counter=").concat(runtimeKeepaliveCounter, ") due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)");
-        readyPromiseReject(msg);
-        err(msg);
-      }
-      _proc_exit(status);
-    };
-    var _exit = exitJS;
-    var SYSCALLS = {
-      varargs: undefined,
-      getStr(ptr) {
-        var ret = UTF8ToString(ptr);
-        return ret;
-      }
-    };
-    var _fd_close = fd => {
-      abort('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM');
-    };
-    function _fd_seek(fd, offset, whence, newOffset) {
-      offset = bigintToI53Checked(offset);
-      return 70;
-      ;
-    }
-    var printCharBuffers = [null, [], []];
-    var printChar = (stream, curr) => {
-      var buffer = printCharBuffers[stream];
-      assert(buffer);
-      if (curr === 0 || curr === 10) {
-        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
-        buffer.length = 0;
-      } else {
-        buffer.push(curr);
-      }
-    };
-    var flush_NO_FILESYSTEM = () => {
-      // flush anything remaining in the buffers during shutdown
-      _fflush(0);
-      if (printCharBuffers[1].length) printChar(1, 10);
-      if (printCharBuffers[2].length) printChar(2, 10);
-    };
-    var _fd_write = (fd, iov, iovcnt, pnum) => {
-      // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
-      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;
+
+    /** @suppress {duplicate } */
     var _glAttachShader = (program, shader) => {
       GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
     };
+    var _emscripten_glAttachShader = _glAttachShader;
+
+    /** @suppress {duplicate } */
+    var _glBeginQuery = (target, id) => {
+      GLctx.beginQuery(target, GL.queries[id]);
+    };
+    var _emscripten_glBeginQuery = _glBeginQuery;
+
+    /** @suppress {duplicate } */
+    var _glBeginQueryEXT = (target, id) => {
+      GLctx.disjointTimerQueryExt['beginQueryEXT'](target, GL.queries[id]);
+    };
+    var _emscripten_glBeginQueryEXT = _glBeginQueryEXT;
+
+    /** @suppress {duplicate } */
     var _glBindAttribLocation = (program, index, name) => {
       GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
     };
+    var _emscripten_glBindAttribLocation = _glBindAttribLocation;
+
+    /** @suppress {duplicate } */
     var _glBindBuffer = (target, buffer) => {
       if (target == 0x88EB /*GL_PIXEL_PACK_BUFFER*/) {
         // In WebGL 2 glReadPixels entry point, we need to use a different WebGL 2
@@ -3463,26 +3279,59 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.bindBuffer(target, GL.buffers[buffer]);
     };
+    var _emscripten_glBindBuffer = _glBindBuffer;
+
+    /** @suppress {duplicate } */
     var _glBindFramebuffer = (target, framebuffer) => {
       GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
     };
+    var _emscripten_glBindFramebuffer = _glBindFramebuffer;
+
+    /** @suppress {duplicate } */
     var _glBindRenderbuffer = (target, renderbuffer) => {
       GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
     };
+    var _emscripten_glBindRenderbuffer = _glBindRenderbuffer;
+
+    /** @suppress {duplicate } */
     var _glBindSampler = (unit, sampler) => {
       GLctx.bindSampler(unit, GL.samplers[sampler]);
     };
+    var _emscripten_glBindSampler = _glBindSampler;
+
+    /** @suppress {duplicate } */
     var _glBindTexture = (target, texture) => {
       GLctx.bindTexture(target, GL.textures[texture]);
     };
+    var _emscripten_glBindTexture = _glBindTexture;
+
+    /** @suppress {duplicate } */
     var _glBindVertexArray = vao => {
       GLctx.bindVertexArray(GL.vaos[vao]);
     };
+    var _emscripten_glBindVertexArray = _glBindVertexArray;
+
+    /** @suppress {duplicate } */
     var _glBindVertexArrayOES = _glBindVertexArray;
+    var _emscripten_glBindVertexArrayOES = _glBindVertexArrayOES;
+
+    /** @suppress {duplicate } */
     var _glBlendColor = (x0, x1, x2, x3) => GLctx.blendColor(x0, x1, x2, x3);
+    var _emscripten_glBlendColor = _glBlendColor;
+
+    /** @suppress {duplicate } */
     var _glBlendEquation = x0 => GLctx.blendEquation(x0);
+    var _emscripten_glBlendEquation = _glBlendEquation;
+
+    /** @suppress {duplicate } */
     var _glBlendFunc = (x0, x1) => GLctx.blendFunc(x0, x1);
+    var _emscripten_glBlendFunc = _glBlendFunc;
+
+    /** @suppress {duplicate } */
     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;
+
+    /** @suppress {duplicate } */
     var _glBufferData = (target, size, data, usage) => {
       if (GL.currentContext.version >= 2) {
         // If size is zero, WebGL would interpret uploading the whole input
@@ -3502,6 +3351,9 @@ var WebRendererWasmFactory = (() => {
       // engine JIT issues.
       GLctx.bufferData(target, data ? HEAPU8.subarray(data, data + size) : size, usage);
     };
+    var _emscripten_glBufferData = _glBufferData;
+
+    /** @suppress {duplicate } */
     var _glBufferSubData = (target, offset, size, data) => {
       if (GL.currentContext.version >= 2) {
         size && GLctx.bufferSubData(target, offset, HEAPU8, data, size);
@@ -3509,10 +3361,25 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size));
     };
+    var _emscripten_glBufferSubData = _glBufferSubData;
+
+    /** @suppress {duplicate } */
     var _glCheckFramebufferStatus = x0 => GLctx.checkFramebufferStatus(x0);
+    var _emscripten_glCheckFramebufferStatus = _glCheckFramebufferStatus;
+
+    /** @suppress {duplicate } */
     var _glClear = x0 => GLctx.clear(x0);
+    var _emscripten_glClear = _glClear;
+
+    /** @suppress {duplicate } */
     var _glClearColor = (x0, x1, x2, x3) => GLctx.clearColor(x0, x1, x2, x3);
+    var _emscripten_glClearColor = _glClearColor;
+
+    /** @suppress {duplicate } */
     var _glClearStencil = x0 => GLctx.clearStencil(x0);
+    var _emscripten_glClearStencil = _glClearStencil;
+
+    /** @suppress {duplicate } */
     var _glClientWaitSync = (sync, flags, timeout) => {
       // WebGL2 vs GLES3 differences: in GLES3, the timeout parameter is a uint64, where 0xFFFFFFFFFFFFFFFFULL means GL_TIMEOUT_IGNORED.
       // In JS, there's no 64-bit value types, so instead timeout is taken to be signed, and GL_TIMEOUT_IGNORED is given value -1.
@@ -3521,13 +3388,22 @@ var WebRendererWasmFactory = (() => {
       timeout = Number(timeout);
       return GLctx.clientWaitSync(GL.syncs[sync], flags, timeout);
     };
+    var _emscripten_glClientWaitSync = _glClientWaitSync;
+
+    /** @suppress {duplicate } */
     var _glColorMask = (red, green, blue, alpha) => {
       GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
     };
+    var _emscripten_glColorMask = _glColorMask;
+
+    /** @suppress {duplicate } */
     var _glCompileShader = shader => {
       GLctx.compileShader(GL.shaders[shader]);
     };
-    var _glCompressedTexImage2D = (target, level, internalFormat, width, height, border, imageSize, data) => {
+    var _emscripten_glCompileShader = _glCompileShader;
+
+    /** @suppress {duplicate } */
+    var _glCompressedTexImage2D = (target, level, internalFormat, width, height, border, imageSize, data) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
           GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data);
@@ -3538,6 +3414,9 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, data ? HEAPU8.subarray(data, data + imageSize) : null);
     };
+    var _emscripten_glCompressedTexImage2D = _glCompressedTexImage2D;
+
+    /** @suppress {duplicate } */
     var _glCompressedTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, imageSize, data) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
@@ -3549,8 +3428,17 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, data ? HEAPU8.subarray(data, data + imageSize) : null);
     };
+    var _emscripten_glCompressedTexSubImage2D = _glCompressedTexSubImage2D;
+
+    /** @suppress {duplicate } */
     var _glCopyBufferSubData = (x0, x1, x2, x3, x4) => GLctx.copyBufferSubData(x0, x1, x2, x3, x4);
+    var _emscripten_glCopyBufferSubData = _glCopyBufferSubData;
+
+    /** @suppress {duplicate } */
     var _glCopyTexSubImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7);
+    var _emscripten_glCopyTexSubImage2D = _glCopyTexSubImage2D;
+
+    /** @suppress {duplicate } */
     var _glCreateProgram = () => {
       var id = GL.getNewId(GL.programs);
       var program = GLctx.createProgram();
@@ -3563,12 +3451,21 @@ var WebRendererWasmFactory = (() => {
       GL.programs[id] = program;
       return id;
     };
+    var _emscripten_glCreateProgram = _glCreateProgram;
+
+    /** @suppress {duplicate } */
     var _glCreateShader = shaderType => {
       var id = GL.getNewId(GL.shaders);
       GL.shaders[id] = GLctx.createShader(shaderType);
       return id;
     };
+    var _emscripten_glCreateShader = _glCreateShader;
+
+    /** @suppress {duplicate } */
     var _glCullFace = x0 => GLctx.cullFace(x0);
+    var _emscripten_glCullFace = _glCullFace;
+
+    /** @suppress {duplicate } */
     var _glDeleteBuffers = (n, buffers) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[buffers + i * 4 >> 2];
@@ -3584,6 +3481,9 @@ var WebRendererWasmFactory = (() => {
         if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
       }
     };
+    var _emscripten_glDeleteBuffers = _glDeleteBuffers;
+
+    /** @suppress {duplicate } */
     var _glDeleteFramebuffers = (n, framebuffers) => {
       for (var i = 0; i < n; ++i) {
         var id = HEAP32[framebuffers + i * 4 >> 2];
@@ -3594,6 +3494,9 @@ var WebRendererWasmFactory = (() => {
         GL.framebuffers[id] = null;
       }
     };
+    var _emscripten_glDeleteFramebuffers = _glDeleteFramebuffers;
+
+    /** @suppress {duplicate } */
     var _glDeleteProgram = id => {
       if (!id) return;
       var program = GL.programs[id];
@@ -3607,6 +3510,33 @@ var WebRendererWasmFactory = (() => {
       program.name = 0;
       GL.programs[id] = null;
     };
+    var _emscripten_glDeleteProgram = _glDeleteProgram;
+
+    /** @suppress {duplicate } */
+    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; // GL spec: "unused names in ids are ignored, as is the name zero."
+        GLctx.deleteQuery(query);
+        GL.queries[id] = null;
+      }
+    };
+    var _emscripten_glDeleteQueries = _glDeleteQueries;
+
+    /** @suppress {duplicate } */
+    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; // GL spec: "unused names in ids are ignored, as is the name zero."
+        GLctx.disjointTimerQueryExt['deleteQueryEXT'](query);
+        GL.queries[id] = null;
+      }
+    };
+    var _emscripten_glDeleteQueriesEXT = _glDeleteQueriesEXT;
+
+    /** @suppress {duplicate } */
     var _glDeleteRenderbuffers = (n, renderbuffers) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[renderbuffers + i * 4 >> 2];
@@ -3617,6 +3547,9 @@ var WebRendererWasmFactory = (() => {
         GL.renderbuffers[id] = null;
       }
     };
+    var _emscripten_glDeleteRenderbuffers = _glDeleteRenderbuffers;
+
+    /** @suppress {duplicate } */
     var _glDeleteSamplers = (n, samplers) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[samplers + i * 4 >> 2];
@@ -3627,6 +3560,9 @@ var WebRendererWasmFactory = (() => {
         GL.samplers[id] = null;
       }
     };
+    var _emscripten_glDeleteSamplers = _glDeleteSamplers;
+
+    /** @suppress {duplicate } */
     var _glDeleteShader = id => {
       if (!id) return;
       var shader = GL.shaders[id];
@@ -3639,6 +3575,9 @@ var WebRendererWasmFactory = (() => {
       GLctx.deleteShader(shader);
       GL.shaders[id] = null;
     };
+    var _emscripten_glDeleteShader = _glDeleteShader;
+
+    /** @suppress {duplicate } */
     var _glDeleteSync = id => {
       if (!id) return;
       var sync = GL.syncs[id];
@@ -3651,6 +3590,9 @@ var WebRendererWasmFactory = (() => {
       sync.name = 0;
       GL.syncs[id] = null;
     };
+    var _emscripten_glDeleteSync = _glDeleteSync;
+
+    /** @suppress {duplicate } */
     var _glDeleteTextures = (n, textures) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[textures + i * 4 >> 2];
@@ -3663,6 +3605,9 @@ var WebRendererWasmFactory = (() => {
         GL.textures[id] = null;
       }
     };
+    var _emscripten_glDeleteTextures = _glDeleteTextures;
+
+    /** @suppress {duplicate } */
     var _glDeleteVertexArrays = (n, vaos) => {
       for (var i = 0; i < n; i++) {
         var id = HEAP32[vaos + i * 4 >> 2];
@@ -3670,24 +3615,48 @@ var WebRendererWasmFactory = (() => {
         GL.vaos[id] = null;
       }
     };
+    var _emscripten_glDeleteVertexArrays = _glDeleteVertexArrays;
+
+    /** @suppress {duplicate } */
     var _glDeleteVertexArraysOES = _glDeleteVertexArrays;
+    var _emscripten_glDeleteVertexArraysOES = _glDeleteVertexArraysOES;
+
+    /** @suppress {duplicate } */
     var _glDepthMask = flag => {
       GLctx.depthMask(!!flag);
     };
+    var _emscripten_glDepthMask = _glDepthMask;
+
+    /** @suppress {duplicate } */
     var _glDisable = x0 => GLctx.disable(x0);
+    var _emscripten_glDisable = _glDisable;
+
+    /** @suppress {duplicate } */
     var _glDisableVertexAttribArray = index => {
       GLctx.disableVertexAttribArray(index);
     };
+    var _emscripten_glDisableVertexAttribArray = _glDisableVertexAttribArray;
+
+    /** @suppress {duplicate } */
     var _glDrawArrays = (mode, first, count) => {
       GLctx.drawArrays(mode, first, count);
     };
+    var _emscripten_glDrawArrays = _glDrawArrays;
+
+    /** @suppress {duplicate } */
     var _glDrawArraysInstanced = (mode, first, count, primcount) => {
       GLctx.drawArraysInstanced(mode, first, count, primcount);
     };
+    var _emscripten_glDrawArraysInstanced = _glDrawArraysInstanced;
+
+    /** @suppress {duplicate } */
     var _glDrawArraysInstancedBaseInstanceWEBGL = (mode, first, count, instanceCount, baseInstance) => {
       GLctx.dibvbi['drawArraysInstancedBaseInstanceWEBGL'](mode, first, count, instanceCount, baseInstance);
     };
+    var _emscripten_glDrawArraysInstancedBaseInstanceWEBGL = _glDrawArraysInstancedBaseInstanceWEBGL;
     var tempFixedLengthArray = [];
+
+    /** @suppress {duplicate } */
     var _glDrawBuffers = (n, bufs) => {
       var bufArray = tempFixedLengthArray[n];
       for (var i = 0; i < n; i++) {
@@ -3695,15 +3664,27 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.drawBuffers(bufArray);
     };
+    var _emscripten_glDrawBuffers = _glDrawBuffers;
+
+    /** @suppress {duplicate } */
     var _glDrawElements = (mode, count, type, indices) => {
       GLctx.drawElements(mode, count, type, indices);
     };
+    var _emscripten_glDrawElements = _glDrawElements;
+
+    /** @suppress {duplicate } */
     var _glDrawElementsInstanced = (mode, count, type, indices, primcount) => {
       GLctx.drawElementsInstanced(mode, count, type, indices, primcount);
     };
+    var _emscripten_glDrawElementsInstanced = _glDrawElementsInstanced;
+
+    /** @suppress {duplicate } */
     var _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL = (mode, count, type, offset, instanceCount, baseVertex, baseinstance) => {
       GLctx.dibvbi['drawElementsInstancedBaseVertexBaseInstanceWEBGL'](mode, count, type, offset, instanceCount, baseVertex, baseinstance);
     };
+    var _emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL = _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL;
+
+    /** @suppress {duplicate } */
     var _glDrawRangeElements = (mode, start, end, count, type, indices) => {
       // TODO: This should be a trivial pass-though function registered at the bottom of this page as
       // glFuncs[6][1] += ' drawRangeElements';
@@ -3711,10 +3692,29 @@ var WebRendererWasmFactory = (() => {
       // we work around by ignoring the range.
       _glDrawElements(mode, count, type, indices);
     };
+    var _emscripten_glDrawRangeElements = _glDrawRangeElements;
+
+    /** @suppress {duplicate } */
     var _glEnable = x0 => GLctx.enable(x0);
+    var _emscripten_glEnable = _glEnable;
+
+    /** @suppress {duplicate } */
     var _glEnableVertexAttribArray = index => {
       GLctx.enableVertexAttribArray(index);
     };
+    var _emscripten_glEnableVertexAttribArray = _glEnableVertexAttribArray;
+
+    /** @suppress {duplicate } */
+    var _glEndQuery = x0 => GLctx.endQuery(x0);
+    var _emscripten_glEndQuery = _glEndQuery;
+
+    /** @suppress {duplicate } */
+    var _glEndQueryEXT = target => {
+      GLctx.disjointTimerQueryExt['endQueryEXT'](target);
+    };
+    var _emscripten_glEndQueryEXT = _glEndQueryEXT;
+
+    /** @suppress {duplicate } */
     var _glFenceSync = (condition, flags) => {
       var sync = GLctx.fenceSync(condition, flags);
       if (sync) {
@@ -3725,35 +3725,100 @@ var WebRendererWasmFactory = (() => {
       }
       return 0; // Failed to create a sync object
     };
+    var _emscripten_glFenceSync = _glFenceSync;
+
+    /** @suppress {duplicate } */
     var _glFinish = () => GLctx.finish();
+    var _emscripten_glFinish = _glFinish;
+
+    /** @suppress {duplicate } */
     var _glFlush = () => GLctx.flush();
+    var _emscripten_glFlush = _glFlush;
+
+    /** @suppress {duplicate } */
     var _glFramebufferRenderbuffer = (target, attachment, renderbuffertarget, renderbuffer) => {
       GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, GL.renderbuffers[renderbuffer]);
     };
+    var _emscripten_glFramebufferRenderbuffer = _glFramebufferRenderbuffer;
+
+    /** @suppress {duplicate } */
     var _glFramebufferTexture2D = (target, attachment, textarget, texture, level) => {
       GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level);
     };
+    var _emscripten_glFramebufferTexture2D = _glFramebufferTexture2D;
+
+    /** @suppress {duplicate } */
     var _glFrontFace = x0 => GLctx.frontFace(x0);
+    var _emscripten_glFrontFace = _glFrontFace;
+
+    /** @suppress {duplicate } */
     var _glGenBuffers = (n, buffers) => {
       GL.genObject(n, buffers, 'createBuffer', GL.buffers);
     };
+    var _emscripten_glGenBuffers = _glGenBuffers;
+
+    /** @suppress {duplicate } */
     var _glGenFramebuffers = (n, ids) => {
       GL.genObject(n, ids, 'createFramebuffer', GL.framebuffers);
     };
+    var _emscripten_glGenFramebuffers = _glGenFramebuffers;
+
+    /** @suppress {duplicate } */
+    var _glGenQueries = (n, ids) => {
+      GL.genObject(n, ids, 'createQuery', GL.queries);
+    };
+    var _emscripten_glGenQueries = _glGenQueries;
+
+    /** @suppress {duplicate } */
+    var _glGenQueriesEXT = (n, ids) => {
+      for (var i = 0; i < n; i++) {
+        var query = GLctx.disjointTimerQueryExt['createQueryEXT']();
+        if (!query) {
+          GL.recordError(0x502 /* GL_INVALID_OPERATION */);
+          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;
+
+    /** @suppress {duplicate } */
     var _glGenRenderbuffers = (n, renderbuffers) => {
       GL.genObject(n, renderbuffers, 'createRenderbuffer', GL.renderbuffers);
     };
+    var _emscripten_glGenRenderbuffers = _glGenRenderbuffers;
+
+    /** @suppress {duplicate } */
     var _glGenSamplers = (n, samplers) => {
       GL.genObject(n, samplers, 'createSampler', GL.samplers);
     };
+    var _emscripten_glGenSamplers = _glGenSamplers;
+
+    /** @suppress {duplicate } */
     var _glGenTextures = (n, textures) => {
       GL.genObject(n, textures, 'createTexture', GL.textures);
     };
+    var _emscripten_glGenTextures = _glGenTextures;
+
+    /** @suppress {duplicate } */
     var _glGenVertexArrays = (n, arrays) => {
       GL.genObject(n, arrays, 'createVertexArray', GL.vaos);
     };
+    var _emscripten_glGenVertexArrays = _glGenVertexArrays;
+
+    /** @suppress {duplicate } */
     var _glGenVertexArraysOES = _glGenVertexArrays;
+    var _emscripten_glGenVertexArraysOES = _glGenVertexArraysOES;
+
+    /** @suppress {duplicate } */
     var _glGenerateMipmap = x0 => GLctx.generateMipmap(x0);
+    var _emscripten_glGenerateMipmap = _glGenerateMipmap;
+
+    /** @suppress {duplicate } */
     var _glGetBufferParameteriv = (target, value, data) => {
       if (!data) {
         // GLES2 specification does not specify how to behave if data is a null
@@ -3764,11 +3829,15 @@ var WebRendererWasmFactory = (() => {
       }
       HEAP32[data >> 2] = GLctx.getBufferParameter(target, value);
     };
+    var _emscripten_glGetBufferParameteriv = _glGetBufferParameteriv;
+
+    /** @suppress {duplicate } */
     var _glGetError = () => {
       var error = GLctx.getError() || GL.lastError;
       GL.lastError = 0 /*GL_NO_ERROR*/;
       return error;
     };
+    var _emscripten_glGetError = _glGetError;
     var readI53FromI64 = ptr => {
       return HEAPU32[ptr >> 2] + HEAP32[ptr + 4 >> 2] * 4294967296;
     };
@@ -3940,7 +4009,12 @@ var WebRendererWasmFactory = (() => {
           break;
       }
     };
+
+    /** @suppress {duplicate } */
     var _glGetFloatv = (name_, p) => emscriptenWebGLGet(name_, p, 2);
+    var _emscripten_glGetFloatv = _glGetFloatv;
+
+    /** @suppress {duplicate } */
     var _glGetFramebufferAttachmentParameteriv = (target, attachment, pname, params) => {
       var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname);
       if (result instanceof WebGLRenderbuffer || result instanceof WebGLTexture) {
@@ -3948,13 +4022,22 @@ var WebRendererWasmFactory = (() => {
       }
       HEAP32[params >> 2] = result;
     };
+    var _emscripten_glGetFramebufferAttachmentParameteriv = _glGetFramebufferAttachmentParameteriv;
+
+    /** @suppress {duplicate } */
     var _glGetIntegerv = (name_, p) => emscriptenWebGLGet(name_, p, 0);
+    var _emscripten_glGetIntegerv = _glGetIntegerv;
+
+    /** @suppress {duplicate } */
     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;
+
+    /** @suppress {duplicate } */
     var _glGetProgramiv = (program, pname, p) => {
       if (!p) {
         // GLES2 specification does not specify how to behave if p is a null
@@ -3998,6 +4081,104 @@ var WebRendererWasmFactory = (() => {
         HEAP32[p >> 2] = GLctx.getProgramParameter(program, pname);
       }
     };
+    var _emscripten_glGetProgramiv = _glGetProgramiv;
+
+    /** @suppress {duplicate } */
+    var _glGetQueryObjecti64vEXT = (id, pname, params) => {
+      if (!params) {
+        // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+        // if p == null, issue a GL error to notify user about it.
+        GL.recordError(0x501 /* GL_INVALID_VALUE */);
+        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;
+
+    /** @suppress {duplicate } */
+    var _glGetQueryObjectui64vEXT = _glGetQueryObjecti64vEXT;
+    var _emscripten_glGetQueryObjectui64vEXT = _glGetQueryObjectui64vEXT;
+
+    /** @suppress {duplicate } */
+    var _glGetQueryObjectuiv = (id, pname, params) => {
+      if (!params) {
+        // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+        // if p == null, issue a GL error to notify user about it.
+        GL.recordError(0x501 /* GL_INVALID_VALUE */);
+        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;
+
+    /** @suppress {duplicate } */
+    var _glGetQueryObjectivEXT = (id, pname, params) => {
+      if (!params) {
+        // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+        // if p == null, issue a GL error to notify user about it.
+        GL.recordError(0x501 /* GL_INVALID_VALUE */);
+        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;
+    };
+    /** @suppress {duplicate } */
+    var _glGetQueryObjectuivEXT = _glGetQueryObjectivEXT;
+    var _emscripten_glGetQueryObjectuivEXT = _glGetQueryObjectuivEXT;
+
+    /** @suppress {duplicate } */
+    var _glGetQueryiv = (target, pname, params) => {
+      if (!params) {
+        // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+        // if p == null, issue a GL error to notify user about it.
+        GL.recordError(0x501 /* GL_INVALID_VALUE */);
+        return;
+      }
+      HEAP32[params >> 2] = GLctx.getQuery(target, pname);
+    };
+    var _emscripten_glGetQueryiv = _glGetQueryiv;
+
+    /** @suppress {duplicate } */
+    var _glGetQueryivEXT = (target, pname, params) => {
+      if (!params) {
+        // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+        // if p == null, issue a GL error to notify user about it.
+        GL.recordError(0x501 /* GL_INVALID_VALUE */);
+        return;
+      }
+      HEAP32[params >> 2] = GLctx.disjointTimerQueryExt['getQueryEXT'](target, pname);
+    };
+    var _emscripten_glGetQueryivEXT = _glGetQueryivEXT;
+
+    /** @suppress {duplicate } */
     var _glGetRenderbufferParameteriv = (target, pname, params) => {
       if (!params) {
         // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
@@ -4007,18 +4188,27 @@ var WebRendererWasmFactory = (() => {
       }
       HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname);
     };
+    var _emscripten_glGetRenderbufferParameteriv = _glGetRenderbufferParameteriv;
+
+    /** @suppress {duplicate } */
     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;
+
+    /** @suppress {duplicate } */
     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;
+
+    /** @suppress {duplicate } */
     var _glGetShaderiv = (shader, pname, p) => {
       if (!p) {
         // GLES2 specification does not specify how to behave if p is a null
@@ -4048,12 +4238,15 @@ 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);
       if (ret) stringToUTF8(str, ret, size);
       return ret;
     };
+
+    /** @suppress {duplicate } */
     var _glGetString = name_ => {
       var ret = GL.stringCache[name_];
       if (!ret) {
@@ -4098,6 +4291,9 @@ var WebRendererWasmFactory = (() => {
       }
       return ret;
     };
+    var _emscripten_glGetString = _glGetString;
+
+    /** @suppress {duplicate } */
     var _glGetStringi = (name, index) => {
       if (GL.currentContext.version < 2) {
         GL.recordError(0x502 /* GL_INVALID_OPERATION */); // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context
@@ -4125,6 +4321,7 @@ var WebRendererWasmFactory = (() => {
           return 0;
       }
     };
+    var _emscripten_glGetStringi = _glGetStringi;
 
     /** @suppress {checkTypes} */
     var jstoi_q = str => parseInt(str);
@@ -4172,6 +4369,8 @@ var WebRendererWasmFactory = (() => {
         }
       }
     };
+
+    /** @suppress {duplicate } */
     var _glGetUniformLocation = (program, name) => {
       name = UTF8ToString(name);
       if (program = GL.programs[program]) {
@@ -4217,6 +4416,9 @@ var WebRendererWasmFactory = (() => {
       }
       return -1;
     };
+    var _emscripten_glGetUniformLocation = _glGetUniformLocation;
+
+    /** @suppress {duplicate } */
     var _glInvalidateFramebuffer = (target, numAttachments, attachments) => {
       var list = tempFixedLengthArray[numAttachments];
       for (var i = 0; i < numAttachments; i++) {
@@ -4224,6 +4426,9 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.invalidateFramebuffer(target, list);
     };
+    var _emscripten_glInvalidateFramebuffer = _glInvalidateFramebuffer;
+
+    /** @suppress {duplicate } */
     var _glInvalidateSubFramebuffer = (target, numAttachments, attachments, x, y, width, height) => {
       var list = tempFixedLengthArray[numAttachments];
       for (var i = 0; i < numAttachments; i++) {
@@ -4231,13 +4436,25 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.invalidateSubFramebuffer(target, list, x, y, width, height);
     };
+    var _emscripten_glInvalidateSubFramebuffer = _glInvalidateSubFramebuffer;
+
+    /** @suppress {duplicate } */
     var _glIsSync = sync => GLctx.isSync(GL.syncs[sync]);
+    var _emscripten_glIsSync = _glIsSync;
+
+    /** @suppress {duplicate } */
     var _glIsTexture = id => {
       var texture = GL.textures[id];
       if (!texture) return 0;
       return GLctx.isTexture(texture);
     };
+    var _emscripten_glIsTexture = _glIsTexture;
+
+    /** @suppress {duplicate } */
     var _glLineWidth = x0 => GLctx.lineWidth(x0);
+    var _emscripten_glLineWidth = _glLineWidth;
+
+    /** @suppress {duplicate } */
     var _glLinkProgram = program => {
       program = GL.programs[program];
       GLctx.linkProgram(program);
@@ -4245,19 +4462,38 @@ var WebRendererWasmFactory = (() => {
       program.uniformLocsById = 0; // Mark as null-like so that glGetUniformLocation() knows to populate this again.
       program.uniformSizeAndIdsByName = {};
     };
+    var _emscripten_glLinkProgram = _glLinkProgram;
+
+    /** @suppress {duplicate } */
     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;
+
+    /** @suppress {duplicate } */
     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;
+
+    /** @suppress {duplicate } */
     var _glPixelStorei = (pname, param) => {
       if (pname == 0xCF5 /* GL_UNPACK_ALIGNMENT */) {
         GL.unpackAlignment = param;
       }
       GLctx.pixelStorei(pname, param);
     };
+    var _emscripten_glPixelStorei = _glPixelStorei;
+
+    /** @suppress {duplicate } */
+    var _glQueryCounterEXT = (id, target) => {
+      GLctx.disjointTimerQueryExt['queryCounterEXT'](GL.queries[id], target);
+    };
+    var _emscripten_glQueryCounterEXT = _glQueryCounterEXT;
+
+    /** @suppress {duplicate } */
     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;
@@ -4310,6 +4546,8 @@ var WebRendererWasmFactory = (() => {
       var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment);
       return heap.subarray(toTypedArrayIndex(pixels, heap), toTypedArrayIndex(pixels + bytes, heap));
     };
+
+    /** @suppress {duplicate } */
     var _glReadPixels = (x, y, width, height, format, type, pixels) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelPackBufferBinding) {
@@ -4328,29 +4566,71 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.readPixels(x, y, width, height, format, type, pixelData);
     };
+    var _emscripten_glReadPixels = _glReadPixels;
+
+    /** @suppress {duplicate } */
     var _glRenderbufferStorage = (x0, x1, x2, x3) => GLctx.renderbufferStorage(x0, x1, x2, x3);
+    var _emscripten_glRenderbufferStorage = _glRenderbufferStorage;
+
+    /** @suppress {duplicate } */
     var _glRenderbufferStorageMultisample = (x0, x1, x2, x3, x4) => GLctx.renderbufferStorageMultisample(x0, x1, x2, x3, x4);
+    var _emscripten_glRenderbufferStorageMultisample = _glRenderbufferStorageMultisample;
+
+    /** @suppress {duplicate } */
     var _glSamplerParameterf = (sampler, pname, param) => {
       GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
     };
+    var _emscripten_glSamplerParameterf = _glSamplerParameterf;
+
+    /** @suppress {duplicate } */
     var _glSamplerParameteri = (sampler, pname, param) => {
       GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
     };
+    var _emscripten_glSamplerParameteri = _glSamplerParameteri;
+
+    /** @suppress {duplicate } */
     var _glSamplerParameteriv = (sampler, pname, params) => {
       var param = HEAP32[params >> 2];
       GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
     };
+    var _emscripten_glSamplerParameteriv = _glSamplerParameteriv;
+
+    /** @suppress {duplicate } */
     var _glScissor = (x0, x1, x2, x3) => GLctx.scissor(x0, x1, x2, x3);
+    var _emscripten_glScissor = _glScissor;
+
+    /** @suppress {duplicate } */
     var _glShaderSource = (shader, count, string, length) => {
       var source = GL.getSource(shader, count, string, length);
       GLctx.shaderSource(GL.shaders[shader], source);
     };
+    var _emscripten_glShaderSource = _glShaderSource;
+
+    /** @suppress {duplicate } */
     var _glStencilFunc = (x0, x1, x2) => GLctx.stencilFunc(x0, x1, x2);
+    var _emscripten_glStencilFunc = _glStencilFunc;
+
+    /** @suppress {duplicate } */
     var _glStencilFuncSeparate = (x0, x1, x2, x3) => GLctx.stencilFuncSeparate(x0, x1, x2, x3);
+    var _emscripten_glStencilFuncSeparate = _glStencilFuncSeparate;
+
+    /** @suppress {duplicate } */
     var _glStencilMask = x0 => GLctx.stencilMask(x0);
+    var _emscripten_glStencilMask = _glStencilMask;
+
+    /** @suppress {duplicate } */
     var _glStencilMaskSeparate = (x0, x1) => GLctx.stencilMaskSeparate(x0, x1);
+    var _emscripten_glStencilMaskSeparate = _glStencilMaskSeparate;
+
+    /** @suppress {duplicate } */
     var _glStencilOp = (x0, x1, x2) => GLctx.stencilOp(x0, x1, x2);
+    var _emscripten_glStencilOp = _glStencilOp;
+
+    /** @suppress {duplicate } */
     var _glStencilOpSeparate = (x0, x1, x2, x3) => GLctx.stencilOpSeparate(x0, x1, x2, x3);
+    var _emscripten_glStencilOpSeparate = _glStencilOpSeparate;
+
+    /** @suppress {duplicate } */
     var _glTexImage2D = (target, level, internalFormat, width, height, border, format, type, pixels) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding) {
@@ -4367,17 +4647,35 @@ 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;
+
+    /** @suppress {duplicate } */
     var _glTexParameterf = (x0, x1, x2) => GLctx.texParameterf(x0, x1, x2);
+    var _emscripten_glTexParameterf = _glTexParameterf;
+
+    /** @suppress {duplicate } */
     var _glTexParameterfv = (target, pname, params) => {
       var param = HEAPF32[params >> 2];
       GLctx.texParameterf(target, pname, param);
     };
+    var _emscripten_glTexParameterfv = _glTexParameterfv;
+
+    /** @suppress {duplicate } */
     var _glTexParameteri = (x0, x1, x2) => GLctx.texParameteri(x0, x1, x2);
+    var _emscripten_glTexParameteri = _glTexParameteri;
+
+    /** @suppress {duplicate } */
     var _glTexParameteriv = (target, pname, params) => {
       var param = HEAP32[params >> 2];
       GLctx.texParameteri(target, pname, param);
     };
+    var _emscripten_glTexParameteriv = _glTexParameteriv;
+
+    /** @suppress {duplicate } */
     var _glTexStorage2D = (x0, x1, x2, x3, x4) => GLctx.texStorage2D(x0, x1, x2, x3, x4);
+    var _emscripten_glTexStorage2D = _glTexStorage2D;
+
+    /** @suppress {duplicate } */
     var _glTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, type, pixels) => {
       if (GL.currentContext.version >= 2) {
         if (GLctx.currentPixelUnpackBufferBinding) {
@@ -4393,6 +4691,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) {
@@ -4410,10 +4709,15 @@ var WebRendererWasmFactory = (() => {
         GL.recordError(0x502 /*GL_INVALID_OPERATION*/);
       }
     };
+
+    /** @suppress {duplicate } */
     var _glUniform1f = (location, v0) => {
       GLctx.uniform1f(webglGetUniformLocation(location), v0);
     };
+    var _emscripten_glUniform1f = _glUniform1f;
     var miniTempWebGLFloatBuffers = [];
+
+    /** @suppress {duplicate } */
     var _glUniform1fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count);
@@ -4430,10 +4734,16 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform1fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform1fv = _glUniform1fv;
+
+    /** @suppress {duplicate } */
     var _glUniform1i = (location, v0) => {
       GLctx.uniform1i(webglGetUniformLocation(location), v0);
     };
+    var _emscripten_glUniform1i = _glUniform1i;
     var miniTempWebGLIntBuffers = [];
+
+    /** @suppress {duplicate } */
     var _glUniform1iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, value >> 2, count);
@@ -4450,9 +4760,15 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform1iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform1iv = _glUniform1iv;
+
+    /** @suppress {duplicate } */
     var _glUniform2f = (location, v0, v1) => {
       GLctx.uniform2f(webglGetUniformLocation(location), v0, v1);
     };
+    var _emscripten_glUniform2f = _glUniform2f;
+
+    /** @suppress {duplicate } */
     var _glUniform2fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2);
@@ -4470,9 +4786,15 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform2fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform2fv = _glUniform2fv;
+
+    /** @suppress {duplicate } */
     var _glUniform2i = (location, v0, v1) => {
       GLctx.uniform2i(webglGetUniformLocation(location), v0, v1);
     };
+    var _emscripten_glUniform2i = _glUniform2i;
+
+    /** @suppress {duplicate } */
     var _glUniform2iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 2);
@@ -4490,9 +4812,15 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform2iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform2iv = _glUniform2iv;
+
+    /** @suppress {duplicate } */
     var _glUniform3f = (location, v0, v1, v2) => {
       GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2);
     };
+    var _emscripten_glUniform3f = _glUniform3f;
+
+    /** @suppress {duplicate } */
     var _glUniform3fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 3);
@@ -4511,9 +4839,15 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform3fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform3fv = _glUniform3fv;
+
+    /** @suppress {duplicate } */
     var _glUniform3i = (location, v0, v1, v2) => {
       GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2);
     };
+    var _emscripten_glUniform3i = _glUniform3i;
+
+    /** @suppress {duplicate } */
     var _glUniform3iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 3);
@@ -4532,9 +4866,15 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform3iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform3iv = _glUniform3iv;
+
+    /** @suppress {duplicate } */
     var _glUniform4f = (location, v0, v1, v2, v3) => {
       GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
     };
+    var _emscripten_glUniform4f = _glUniform4f;
+
+    /** @suppress {duplicate } */
     var _glUniform4fv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4);
@@ -4558,9 +4898,15 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform4fv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform4fv = _glUniform4fv;
+
+    /** @suppress {duplicate } */
     var _glUniform4i = (location, v0, v1, v2, v3) => {
       GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3);
     };
+    var _emscripten_glUniform4i = _glUniform4i;
+
+    /** @suppress {duplicate } */
     var _glUniform4iv = (location, count, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4);
@@ -4580,6 +4926,9 @@ var WebRendererWasmFactory = (() => {
       }
       GLctx.uniform4iv(webglGetUniformLocation(location), view);
     };
+    var _emscripten_glUniform4iv = _glUniform4iv;
+
+    /** @suppress {duplicate } */
     var _glUniformMatrix2fv = (location, count, transpose, value) => {
       if (GL.currentContext.version >= 2) {
         count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 4);
@@ -4594,101 +4943,344 @@ var WebRendererWasmFactory = (() => {
           view[i + 2] = HEAPF32[value + (4 * i + 8) >> 2];
           view[i + 3] = HEAPF32[value + (4 * i + 12) >> 2];
         }
-      } else {
-        var view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2);
-      }
-      GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view);
-    };
-    var _glUniformMatrix3fv = (location, count, transpose, value) => {
-      if (GL.currentContext.version >= 2) {
-        count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 9);
-        return;
-      }
-      if (count <= 32) {
-        // avoid allocation when uploading few enough uniforms
-        var view = miniTempWebGLFloatBuffers[9 * count];
-        for (var i = 0; i < 9 * count; i += 9) {
-          view[i] = HEAPF32[value + 4 * i >> 2];
-          view[i + 1] = HEAPF32[value + (4 * i + 4) >> 2];
-          view[i + 2] = HEAPF32[value + (4 * i + 8) >> 2];
-          view[i + 3] = HEAPF32[value + (4 * i + 12) >> 2];
-          view[i + 4] = HEAPF32[value + (4 * i + 16) >> 2];
-          view[i + 5] = HEAPF32[value + (4 * i + 20) >> 2];
-          view[i + 6] = HEAPF32[value + (4 * i + 24) >> 2];
-          view[i + 7] = HEAPF32[value + (4 * i + 28) >> 2];
-          view[i + 8] = HEAPF32[value + (4 * i + 32) >> 2];
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2);
+      }
+      GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view);
+    };
+    var _emscripten_glUniformMatrix2fv = _glUniformMatrix2fv;
+
+    /** @suppress {duplicate } */
+    var _glUniformMatrix3fv = (location, count, transpose, value) => {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 9);
+        return;
+      }
+      if (count <= 32) {
+        // avoid allocation when uploading few enough uniforms
+        var view = miniTempWebGLFloatBuffers[9 * count];
+        for (var i = 0; i < 9 * count; i += 9) {
+          view[i] = HEAPF32[value + 4 * i >> 2];
+          view[i + 1] = HEAPF32[value + (4 * i + 4) >> 2];
+          view[i + 2] = HEAPF32[value + (4 * i + 8) >> 2];
+          view[i + 3] = HEAPF32[value + (4 * i + 12) >> 2];
+          view[i + 4] = HEAPF32[value + (4 * i + 16) >> 2];
+          view[i + 5] = HEAPF32[value + (4 * i + 20) >> 2];
+          view[i + 6] = HEAPF32[value + (4 * i + 24) >> 2];
+          view[i + 7] = HEAPF32[value + (4 * i + 28) >> 2];
+          view[i + 8] = HEAPF32[value + (4 * i + 32) >> 2];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 36 >> 2);
+      }
+      GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view);
+    };
+    var _emscripten_glUniformMatrix3fv = _glUniformMatrix3fv;
+
+    /** @suppress {duplicate } */
+    var _glUniformMatrix4fv = (location, count, transpose, value) => {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 16);
+        return;
+      }
+      if (count <= 18) {
+        // avoid allocation when uploading few enough uniforms
+        var view = miniTempWebGLFloatBuffers[16 * count];
+        // hoist the heap out of the loop for size and for pthreads+growth.
+        var heap = HEAPF32;
+        value = value >> 2;
+        for (var i = 0; i < 16 * count; i += 16) {
+          var dst = value + i;
+          view[i] = heap[dst];
+          view[i + 1] = heap[dst + 1];
+          view[i + 2] = heap[dst + 2];
+          view[i + 3] = heap[dst + 3];
+          view[i + 4] = heap[dst + 4];
+          view[i + 5] = heap[dst + 5];
+          view[i + 6] = heap[dst + 6];
+          view[i + 7] = heap[dst + 7];
+          view[i + 8] = heap[dst + 8];
+          view[i + 9] = heap[dst + 9];
+          view[i + 10] = heap[dst + 10];
+          view[i + 11] = heap[dst + 11];
+          view[i + 12] = heap[dst + 12];
+          view[i + 13] = heap[dst + 13];
+          view[i + 14] = heap[dst + 14];
+          view[i + 15] = heap[dst + 15];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 64 >> 2);
+      }
+      GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view);
+    };
+    var _emscripten_glUniformMatrix4fv = _glUniformMatrix4fv;
+
+    /** @suppress {duplicate } */
+    var _glUseProgram = program => {
+      program = GL.programs[program];
+      GLctx.useProgram(program);
+      // Record the currently active program so that we can access the uniform
+      // mapping table of that program.
+      GLctx.currentProgram = program;
+    };
+    var _emscripten_glUseProgram = _glUseProgram;
+
+    /** @suppress {duplicate } */
+    var _glVertexAttrib1f = (x0, x1) => GLctx.vertexAttrib1f(x0, x1);
+    var _emscripten_glVertexAttrib1f = _glVertexAttrib1f;
+
+    /** @suppress {duplicate } */
+    var _glVertexAttrib2fv = (index, v) => {
+      GLctx.vertexAttrib2f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2]);
+    };
+    var _emscripten_glVertexAttrib2fv = _glVertexAttrib2fv;
+
+    /** @suppress {duplicate } */
+    var _glVertexAttrib3fv = (index, v) => {
+      GLctx.vertexAttrib3f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2]);
+    };
+    var _emscripten_glVertexAttrib3fv = _glVertexAttrib3fv;
+
+    /** @suppress {duplicate } */
+    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;
+
+    /** @suppress {duplicate } */
+    var _glVertexAttribDivisor = (index, divisor) => {
+      GLctx.vertexAttribDivisor(index, divisor);
+    };
+    var _emscripten_glVertexAttribDivisor = _glVertexAttribDivisor;
+
+    /** @suppress {duplicate } */
+    var _glVertexAttribIPointer = (index, size, type, stride, ptr) => {
+      GLctx.vertexAttribIPointer(index, size, type, stride, ptr);
+    };
+    var _emscripten_glVertexAttribIPointer = _glVertexAttribIPointer;
+
+    /** @suppress {duplicate } */
+    var _glVertexAttribPointer = (index, size, type, normalized, stride, ptr) => {
+      GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
+    };
+    var _emscripten_glVertexAttribPointer = _glVertexAttribPointer;
+
+    /** @suppress {duplicate } */
+    var _glViewport = (x0, x1, x2, x3) => GLctx.viewport(x0, x1, x2, x3);
+    var _emscripten_glViewport = _glViewport;
+
+    /** @suppress {duplicate } */
+    var _glWaitSync = (sync, flags, timeout) => {
+      // See WebGL2 vs GLES3 difference on GL_TIMEOUT_IGNORED above (https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15)
+      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 = () =>
+    // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+    // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+    // for any code that deals with heap sizes, which would require special
+    // casing all heap size related code to treat 0 specially.
+    2147483648;
+    var growMemory = size => {
+      var b = wasmMemory.buffer;
+      var pages = (size - b.byteLength + 65535) / 65536;
+      try {
+        // round size grow request up to wasm page size (fixed 64KB per spec)
+        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
+        updateMemoryViews();
+        return 1 /*success*/;
+      } catch (e) {
+        err("growMemory: Attempted to grow heap from ".concat(b.byteLength, " bytes to ").concat(size, " bytes, but got error: ").concat(e));
+      }
+      // implicit 0 return to save code size (caller will cast "undefined" into 0
+      // anyhow)
+    };
+    var _emscripten_resize_heap = requestedSize => {
+      var oldSize = HEAPU8.length;
+      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+      requestedSize >>>= 0;
+      // With multithreaded builds, races can happen (another thread might increase the size
+      // in between), so return a failure, and let the caller retry.
+      assert(requestedSize > oldSize);
+
+      // Memory resize rules:
+      // 1.  Always increase heap size to at least the requested size, rounded up
+      //     to next page multiple.
+      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
+      //     geometrically: increase the heap size according to
+      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
+      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
+      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
+      //     linearly: increase the heap size by at least
+      //     MEMORY_GROWTH_LINEAR_STEP bytes.
+      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
+      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
+      // 4.  If we were unable to allocate as much memory, it may be due to
+      //     over-eager decision to excessively reserve due to (3) above.
+      //     Hence if an allocation fails, cut down on the amount of excess
+      //     growth, in an attempt to succeed to perform a smaller allocation.
+
+      // A limit is set for how much we can grow. We should not exceed that
+      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        err("Cannot enlarge memory, requested ".concat(requestedSize, " bytes, but the limit is ").concat(maxHeapSize, " bytes!"));
+        return false;
+      }
+      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+
+      // Loop through potential heap size increases. If we attempt a too eager
+      // reservation that fails, cut down on the attempted size and reserve a
+      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
+        // but limit overreserving (default to capping at +96MB overgrowth at most)
+        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;
+        }
+      }
+      err("Failed to grow the heap from ".concat(oldSize, " bytes to ").concat(newSize, " bytes, not enough memory!"));
+      return false;
+    };
+    var _emscripten_webgl_make_context_current = contextHandle => {
+      var success = GL.makeContextCurrent(contextHandle);
+      return success ? 0 : -5;
+    };
+    var ENV = {};
+    var getExecutableName = () => {
+      return thisProgram || './this.program';
+    };
+    var getEnvStrings = () => {
+      if (!getEnvStrings.strings) {
+        // Default values.
+        // Browser language detection #8751
+        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()
+        };
+        // Apply the user-provided values, if any.
+        for (var x in ENV) {
+          // x is a key in ENV; if ENV[x] is undefined, that means it was
+          // explicitly set to be so. We allow user code to do that to
+          // force variables with default values to remain unset.
+          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]));
         }
-      } else {
-        var view = HEAPF32.subarray(value >> 2, value + count * 36 >> 2);
+        getEnvStrings.strings = strings;
       }
-      GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view);
+      return getEnvStrings.strings;
     };
-    var _glUniformMatrix4fv = (location, count, transpose, value) => {
-      if (GL.currentContext.version >= 2) {
-        count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 16);
-        return;
-      }
-      if (count <= 18) {
-        // avoid allocation when uploading few enough uniforms
-        var view = miniTempWebGLFloatBuffers[16 * count];
-        // hoist the heap out of the loop for size and for pthreads+growth.
-        var heap = HEAPF32;
-        value = value >> 2;
-        for (var i = 0; i < 16 * count; i += 16) {
-          var dst = value + i;
-          view[i] = heap[dst];
-          view[i + 1] = heap[dst + 1];
-          view[i + 2] = heap[dst + 2];
-          view[i + 3] = heap[dst + 3];
-          view[i + 4] = heap[dst + 4];
-          view[i + 5] = heap[dst + 5];
-          view[i + 6] = heap[dst + 6];
-          view[i + 7] = heap[dst + 7];
-          view[i + 8] = heap[dst + 8];
-          view[i + 9] = heap[dst + 9];
-          view[i + 10] = heap[dst + 10];
-          view[i + 11] = heap[dst + 11];
-          view[i + 12] = heap[dst + 12];
-          view[i + 13] = heap[dst + 13];
-          view[i + 14] = heap[dst + 14];
-          view[i + 15] = heap[dst + 15];
-        }
-      } else {
-        var view = HEAPF32.subarray(value >> 2, value + count * 64 >> 2);
+    var stringToAscii = (str, buffer) => {
+      for (var i = 0; i < str.length; ++i) {
+        assert(str.charCodeAt(i) === (str.charCodeAt(i) & 0xff));
+        HEAP8[buffer++] = str.charCodeAt(i);
       }
-      GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view);
+      // Null-terminate the string
+      HEAP8[buffer] = 0;
     };
-    var _glUseProgram = program => {
-      program = GL.programs[program];
-      GLctx.useProgram(program);
-      // Record the currently active program so that we can access the uniform
-      // mapping table of that program.
-      GLctx.currentProgram = program;
+    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 _glVertexAttrib1f = (x0, x1) => GLctx.vertexAttrib1f(x0, x1);
-    var _glVertexAttrib2fv = (index, v) => {
-      GLctx.vertexAttrib2f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2]);
+    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 _glVertexAttrib3fv = (index, v) => {
-      GLctx.vertexAttrib3f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2]);
+    var runtimeKeepaliveCounter = 0;
+    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+    var _proc_exit = code => {
+      EXITSTATUS = code;
+      if (!keepRuntimeAlive()) {
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
     };
-    var _glVertexAttrib4fv = (index, v) => {
-      GLctx.vertexAttrib4f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2], HEAPF32[v + 12 >> 2]);
+
+    /** @suppress {duplicate } */
+    /** @param {boolean|number=} implicit */
+    var exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      checkUnflushedContent();
+
+      // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
+      if (keepRuntimeAlive() && !implicit) {
+        var msg = "program exited (with status: ".concat(status, "), but keepRuntimeAlive() is set (counter=").concat(runtimeKeepaliveCounter, ") due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)");
+        readyPromiseReject(msg);
+        err(msg);
+      }
+      _proc_exit(status);
     };
-    var _glVertexAttribDivisor = (index, divisor) => {
-      GLctx.vertexAttribDivisor(index, divisor);
+    var _exit = exitJS;
+    var SYSCALLS = {
+      varargs: undefined,
+      getStr(ptr) {
+        var ret = UTF8ToString(ptr);
+        return ret;
+      }
     };
-    var _glVertexAttribIPointer = (index, size, type, stride, ptr) => {
-      GLctx.vertexAttribIPointer(index, size, type, stride, ptr);
+    var _fd_close = fd => {
+      abort('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM');
     };
-    var _glVertexAttribPointer = (index, size, type, normalized, stride, ptr) => {
-      GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
+    function _fd_seek(fd, offset, whence, newOffset) {
+      offset = bigintToI53Checked(offset);
+      return 70;
+      ;
+    }
+    var printCharBuffers = [null, [], []];
+    var printChar = (stream, curr) => {
+      var buffer = printCharBuffers[stream];
+      assert(buffer);
+      if (curr === 0 || curr === 10) {
+        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+        buffer.length = 0;
+      } else {
+        buffer.push(curr);
+      }
     };
-    var _glViewport = (x0, x1, x2, x3) => GLctx.viewport(x0, x1, x2, x3);
-    var _glWaitSync = (sync, flags, timeout) => {
-      // See WebGL2 vs GLES3 difference on GL_TIMEOUT_IGNORED above (https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15)
-      timeout = Number(timeout);
-      GLctx.waitSync(GL.syncs[sync], flags, timeout);
+    var flush_NO_FILESYSTEM = () => {
+      // flush anything remaining in the buffers during shutdown
+      _fflush(0);
+      if (printCharBuffers[1].length) printChar(1, 10);
+      if (printCharBuffers[2].length) printChar(2, 10);
+    };
+    var _fd_write = (fd, iov, iovcnt, pnum) => {
+      // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
+      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) => {
@@ -5177,305 +5769,349 @@ var WebRendererWasmFactory = (() => {
       /** @export */
       emscripten_get_now: _emscripten_get_now,
       /** @export */
-      emscripten_request_animation_frame: _emscripten_request_animation_frame,
+      emscripten_glActiveTexture: _emscripten_glActiveTexture,
       /** @export */
-      emscripten_resize_heap: _emscripten_resize_heap,
+      emscripten_glAttachShader: _emscripten_glAttachShader,
       /** @export */
-      emscripten_webgl_make_context_current: _emscripten_webgl_make_context_current,
+      emscripten_glBeginQuery: _emscripten_glBeginQuery,
       /** @export */
-      environ_get: _environ_get,
+      emscripten_glBeginQueryEXT: _emscripten_glBeginQueryEXT,
       /** @export */
-      environ_sizes_get: _environ_sizes_get,
+      emscripten_glBindAttribLocation: _emscripten_glBindAttribLocation,
       /** @export */
-      exit: _exit,
+      emscripten_glBindBuffer: _emscripten_glBindBuffer,
       /** @export */
-      fd_close: _fd_close,
+      emscripten_glBindFramebuffer: _emscripten_glBindFramebuffer,
       /** @export */
-      fd_seek: _fd_seek,
+      emscripten_glBindRenderbuffer: _emscripten_glBindRenderbuffer,
       /** @export */
-      fd_write: _fd_write,
+      emscripten_glBindSampler: _emscripten_glBindSampler,
       /** @export */
-      glActiveTexture: _glActiveTexture,
+      emscripten_glBindTexture: _emscripten_glBindTexture,
       /** @export */
-      glAttachShader: _glAttachShader,
+      emscripten_glBindVertexArray: _emscripten_glBindVertexArray,
       /** @export */
-      glBindAttribLocation: _glBindAttribLocation,
+      emscripten_glBindVertexArrayOES: _emscripten_glBindVertexArrayOES,
       /** @export */
-      glBindBuffer: _glBindBuffer,
+      emscripten_glBlendColor: _emscripten_glBlendColor,
       /** @export */
-      glBindFramebuffer: _glBindFramebuffer,
+      emscripten_glBlendEquation: _emscripten_glBlendEquation,
       /** @export */
-      glBindRenderbuffer: _glBindRenderbuffer,
+      emscripten_glBlendFunc: _emscripten_glBlendFunc,
       /** @export */
-      glBindSampler: _glBindSampler,
+      emscripten_glBlitFramebuffer: _emscripten_glBlitFramebuffer,
       /** @export */
-      glBindTexture: _glBindTexture,
+      emscripten_glBufferData: _emscripten_glBufferData,
       /** @export */
-      glBindVertexArray: _glBindVertexArray,
+      emscripten_glBufferSubData: _emscripten_glBufferSubData,
       /** @export */
-      glBindVertexArrayOES: _glBindVertexArrayOES,
+      emscripten_glCheckFramebufferStatus: _emscripten_glCheckFramebufferStatus,
       /** @export */
-      glBlendColor: _glBlendColor,
+      emscripten_glClear: _emscripten_glClear,
       /** @export */
-      glBlendEquation: _glBlendEquation,
+      emscripten_glClearColor: _emscripten_glClearColor,
       /** @export */
-      glBlendFunc: _glBlendFunc,
+      emscripten_glClearStencil: _emscripten_glClearStencil,
       /** @export */
-      glBlitFramebuffer: _glBlitFramebuffer,
+      emscripten_glClientWaitSync: _emscripten_glClientWaitSync,
       /** @export */
-      glBufferData: _glBufferData,
+      emscripten_glColorMask: _emscripten_glColorMask,
       /** @export */
-      glBufferSubData: _glBufferSubData,
+      emscripten_glCompileShader: _emscripten_glCompileShader,
       /** @export */
-      glCheckFramebufferStatus: _glCheckFramebufferStatus,
+      emscripten_glCompressedTexImage2D: _emscripten_glCompressedTexImage2D,
       /** @export */
-      glClear: _glClear,
+      emscripten_glCompressedTexSubImage2D: _emscripten_glCompressedTexSubImage2D,
       /** @export */
-      glClearColor: _glClearColor,
+      emscripten_glCopyBufferSubData: _emscripten_glCopyBufferSubData,
       /** @export */
-      glClearStencil: _glClearStencil,
+      emscripten_glCopyTexSubImage2D: _emscripten_glCopyTexSubImage2D,
       /** @export */
-      glClientWaitSync: _glClientWaitSync,
+      emscripten_glCreateProgram: _emscripten_glCreateProgram,
       /** @export */
-      glColorMask: _glColorMask,
+      emscripten_glCreateShader: _emscripten_glCreateShader,
       /** @export */
-      glCompileShader: _glCompileShader,
+      emscripten_glCullFace: _emscripten_glCullFace,
       /** @export */
-      glCompressedTexImage2D: _glCompressedTexImage2D,
+      emscripten_glDeleteBuffers: _emscripten_glDeleteBuffers,
       /** @export */
-      glCompressedTexSubImage2D: _glCompressedTexSubImage2D,
+      emscripten_glDeleteFramebuffers: _emscripten_glDeleteFramebuffers,
       /** @export */
-      glCopyBufferSubData: _glCopyBufferSubData,
+      emscripten_glDeleteProgram: _emscripten_glDeleteProgram,
       /** @export */
-      glCopyTexSubImage2D: _glCopyTexSubImage2D,
+      emscripten_glDeleteQueries: _emscripten_glDeleteQueries,
       /** @export */
-      glCreateProgram: _glCreateProgram,
+      emscripten_glDeleteQueriesEXT: _emscripten_glDeleteQueriesEXT,
       /** @export */
-      glCreateShader: _glCreateShader,
+      emscripten_glDeleteRenderbuffers: _emscripten_glDeleteRenderbuffers,
       /** @export */
-      glCullFace: _glCullFace,
+      emscripten_glDeleteSamplers: _emscripten_glDeleteSamplers,
       /** @export */
-      glDeleteBuffers: _glDeleteBuffers,
+      emscripten_glDeleteShader: _emscripten_glDeleteShader,
       /** @export */
-      glDeleteFramebuffers: _glDeleteFramebuffers,
+      emscripten_glDeleteSync: _emscripten_glDeleteSync,
       /** @export */
-      glDeleteProgram: _glDeleteProgram,
+      emscripten_glDeleteTextures: _emscripten_glDeleteTextures,
       /** @export */
-      glDeleteRenderbuffers: _glDeleteRenderbuffers,
+      emscripten_glDeleteVertexArrays: _emscripten_glDeleteVertexArrays,
       /** @export */
-      glDeleteSamplers: _glDeleteSamplers,
+      emscripten_glDeleteVertexArraysOES: _emscripten_glDeleteVertexArraysOES,
       /** @export */
-      glDeleteShader: _glDeleteShader,
+      emscripten_glDepthMask: _emscripten_glDepthMask,
       /** @export */
-      glDeleteSync: _glDeleteSync,
+      emscripten_glDisable: _emscripten_glDisable,
       /** @export */
-      glDeleteTextures: _glDeleteTextures,
+      emscripten_glDisableVertexAttribArray: _emscripten_glDisableVertexAttribArray,
       /** @export */
-      glDeleteVertexArrays: _glDeleteVertexArrays,
+      emscripten_glDrawArrays: _emscripten_glDrawArrays,
       /** @export */
-      glDeleteVertexArraysOES: _glDeleteVertexArraysOES,
+      emscripten_glDrawArraysInstanced: _emscripten_glDrawArraysInstanced,
       /** @export */
-      glDepthMask: _glDepthMask,
+      emscripten_glDrawArraysInstancedBaseInstanceWEBGL: _emscripten_glDrawArraysInstancedBaseInstanceWEBGL,
       /** @export */
-      glDisable: _glDisable,
+      emscripten_glDrawBuffers: _emscripten_glDrawBuffers,
       /** @export */
-      glDisableVertexAttribArray: _glDisableVertexAttribArray,
+      emscripten_glDrawElements: _emscripten_glDrawElements,
       /** @export */
-      glDrawArrays: _glDrawArrays,
+      emscripten_glDrawElementsInstanced: _emscripten_glDrawElementsInstanced,
       /** @export */
-      glDrawArraysInstanced: _glDrawArraysInstanced,
+      emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL: _emscripten_glDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
       /** @export */
-      glDrawArraysInstancedBaseInstanceWEBGL: _glDrawArraysInstancedBaseInstanceWEBGL,
+      emscripten_glDrawRangeElements: _emscripten_glDrawRangeElements,
       /** @export */
-      glDrawBuffers: _glDrawBuffers,
+      emscripten_glEnable: _emscripten_glEnable,
       /** @export */
-      glDrawElements: _glDrawElements,
+      emscripten_glEnableVertexAttribArray: _emscripten_glEnableVertexAttribArray,
       /** @export */
-      glDrawElementsInstanced: _glDrawElementsInstanced,
+      emscripten_glEndQuery: _emscripten_glEndQuery,
       /** @export */
-      glDrawElementsInstancedBaseVertexBaseInstanceWEBGL: _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
+      emscripten_glEndQueryEXT: _emscripten_glEndQueryEXT,
       /** @export */
-      glDrawRangeElements: _glDrawRangeElements,
+      emscripten_glFenceSync: _emscripten_glFenceSync,
       /** @export */
-      glEnable: _glEnable,
+      emscripten_glFinish: _emscripten_glFinish,
       /** @export */
-      glEnableVertexAttribArray: _glEnableVertexAttribArray,
+      emscripten_glFlush: _emscripten_glFlush,
       /** @export */
-      glFenceSync: _glFenceSync,
+      emscripten_glFramebufferRenderbuffer: _emscripten_glFramebufferRenderbuffer,
       /** @export */
-      glFinish: _glFinish,
+      emscripten_glFramebufferTexture2D: _emscripten_glFramebufferTexture2D,
       /** @export */
-      glFlush: _glFlush,
+      emscripten_glFrontFace: _emscripten_glFrontFace,
       /** @export */
-      glFramebufferRenderbuffer: _glFramebufferRenderbuffer,
+      emscripten_glGenBuffers: _emscripten_glGenBuffers,
       /** @export */
-      glFramebufferTexture2D: _glFramebufferTexture2D,
+      emscripten_glGenFramebuffers: _emscripten_glGenFramebuffers,
       /** @export */
-      glFrontFace: _glFrontFace,
+      emscripten_glGenQueries: _emscripten_glGenQueries,
       /** @export */
-      glGenBuffers: _glGenBuffers,
+      emscripten_glGenQueriesEXT: _emscripten_glGenQueriesEXT,
       /** @export */
-      glGenFramebuffers: _glGenFramebuffers,
+      emscripten_glGenRenderbuffers: _emscripten_glGenRenderbuffers,
       /** @export */
-      glGenRenderbuffers: _glGenRenderbuffers,
+      emscripten_glGenSamplers: _emscripten_glGenSamplers,
       /** @export */
-      glGenSamplers: _glGenSamplers,
+      emscripten_glGenTextures: _emscripten_glGenTextures,
       /** @export */
-      glGenTextures: _glGenTextures,
+      emscripten_glGenVertexArrays: _emscripten_glGenVertexArrays,
       /** @export */
-      glGenVertexArrays: _glGenVertexArrays,
+      emscripten_glGenVertexArraysOES: _emscripten_glGenVertexArraysOES,
       /** @export */
-      glGenVertexArraysOES: _glGenVertexArraysOES,
+      emscripten_glGenerateMipmap: _emscripten_glGenerateMipmap,
       /** @export */
-      glGenerateMipmap: _glGenerateMipmap,
+      emscripten_glGetBufferParameteriv: _emscripten_glGetBufferParameteriv,
       /** @export */
-      glGetBufferParameteriv: _glGetBufferParameteriv,
+      emscripten_glGetError: _emscripten_glGetError,
       /** @export */
-      glGetError: _glGetError,
+      emscripten_glGetFloatv: _emscripten_glGetFloatv,
       /** @export */
-      glGetFloatv: _glGetFloatv,
+      emscripten_glGetFramebufferAttachmentParameteriv: _emscripten_glGetFramebufferAttachmentParameteriv,
       /** @export */
-      glGetFramebufferAttachmentParameteriv: _glGetFramebufferAttachmentParameteriv,
+      emscripten_glGetIntegerv: _emscripten_glGetIntegerv,
       /** @export */
-      glGetIntegerv: _glGetIntegerv,
+      emscripten_glGetProgramInfoLog: _emscripten_glGetProgramInfoLog,
       /** @export */
-      glGetProgramInfoLog: _glGetProgramInfoLog,
+      emscripten_glGetProgramiv: _emscripten_glGetProgramiv,
       /** @export */
-      glGetProgramiv: _glGetProgramiv,
+      emscripten_glGetQueryObjecti64vEXT: _emscripten_glGetQueryObjecti64vEXT,
       /** @export */
-      glGetRenderbufferParameteriv: _glGetRenderbufferParameteriv,
+      emscripten_glGetQueryObjectui64vEXT: _emscripten_glGetQueryObjectui64vEXT,
       /** @export */
-      glGetShaderInfoLog: _glGetShaderInfoLog,
+      emscripten_glGetQueryObjectuiv: _emscripten_glGetQueryObjectuiv,
       /** @export */
-      glGetShaderPrecisionFormat: _glGetShaderPrecisionFormat,
+      emscripten_glGetQueryObjectuivEXT: _emscripten_glGetQueryObjectuivEXT,
       /** @export */
-      glGetShaderiv: _glGetShaderiv,
+      emscripten_glGetQueryiv: _emscripten_glGetQueryiv,
       /** @export */
-      glGetString: _glGetString,
+      emscripten_glGetQueryivEXT: _emscripten_glGetQueryivEXT,
       /** @export */
-      glGetStringi: _glGetStringi,
+      emscripten_glGetRenderbufferParameteriv: _emscripten_glGetRenderbufferParameteriv,
+      /** @export */
+      emscripten_glGetShaderInfoLog: _emscripten_glGetShaderInfoLog,
+      /** @export */
+      emscripten_glGetShaderPrecisionFormat: _emscripten_glGetShaderPrecisionFormat,
+      /** @export */
+      emscripten_glGetShaderiv: _emscripten_glGetShaderiv,
+      /** @export */
+      emscripten_glGetString: _emscripten_glGetString,
+      /** @export */
+      emscripten_glGetStringi: _emscripten_glGetStringi,
+      /** @export */
+      emscripten_glGetUniformLocation: _emscripten_glGetUniformLocation,
+      /** @export */
+      emscripten_glInvalidateFramebuffer: _emscripten_glInvalidateFramebuffer,
+      /** @export */
+      emscripten_glInvalidateSubFramebuffer: _emscripten_glInvalidateSubFramebuffer,
+      /** @export */
+      emscripten_glIsSync: _emscripten_glIsSync,
+      /** @export */
+      emscripten_glIsTexture: _emscripten_glIsTexture,
+      /** @export */
+      emscripten_glLineWidth: _emscripten_glLineWidth,
+      /** @export */
+      emscripten_glLinkProgram: _emscripten_glLinkProgram,
       /** @export */
-      glGetUniformLocation: _glGetUniformLocation,
+      emscripten_glMultiDrawArraysInstancedBaseInstanceWEBGL: _emscripten_glMultiDrawArraysInstancedBaseInstanceWEBGL,
       /** @export */
-      glInvalidateFramebuffer: _glInvalidateFramebuffer,
+      emscripten_glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL: _emscripten_glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
       /** @export */
-      glInvalidateSubFramebuffer: _glInvalidateSubFramebuffer,
+      emscripten_glPixelStorei: _emscripten_glPixelStorei,
       /** @export */
-      glIsSync: _glIsSync,
+      emscripten_glQueryCounterEXT: _emscripten_glQueryCounterEXT,
       /** @export */
-      glIsTexture: _glIsTexture,
+      emscripten_glReadBuffer: _emscripten_glReadBuffer,
       /** @export */
-      glLineWidth: _glLineWidth,
+      emscripten_glReadPixels: _emscripten_glReadPixels,
       /** @export */
-      glLinkProgram: _glLinkProgram,
+      emscripten_glRenderbufferStorage: _emscripten_glRenderbufferStorage,
       /** @export */
-      glMultiDrawArraysInstancedBaseInstanceWEBGL: _glMultiDrawArraysInstancedBaseInstanceWEBGL,
+      emscripten_glRenderbufferStorageMultisample: _emscripten_glRenderbufferStorageMultisample,
       /** @export */
-      glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL: _glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
+      emscripten_glSamplerParameterf: _emscripten_glSamplerParameterf,
       /** @export */
-      glPixelStorei: _glPixelStorei,
+      emscripten_glSamplerParameteri: _emscripten_glSamplerParameteri,
       /** @export */
-      glReadBuffer: _glReadBuffer,
+      emscripten_glSamplerParameteriv: _emscripten_glSamplerParameteriv,
       /** @export */
-      glReadPixels: _glReadPixels,
+      emscripten_glScissor: _emscripten_glScissor,
       /** @export */
-      glRenderbufferStorage: _glRenderbufferStorage,
+      emscripten_glShaderSource: _emscripten_glShaderSource,
       /** @export */
-      glRenderbufferStorageMultisample: _glRenderbufferStorageMultisample,
+      emscripten_glStencilFunc: _emscripten_glStencilFunc,
       /** @export */
-      glSamplerParameterf: _glSamplerParameterf,
+      emscripten_glStencilFuncSeparate: _emscripten_glStencilFuncSeparate,
       /** @export */
-      glSamplerParameteri: _glSamplerParameteri,
+      emscripten_glStencilMask: _emscripten_glStencilMask,
       /** @export */
-      glSamplerParameteriv: _glSamplerParameteriv,
+      emscripten_glStencilMaskSeparate: _emscripten_glStencilMaskSeparate,
       /** @export */
-      glScissor: _glScissor,
+      emscripten_glStencilOp: _emscripten_glStencilOp,
       /** @export */
-      glShaderSource: _glShaderSource,
+      emscripten_glStencilOpSeparate: _emscripten_glStencilOpSeparate,
       /** @export */
-      glStencilFunc: _glStencilFunc,
+      emscripten_glTexImage2D: _emscripten_glTexImage2D,
       /** @export */
-      glStencilFuncSeparate: _glStencilFuncSeparate,
+      emscripten_glTexParameterf: _emscripten_glTexParameterf,
       /** @export */
-      glStencilMask: _glStencilMask,
+      emscripten_glTexParameterfv: _emscripten_glTexParameterfv,
       /** @export */
-      glStencilMaskSeparate: _glStencilMaskSeparate,
+      emscripten_glTexParameteri: _emscripten_glTexParameteri,
       /** @export */
-      glStencilOp: _glStencilOp,
+      emscripten_glTexParameteriv: _emscripten_glTexParameteriv,
       /** @export */
-      glStencilOpSeparate: _glStencilOpSeparate,
+      emscripten_glTexStorage2D: _emscripten_glTexStorage2D,
       /** @export */
-      glTexImage2D: _glTexImage2D,
+      emscripten_glTexSubImage2D: _emscripten_glTexSubImage2D,
       /** @export */
-      glTexParameterf: _glTexParameterf,
+      emscripten_glUniform1f: _emscripten_glUniform1f,
       /** @export */
-      glTexParameterfv: _glTexParameterfv,
+      emscripten_glUniform1fv: _emscripten_glUniform1fv,
       /** @export */
-      glTexParameteri: _glTexParameteri,
+      emscripten_glUniform1i: _emscripten_glUniform1i,
       /** @export */
-      glTexParameteriv: _glTexParameteriv,
+      emscripten_glUniform1iv: _emscripten_glUniform1iv,
       /** @export */
-      glTexStorage2D: _glTexStorage2D,
+      emscripten_glUniform2f: _emscripten_glUniform2f,
       /** @export */
-      glTexSubImage2D: _glTexSubImage2D,
+      emscripten_glUniform2fv: _emscripten_glUniform2fv,
       /** @export */
-      glUniform1f: _glUniform1f,
+      emscripten_glUniform2i: _emscripten_glUniform2i,
       /** @export */
-      glUniform1fv: _glUniform1fv,
+      emscripten_glUniform2iv: _emscripten_glUniform2iv,
       /** @export */
-      glUniform1i: _glUniform1i,
+      emscripten_glUniform3f: _emscripten_glUniform3f,
       /** @export */
-      glUniform1iv: _glUniform1iv,
+      emscripten_glUniform3fv: _emscripten_glUniform3fv,
       /** @export */
-      glUniform2f: _glUniform2f,
+      emscripten_glUniform3i: _emscripten_glUniform3i,
       /** @export */
-      glUniform2fv: _glUniform2fv,
+      emscripten_glUniform3iv: _emscripten_glUniform3iv,
       /** @export */
-      glUniform2i: _glUniform2i,
+      emscripten_glUniform4f: _emscripten_glUniform4f,
       /** @export */
-      glUniform2iv: _glUniform2iv,
+      emscripten_glUniform4fv: _emscripten_glUniform4fv,
       /** @export */
-      glUniform3f: _glUniform3f,
+      emscripten_glUniform4i: _emscripten_glUniform4i,
       /** @export */
-      glUniform3fv: _glUniform3fv,
+      emscripten_glUniform4iv: _emscripten_glUniform4iv,
       /** @export */
-      glUniform3i: _glUniform3i,
+      emscripten_glUniformMatrix2fv: _emscripten_glUniformMatrix2fv,
       /** @export */
-      glUniform3iv: _glUniform3iv,
+      emscripten_glUniformMatrix3fv: _emscripten_glUniformMatrix3fv,
       /** @export */
-      glUniform4f: _glUniform4f,
+      emscripten_glUniformMatrix4fv: _emscripten_glUniformMatrix4fv,
       /** @export */
-      glUniform4fv: _glUniform4fv,
+      emscripten_glUseProgram: _emscripten_glUseProgram,
       /** @export */
-      glUniform4i: _glUniform4i,
+      emscripten_glVertexAttrib1f: _emscripten_glVertexAttrib1f,
       /** @export */
-      glUniform4iv: _glUniform4iv,
+      emscripten_glVertexAttrib2fv: _emscripten_glVertexAttrib2fv,
       /** @export */
-      glUniformMatrix2fv: _glUniformMatrix2fv,
+      emscripten_glVertexAttrib3fv: _emscripten_glVertexAttrib3fv,
       /** @export */
-      glUniformMatrix3fv: _glUniformMatrix3fv,
+      emscripten_glVertexAttrib4fv: _emscripten_glVertexAttrib4fv,
       /** @export */
-      glUniformMatrix4fv: _glUniformMatrix4fv,
+      emscripten_glVertexAttribDivisor: _emscripten_glVertexAttribDivisor,
+      /** @export */
+      emscripten_glVertexAttribIPointer: _emscripten_glVertexAttribIPointer,
+      /** @export */
+      emscripten_glVertexAttribPointer: _emscripten_glVertexAttribPointer,
+      /** @export */
+      emscripten_glViewport: _emscripten_glViewport,
+      /** @export */
+      emscripten_glWaitSync: _emscripten_glWaitSync,
+      /** @export */
+      emscripten_request_animation_frame: _emscripten_request_animation_frame,
+      /** @export */
+      emscripten_resize_heap: _emscripten_resize_heap,
+      /** @export */
+      emscripten_webgl_make_context_current: _emscripten_webgl_make_context_current,
+      /** @export */
+      environ_get: _environ_get,
+      /** @export */
+      environ_sizes_get: _environ_sizes_get,
+      /** @export */
+      exit: _exit,
       /** @export */
-      glUseProgram: _glUseProgram,
+      fd_close: _fd_close,
       /** @export */
-      glVertexAttrib1f: _glVertexAttrib1f,
+      fd_seek: _fd_seek,
       /** @export */
-      glVertexAttrib2fv: _glVertexAttrib2fv,
+      fd_write: _fd_write,
       /** @export */
-      glVertexAttrib3fv: _glVertexAttrib3fv,
+      glBindFramebuffer: _glBindFramebuffer,
       /** @export */
-      glVertexAttrib4fv: _glVertexAttrib4fv,
+      glClear: _glClear,
       /** @export */
-      glVertexAttribDivisor: _glVertexAttribDivisor,
+      glClearColor: _glClearColor,
       /** @export */
-      glVertexAttribIPointer: _glVertexAttribIPointer,
+      glClearStencil: _glClearStencil,
       /** @export */
-      glVertexAttribPointer: _glVertexAttribPointer,
+      glGetIntegerv: _glGetIntegerv,
       /** @export */
-      glViewport: _glViewport,
+      glGetString: _glGetString,
       /** @export */
-      glWaitSync: _glWaitSync,
+      glGetStringi: _glGetStringi,
       /** @export */
       invoke_ii,
       /** @export */
@@ -5489,6 +6125,8 @@ var WebRendererWasmFactory = (() => {
       /** @export */
       invoke_iiiiiii,
       /** @export */
+      invoke_iiiiiiii,
+      /** @export */
       invoke_v,
       /** @export */
       invoke_vi,
@@ -5499,8 +6137,6 @@ var WebRendererWasmFactory = (() => {
       /** @export */
       invoke_viiii,
       /** @export */
-      invoke_viiiii,
-      /** @export */
       invoke_viiiiii,
       /** @export */
       invoke_viiiiiiiii,
@@ -5601,60 +6237,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;