@stream-io/video-filters-web 0.0.1

package/src/tflite-simd.js

@@ -0,0 +1,874 @@
+export const createTFLiteSIMDModule = (__Module) => {
+  __Module = __Module || {};
+
+  var _scriptDir =
+    typeof document !== 'undefined' && document.currentScript
+      ? document.currentScript.src
+      : undefined;
+
+  var Module = typeof __Module != 'undefined' ? __Module : {};
+  var readyPromiseResolve, readyPromiseReject;
+  Module['ready'] = new Promise(function (resolve, reject) {
+    readyPromiseResolve = resolve;
+    readyPromiseReject = reject;
+  });
+  var moduleOverrides = Object.assign({}, Module);
+  var arguments_ = [];
+  var thisProgram = './this.program';
+  var quit_ = (status, toThrow) => {
+    throw toThrow;
+  };
+  var ENVIRONMENT_IS_WEB = true;
+  var ENVIRONMENT_IS_WORKER = false;
+  var scriptDirectory = '';
+
+  function locateFile(path) {
+    if (Module['locateFile']) {
+      return Module['locateFile'](path, scriptDirectory);
+    }
+    return scriptDirectory + path;
+  }
+
+  var read_, readAsync, readBinary, setWindowTitle;
+  if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+    if (ENVIRONMENT_IS_WORKER) {
+      // eslint-disable-next-line no-restricted-globals
+      scriptDirectory = self.location.href;
+    } else if (typeof document != 'undefined' && document.currentScript) {
+      scriptDirectory = document.currentScript.src;
+    }
+    if (_scriptDir) {
+      scriptDirectory = _scriptDir;
+    }
+    if (scriptDirectory.indexOf('blob:') !== 0) {
+      scriptDirectory = scriptDirectory.substr(
+        0,
+        scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1,
+      );
+    } else {
+      scriptDirectory = '';
+    }
+    {
+      read_ = (url) => {
+        var xhr = new XMLHttpRequest();
+        xhr.open('GET', url, false);
+        xhr.send(null);
+        return xhr.responseText;
+      };
+      if (ENVIRONMENT_IS_WORKER) {
+        readBinary = (url) => {
+          var xhr = new XMLHttpRequest();
+          xhr.open('GET', url, false);
+          xhr.responseType = 'arraybuffer';
+          xhr.send(null);
+          return new Uint8Array(xhr.response);
+        };
+      }
+      readAsync = (url, onload, onerror) => {
+        var xhr = new XMLHttpRequest();
+        xhr.open('GET', url, true);
+        xhr.responseType = 'arraybuffer';
+        xhr.onload = () => {
+          if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+            onload(xhr.response);
+            return;
+          }
+          onerror();
+        };
+        xhr.onerror = onerror;
+        xhr.send(null);
+      };
+    }
+    setWindowTitle = (title) => (document.title = title);
+  } else {
+  }
+  var out = Module['print'] || console.log.bind(console);
+  var err = Module['printErr'] || console.warn.bind(console);
+  Object.assign(Module, moduleOverrides);
+  moduleOverrides = null;
+  if (Module['arguments']) arguments_ = Module['arguments'];
+  if (Module['thisProgram']) thisProgram = Module['thisProgram'];
+  if (Module['quit']) quit_ = Module['quit'];
+  var POINTER_SIZE = 4;
+  var wasmBinary;
+  if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
+  var noExitRuntime = Module['noExitRuntime'] || true;
+  if (typeof WebAssembly != 'object') {
+    abort('no native wasm support detected');
+  }
+  var wasmMemory;
+  var ABORT = false;
+  var EXITSTATUS;
+
+  function assert(condition, text) {
+    if (!condition) {
+      abort(text);
+    }
+  }
+
+  var UTF8Decoder =
+    typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
+
+  function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+    var endIdx = idx + maxBytesToRead;
+    var endPtr = idx;
+    while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
+    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+    }
+    var str = '';
+    while (idx < endPtr) {
+      var u0 = heapOrArray[idx++];
+      if (!(u0 & 128)) {
+        str += String.fromCharCode(u0);
+        continue;
+      }
+      var u1 = heapOrArray[idx++] & 63;
+      if ((u0 & 224) == 192) {
+        str += String.fromCharCode(((u0 & 31) << 6) | u1);
+        continue;
+      }
+      var u2 = heapOrArray[idx++] & 63;
+      if ((u0 & 240) == 224) {
+        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+      } else {
+        u0 =
+          ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+      }
+      if (u0 < 65536) {
+        str += String.fromCharCode(u0);
+      } else {
+        var ch = u0 - 65536;
+        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+      }
+    }
+    return str;
+  }
+
+  function UTF8ToString(ptr, maxBytesToRead) {
+    return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
+  }
+
+  function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+    if (!(maxBytesToWrite > 0)) return 0;
+    var startIdx = outIdx;
+    var endIdx = outIdx + maxBytesToWrite - 1;
+    for (var i = 0; i < str.length; ++i) {
+      var u = str.charCodeAt(i);
+      if (u >= 55296 && u <= 57343) {
+        var u1 = str.charCodeAt(++i);
+        u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
+      }
+      if (u <= 127) {
+        if (outIdx >= endIdx) break;
+        heap[outIdx++] = u;
+      } else if (u <= 2047) {
+        if (outIdx + 1 >= endIdx) break;
+        heap[outIdx++] = 192 | (u >> 6);
+        heap[outIdx++] = 128 | (u & 63);
+      } else if (u <= 65535) {
+        if (outIdx + 2 >= endIdx) break;
+        heap[outIdx++] = 224 | (u >> 12);
+        heap[outIdx++] = 128 | ((u >> 6) & 63);
+        heap[outIdx++] = 128 | (u & 63);
+      } else {
+        if (outIdx + 3 >= endIdx) break;
+        heap[outIdx++] = 240 | (u >> 18);
+        heap[outIdx++] = 128 | ((u >> 12) & 63);
+        heap[outIdx++] = 128 | ((u >> 6) & 63);
+        heap[outIdx++] = 128 | (u & 63);
+      }
+    }
+    heap[outIdx] = 0;
+    return outIdx - startIdx;
+  }
+
+  var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+  function updateGlobalBufferAndViews(buf) {
+    buffer = buf;
+    Module['HEAP8'] = HEAP8 = new Int8Array(buf);
+    Module['HEAP16'] = HEAP16 = new Int16Array(buf);
+    Module['HEAP32'] = HEAP32 = new Int32Array(buf);
+    Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf);
+    Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf);
+    Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf);
+    Module['HEAPF32'] = HEAPF32 = new Float32Array(buf);
+    Module['HEAPF64'] = HEAPF64 = new Float64Array(buf);
+  }
+
+  var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216;
+  var wasmTable;
+  var __ATPRERUN__ = [];
+  var __ATINIT__ = [];
+  var __ATPOSTRUN__ = [];
+  var runtimeInitialized = false;
+
+  function keepRuntimeAlive() {
+    return noExitRuntime;
+  }
+
+  function preRun() {
+    if (Module['preRun']) {
+      if (typeof Module['preRun'] == 'function')
+        Module['preRun'] = [Module['preRun']];
+      while (Module['preRun'].length) {
+        addOnPreRun(Module['preRun'].shift());
+      }
+    }
+    callRuntimeCallbacks(__ATPRERUN__);
+  }
+
+  function initRuntime() {
+    runtimeInitialized = true;
+    callRuntimeCallbacks(__ATINIT__);
+  }
+
+  function postRun() {
+    if (Module['postRun']) {
+      if (typeof Module['postRun'] == 'function')
+        Module['postRun'] = [Module['postRun']];
+      while (Module['postRun'].length) {
+        addOnPostRun(Module['postRun'].shift());
+      }
+    }
+    callRuntimeCallbacks(__ATPOSTRUN__);
+  }
+
+  function addOnPreRun(cb) {
+    __ATPRERUN__.unshift(cb);
+  }
+
+  function addOnInit(cb) {
+    __ATINIT__.unshift(cb);
+  }
+
+  function addOnPostRun(cb) {
+    __ATPOSTRUN__.unshift(cb);
+  }
+
+  var runDependencies = 0;
+  var runDependencyWatcher = null;
+  var dependenciesFulfilled = null;
+
+  function addRunDependency(id) {
+    runDependencies++;
+    if (Module['monitorRunDependencies']) {
+      Module['monitorRunDependencies'](runDependencies);
+    }
+  }
+
+  function removeRunDependency(id) {
+    runDependencies--;
+    if (Module['monitorRunDependencies']) {
+      Module['monitorRunDependencies'](runDependencies);
+    }
+    if (runDependencies == 0) {
+      if (runDependencyWatcher !== null) {
+        clearInterval(runDependencyWatcher);
+        runDependencyWatcher = null;
+      }
+      if (dependenciesFulfilled) {
+        var callback = dependenciesFulfilled;
+        dependenciesFulfilled = null;
+        callback();
+      }
+    }
+  }
+
+  function abort(what) {
+    {
+      if (Module['onAbort']) {
+        Module['onAbort'](what);
+      }
+    }
+    what = 'Aborted(' + what + ')';
+    err(what);
+    ABORT = true;
+    EXITSTATUS = 1;
+    what += '. Build with -sASSERTIONS for more info.';
+    var e = new WebAssembly.RuntimeError(what);
+    readyPromiseReject(e);
+    throw e;
+  }
+
+  var dataURIPrefix = 'data:application/octet-stream;base64,';
+
+  function isDataURI(filename) {
+    return filename.startsWith(dataURIPrefix);
+  }
+
+  var wasmBinaryFile;
+  wasmBinaryFile = 'tflite-simd.wasm';
+  if (!isDataURI(wasmBinaryFile)) {
+    wasmBinaryFile = locateFile(wasmBinaryFile);
+  }
+
+  function getBinary(file) {
+    try {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary);
+      }
+      if (readBinary) {
+        return readBinary(file);
+      }
+      throw 'both async and sync fetching of the wasm failed';
+      // eslint-disable-next-line @typescript-eslint/no-shadow
+    } catch (err) {
+      abort(err);
+    }
+  }
+
+  function getBinaryPromise() {
+    if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+      if (typeof fetch == 'function') {
+        return fetch(wasmBinaryFile, { credentials: 'same-origin' })
+          .then(function (response) {
+            if (!response['ok']) {
+              throw (
+                "failed to load wasm binary file at '" + wasmBinaryFile + "'"
+              );
+            }
+            return response['arrayBuffer']();
+          })
+          .catch(function () {
+            return getBinary(wasmBinaryFile);
+          });
+      }
+    }
+    return Promise.resolve().then(function () {
+      return getBinary(wasmBinaryFile);
+    });
+  }
+
+  function createWasm() {
+    var info = {
+      env: asmLibraryArg,
+      wasi_snapshot_preview1: asmLibraryArg,
+    };
+
+    function receiveInstance(instance, module) {
+      var exports = instance.exports;
+      Module['asm'] = exports;
+      wasmMemory = Module['asm']['memory'];
+      updateGlobalBufferAndViews(wasmMemory.buffer);
+      wasmTable = Module['asm']['__indirect_function_table'];
+      addOnInit(Module['asm']['__wasm_call_ctors']);
+      removeRunDependency('wasm-instantiate');
+    }
+
+    addRunDependency('wasm-instantiate');
+
+    function receiveInstantiationResult(result) {
+      receiveInstance(result['instance']);
+    }
+
+    function instantiateArrayBuffer(receiver) {
+      return getBinaryPromise()
+        .then(function (binary) {
+          return WebAssembly.instantiate(binary, info);
+        })
+        .then(function (instance) {
+          return instance;
+        })
+        .then(receiver, function (reason) {
+          err('failed to asynchronously prepare wasm: ' + reason);
+          abort(reason);
+        });
+    }
+
+    function instantiateAsync() {
+      if (
+        !wasmBinary &&
+        typeof WebAssembly.instantiateStreaming == 'function' &&
+        !isDataURI(wasmBinaryFile) &&
+        typeof fetch == 'function'
+      ) {
+        return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(
+          function (response) {
+            var result = WebAssembly.instantiateStreaming(response, info);
+            return result.then(receiveInstantiationResult, function (reason) {
+              err('wasm streaming compile failed: ' + reason);
+              err('falling back to ArrayBuffer instantiation');
+              return instantiateArrayBuffer(receiveInstantiationResult);
+            });
+          },
+        );
+      } else {
+        return instantiateArrayBuffer(receiveInstantiationResult);
+      }
+    }
+
+    if (Module['instantiateWasm']) {
+      try {
+        var exports = Module['instantiateWasm'](info, receiveInstance);
+        return exports;
+      } catch (e) {
+        err('Module.instantiateWasm callback failed with error: ' + e);
+        readyPromiseReject(e);
+      }
+    }
+    instantiateAsync().catch(readyPromiseReject);
+    return {};
+  }
+
+  var tempDouble;
+  var tempI64;
+
+  function ExitStatus(status) {
+    this.name = 'ExitStatus';
+    this.message = 'Program terminated with exit(' + status + ')';
+    this.status = status;
+  }
+
+  function callRuntimeCallbacks(callbacks) {
+    while (callbacks.length > 0) {
+      callbacks.shift()(Module);
+    }
+  }
+
+  function demangle(func) {
+    return func;
+  }
+
+  function demangleAll(text) {
+    var regex = /\b_Z[\w\d_]+/g;
+    return text.replace(regex, function (x) {
+      var y = demangle(x);
+      return x === y ? x : y + ' [' + x + ']';
+    });
+  }
+
+  function jsStackTrace() {
+    var error = new Error();
+    if (!error.stack) {
+      try {
+        throw new Error();
+      } catch (e) {
+        error = e;
+      }
+      if (!error.stack) {
+        return '(no stack trace available)';
+      }
+    }
+    return error.stack.toString();
+  }
+
+  function __dlinit(main_dso_handle) {}
+
+  var dlopenMissingError =
+    'To use dlopen, you need enable dynamic linking, see https://github.com/emscripten-core/emscripten/wiki/Linking';
+
+  function __dlopen_js(filename, flag) {
+    abort(dlopenMissingError);
+  }
+
+  function __dlsym_js(handle, symbol) {
+    abort(dlopenMissingError);
+  }
+
+  var nowIsMonotonic = true;
+
+  function __emscripten_get_now_is_monotonic() {
+    return nowIsMonotonic;
+  }
+
+  var SYSCALLS = {
+    varargs: undefined,
+    get: function () {
+      SYSCALLS.varargs += 4;
+      var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
+      return ret;
+    },
+    getStr: function (ptr) {
+      var ret = UTF8ToString(ptr);
+      return ret;
+    },
+  };
+
+  function __mmap_js(len, prot, flags, fd, off, allocated) {
+    return -52;
+  }
+
+  function __munmap_js(addr, len, prot, flags, fd, offset) {}
+
+  function _abort() {
+    abort('');
+  }
+
+  function _emscripten_date_now() {
+    return Date.now();
+  }
+
+  function getHeapMax() {
+    return 2147483648;
+  }
+
+  function _emscripten_get_heap_max() {
+    return getHeapMax();
+  }
+
+  var _emscripten_get_now;
+  _emscripten_get_now = () => performance.now();
+
+  function _emscripten_memcpy_big(dest, src, num) {
+    HEAPU8.copyWithin(dest, src, src + num);
+  }
+
+  function emscripten_realloc_buffer(size) {
+    try {
+      wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
+      updateGlobalBufferAndViews(wasmMemory.buffer);
+      return 1;
+    } catch (e) {}
+  }
+
+  function _emscripten_resize_heap(requestedSize) {
+    var oldSize = HEAPU8.length;
+    requestedSize = requestedSize >>> 0;
+    var maxHeapSize = getHeapMax();
+    if (requestedSize > maxHeapSize) {
+      return false;
+    }
+    let alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
+    for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+      var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+      overGrownHeapSize = Math.min(
+        overGrownHeapSize,
+        requestedSize + 100663296,
+      );
+      var newSize = Math.min(
+        maxHeapSize,
+        alignUp(Math.max(requestedSize, overGrownHeapSize), 65536),
+      );
+      var replacement = emscripten_realloc_buffer(newSize);
+      if (replacement) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  var ENV = {};
+
+  function getExecutableName() {
+    return thisProgram || './this.program';
+  }
+
+  function getEnvStrings() {
+    if (!getEnvStrings.strings) {
+      var lang =
+        (
+          (typeof navigator == 'object' &&
+            navigator.languages &&
+            navigator.languages[0]) ||
+          'C'
+        ).replace('-', '_') + '.UTF-8';
+      var env = {
+        USER: 'web_user',
+        LOGNAME: 'web_user',
+        PATH: '/',
+        PWD: '/',
+        HOME: '/home/web_user',
+        LANG: lang,
+        _: getExecutableName(),
+      };
+      for (var x in ENV) {
+        if (ENV[x] === undefined) delete env[x];
+        else env[x] = ENV[x];
+      }
+      var strings = [];
+      for (var x in env) {
+        strings.push(x + '=' + env[x]);
+      }
+      getEnvStrings.strings = strings;
+    }
+    return getEnvStrings.strings;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  function writeAsciiToMemory(str, buffer, dontAddNull) {
+    for (var i = 0; i < str.length; ++i) {
+      HEAP8[buffer++ >> 0] = str.charCodeAt(i);
+    }
+    if (!dontAddNull) HEAP8[buffer >> 0] = 0;
+  }
+
+  function _environ_get(__environ, environ_buf) {
+    var bufSize = 0;
+    getEnvStrings().forEach(function (string, i) {
+      var ptr = environ_buf + bufSize;
+      HEAPU32[(__environ + i * 4) >> 2] = ptr;
+      writeAsciiToMemory(string, ptr);
+      bufSize += string.length + 1;
+    });
+    return 0;
+  }
+
+  function _environ_sizes_get(penviron_count, penviron_buf_size) {
+    var strings = getEnvStrings();
+    HEAPU32[penviron_count >> 2] = strings.length;
+    var bufSize = 0;
+    strings.forEach(function (string) {
+      bufSize += string.length + 1;
+    });
+    HEAPU32[penviron_buf_size >> 2] = bufSize;
+    return 0;
+  }
+
+  function _proc_exit(code) {
+    EXITSTATUS = code;
+    if (!keepRuntimeAlive()) {
+      if (Module['onExit']) Module['onExit'](code);
+      ABORT = true;
+    }
+    quit_(code, new ExitStatus(code));
+  }
+
+  function exitJS(status, implicit) {
+    EXITSTATUS = status;
+    _proc_exit(status);
+  }
+
+  var _exit = exitJS;
+
+  function _fd_close(fd) {
+    return 52;
+  }
+
+  function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+    return 70;
+  }
+
+  var printCharBuffers = [null, [], []];
+
+  function printChar(stream, curr) {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    var buffer = printCharBuffers[stream];
+    if (curr === 0 || curr === 10) {
+      (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+      buffer.length = 0;
+    } else {
+      buffer.push(curr);
+    }
+  }
+
+  function _fd_write(fd, iov, iovcnt, pnum) {
+    var num = 0;
+    for (var i = 0; i < iovcnt; i++) {
+      var ptr = HEAPU32[iov >> 2];
+      var len = HEAPU32[(iov + 4) >> 2];
+      iov += 8;
+      for (var j = 0; j < len; j++) {
+        printChar(fd, HEAPU8[ptr + j]);
+      }
+      num += len;
+    }
+    HEAPU32[pnum >> 2] = num;
+    return 0;
+  }
+
+  function getRandomDevice() {
+    if (
+      typeof crypto == 'object' &&
+      typeof crypto['getRandomValues'] == 'function'
+    ) {
+      var randomBuffer = new Uint8Array(1);
+      return () => {
+        crypto.getRandomValues(randomBuffer);
+        return randomBuffer[0];
+      };
+    } else return () => abort('randomDevice');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  function _getentropy(buffer, size) {
+    if (!_getentropy.randomDevice) {
+      _getentropy.randomDevice = getRandomDevice();
+    }
+    for (var i = 0; i < size; i++) {
+      HEAP8[(buffer + i) >> 0] = _getentropy.randomDevice();
+    }
+    return 0;
+  }
+
+  var asmLibraryArg = {
+    _dlinit: __dlinit,
+    _dlopen_js: __dlopen_js,
+    _dlsym_js: __dlsym_js,
+    _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
+    _mmap_js: __mmap_js,
+    _munmap_js: __munmap_js,
+    abort: _abort,
+    emscripten_date_now: _emscripten_date_now,
+    emscripten_get_heap_max: _emscripten_get_heap_max,
+    emscripten_get_now: _emscripten_get_now,
+    emscripten_memcpy_big: _emscripten_memcpy_big,
+    emscripten_resize_heap: _emscripten_resize_heap,
+    environ_get: _environ_get,
+    environ_sizes_get: _environ_sizes_get,
+    exit: _exit,
+    fd_close: _fd_close,
+    fd_seek: _fd_seek,
+    fd_write: _fd_write,
+    getentropy: _getentropy,
+  };
+  var asm = createWasm();
+  var ___wasm_call_ctors = (Module['___wasm_call_ctors'] = function () {
+    return (___wasm_call_ctors = Module['___wasm_call_ctors'] =
+      Module['asm']['__wasm_call_ctors']).apply(null, arguments);
+  });
+  var _getModelBufferMemoryOffset = (Module['_getModelBufferMemoryOffset'] =
+    function () {
+      return (_getModelBufferMemoryOffset = Module[
+        '_getModelBufferMemoryOffset'
+      ] =
+        Module['asm']['getModelBufferMemoryOffset']).apply(null, arguments);
+    });
+  var _getInputMemoryOffset = (Module['_getInputMemoryOffset'] = function () {
+    return (_getInputMemoryOffset = Module['_getInputMemoryOffset'] =
+      Module['asm']['getInputMemoryOffset']).apply(null, arguments);
+  });
+  var _getInputHeight = (Module['_getInputHeight'] = function () {
+    return (_getInputHeight = Module['_getInputHeight'] =
+      Module['asm']['getInputHeight']).apply(null, arguments);
+  });
+  var _getInputWidth = (Module['_getInputWidth'] = function () {
+    return (_getInputWidth = Module['_getInputWidth'] =
+      Module['asm']['getInputWidth']).apply(null, arguments);
+  });
+  var _getInputChannelCount = (Module['_getInputChannelCount'] = function () {
+    return (_getInputChannelCount = Module['_getInputChannelCount'] =
+      Module['asm']['getInputChannelCount']).apply(null, arguments);
+  });
+  var _getOutputMemoryOffset = (Module['_getOutputMemoryOffset'] = function () {
+    return (_getOutputMemoryOffset = Module['_getOutputMemoryOffset'] =
+      Module['asm']['getOutputMemoryOffset']).apply(null, arguments);
+  });
+  var _getOutputHeight = (Module['_getOutputHeight'] = function () {
+    return (_getOutputHeight = Module['_getOutputHeight'] =
+      Module['asm']['getOutputHeight']).apply(null, arguments);
+  });
+  var _getOutputWidth = (Module['_getOutputWidth'] = function () {
+    return (_getOutputWidth = Module['_getOutputWidth'] =
+      Module['asm']['getOutputWidth']).apply(null, arguments);
+  });
+  var _getOutputChannelCount = (Module['_getOutputChannelCount'] = function () {
+    return (_getOutputChannelCount = Module['_getOutputChannelCount'] =
+      Module['asm']['getOutputChannelCount']).apply(null, arguments);
+  });
+  var _loadModel = (Module['_loadModel'] = function () {
+    return (_loadModel = Module['_loadModel'] =
+      Module['asm']['loadModel']).apply(null, arguments);
+  });
+  var _runInference = (Module['_runInference'] = function () {
+    return (_runInference = Module['_runInference'] =
+      Module['asm']['runInference']).apply(null, arguments);
+  });
+  var _malloc = (Module['_malloc'] = function () {
+    return (_malloc = Module['_malloc'] = Module['asm']['malloc']).apply(
+      null,
+      arguments,
+    );
+  });
+  var ___errno_location = (Module['___errno_location'] = function () {
+    return (___errno_location = Module['___errno_location'] =
+      Module['asm']['__errno_location']).apply(null, arguments);
+  });
+  var ___dl_seterr = (Module['___dl_seterr'] = function () {
+    return (___dl_seterr = Module['___dl_seterr'] =
+      Module['asm']['__dl_seterr']).apply(null, arguments);
+  });
+  var stackSave = (Module['stackSave'] = function () {
+    return (stackSave = Module['stackSave'] = Module['asm']['stackSave']).apply(
+      null,
+      arguments,
+    );
+  });
+  var stackRestore = (Module['stackRestore'] = function () {
+    return (stackRestore = Module['stackRestore'] =
+      Module['asm']['stackRestore']).apply(null, arguments);
+  });
+  var stackAlloc = (Module['stackAlloc'] = function () {
+    return (stackAlloc = Module['stackAlloc'] =
+      Module['asm']['stackAlloc']).apply(null, arguments);
+  });
+  var dynCall_jjj = (Module['dynCall_jjj'] = function () {
+    return (dynCall_jjj = Module['dynCall_jjj'] =
+      Module['asm']['dynCall_jjj']).apply(null, arguments);
+  });
+  var dynCall_jiii = (Module['dynCall_jiii'] = function () {
+    return (dynCall_jiii = Module['dynCall_jiii'] =
+      Module['asm']['dynCall_jiii']).apply(null, arguments);
+  });
+  var dynCall_iiiijj = (Module['dynCall_iiiijj'] = function () {
+    return (dynCall_iiiijj = Module['dynCall_iiiijj'] =
+      Module['asm']['dynCall_iiiijj']).apply(null, arguments);
+  });
+  var dynCall_viijj = (Module['dynCall_viijj'] = function () {
+    return (dynCall_viijj = Module['dynCall_viijj'] =
+      Module['asm']['dynCall_viijj']).apply(null, arguments);
+  });
+  var dynCall_viiijjj = (Module['dynCall_viiijjj'] = function () {
+    return (dynCall_viiijjj = Module['dynCall_viiijjj'] =
+      Module['asm']['dynCall_viiijjj']).apply(null, arguments);
+  });
+  var dynCall_iijjiiii = (Module['dynCall_iijjiiii'] = function () {
+    return (dynCall_iijjiiii = Module['dynCall_iijjiiii'] =
+      Module['asm']['dynCall_iijjiiii']).apply(null, arguments);
+  });
+  var dynCall_jiji = (Module['dynCall_jiji'] = function () {
+    return (dynCall_jiji = Module['dynCall_jiji'] =
+      Module['asm']['dynCall_jiji']).apply(null, arguments);
+  });
+  var calledRun;
+  dependenciesFulfilled = function runCaller() {
+    if (!calledRun) run();
+    if (!calledRun) dependenciesFulfilled = runCaller;
+  };
+
+  function run(args) {
+    args = args || arguments_;
+    if (runDependencies > 0) {
+      return;
+    }
+    preRun();
+    if (runDependencies > 0) {
+      return;
+    }
+
+    function doRun() {
+      if (calledRun) return;
+      calledRun = true;
+      Module['calledRun'] = true;
+      if (ABORT) return;
+      initRuntime();
+      readyPromiseResolve(Module);
+      if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
+      postRun();
+    }
+
+    if (Module['setStatus']) {
+      Module['setStatus']('Running...');
+      setTimeout(function () {
+        setTimeout(function () {
+          Module['setStatus']('');
+        }, 1);
+        doRun();
+      }, 1);
+    } else {
+      doRun();
+    }
+  }
+
+  if (Module['preInit']) {
+    if (typeof Module['preInit'] == 'function')
+      Module['preInit'] = [Module['preInit']];
+    while (Module['preInit'].length > 0) {
+      Module['preInit'].pop()();
+    }
+  }
+  run();
+
+  return __Module.ready;
+};