"use strict";

function _classCallCheck(instance, Constructor) {
  if (!_instanceof(instance, Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _instanceof(left, right) {
  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
    return !!right[Symbol.hasInstance](left);
  } else {
    return left instanceof right;
  }
}

function _typeof(obj) {
  "@babel/helpers - typeof";
  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function _typeof(obj) {
      return typeof obj;
    };
  } else {
    _typeof = function _typeof(obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype
        ? "symbol"
        : typeof obj;
    };
  }
  return _typeof(obj);
}

var wasm_bindgen;

(function () {
  var __exports = {};
  var wasm;
  var heap = new Array(32).fill(undefined);
  heap.push(undefined, null, true, false);

  function getObject(idx) {
    return heap[idx];
  }

  var heap_next = heap.length;

  function dropObject(idx) {
    if (idx < 36) return;
    heap[idx] = heap_next;
    heap_next = idx;
  }

  function takeObject(idx) {
    var ret = getObject(idx);
    dropObject(idx);
    return ret;
  }

  var cachedTextDecoder = new TextDecoder("utf-8", {
    ignoreBOM: true,
    fatal: true,
  });
  cachedTextDecoder.decode();
  var cachegetUint8Memory0 = null;

  function getUint8Memory0() {
    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
      cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
    }

    return cachegetUint8Memory0;
  }

  function getStringFromWasm0(ptr, len) {
    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
  }

  function addHeapObject(obj) {
    if (heap_next === heap.length) heap.push(heap.length + 1);
    var idx = heap_next;
    heap_next = heap[idx];
    heap[idx] = obj;
    return idx;
  }

  var WASM_VECTOR_LEN = 0;
  var cachedTextEncoder = new TextEncoder("utf-8");
  var encodeString =
    typeof cachedTextEncoder.encodeInto === "function"
      ? function (arg, view) {
          return cachedTextEncoder.encodeInto(arg, view);
        }
      : function (arg, view) {
          var buf = cachedTextEncoder.encode(arg);
          view.set(buf);
          return {
            read: arg.length,
            written: buf.length,
          };
        };

  function passStringToWasm0(arg, malloc, realloc) {
    if (realloc === undefined) {
      var buf = cachedTextEncoder.encode(arg);

      var _ptr = malloc(buf.length);

      getUint8Memory0()
        .subarray(_ptr, _ptr + buf.length)
        .set(buf);
      WASM_VECTOR_LEN = buf.length;
      return _ptr;
    }

    var len = arg.length;
    var ptr = malloc(len);
    var mem = getUint8Memory0();
    var offset = 0;

    for (; offset < len; offset++) {
      var code = arg.charCodeAt(offset);
      if (code > 0x7f) break;
      mem[ptr + offset] = code;
    }

    if (offset !== len) {
      if (offset !== 0) {
        arg = arg.slice(offset);
      }

      ptr = realloc(ptr, len, (len = offset + arg.length * 3));
      var view = getUint8Memory0().subarray(ptr + offset, ptr + len);
      var ret = encodeString(arg, view);
      offset += ret.written;
    }

    WASM_VECTOR_LEN = offset;
    return ptr;
  }

  function isLikeNone(x) {
    return x === undefined || x === null;
  }

  var cachegetInt32Memory0 = null;

  function getInt32Memory0() {
    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
      cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
    }

    return cachegetInt32Memory0;
  }

  function debugString(val) {
    // primitive types
    var type = _typeof(val);

    if (type == "number" || type == "boolean" || val == null) {
      return "".concat(val);
    }

    if (type == "string") {
      return '"'.concat(val, '"');
    }

    if (type == "symbol") {
      var description = val.description;

      if (description == null) {
        return "Symbol";
      } else {
        return "Symbol(".concat(description, ")");
      }
    }

    if (type == "function") {
      var name = val.name;

      if (typeof name == "string" && name.length > 0) {
        return "Function(".concat(name, ")");
      } else {
        return "Function";
      }
    } // objects

    if (Array.isArray(val)) {
      var length = val.length;
      var debug = "[";

      if (length > 0) {
        debug += debugString(val[0]);
      }

      for (var i = 1; i < length; i++) {
        debug += ", " + debugString(val[i]);
      }

      debug += "]";
      return debug;
    } // Test for built-in

    var builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
    var className;

    if (builtInMatches.length > 1) {
      className = builtInMatches[1];
    } else {
      // Failed to match the standard '[object ClassName]'
      return toString.call(val);
    }

    if (className == "Object") {
      // we're a user defined class or Object
      // JSON.stringify avoids problems with cycles, and is generally much
      // easier than looping through ownProperties of `val`.
      try {
        return "Object(" + JSON.stringify(val) + ")";
      } catch (_) {
        return "Object";
      }
    } // errors

    if (_instanceof(val, Error)) {
      return "".concat(val.name, ": ").concat(val.message, "\n").concat(val.stack);
    } // TODO we could test for more things here, like `Set`s and `Map`s.

    return className;
  }

  function makeMutClosure(arg0, arg1, dtor, f) {
    var state = {
      a: arg0,
      b: arg1,
      cnt: 1,
    };

    var real = function real() {
      // First up with a closure we increment the internal reference
      // count. This ensures that the Rust closure environment won't
      // be deallocated while we're invoking it.
      state.cnt++;
      var a = state.a;
      state.a = 0;

      try {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return f.apply(void 0, [a, state.b].concat(args));
      } finally {
        if (--state.cnt === 0) wasm.__wbindgen_export_2.get(dtor)(a, state.b);
        else state.a = a;
      }
    };

    real.original = state;
    return real;
  }

  function __wbg_adapter_26(arg0, arg1) {
    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__he25972c9b3fefae8(
      arg0,
      arg1,
    );
  }

  function __wbg_adapter_29(arg0, arg1, arg2) {
    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h7b132ceac93324a9(
      arg0,
      arg1,
      addHeapObject(arg2),
    );
  }

  function __wbg_adapter_32(arg0, arg1, arg2) {
    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h6d18d2f5d81b3bb0(
      arg0,
      arg1,
      addHeapObject(arg2),
    );
  }
  /**
   */

  __exports.run = function () {
    wasm.run();
  };

  function handleError(f) {
    return function () {
      try {
        return f.apply(this, arguments);
      } catch (e) {
        wasm.__wbindgen_exn_store(addHeapObject(e));
      }
    };
  }

  function getArrayU8FromWasm0(ptr, len) {
    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
  }

  var cachegetFloat64Memory0 = null;

  function getFloat64Memory0() {
    if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
      cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
    }

    return cachegetFloat64Memory0;
  }

  function __wbg_adapter_165(arg0, arg1, arg2, arg3) {
    wasm.wasm_bindgen__convert__closures__invoke2_mut__h695c06ab86e08564(
      arg0,
      arg1,
      addHeapObject(arg2),
      addHeapObject(arg3),
    );
  }
  /**
   */

  var EData = /*#__PURE__*/ (function () {
    _createClass(
      EData,
      [
        {
          key: "free",
          value: function free() {
            var ptr = this.ptr;
            this.ptr = 0;

            wasm.__wbg_edata_free(ptr);
          },
          /**
           */
        },
      ],
      [
        {
          key: "__wrap",
          value: function __wrap(ptr) {
            var obj = Object.create(EData.prototype);
            obj.ptr = ptr;
            return obj;
          },
        },
      ],
    );

    function EData() {
      _classCallCheck(this, EData);

      var ret = wasm.edata_new();
      return EData.__wrap(ret);
    }
    /**
     * @returns {string}
     */

    _createClass(EData, [
      {
        key: "get_edt",
        value: function get_edt() {
          try {
            wasm.edata_get_edt(8, this.ptr);
            var r0 = getInt32Memory0()[8 / 4 + 0];
            var r1 = getInt32Memory0()[8 / 4 + 1];
            return getStringFromWasm0(r0, r1);
          } finally {
            wasm.__wbindgen_free(r0, r1);
          }
        },
        /**
         * @returns {string}
         */
      },
      {
        key: "get_sid",
        value: function get_sid() {
          try {
            wasm.edata_get_sid(8, this.ptr);
            var r0 = getInt32Memory0()[8 / 4 + 0];
            var r1 = getInt32Memory0()[8 / 4 + 1];
            return getStringFromWasm0(r0, r1);
          } finally {
            wasm.__wbindgen_free(r0, r1);
          }
        },
      },
    ]);

    return EData;
  })();

  __exports.EData = EData;

  async function load(module, imports) {
    if (typeof Response === "function" && _instanceof(module, Response)) {
      if (typeof WebAssembly.instantiateStreaming === "function") {
        try {
          return await WebAssembly.instantiateStreaming(module, imports);
        } catch (e) {
          if (module.headers.get("Content-Type") != "application/wasm") {
            console.warn(
              "`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
              e,
            );
          } else {
            throw e;
          }
        }
      }

      var bytes = await module.arrayBuffer();
      return await WebAssembly.instantiate(bytes, imports);
    } else {
      var instance = await WebAssembly.instantiate(module, imports);

      if (_instanceof(instance, WebAssembly.Instance)) {
        return {
          instance: instance,
          module: module,
        };
      } else {
        return instance;
      }
    }
  }

  async function init(input) {
    if (typeof input === "undefined") {
      var src;

      if (typeof document === "undefined") {
        src = location.href;
      } else {
        src = document.currentScript.src;
      }

      input = src.replace(/\.js$/, "_bg.wasm");
    }

    var imports = {};
    imports.wbg = {};

    imports.wbg.__wbg_setTimeout_b3d3e28b860025e3 = function (arg0, arg1) {
      setTimeout(takeObject(arg0), arg1 >>> 0);
    };

    imports.wbg.__wbindgen_object_drop_ref = function (arg0) {
      takeObject(arg0);
    };

    imports.wbg.__wbindgen_cb_drop = function (arg0) {
      var obj = takeObject(arg0).original;

      if (obj.cnt-- == 1) {
        obj.a = 0;
        return true;
      }

      var ret = false;
      return ret;
    };

    imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
      var ret = getStringFromWasm0(arg0, arg1);
      return addHeapObject(ret);
    };

    imports.wbg.__wbindgen_jsval_eq = function (arg0, arg1) {
      var ret = getObject(arg0) === getObject(arg1);
      return ret;
    };

    imports.wbg.__wbindgen_object_clone_ref = function (arg0) {
      var ret = getObject(arg0);
      return addHeapObject(ret);
    };

    imports.wbg.__wbindgen_cb_forget = function (arg0) {
      takeObject(arg0);
    };

    imports.wbg.__wbg_instanceof_Window_d64060d13377409b = function (arg0) {
      var ret = _instanceof(getObject(arg0), Window);

      return ret;
    };

    imports.wbg.__wbg_document_bcf9d67bc56e8c6d = function (arg0) {
      var ret = getObject(arg0).document;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };

    imports.wbg.__wbg_navigator_a1711d7939511fb0 = function (arg0) {
      var ret = getObject(arg0).navigator;
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_crypto_e775ee2e074e46de = handleError(function (arg0) {
      var ret = getObject(arg0).crypto;
      return addHeapObject(ret);
    });
    imports.wbg.__wbg_requestAnimationFrame_96f88ce2d311332e = handleError(function (arg0, arg1) {
      var ret = getObject(arg0).requestAnimationFrame(getObject(arg1));
      return ret;
    });
    imports.wbg.__wbg_createElement_467bb064d2ae5833 = handleError(function (arg0, arg1, arg2) {
      var ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
      return addHeapObject(ret);
    });

    imports.wbg.__wbg_clientX_48aae9fc88d6ea69 = function (arg0) {
      var ret = getObject(arg0).clientX;
      return ret;
    };

    imports.wbg.__wbg_clientY_b23802d9e0dd2c51 = function (arg0) {
      var ret = getObject(arg0).clientY;
      return ret;
    };

    imports.wbg.__wbg_buttons_d9a487d62a2bcfad = function (arg0) {
      var ret = getObject(arg0).buttons;
      return ret;
    };

    imports.wbg.__wbg_encrypt_3eac7f61933c3be9 = handleError(function (arg0, arg1, arg2, arg3) {
      var ret = getObject(arg0).encrypt(getObject(arg1), getObject(arg2), getObject(arg3));
      return addHeapObject(ret);
    });
    imports.wbg.__wbg_importKey_370896d933eba99c = handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
      var ret = getObject(arg0).importKey(
        getStringFromWasm0(arg1, arg2),
        getObject(arg3),
        getObject(arg4),
        arg5 !== 0,
        getObject(arg6),
      );
      return addHeapObject(ret);
    });

    imports.wbg.__wbg_deltaX_91eab99c5941b593 = function (arg0) {
      var ret = getObject(arg0).deltaX;
      return ret;
    };

    imports.wbg.__wbg_deltaY_ba4bc93322183cab = function (arg0) {
      var ret = getObject(arg0).deltaY;
      return ret;
    };

    imports.wbg.__wbg_subtle_a33b474f137433b4 = function (arg0) {
      var ret = getObject(arg0).subtle;
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_getRandomValues_bd83b9bca41f01e4 = handleError(function (arg0, arg1, arg2) {
      var ret = getObject(arg0).getRandomValues(getArrayU8FromWasm0(arg1, arg2));
      return addHeapObject(ret);
    });

    imports.wbg.__wbg_clientX_bc61648c02723dc7 = function (arg0) {
      var ret = getObject(arg0).clientX;
      return ret;
    };

    imports.wbg.__wbg_clientY_67b12bba9c15ace2 = function (arg0) {
      var ret = getObject(arg0).clientY;
      return ret;
    };

    imports.wbg.__wbg_length_4c6909494a0e02f9 = function (arg0) {
      var ret = getObject(arg0).length;
      return ret;
    };

    imports.wbg.__wbg_item_bb8a8818d4856ef0 = function (arg0, arg1) {
      var ret = getObject(arg0).item(arg1 >>> 0);
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };

    imports.wbg.__wbg_setAttribute_02daabbc925a51e3 = handleError(function (arg0, arg1, arg2, arg3, arg4) {
      getObject(arg0).setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
    });

    imports.wbg.__wbg_instanceof_WebGlRenderingContext_dca65729c7187d57 = function (arg0) {
      var ret = _instanceof(getObject(arg0), WebGLRenderingContext);

      return ret;
    };

    imports.wbg.__wbg_bufferData_e135b678b6ef2433 = function (arg0, arg1, arg2, arg3) {
      getObject(arg0).bufferData(arg1 >>> 0, getObject(arg2), arg3 >>> 0);
    };

    imports.wbg.__wbg_attachShader_9958cc9636fc8494 = function (arg0, arg1, arg2) {
      getObject(arg0).attachShader(getObject(arg1), getObject(arg2));
    };

    imports.wbg.__wbg_bindBuffer_c96c99b259d952f4 = function (arg0, arg1, arg2) {
      getObject(arg0).bindBuffer(arg1 >>> 0, getObject(arg2));
    };

    imports.wbg.__wbg_clear_ec5c1c21ed3b2fe2 = function (arg0, arg1) {
      getObject(arg0).clear(arg1 >>> 0);
    };

    imports.wbg.__wbg_clearColor_b9e0f7e215dc534e = function (arg0, arg1, arg2, arg3, arg4) {
      getObject(arg0).clearColor(arg1, arg2, arg3, arg4);
    };

    imports.wbg.__wbg_compileShader_82966bc7f1d070fe = function (arg0, arg1) {
      getObject(arg0).compileShader(getObject(arg1));
    };

    imports.wbg.__wbg_createBuffer_501da6aef1c4b91c = function (arg0) {
      var ret = getObject(arg0).createBuffer();
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };

    imports.wbg.__wbg_createProgram_531dab3c15c28e4f = function (arg0) {
      var ret = getObject(arg0).createProgram();
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };

    imports.wbg.__wbg_createShader_376b269548a48c7a = function (arg0, arg1) {
      var ret = getObject(arg0).createShader(arg1 >>> 0);
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };

    imports.wbg.__wbg_drawArrays_1c6a2bff627558ed = function (arg0, arg1, arg2, arg3) {
      getObject(arg0).drawArrays(arg1 >>> 0, arg2, arg3);
    };

    imports.wbg.__wbg_enableVertexAttribArray_0f8b0b1592940e3f = function (arg0, arg1) {
      getObject(arg0).enableVertexAttribArray(arg1 >>> 0);
    };

    imports.wbg.__wbg_getProgramInfoLog_5def5bb3d8d30e1f = function (arg0, arg1, arg2) {
      var ret = getObject(arg1).getProgramInfoLog(getObject(arg2));
      var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    };

    imports.wbg.__wbg_getProgramParameter_c021157c5817259f = function (arg0, arg1, arg2) {
      var ret = getObject(arg0).getProgramParameter(getObject(arg1), arg2 >>> 0);
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_getShaderInfoLog_b619769ff40aac70 = function (arg0, arg1, arg2) {
      var ret = getObject(arg1).getShaderInfoLog(getObject(arg2));
      var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    };

    imports.wbg.__wbg_getShaderParameter_d03718a8c98a4d23 = function (arg0, arg1, arg2) {
      var ret = getObject(arg0).getShaderParameter(getObject(arg1), arg2 >>> 0);
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_linkProgram_9e60adcb42d34c3c = function (arg0, arg1) {
      getObject(arg0).linkProgram(getObject(arg1));
    };

    imports.wbg.__wbg_shaderSource_c208cc7a688e8923 = function (arg0, arg1, arg2, arg3) {
      getObject(arg0).shaderSource(getObject(arg1), getStringFromWasm0(arg2, arg3));
    };

    imports.wbg.__wbg_useProgram_c4a6df84383cd1a6 = function (arg0, arg1) {
      getObject(arg0).useProgram(getObject(arg1));
    };

    imports.wbg.__wbg_vertexAttribPointer_5660aa1f2b819de1 = function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
      getObject(arg0).vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
    };

    imports.wbg.__wbg_addEventListener_fe52a115589ccc2c = handleError(function (arg0, arg1, arg2, arg3) {
      getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
    });

    imports.wbg.__wbg_instanceof_HtmlCanvasElement_308a7fa689ff20ef = function (arg0) {
      var ret = _instanceof(getObject(arg0), HTMLCanvasElement);

      return ret;
    };

    imports.wbg.__wbg_getContext_554fc171434d411b = handleError(function (arg0, arg1, arg2) {
      var ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    });
    imports.wbg.__wbg_toDataURL_ca175b3d0bb6f5d9 = handleError(function (arg0, arg1) {
      var ret = getObject(arg1).toDataURL();
      var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    });
    imports.wbg.__wbg_cookie_eb31c284e2ed620b = handleError(function (arg0, arg1) {
      var ret = getObject(arg1).cookie;
      var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    });

    imports.wbg.__wbg_keyCode_e19b105e5d2d09d5 = function (arg0) {
      var ret = getObject(arg0).keyCode;
      return ret;
    };

    imports.wbg.__wbg_shiftKey_0924a6b92b68d3f6 = function (arg0) {
      var ret = getObject(arg0).shiftKey;
      return ret;
    };

    imports.wbg.__wbg_alpha_71e14e01b1c605a6 = function (arg0, arg1) {
      var ret = getObject(arg1).alpha;
      getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
      getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
    };

    imports.wbg.__wbg_beta_f48a7d1a10feff4e = function (arg0, arg1) {
      var ret = getObject(arg1).beta;
      getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
      getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
    };

    imports.wbg.__wbg_gamma_eb5fbdd72123221e = function (arg0, arg1) {
      var ret = getObject(arg1).gamma;
      getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
      getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
    };

    imports.wbg.__wbg_touches_ea1e29cf107bf92b = function (arg0) {
      var ret = getObject(arg0).touches;
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_next_7a1e3e5ba77a5417 = handleError(function (arg0) {
      var ret = getObject(arg0).next();
      return addHeapObject(ret);
    });

    imports.wbg.__wbg_done_179f9d81f2c93943 = function (arg0) {
      var ret = getObject(arg0).done;
      return ret;
    };

    imports.wbg.__wbg_value_dd36c45a14714446 = function (arg0) {
      var ret = getObject(arg0).value;
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_get_fa38f22e54fe1ab1 = handleError(function (arg0, arg1) {
      var ret = Reflect.get(getObject(arg0), getObject(arg1));
      return addHeapObject(ret);
    });
    imports.wbg.__wbg_call_20c04382b27a4486 = handleError(function (arg0, arg1) {
      var ret = getObject(arg0).call(getObject(arg1));
      return addHeapObject(ret);
    });

    imports.wbg.__wbg_new_a938277eeb06668d = function () {
      var ret = new Array();
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_push_2bfc5fcfa4d4389d = function (arg0, arg1) {
      var ret = getObject(arg0).push(getObject(arg1));
      return ret;
    };

    imports.wbg.__wbg_values_04df67902f0aa20f = function (arg0) {
      var ret = getObject(arg0).values();
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_newnoargs_bfddd41728ab0b9c = function (arg0, arg1) {
      var ret = new Function(getStringFromWasm0(arg0, arg1));
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_now_40a39f1fea2317e3 = function () {
      var ret = Date.now();
      return ret;
    };

    imports.wbg.__wbg_new_f46e6afe0b8a862e = function () {
      var ret = new Object();
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_exec_0847b50db1960a9b = function (arg0, arg1, arg2) {
      var ret = getObject(arg0).exec(getStringFromWasm0(arg1, arg2));
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };

    imports.wbg.__wbg_new_ad3a28429d2566a0 = function (arg0, arg1, arg2, arg3) {
      var ret = new RegExp(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_new_261626435fed913c = function (arg0, arg1) {
      try {
        var state0 = {
          a: arg0,
          b: arg1,
        };

        var cb0 = function cb0(arg0, arg1) {
          var a = state0.a;
          state0.a = 0;

          try {
            return __wbg_adapter_165(a, state0.b, arg0, arg1);
          } finally {
            state0.a = a;
          }
        };

        var ret = new Promise(cb0);
        return addHeapObject(ret);
      } finally {
        state0.a = state0.b = 0;
      }
    };

    imports.wbg.__wbg_resolve_430b2f40a51592cc = function (arg0) {
      var ret = Promise.resolve(getObject(arg0));
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_then_a9485ea9ef567f90 = function (arg0, arg1) {
      var ret = getObject(arg0).then(getObject(arg1));
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_then_b114127b40814c36 = function (arg0, arg1, arg2) {
      var ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_self_944d201f31e01c91 = handleError(function () {
      var ret = self.self;
      return addHeapObject(ret);
    });
    imports.wbg.__wbg_window_993fd51731b86960 = handleError(function () {
      var ret = window.window;
      return addHeapObject(ret);
    });
    imports.wbg.__wbg_globalThis_8379563d70fab135 = handleError(function () {
      var ret = globalThis.globalThis;
      return addHeapObject(ret);
    });
    imports.wbg.__wbg_global_073eb4249a3a8c12 = handleError(function () {
      var ret = global.global;
      return addHeapObject(ret);
    });

    imports.wbg.__wbindgen_is_undefined = function (arg0) {
      var ret = getObject(arg0) === undefined;
      return ret;
    };

    imports.wbg.__wbg_buffer_985803c87989344b = function (arg0) {
      var ret = getObject(arg0).buffer;
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_newwithbyteoffsetandlength_36d42f1c91e7259d = function (arg0, arg1, arg2) {
      var ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_length_32e166b42b85060a = function (arg0) {
      var ret = getObject(arg0).length;
      return ret;
    };

    imports.wbg.__wbg_new_b7e3d6adc8b9377a = function (arg0) {
      var ret = new Uint8Array(getObject(arg0));
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_set_66e888cef8f00a73 = function (arg0, arg1, arg2) {
      getObject(arg0).set(getObject(arg1), arg2 >>> 0);
    };

    imports.wbg.__wbg_newwithbyteoffsetandlength_3c83a6445776097f = function (arg0, arg1, arg2) {
      var ret = new Float32Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_buffer_4f0ba77e90f96e9d = function (arg0) {
      var ret = getObject(arg0).buffer;
      return addHeapObject(ret);
    };

    imports.wbg.__wbg_ownKeys_8a63b9d67c805cfd = handleError(function (arg0) {
      var ret = Reflect.ownKeys(getObject(arg0));
      return addHeapObject(ret);
    });
    imports.wbg.__wbg_set_6db0a4cb6e322f85 = handleError(function (arg0, arg1, arg2) {
      var ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
      return ret;
    });

    imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
      var obj = getObject(arg1);
      var ret = typeof obj === "string" ? obj : undefined;
      var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    };

    imports.wbg.__wbindgen_boolean_get = function (arg0) {
      var v = getObject(arg0);
      var ret = typeof v === "boolean" ? (v ? 1 : 0) : 2;
      return ret;
    };

    imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {
      var ret = debugString(getObject(arg1));
      var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    };

    imports.wbg.__wbindgen_throw = function (arg0, arg1) {
      throw new Error(getStringFromWasm0(arg0, arg1));
    };

    imports.wbg.__wbindgen_memory = function () {
      var ret = wasm.memory;
      return addHeapObject(ret);
    };

    imports.wbg.__wbindgen_closure_wrapper191 = function (arg0, arg1, arg2) {
      var ret = makeMutClosure(arg0, arg1, 64, __wbg_adapter_26);
      return addHeapObject(ret);
    };

    imports.wbg.__wbindgen_closure_wrapper193 = function (arg0, arg1, arg2) {
      var ret = makeMutClosure(arg0, arg1, 64, __wbg_adapter_32);
      return addHeapObject(ret);
    };

    imports.wbg.__wbindgen_closure_wrapper220 = function (arg0, arg1, arg2) {
      var ret = makeMutClosure(arg0, arg1, 73, __wbg_adapter_29);
      return addHeapObject(ret);
    };

    if (
      typeof input === "string" ||
      (typeof Request === "function" && _instanceof(input, Request)) ||
      (typeof URL === "function" && _instanceof(input, URL))
    ) {
      input = fetch(input);
    }

    var _await$load = await load(await input, imports),
      instance = _await$load.instance,
      module = _await$load.module;

    wasm = instance.exports;
    init.__wbindgen_wasm_module = module;

    wasm.__wbindgen_start();

    return wasm;
  }

  wasm_bindgen = Object.assign(init, __exports);
})();