@openziti/libcrypto-js/dist/cjs/index.js

The OpenSSL libcrypto library compiled to pure JavaScript

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var libCrypto$1 = (() => {
  var _scriptName = (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.js', document.baseURI).href));
  return function (moduleArg = {}) {
    var moduleRtn;
    var Module = moduleArg;
    var readyPromiseResolve, readyPromiseReject;
    var readyPromise = new Promise((resolve, reject) => {
      readyPromiseResolve = resolve;
      readyPromiseReject = reject;
    });
    var arguments_ = {};
    arguments_["foo"] = 1;
    var moduleOverrides = Object.assign({}, Module);
    var arguments_ = [];
    var thisProgram = "./this.program";

    var quit_ = (status, toThrow) => {
      throw toThrow;
    };

    var scriptDirectory = "";

    function locateFile(path) {
      if (Module["locateFile"]) {
        return Module["locateFile"](path, scriptDirectory);
      }

      return scriptDirectory + path;
    }

    var readAsync;

    {
      if (typeof document != "undefined" && document.currentScript) {
        scriptDirectory = document.currentScript.src;
      }

      if (_scriptName) {
        scriptDirectory = _scriptName;
      }

      if (scriptDirectory.startsWith("blob:")) {
        scriptDirectory = "";
      } else {
        scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
      }

      {
        readAsync = url => fetch(url, {
          credentials: "same-origin"
        }).then(response => {
          if (response.ok) {
            return response.arrayBuffer();
          }

          return Promise.reject(new Error(response.status + " : " + response.url));
        });
      }
    }

    var out = Module["print"] || console.log.bind(console);
    var err = Module["printErr"] || console.error.bind(console);
    Object.assign(Module, moduleOverrides);
    moduleOverrides = null;
    if (Module["arguments"]) arguments_ = Module["arguments"];
    if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
    var wasmBinary = Module["wasmBinary"];
    var wasmMemory;
    var ABORT = false;
    var EXITSTATUS;

    function assert(condition, text) {
      if (!condition) {
        abort(text);
      }
    }

    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPF64;

    function updateMemoryViews() {
      var b = wasmMemory.buffer;
      Module["HEAP8"] = HEAP8 = new Int8Array(b);
      Module["HEAP16"] = HEAP16 = new Int16Array(b);
      Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
      Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
      Module["HEAP32"] = HEAP32 = new Int32Array(b);
      Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
      Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
      Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
      Module["HEAP64"] = HEAP64 = new BigInt64Array(b);
      Module["HEAPU64"] = new BigUint64Array(b);
    }

    var __ATPRERUN__ = [];
    var __ATINIT__ = [];
    var __ATMAIN__ = [];
    var __ATPOSTRUN__ = [];

    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() {
      callRuntimeCallbacks(__ATINIT__);
    }

    function preMain() {
      callRuntimeCallbacks(__ATMAIN__);
    }

    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 addOnPostRun(cb) {
      __ATPOSTRUN__.unshift(cb);
    }

    var runDependencies = 0;
    var dependenciesFulfilled = null;

    function addRunDependency(id) {
      runDependencies++;
      Module["monitorRunDependencies"]?.(runDependencies);
    }

    function removeRunDependency(id) {
      runDependencies--;
      Module["monitorRunDependencies"]?.(runDependencies);

      if (runDependencies == 0) {

        if (dependenciesFulfilled) {
          var callback = dependenciesFulfilled;
          dependenciesFulfilled = null;
          callback();
        }
      }
    }

    function abort(what) {
      Module["onAbort"]?.(what);
      what = "Aborted(" + what + ")";
      err(what);
      ABORT = true;
      what += ". Build with -sASSERTIONS for more info.";
      var e = new WebAssembly.RuntimeError(what);
      readyPromiseReject(e);
      throw e;
    }

    var dataURIPrefix = "data:application/octet-stream;base64,";

    var isDataURI = filename => filename.startsWith(dataURIPrefix);

    function findWasmBinary() {
      if (Module["locateFile"]) {
        var f = "libcrypto.JSPI.5497e3a.wasm";

        if (!isDataURI(f)) {
          return locateFile(f);
        }

        return f;
      }

      return new URL("libcrypto.JSPI.5497e3a.wasm", (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.js', document.baseURI).href))).href;
    }

    var wasmBinaryFile;

    function getBinarySync(file) {
      if (file == wasmBinaryFile && wasmBinary) {
        return new Uint8Array(wasmBinary);
      }

      throw "both async and sync fetching of the wasm failed";
    }

    function getBinaryPromise(binaryFile) {
      if (!wasmBinary) {
        return readAsync(binaryFile).then(response => new Uint8Array(response), () => getBinarySync(binaryFile));
      }

      return Promise.resolve().then(() => getBinarySync(binaryFile));
    }

    function instantiateArrayBuffer(binaryFile, imports, receiver) {
      return getBinaryPromise(binaryFile).then(binary => WebAssembly.instantiate(binary, imports)).then(receiver, reason => {
        err(`failed to asynchronously prepare wasm: ${reason}`);
        abort(reason);
      });
    }

    function instantiateAsync(binary, binaryFile, imports, callback) {
      if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
        return fetch(binaryFile, {
          credentials: "same-origin"
        }).then(response => {
          var result = WebAssembly.instantiateStreaming(response, imports);
          return result.then(callback, function (reason) {
            err(`wasm streaming compile failed: ${reason}`);
            err("falling back to ArrayBuffer instantiation");
            return instantiateArrayBuffer(binaryFile, imports, callback);
          });
        });
      }

      return instantiateArrayBuffer(binaryFile, imports, callback);
    }

    function getWasmImports() {
      Asyncify.instrumentWasmImports(wasmImports);
      return {
        env: wasmImports,
        wasi_snapshot_preview1: wasmImports
      };
    }

    function createWasm() {
      var info = getWasmImports();

      function receiveInstance(instance, module) {
        wasmExports = instance.exports;
        wasmExports = Asyncify.instrumentWasmExports(wasmExports);
        wasmMemory = wasmExports["memory"];
        updateMemoryViews();
        wasmTable = wasmExports["__indirect_function_table"];
        removeRunDependency();
        return wasmExports;
      }

      addRunDependency();

      function receiveInstantiationResult(result) {
        receiveInstance(result["instance"]);
      }

      if (Module["instantiateWasm"]) {
        try {
          return Module["instantiateWasm"](info, receiveInstance);
        } catch (e) {
          err(`Module.instantiateWasm callback failed with error: ${e}`);
          readyPromiseReject(e);
        }
      }

      if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();
      instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
      return {};
    }

    function ExitStatus(status) {
      this.name = "ExitStatus";
      this.message = `Program terminated with exit(${status})`;
      this.status = status;
    }

    var callRuntimeCallbacks = callbacks => {
      while (callbacks.length > 0) {
        callbacks.shift()(Module);
      }
    };

    function getValue(ptr, type = "i8") {
      if (type.endsWith("*")) type = "*";

      switch (type) {
        case "i1":
          return HEAP8[ptr];

        case "i8":
          return HEAP8[ptr];

        case "i16":
          return HEAP16[ptr >> 1];

        case "i32":
          return HEAP32[ptr >> 2];

        case "i64":
          return HEAP64[ptr >> 3];

        case "float":
          return HEAPF32[ptr >> 2];

        case "double":
          return HEAPF64[ptr >> 3];

        case "*":
          return HEAPU32[ptr >> 2];

        default:
          abort(`invalid type for getValue: ${type}`);
      }
    }

    var noExitRuntime = Module["noExitRuntime"] || true;

    function setValue(ptr, value, type = "i8") {
      if (type.endsWith("*")) type = "*";

      switch (type) {
        case "i1":
          HEAP8[ptr] = value;
          break;

        case "i8":
          HEAP8[ptr] = value;
          break;

        case "i16":
          HEAP16[ptr >> 1] = value;
          break;

        case "i32":
          HEAP32[ptr >> 2] = value;
          break;

        case "i64":
          HEAP64[ptr >> 3] = BigInt(value);
          break;

        case "float":
          HEAPF32[ptr >> 2] = value;
          break;

        case "double":
          HEAPF64[ptr >> 3] = value;
          break;

        case "*":
          HEAPU32[ptr >> 2] = value;
          break;

        default:
          abort(`invalid type for setValue: ${type}`);
      }
    }

    var stackRestore = val => __emscripten_stack_restore(val);

    var stackSave = () => _emscripten_stack_get_current();

    var inetNtop4 = addr => (addr & 255) + "." + (addr >> 8 & 255) + "." + (addr >> 16 & 255) + "." + (addr >> 24 & 255);

    var inetNtop6 = ints => {
      var str = "";
      var word = 0;
      var longest = 0;
      var lastzero = 0;
      var zstart = 0;
      var len = 0;
      var i = 0;
      var parts = [ints[0] & 65535, ints[0] >> 16, ints[1] & 65535, ints[1] >> 16, ints[2] & 65535, ints[2] >> 16, ints[3] & 65535, ints[3] >> 16];
      var hasipv4 = true;
      var v4part = "";

      for (i = 0; i < 5; i++) {
        if (parts[i] !== 0) {
          hasipv4 = false;
          break;
        }
      }

      if (hasipv4) {
        v4part = inetNtop4(parts[6] | parts[7] << 16);

        if (parts[5] === -1) {
          str = "::ffff:";
          str += v4part;
          return str;
        }

        if (parts[5] === 0) {
          str = "::";
          if (v4part === "0.0.0.0") v4part = "";
          if (v4part === "0.0.0.1") v4part = "1";
          str += v4part;
          return str;
        }
      }

      for (word = 0; word < 8; word++) {
        if (parts[word] === 0) {
          if (word - lastzero > 1) {
            len = 0;
          }

          lastzero = word;
          len++;
        }

        if (len > longest) {
          longest = len;
          zstart = word - longest + 1;
        }
      }

      for (word = 0; word < 8; word++) {
        if (longest > 1) {
          if (parts[word] === 0 && word >= zstart && word < zstart + longest) {
            if (word === zstart) {
              str += ":";
              if (zstart === 0) str += ":";
            }

            continue;
          }
        }

        str += Number(_ntohs(parts[word] & 65535)).toString(16);
        str += word < 7 ? ":" : "";
      }

      return str;
    };

    var readSockaddr = (sa, salen) => {
      var family = HEAP16[sa >> 1];

      var port = _ntohs(HEAPU16[sa + 2 >> 1]);

      var addr;

      switch (family) {
        case 2:
          if (salen !== 16) {
            return {
              errno: 28
            };
          }

          addr = HEAP32[sa + 4 >> 2];
          addr = inetNtop4(addr);
          break;

        case 10:
          if (salen !== 28) {
            return {
              errno: 28
            };
          }

          addr = [HEAP32[sa + 8 >> 2], HEAP32[sa + 12 >> 2], HEAP32[sa + 16 >> 2], HEAP32[sa + 20 >> 2]];
          addr = inetNtop6(addr);
          break;

        default:
          return {
            errno: 5
          };
      }

      return {
        family,
        addr,
        port
      };
    };

    var inetPton4 = str => {
      var b = str.split(".");

      for (var i = 0; i < 4; i++) {
        var tmp = Number(b[i]);
        if (isNaN(tmp)) return null;
        b[i] = tmp;
      }

      return (b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24) >>> 0;
    };

    var jstoi_q = str => parseInt(str);

    var inetPton6 = str => {
      var words;
      var w, offset, z;
      var valid6regx = /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i;
      var parts = [];

      if (!valid6regx.test(str)) {
        return null;
      }

      if (str === "::") {
        return [0, 0, 0, 0, 0, 0, 0, 0];
      }

      if (str.startsWith("::")) {
        str = str.replace("::", "Z:");
      } else {
        str = str.replace("::", ":Z:");
      }

      if (str.indexOf(".") > 0) {
        str = str.replace(new RegExp("[.]", "g"), ":");
        words = str.split(":");
        words[words.length - 4] = jstoi_q(words[words.length - 4]) + jstoi_q(words[words.length - 3]) * 256;
        words[words.length - 3] = jstoi_q(words[words.length - 2]) + jstoi_q(words[words.length - 1]) * 256;
        words = words.slice(0, words.length - 2);
      } else {
        words = str.split(":");
      }

      offset = 0;
      z = 0;

      for (w = 0; w < words.length; w++) {
        if (typeof words[w] == "string") {
          if (words[w] === "Z") {
            for (z = 0; z < 8 - words.length + 1; z++) {
              parts[w + z] = 0;
            }

            offset = z - 1;
          } else {
            parts[w + offset] = _htons(parseInt(words[w], 16));
          }
        } else {
          parts[w + offset] = words[w];
        }
      }

      return [parts[1] << 16 | parts[0], parts[3] << 16 | parts[2], parts[5] << 16 | parts[4], parts[7] << 16 | parts[6]];
    };

    var DNS = {
      address_map: {
        id: 1,
        addrs: {},
        names: {}
      },

      lookup_name(name) {
        var res = inetPton4(name);

        if (res !== null) {
          return name;
        }

        res = inetPton6(name);

        if (res !== null) {
          return name;
        }

        var addr;

        if (DNS.address_map.addrs[name]) {
          addr = DNS.address_map.addrs[name];
        } else {
          var id = DNS.address_map.id++;
          assert(id < 65535, "exceeded max address mappings of 65535");
          addr = "172.29." + (id & 255) + "." + (id & 65280);
          DNS.address_map.names[addr] = name;
          DNS.address_map.addrs[name] = addr;
        }

        return addr;
      },

      lookup_addr(addr) {
        if (DNS.address_map.names[addr]) {
          return DNS.address_map.names[addr];
        }

        return null;
      }

    };

    function ___syscall_connect() {
      return 0;
    }

    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
      if (!(maxBytesToWrite > 0)) return 0;
      var startIdx = outIdx;
      var endIdx = outIdx + maxBytesToWrite - 1;

      for (var i = 0; i < str.length; ++i) {
        var u = str.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 stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);

    var ___syscall_getdents64 = (fd, dirp, count) => {};

    function ___syscall_getsockopt(fd, level, optname, optval, optlen, d1) {
      return -50;
    }

    var ___syscall_socket = (domain, type, protocol) => {};

    var _emscripten_get_now;

    _emscripten_get_now = () => performance.now();

    var checkWasiClock = clock_id => clock_id == 0 || clock_id == 1 || clock_id == 2 || clock_id == 3;

    function _clock_time_get(clk_id, ignored_precision, ptime) {

      if (!checkWasiClock(clk_id)) {
        return 28;
      }

      var now;

      if (clk_id === 0) {
        now = Date.now();
      } else {
        now = _emscripten_get_now();
      }

      var nsec = Math.round(now * 1e3 * 1e3);
      HEAP32[ptime >> 2] = nsec >>> 0;
      HEAP32[ptime + 4 >> 2] = nsec / Math.pow(2, 32) >>> 0;
      return 0;
    }

    var _emscripten_notify_memory_growth = memoryIndex => {
      updateMemoryViews();
    };

    var handleException = e => {
      if (e instanceof ExitStatus || e == "unwind") {
        return EXITSTATUS;
      }

      quit_(1, e);
    };

    var runtimeKeepaliveCounter = 0;

    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;

    var _proc_exit = code => {
      EXITSTATUS = code;

      if (!keepRuntimeAlive()) {
        Module["onExit"]?.(code);
        ABORT = true;
      }

      quit_(code, new ExitStatus(code));
    };

    var exitJS = (status, implicit) => {
      EXITSTATUS = status;

      _proc_exit(status);
    };

    var _exit = exitJS;

    var maybeExit = () => {
      if (!keepRuntimeAlive()) {
        try {
          _exit(EXITSTATUS);
        } catch (e) {
          handleException(e);
        }
      }
    };

    var callUserCallback = func => {
      if (ABORT) {
        return;
      }

      try {
        func();
        maybeExit();
      } catch (e) {
        handleException(e);
      }
    };

    var safeSetTimeout = (func, timeout) => setTimeout(() => {
      callUserCallback(func);
    }, timeout);

    var _emscripten_sleep = ms => Asyncify.handleSleep(wakeUp => safeSetTimeout(wakeUp, ms));

    _emscripten_sleep.isAsync = true;
    var ENV = {};

    var getExecutableName = () => thisProgram || "./this.program";

    var getEnvStrings = () => {
      if (!getEnvStrings.strings) {
        var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
        var env = {
          USER: "web_user",
          LOGNAME: "web_user",
          PATH: "/",
          PWD: "/",
          HOME: "/home/web_user",
          LANG: lang,
          _: getExecutableName()
        };

        for (var x in ENV) {
          if (ENV[x] === undefined) delete env[x];else env[x] = ENV[x];
        }

        var strings = [];

        for (var x in env) {
          strings.push(`${x}=${env[x]}`);
        }

        getEnvStrings.strings = strings;
      }

      return getEnvStrings.strings;
    };

    var stringToAscii = (str, buffer) => {
      for (var i = 0; i < str.length; ++i) {
        HEAP8[buffer++] = str.charCodeAt(i);
      }

      HEAP8[buffer] = 0;
    };

    var _environ_get = (__environ, environ_buf) => {
      var bufSize = 0;
      getEnvStrings().forEach((string, i) => {
        var ptr = environ_buf + bufSize;
        HEAPU32[__environ + i * 4 >> 2] = ptr;
        stringToAscii(string, ptr);
        bufSize += string.length + 1;
      });
      return 0;
    };

    var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
      var strings = getEnvStrings();
      HEAPU32[penviron_count >> 2] = strings.length;
      var bufSize = 0;
      strings.forEach(string => bufSize += string.length + 1);
      HEAPU32[penviron_buf_size >> 2] = bufSize;
      return 0;
    };

    var _fd_close = fd => 52;

    async function _fd_read(fd, iov, iovcnt, pnum) {
      console.log("fd_read: entered");

      if (fd < 10) {
        var stream = SYSCALLS.getStreamFromFD(fd);
        var num = SYSCALLS.doReadv(stream, iov, iovcnt);
        HEAP32[pnum >> 2] = num;
        return 0;
      } else {
        const wasmFD = _zitiContext._wasmFDsById.get(fd);

        if (wasmFD === null) throw new Error("cannot find wasmFD");
        wasmFD.socket.fd_read();
        HEAP32[pnum >> 2] = 0;
        return 0;
      }
    }

    _fd_read.isAsync = true;

    function _fd_seek(fd, offset, whence, newOffset) {
      return 70;
    }

    var printCharBuffers = [null, [], []];
    var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : undefined;

    var 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;
    };

    var printChar = (stream, curr) => {
      var buffer = printCharBuffers[stream];

      if (curr === 0 || curr === 10) {
        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
        buffer.length = 0;
      } else {
        buffer.push(curr);
      }
    };

    var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";

    var SYSCALLS = {
      varargs: undefined,

      getStr(ptr) {
        var ret = UTF8ToString(ptr);
        return ret;
      }

    };

    function _fd_write(fd, iov, iovcnt, pnum) {
      if (fd < 10) {
        var num = 0;

        for (var i = 0; i < iovcnt; i++) {
          var ptr = HEAP32[iov >> 2];
          var len = HEAP32[iov + 4 >> 2];
          iov += 8;

          for (var j = 0; j < len; j++) {
            printChar(fd, HEAPU8[ptr + j]);
          }

          num += len;
        }

        HEAP32[pnum >> 2] = num;
        return 0;
      } else {
        const wasmFD = _zitiContext._wasmFDsById.get(fd);

        if (wasmFD === null) throw new Error("cannot find wasmFD");
        var num = 0;

        for (var i = 0; i < iovcnt; i++) {
          var ptr = HEAP32[iov >> 2];
          var len = HEAP32[iov + 4 >> 2];
          iov += 8;
          var array = new Uint8Array(Module.HEAPU8.buffer, ptr, len);
          wasmFD.socket.fd_write(array);
          num += len;
        }

        HEAP32[pnum >> 2] = num;
        return 0;
      }
    }

    var zeroMemory = (address, size) => {
      HEAPU8.fill(0, address, address + size);
      return address;
    };

    var writeSockaddr = (sa, family, addr, port, addrlen) => {
      switch (family) {
        case 2:
          addr = inetPton4(addr);
          zeroMemory(sa, 16);

          if (addrlen) {
            HEAP32[addrlen >> 2] = 16;
          }

          HEAP16[sa >> 1] = family;
          HEAP32[sa + 4 >> 2] = addr;
          HEAP16[sa + 2 >> 1] = _htons(port);
          break;

        case 10:
          addr = inetPton6(addr);
          zeroMemory(sa, 28);

          if (addrlen) {
            HEAP32[addrlen >> 2] = 28;
          }

          HEAP32[sa >> 2] = family;
          HEAP32[sa + 8 >> 2] = addr[0];
          HEAP32[sa + 12 >> 2] = addr[1];
          HEAP32[sa + 16 >> 2] = addr[2];
          HEAP32[sa + 20 >> 2] = addr[3];
          HEAP16[sa + 2 >> 1] = _htons(port);
          break;

        default:
          return 5;
      }

      return 0;
    };

    var _getaddrinfo = (node, service, hint, out) => {
      var addr = 0;
      var port = 0;
      var flags = 0;
      var family = 0;
      var type = 0;
      var proto = 0;
      var ai;

      function allocaddrinfo(family, type, proto, canon, addr, port) {
        var sa, salen, ai;
        var errno;
        salen = family === 10 ? 28 : 16;
        addr = family === 10 ? inetNtop6(addr) : inetNtop4(addr);
        sa = _malloc(salen);
        errno = writeSockaddr(sa, family, addr, port);
        assert(!errno);
        ai = _malloc(32);
        HEAP32[ai + 4 >> 2] = family;
        HEAP32[ai + 8 >> 2] = type;
        HEAP32[ai + 12 >> 2] = proto;
        HEAPU32[ai + 24 >> 2] = canon;
        HEAPU32[ai + 20 >> 2] = sa;

        if (family === 10) {
          HEAP32[ai + 16 >> 2] = 28;
        } else {
          HEAP32[ai + 16 >> 2] = 16;
        }

        HEAP32[ai + 28 >> 2] = 0;
        return ai;
      }

      if (hint) {
        flags = HEAP32[hint >> 2];
        family = HEAP32[hint + 4 >> 2];
        type = HEAP32[hint + 8 >> 2];
        proto = HEAP32[hint + 12 >> 2];
      }

      if (type && !proto) {
        proto = type === 2 ? 17 : 6;
      }

      if (!type && proto) {
        type = proto === 17 ? 2 : 1;
      }

      if (proto === 0) {
        proto = 6;
      }

      if (type === 0) {
        type = 1;
      }

      if (!node && !service) {
        return -2;
      }

      if (flags & ~(1 | 2 | 4 | 1024 | 8 | 16 | 32)) {
        return -1;
      }

      if (hint !== 0 && HEAP32[hint >> 2] & 2 && !node) {
        return -1;
      }

      if (flags & 32) {
        return -2;
      }

      if (type !== 0 && type !== 1 && type !== 2) {
        return -7;
      }

      if (family !== 0 && family !== 2 && family !== 10) {
        return -6;
      }

      if (service) {
        service = UTF8ToString(service);
        port = parseInt(service, 10);

        if (isNaN(port)) {
          if (flags & 1024) {
            return -2;
          }

          return -8;
        }
      }

      if (!node) {
        if (family === 0) {
          family = 2;
        }

        if ((flags & 1) === 0) {
          if (family === 2) {
            addr = _htonl(2130706433);
          } else {
            addr = [0, 0, 0, 1];
          }
        }

        ai = allocaddrinfo(family, type, proto, null, addr, port);
        HEAPU32[out >> 2] = ai;
        return 0;
      }

      node = UTF8ToString(node);
      addr = inetPton4(node);

      if (addr !== null) {
        if (family === 0 || family === 2) {
          family = 2;
        } else if (family === 10 && flags & 8) {
          addr = [0, 0, _htonl(65535), addr];
          family = 10;
        } else {
          return -2;
        }
      } else {
        addr = inetPton6(node);

        if (addr !== null) {
          if (family === 0 || family === 10) {
            family = 10;
          } else {
            return -2;
          }
        }
      }

      if (addr != null) {
        ai = allocaddrinfo(family, type, proto, node, addr, port);
        HEAPU32[out >> 2] = ai;
        return 0;
      }

      if (flags & 4) {
        return -2;
      }

      node = DNS.lookup_name(node);
      addr = inetPton4(node);

      if (family === 0) {
        family = 2;
      } else if (family === 10) {
        addr = [0, 0, _htonl(65535), addr];
      }

      ai = allocaddrinfo(family, type, proto, null, addr, port);
      HEAPU32[out >> 2] = ai;
      return 0;
    };

    var _getnameinfo = (sa, salen, node, nodelen, serv, servlen, flags) => {
      var info = readSockaddr(sa, salen);

      if (info.errno) {
        return -6;
      }

      var port = info.port;
      var addr = info.addr;
      var overflowed = false;

      if (node && nodelen) {
        var lookup;

        if (flags & 1 || !(lookup = DNS.lookup_addr(addr))) {
          if (flags & 8) {
            return -2;
          }
        } else {
          addr = lookup;
        }

        var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen);

        if (numBytesWrittenExclNull + 1 >= nodelen) {
          overflowed = true;
        }
      }

      if (serv && servlen) {
        port = "" + port;
        var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);

        if (numBytesWrittenExclNull + 1 >= servlen) {
          overflowed = true;
        }
      }

      if (overflowed) {
        return -12;
      }

      return 0;
    };

    function _ziti_getentropy(buf, buflen) {
      let array = new Uint8Array(Module.HEAPU8.buffer, buf, buflen);
      crypto.getRandomValues(array);
    }

    var sigToWasmTypes = sig => {
      var typeNames = {
        i: "i32",
        j: "i64",
        f: "f32",
        d: "f64",
        e: "externref",
        p: "i32"
      };
      var type = {
        parameters: [],
        results: sig[0] == "v" ? [] : [typeNames[sig[0]]]
      };

      for (var i = 1; i < sig.length; ++i) {
        type.parameters.push(typeNames[sig[i]]);
      }

      return type;
    };

    var Asyncify = {
      instrumentWasmImports(imports) {
        var importPattern = /^(invoke_.*|__asyncjs__.*)$/;

        for (let [x, original] of Object.entries(imports)) {
          if (typeof original == "function") {
            let isAsyncifyImport = original.isAsync || importPattern.test(x);

            if (isAsyncifyImport) {
              imports[x] = original = new WebAssembly.Suspending(original);
            }
          }
        }
      },

      instrumentWasmExports(exports) {
        var exportPattern = /^(ssl_do_handshake|tls_read|main|__main_argc_argv)$/;
        Asyncify.asyncExports = new Set();
        var ret = {};

        for (let [x, original] of Object.entries(exports)) {
          if (typeof original == "function") {
            let isAsyncifyExport = exportPattern.test(x);

            if (isAsyncifyExport) {
              Asyncify.asyncExports.add(original);
              original = Asyncify.makeAsyncFunction(original);
            }

            ret[x] = (...args) => original(...args);
          } else {
            ret[x] = original;
          }
        }

        return ret;
      },

      asyncExports: null,

      isAsyncExport(func) {
        return Asyncify.asyncExports?.has(func);
      },

      handleAsync: async startAsync => {
        try {
          return await startAsync();
        } finally {}
      },

      handleSleep(startAsync) {
        return Asyncify.handleAsync(() => new Promise(startAsync));
      },

      makeAsyncFunction(original) {
        return WebAssembly.promising(original);
      }

    };

    var getCFunc = ident => {
      var func = Module["_" + ident];
      return func;
    };

    var writeArrayToMemory = (array, buffer) => {
      HEAP8.set(array, buffer);
    };

    var lengthBytesUTF8 = str => {
      var len = 0;

      for (var i = 0; i < str.length; ++i) {
        var c = str.charCodeAt(i);

        if (c <= 127) {
          len++;
        } else if (c <= 2047) {
          len += 2;
        } else if (c >= 55296 && c <= 57343) {
          len += 4;
          ++i;
        } else {
          len += 3;
        }
      }

      return len;
    };

    var stackAlloc = sz => __emscripten_stack_alloc(sz);

    var stringToUTF8OnStack = str => {
      var size = lengthBytesUTF8(str) + 1;
      var ret = stackAlloc(size);
      stringToUTF8(str, ret, size);
      return ret;
    };

    var ccall = (ident, returnType, argTypes, args, opts) => {
      var toC = {
        string: str => {
          var ret = 0;

          if (str !== null && str !== undefined && str !== 0) {
            ret = stringToUTF8OnStack(str);
          }

          return ret;
        },
        array: arr => {
          var ret = stackAlloc(arr.length);
          writeArrayToMemory(arr, ret);
          return ret;
        }
      };

      function convertReturnValue(ret) {
        if (returnType === "string") {
          return UTF8ToString(ret);
        }

        if (returnType === "boolean") return Boolean(ret);
        return ret;
      }

      var func = getCFunc(ident);
      var cArgs = [];
      var stack = 0;

      if (args) {
        for (var i = 0; i < args.length; i++) {
          var converter = toC[argTypes[i]];

          if (converter) {
            if (stack === 0) stack = stackSave();
            cArgs[i] = converter(args[i]);
          } else {
            cArgs[i] = args[i];
          }
        }
      }

      var ret = func(...cArgs);

      function onDone(ret) {
        if (stack !== 0) stackRestore(stack);
        return convertReturnValue(ret);
      }

      var asyncMode = opts?.async;
      if (asyncMode) return ret.then(onDone);
      ret = onDone(ret);
      return ret;
    };

    var cwrap = (ident, returnType, argTypes, opts) => {
      var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean");
      var numericRet = returnType !== "string";

      if (numericRet && numericArgs && !opts) {
        return getCFunc(ident);
      }

      return (...args) => ccall(ident, returnType, argTypes, args, opts);
    };

    var uleb128Encode = (n, target) => {
      if (n < 128) {
        target.push(n);
      } else {
        target.push(n % 128 | 128, n >> 7);
      }
    };

    var generateFuncType = (sig, target) => {
      var sigRet = sig.slice(0, 1);
      var sigParam = sig.slice(1);
      var typeCodes = {
        i: 127,
        p: 127,
        j: 126,
        f: 125,
        d: 124,
        e: 111
      };
      target.push(96);
      uleb128Encode(sigParam.length, target);

      for (var i = 0; i < sigParam.length; ++i) {
        target.push(typeCodes[sigParam[i]]);
      }

      if (sigRet == "v") {
        target.push(0);
      } else {
        target.push(1, typeCodes[sigRet]);
      }
    };

    var convertJsFunctionToWasm = (func, sig) => {
      if (typeof WebAssembly.Function == "function") {
        return new WebAssembly.Function(sigToWasmTypes(sig), func);
      }

      var typeSectionBody = [1];
      generateFuncType(sig, typeSectionBody);
      var bytes = [0, 97, 115, 109, 1, 0, 0, 0, 1];
      uleb128Encode(typeSectionBody.length, bytes);
      bytes.push(...typeSectionBody);
      bytes.push(2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
      var module = new WebAssembly.Module(new Uint8Array(bytes));
      var instance = new WebAssembly.Instance(module, {
        e: {
          f: func
        }
      });
      var wrappedFunc = instance.exports["f"];
      return wrappedFunc;
    };

    var wasmTableMirror = [];
    var wasmTable;

    var getWasmTableEntry = funcPtr => {
      var func = wasmTableMirror[funcPtr];

      if (!func) {
        if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);

        if (Asyncify.isAsyncExport(func)) {
          wasmTableMirror[funcPtr] = func = Asyncify.makeAsyncFunction(func);
        }
      }

      return func;
    };

    var updateTableMap = (offset, count) => {
      if (functionsInTableMap) {
        for (var i = offset; i < offset + count; i++) {
          var item = getWasmTableEntry(i);

          if (item) {
            functionsInTableMap.set(item, i);
          }
        }
      }
    };

    var functionsInTableMap;

    var getFunctionAddress = func => {
      if (!functionsInTableMap) {
        functionsInTableMap = new WeakMap();
        updateTableMap(0, wasmTable.length);
      }

      return functionsInTableMap.get(func) || 0;
    };

    var freeTableIndexes = [];

    var getEmptyTableSlot = () => {
      if (freeTableIndexes.length) {
        return freeTableIndexes.pop();
      }

      try {
        wasmTable.grow(1);
      } catch (err) {
        if (!(err instanceof RangeError)) {
          throw err;
        }

        throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
      }

      return wasmTable.length - 1;
    };

    var setWasmTableEntry = (idx, func) => {
      wasmTable.set(idx, func);
      wasmTableMirror[idx] = wasmTable.get(idx);
    };

    var addFunction = (func, sig) => {
      var rtn = getFunctionAddress(func);

      if (rtn) {
        return rtn;
      }

      var ret = getEmptyTableSlot();

      try {
        setWasmTableEntry(ret, func);
      } catch (err) {
        if (!(err instanceof TypeError)) {
          throw err;
        }

        var wrapped = convertJsFunctionToWasm(func, sig);
        setWasmTableEntry(ret, wrapped);
      }

      functionsInTableMap.set(func, ret);
      return ret;
    };

    var wasmImports = {
      __syscall_connect: ___syscall_connect,
      __syscall_getdents64: ___syscall_getdents64,
      __syscall_getsockopt: ___syscall_getsockopt,
      __syscall_socket: ___syscall_socket,
      clock_time_get: _clock_time_get,
      emscripten_notify_memory_growth: _emscripten_notify_memory_growth,
      emscripten_sleep: _emscripten_sleep,
      environ_get: _environ_get,
      environ_sizes_get: _environ_sizes_get,
      fd_close: _fd_close,
      fd_read: _fd_read,
      fd_seek: _fd_seek,
      fd_write: _fd_write,
      getaddrinfo: _getaddrinfo,
      getnameinfo: _getnameinfo,
      ziti_getentropy: _ziti_getentropy
    };
    var wasmExports = createWasm();

    var _malloc = Module["_malloc"] = a0 => (_malloc = Module["_malloc"] = wasmExports["malloc"])(a0);

    Module["_createCertificateSigningRequest"] = (a0, a1, a2, a3, a4, a5, a6, a7) => (Module["_createCertificateSigningRequest"] = wasmExports["createCertificateSigningRequest"])(a0, a1, a2, a3, a4, a5, a6, a7);

    Module["_generateKey"] = a0 => (Module["_generateKey"] = wasmExports["generateKey"])(a0);

    Module["_EVP_PKEY_CTX_new_id"] = (a0, a1) => (Module["_EVP_PKEY_CTX_new_id"] = wasmExports["EVP_PKEY_CTX_new_id"])(a0, a1);

    Module["_EVP_PKEY_keygen_init"] = a0 => (Module["_EVP_PKEY_keygen_init"] = wasmExports["EVP_PKEY_keygen_init"])(a0);

    Module["_EVP_PKEY_keygen"] = (a0, a1) => (Module["_EVP_PKEY_keygen"] = wasmExports["EVP_PKEY_keygen"])(a0, a1);

    Module["_generateECKey"] = () => (Module["_generateECKey"] = wasmExports["generateECKey"])();

    Module["_EVP_PKEY_new"] = () => (Module["_EVP_PKEY_new"] = wasmExports["EVP_PKEY_new"])();

    Module["_getPrivateKeyPEM"] = a0 => (Module["_getPrivateKeyPEM"] = wasmExports["getPrivateKeyPEM"])(a0);

    Module["_getPublicKeyPEM"] = a0 => (Module["_getPublicKeyPEM"] = wasmExports["getPublicKeyPEM"])(a0);

    Module["_cleanup"] = () => (Module["_cleanup"] = wasmExports["cleanup"])();

    Module["_fd_kv_alloc"] = () => (Module["_fd_kv_alloc"] = wasmExports["fd_kv_alloc"])();

    Module["_fd_kv_getItem"] = a0 => (Module["_fd_kv_getItem"] = wasmExports["fd_kv_getItem"])(a0);

    Module["_fd_kv_delItem"] = a0 => (Module["_fd_kv_delItem"] = wasmExports["fd_kv_delItem"])(a0);

    Module["_fd_kv_addItem"] = (a0, a1) => (Module["_fd_kv_addItem"] = wasmExports["fd_kv_addItem"])(a0, a1);

    Module["_constructTLSDataQueue"] = (a0, a1) => (Module["_constructTLSDataQueue"] = wasmExports["constructTLSDataQueue"])(a0, a1);

    Module["_destructTLSDataQueue"] = a0 => (Module["_destructTLSDataQueue"] = wasmExports["destructTLSDataQueue"])(a0);

    Module["_isEmptyTLSData"] = a0 => (Module["_isEmptyTLSData"] = wasmExports["isEmptyTLSData"])(a0);

    Module["_dequeueTLSData"] = a0 => (Module["_dequeueTLSData"] = wasmExports["dequeueTLSData"])(a0);

    Module["_allocateTLSDataBuf"] = a0 => (Module["_allocateTLSDataBuf"] = wasmExports["allocateTLSDataBuf"])(a0);

    Module["_freeTLSDataBuf"] = a0 => (Module["_freeTLSDataBuf"] = wasmExports["freeTLSDataBuf"])(a0);

    Module["_enqueueTLSData"] = (a0, a1, a2) => (Module["_enqueueTLSData"] = wasmExports["enqueueTLSData"])(a0, a1, a2);

    Module["_peekTLSData"] = a0 => (Module["_peekTLSData"] = wasmExports["peekTLSData"])(a0);

    Module["_ssl_CTX_new"] = () => (Module["_ssl_CTX_new"] = wasmExports["ssl_CTX_new"])();

    Module["_ssl_CTX_add_private_key"] = (a0, a1) => (Module["_ssl_CTX_add_private_key"] = wasmExports["ssl_CTX_add_private_key"])(a0, a1);

    Module["_ssl_CTX_add_certificate"] = (a0, a1) => (Module["_ssl_CTX_add_certificate"] = wasmExports["ssl_CTX_add_certificate"])(a0, a1);

    Module["_ssl_CTX_add_extra_chain_cert"] = (a0, a1) => (Module["_ssl_CTX_add_extra_chain_cert"] = wasmExports["ssl_CTX_add_extra_chain_cert"])(a0, a1);

    Module["_ssl_CTX_add1_to_CA_list"] = (a0, a1) => (Module["_ssl_CTX_add1_to_CA_list"] = wasmExports["ssl_CTX_add1_to_CA_list"])(a0, a1);

    Module["_ssl_CTX_verify_certificate_and_key"] = a0 => (Module["_ssl_CTX_verify_certificate_and_key"] = wasmExports["ssl_CTX_verify_certificate_and_key"])(a0);

    Module["_ssl_new"] = a0 => (Module["_ssl_new"] = wasmExports["ssl_new"])(a0);

    Module["_bio_new_ssl_connect"] = a0 => (Module["_bio_new_ssl_connect"] = wasmExports["bio_new_ssl_connect"])(a0);

    Module["_bio_get_ssl"] = a0 => (Module["_bio_get_ssl"] = wasmExports["bio_get_ssl"])(a0);

    Module["_bio_set_conn_hostname"] = (a0, a1) => (Module["_bio_set_conn_hostname"] = wasmExports["bio_set_conn_hostname"])(a0, a1);

    Module["_bio_do_connect"] = a0 => (Module["_bio_do_connect"] = wasmExports["bio_do_connect"])(a0);

    Module["_ssl_do_handshake"] = a0 => (Module["_ssl_do_handshake"] = wasmExports["ssl_do_handshake"])(a0);

    Module["_ssl_get_verify_result"] = a0 => (Module["_ssl_get_verify_result"] = wasmExports["ssl_get_verify_result"])(a0);

    Module["_tls_write"] = (a0, a1, a2) => (Module["_tls_write"] = wasmExports["tls_write"])(a0, a1, a2);

    Module["_SSL_get_fd"] = a0 => (Module["_SSL_get_fd"] = wasmExports["SSL_get_fd"])(a0);

    Module["_tls_read"] = (a0, a1, a2) => (Module["_tls_read"] = wasmExports["tls_read"])(a0, a1, a2);

    Module["_ssl_set_fd"] = (a0, a1) => (Module["_ssl_set_fd"] = wasmExports["ssl_set_fd"])(a0, a1);

    Module["_ssl_connect"] = a0 => (Module["_ssl_connect"] = wasmExports["ssl_connect"])(a0);

    Module["_createBuffer"] = a0 => (Module["_createBuffer"] = wasmExports["createBuffer"])(a0);

    Module["_destroyBuffer"] = a0 => (Module["_destroyBuffer"] = wasmExports["destroyBuffer"])(a0);

    var _ntohs = a0 => (_ntohs = wasmExports["ntohs"])(a0);

    Module["_BIO_new_fp"] = (a0, a1) => (Module["_BIO_new_fp"] = wasmExports["BIO_new_fp"])(a0, a1);

    Module["_DSA_free"] = a0 => (Module["_DSA_free"] = wasmExports["DSA_free"])(a0);

    Module["_EVP_PKEY_CTX_free"] = a0 => (Module["_EVP_PKEY_CTX_free"] = wasmExports["EVP_PKEY_CTX_free"])(a0);

    Module["_EVP_PKEY_free"] = a0 => (Module["_EVP_PKEY_free"] = wasmExports["EVP_PKEY_free"])(a0);

    Module["_EVP_PKEY_get1_DSA"] = a0 => (Module["_EVP_PKEY_get1_DSA"] = wasmExports["EVP_PKEY_get1_DSA"])(a0);

    Module["_EVP_PKEY_paramgen_init"] = a0 => (Module["_EVP_PKEY_paramgen_init"] = wasmExports["EVP_PKEY_paramgen_init"])(a0);

    Module["_EVP_PKEY_paramgen"] = (a0, a1) => (Module["_EVP_PKEY_paramgen"] = wasmExports["EVP_PKEY_paramgen"])(a0, a1);

    Module["_OPENSSL_init"] = () => (Module["_OPENSSL_init"] = wasmExports["OPENSSL_init"])();

    Module["_PEM_write_bio_DSAPrivateKey"] = (a0, a1, a2, a3, a4, a5, a6) => (Module["_PEM_write_bio_DSAPrivateKey"] = wasmExports["PEM_write_bio_DSAPrivateKey"])(a0, a1, a2, a3, a4, a5, a6);

    Module["_RSA_new"] = () => (Module["_RSA_new"] = wasmExports["RSA_new"])();

    Module["_EVP_PKEY_CTX_set_rsa_keygen_bits"] = (a0, a1) => (Module["_EVP_PKEY_CTX_set_rsa_keygen_bits"] = wasmExports["EVP_PKEY_CTX_set_rsa_keygen_bits"])(a0, a1);

    Module["_SSL_is_init_finished"] = a0 => (Module["_SSL_is_init_finished"] = wasmExports["SSL_is_init_finished"])(a0);

    var __initialize = Module["__initialize"] = () => (__initialize = Module["__initialize"] = wasmExports["_initialize"])();

    var _htonl = a0 => (_htonl = wasmExports["htonl"])(a0);

    var _htons = a0 => (_htons = wasmExports["htons"])(a0);

    var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);

    var __emscripten_stack_alloc = a0 => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);

    var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])();

    Module["_whichWASMstring"] = 1024;

    Module["ccall"] = ccall;
    Module["cwrap"] = cwrap;
    Module["addFunction"] = addFunction;
    Module["setValue"] = setValue;
    Module["getValue"] = getValue;
    Module["stringToUTF8"] = stringToUTF8;
    Module["lengthBytesUTF8"] = lengthBytesUTF8;
    var calledRun;

    dependenciesFulfilled = function runCaller() {
      if (!calledRun) run();
      if (!calledRun) dependenciesFulfilled = runCaller;
    };

    function callMain(args = []) {
      var entryFunction = __initialize;

      try {
        entryFunction();
        var ret = 0;
        Promise.resolve(ret).then(result => {
          exitJS(result, true);
        }).catch(e => {
          handleException(e);
        });
        return ret;
      } catch (e) {
        return handleException(e);
      }
    }

    function run(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();
        preMain();
        readyPromiseResolve(Module);
        Module["onRuntimeInitialized"]?.();
        if (shouldRunNow) callMain(args);
        postRun();
      }

      if (Module["setStatus"]) {
        Module["setStatus"]("Running...");
        setTimeout(() => {
          setTimeout(() => 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()();
      }
    }

    var shouldRunNow = false;
    if (Module["noInitialRun"]) shouldRunNow = false;
    run();
    moduleRtn = readyPromise;
    return moduleRtn;
  };
})();

var libCrypto = (() => {
  var _scriptName = (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.js', document.baseURI).href));
  return function (moduleArg = {}) {
    var moduleRtn;
    var Module = moduleArg;
    var readyPromiseResolve, readyPromiseReject;
    var readyPromise = new Promise((resolve, reject) => {
      readyPromiseResolve = resolve;
      readyPromiseReject = reject;
    });
    var arguments_ = {};
    arguments_["foo"] = 1;
    var moduleOverrides = Object.assign({}, Module);
    var arguments_ = [];
    var thisProgram = "./this.program";

    var quit_ = (status, toThrow) => {
      throw toThrow;
    };

    var scriptDirectory = "";

    function locateFile(path) {
      return scriptDirectory + path;
    }

    var readAsync;

    {
      if (typeof document != "undefined" && document.currentScript) {
        scriptDirectory = document.currentScript.src;
      }

      if (_scriptName) {
        scriptDirectory = _scriptName;
      }

      if (scriptDirectory.startsWith("blob:")) {
        scriptDirectory = "";
      } else {
        scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
      }

      {
        readAsync = url => fetch(url, {
          credentials: "same-origin"
        }).then(response => {
          if (response.ok) {
            return response.arrayBuffer();
          }

          return Promise.reject(new Error(response.status + " : " + response.url));
        });
      }
    }

    var out = console.log.bind(console);
    var err = console.error.bind(console);
    Object.assign(Module, moduleOverrides);
    moduleOverrides = null;
    var wasmBinary;
    var wasmMemory;
    var ABORT = false;
    var EXITSTATUS;
    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPF64;

    function updateMemoryViews() {
      var b = wasmMemory.buffer;
      HEAP8 = new Int8Array(b);
      HEAP16 = new Int16Array(b);
      HEAPU8 = new Uint8Array(b);
      HEAPU16 = new Uint16Array(b);
      HEAP32 = new Int32Array(b);
      HEAPU32 = new Uint32Array(b);
      HEAPF32 = new Float32Array(b);
      HEAPF64 = new Float64Array(b);
      HEAP64 = new BigInt64Array(b);
      new BigUint64Array(b);
    }

    var __ATPRERUN__ = [];
    var __ATINIT__ = [];
    var __ATMAIN__ = [];
    var __ATPOSTRUN__ = [];

    function preRun() {
      callRuntimeCallbacks(__ATPRERUN__);
    }

    function initRuntime() {
      callRunt