text: 
  (function(l, r) { if (!l || l.getElementById('livereloadscript')) return; r = l.createElement('script'); r.async = 1; r.src = '//' + (self.location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; r.id = 'livereloadscript'; l.getElementsByTagName('head')[0].appendChild(r) })(self.document);
  (function () {
      'use strict';
  
      function add_event(elem, name, capture, passive, f) {
              elem.addEventListener(name, f, {
                  capture,
                  passive,
                  once: false,
              });
          }
  
          function remove_event(elem, name, capture, f) {
              elem.removeEventListener(name, f, capture);
          }
  
      let wasm;
  
      const heap = new Array(32).fill(undefined);
  
      heap.push(undefined, null, true, false);
  
      function getObject(idx) { return heap[idx]; }
  
      let WASM_VECTOR_LEN = 0;
  
      let cachegetUint8Memory0 = null;
      function getUint8Memory0() {
          if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
              cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
          }
          return cachegetUint8Memory0;
      }
  
      let cachedTextEncoder = new TextEncoder('utf-8');
  
      const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
          ? function (arg, view) {
          return cachedTextEncoder.encodeInto(arg, view);
      }
          : function (arg, view) {
          const buf = cachedTextEncoder.encode(arg);
          view.set(buf);
          return {
              read: arg.length,
              written: buf.length
          };
      });
  
      function passStringToWasm0(arg, malloc, realloc) {
  
          if (typeof(arg) !== 'string') throw new Error('expected a string argument');
  
          if (realloc === undefined) {
              const buf = cachedTextEncoder.encode(arg);
              const ptr = malloc(buf.length);
              getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
              WASM_VECTOR_LEN = buf.length;
              return ptr;
          }
  
          let len = arg.length;
          let ptr = malloc(len);
  
          const mem = getUint8Memory0();
  
          let offset = 0;
  
          for (; offset < len; offset++) {
              const 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);
              const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
              const ret = encodeString(arg, view);
              if (ret.read !== arg.length) throw new Error('failed to pass whole string');
              offset += ret.written;
          }
  
          WASM_VECTOR_LEN = offset;
          return ptr;
      }
  
      let cachegetInt32Memory0 = null;
      function getInt32Memory0() {
          if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
              cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
          }
          return cachegetInt32Memory0;
      }
  
      let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
  
      cachedTextDecoder.decode();
  
      function getStringFromWasm0(ptr, len) {
          return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
      }
  
      let heap_next = heap.length;
  
      function addHeapObject(obj) {
          if (heap_next === heap.length) heap.push(heap.length + 1);
          const idx = heap_next;
          heap_next = heap[idx];
  
          if (typeof(heap_next) !== 'number') throw new Error('corrupt heap');
  
          heap[idx] = obj;
          return idx;
      }
  
      function dropObject(idx) {
          if (idx < 36) return;
          heap[idx] = heap_next;
          heap_next = idx;
      }
  
      function takeObject(idx) {
          const ret = getObject(idx);
          dropObject(idx);
          return ret;
      }
  
      function _assertBoolean(n) {
          if (typeof(n) !== 'boolean') {
              throw new Error('expected a boolean argument');
          }
      }
  
      function debugString(val) {
          // primitive types
          const type = typeof val;
          if (type == 'number' || type == 'boolean' || val == null) {
              return  `${val}`;
          }
          if (type == 'string') {
              return `"${val}"`;
          }
          if (type == 'symbol') {
              const description = val.description;
              if (description == null) {
                  return 'Symbol';
              } else {
                  return `Symbol(${description})`;
              }
          }
          if (type == 'function') {
              const name = val.name;
              if (typeof name == 'string' && name.length > 0) {
                  return `Function(${name})`;
              } else {
                  return 'Function';
              }
          }
          // objects
          if (Array.isArray(val)) {
              const length = val.length;
              let debug = '[';
              if (length > 0) {
                  debug += debugString(val[0]);
              }
              for(let i = 1; i < length; i++) {
                  debug += ', ' + debugString(val[i]);
              }
              debug += ']';
              return debug;
          }
          // Test for built-in
          const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
          let 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 (val instanceof Error) {
              return `${val.name}: ${val.message}\n${val.stack}`;
          }
          // TODO we could test for more things here, like `Set`s and `Map`s.
          return className;
      }
  
      function makeMutClosure(arg0, arg1, dtor, f) {
          const state = { a: arg0, b: arg1, cnt: 1, dtor };
          const real = (...args) => {
              // 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++;
              const a = state.a;
              state.a = 0;
              try {
                  return f(a, state.b, ...args);
              } finally {
                  if (--state.cnt === 0) {
                      wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
  
                  } else {
                      state.a = a;
                  }
              }
          };
          real.original = state;
  
          return real;
      }
  
      function logError(f, args) {
          try {
              return f.apply(this, args);
          } catch (e) {
              let error = (function () {
                  try {
                      return e instanceof Error ? `${e.message}\n\nStack:\n${e.stack}` : e.toString();
                  } catch(_) {
                      return "<failed to stringify thrown value>";
                  }
              }());
              console.error("wasm-bindgen: imported JS function that was not marked as `catch` threw an error:", error);
              throw e;
          }
      }
  
      function _assertNum(n) {
          if (typeof(n) !== 'number') throw new Error('expected a number argument');
      }
  
      let stack_pointer = 32;
  
      function addBorrowedObject(obj) {
          if (stack_pointer == 1) throw new Error('out of js stack');
          heap[--stack_pointer] = obj;
          return stack_pointer;
      }
      function __wbg_adapter_20(arg0, arg1, arg2) {
          try {
              _assertNum(arg0);
              _assertNum(arg1);
              wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__he8daf73c2cea8cb0(arg0, arg1, addBorrowedObject(arg2));
          } finally {
              heap[stack_pointer++] = undefined;
          }
      }
  
      function __wbg_adapter_23(arg0, arg1, arg2) {
          _assertNum(arg0);
          _assertNum(arg1);
          wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h8f0d3c26ea6c70e1(arg0, arg1, addHeapObject(arg2));
      }
  
      function getCachedStringFromWasm0(ptr, len) {
          if (ptr === 0) {
              return getObject(len);
          } else {
              return getStringFromWasm0(ptr, len);
          }
      }
  
      function isLikeNone(x) {
          return x === undefined || x === null;
      }
  
      function handleError(f, args) {
          try {
              return f.apply(this, args);
          } catch (e) {
              wasm.__wbindgen_exn_store(addHeapObject(e));
          }
      }
  
      async function load(module, imports) {
          if (typeof Response === 'function' && module instanceof 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;
                      }
                  }
              }
  
              const bytes = await module.arrayBuffer();
              return await WebAssembly.instantiate(bytes, imports);
  
          } else {
              const instance = await WebAssembly.instantiate(module, imports);
  
              if (instance instanceof WebAssembly.Instance) {
                  return { instance, module };
  
              } else {
                  return instance;
              }
          }
      }
  
      async function init(input) {
          if (typeof input === 'undefined') {
              input = new URL('index_bg.wasm', (document.currentScript && document.currentScript.src || new URL('index.js', document.baseURI).href));
          }
          const imports = {};
          imports.wbg = {};
          imports.wbg.__wbindgen_json_serialize = function(arg0, arg1) {
              const obj = getObject(arg1);
              var ret = JSON.stringify(obj === undefined ? null : obj);
              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_string_new = function(arg0, arg1) {
              var ret = getStringFromWasm0(arg0, arg1);
              return addHeapObject(ret);
          };
          imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
              var ret = getObject(arg0);
              return addHeapObject(ret);
          };
          imports.wbg.__wbg_error_09919627ac0992f5 = function() { return logError(function (arg0, arg1) {
              var v0 = getCachedStringFromWasm0(arg0, arg1);
          if (arg0 !== 0) { wasm.__wbindgen_free(arg0, arg1); }
          console.error(v0);
      }, arguments) };
      imports.wbg.__wbg_new_693216e109162396 = function() { return logError(function () {
          var ret = new Error();
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_stack_0ddaca5d1abfb52f = function() { return logError(function (arg0, arg1) {
          var ret = getObject(arg1).stack;
          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;
      }, arguments) };
      imports.wbg.__wbg_addevent_66db3d105a9795d9 = function() { return logError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          add_event(getObject(arg0), v0, arg3 !== 0, arg4 !== 0, getObject(arg5));
      }, arguments) };
      imports.wbg.__wbg_removeevent_1e1f62952bbff820 = function() { return logError(function (arg0, arg1, arg2, arg3, arg4) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          remove_event(getObject(arg0), v0, arg3 !== 0, getObject(arg4));
      }, arguments) };
      imports.wbg.__wbindgen_cb_drop = function(arg0) {
          const obj = takeObject(arg0).original;
          if (obj.cnt-- == 1) {
              obj.a = 0;
              return true;
          }
          var ret = false;
          _assertBoolean(ret);
          return ret;
      };
      imports.wbg.__wbg_instanceof_Window_c4b70662a0d2c5ec = function() { return logError(function (arg0) {
          var ret = getObject(arg0) instanceof Window;
          _assertBoolean(ret);
          return ret;
      }, arguments) };
      imports.wbg.__wbg_document_1c64944725c0d81d = function() { return logError(function (arg0) {
          var ret = getObject(arg0).document;
          return isLikeNone(ret) ? 0 : addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_location_f98ad02632f88c43 = function() { return logError(function (arg0) {
          var ret = getObject(arg0).location;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_history_3ac8f1466e0c0528 = function() { return handleError(function (arg0) {
          var ret = getObject(arg0).history;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_fetch_cfe0d1dd786e9cd4 = function() { return logError(function (arg0, arg1) {
          var ret = getObject(arg0).fetch(getObject(arg1));
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_body_78ae4fd43b446013 = function() { return logError(function (arg0) {
          var ret = getObject(arg0).body;
          return isLikeNone(ret) ? 0 : addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_head_d205ec9bd59f31a7 = function() { return logError(function (arg0) {
          var ret = getObject(arg0).head;
          return isLikeNone(ret) ? 0 : addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_createElement_86c152812a141a62 = function() { return handleError(function (arg0, arg1, arg2) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          var ret = getObject(arg0).createElement(v0);
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_createTextNode_365db3bc3d0523ab = function() { return logError(function (arg0, arg1, arg2) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          var ret = getObject(arg0).createTextNode(v0);
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_length_1ac7ec4672c36486 = function() { return logError(function (arg0) {
          var ret = getObject(arg0).length;
          _assertNum(ret);
          return ret;
      }, arguments) };
      imports.wbg.__wbg_get_04c5c697dff89315 = function() { return logError(function (arg0, arg1) {
          var ret = getObject(arg0)[arg1 >>> 0];
          return isLikeNone(ret) ? 0 : addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_headers_4764f5445b6a6c89 = function() { return logError(function (arg0) {
          var ret = getObject(arg0).headers;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_newwithstrandinit_9b0fa00478c37287 = function() { return handleError(function (arg0, arg1, arg2) {
          var v0 = getCachedStringFromWasm0(arg0, arg1);
          var ret = new Request(v0, getObject(arg2));
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_cssRules_b9ce8ac851304351 = function() { return handleError(function (arg0) {
          var ret = getObject(arg0).cssRules;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_insertRule_e5808a97c0c5ecbe = function() { return handleError(function (arg0, arg1, arg2, arg3) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          var ret = getObject(arg0).insertRule(v0, arg3 >>> 0);
          _assertNum(ret);
          return ret;
      }, arguments) };
      imports.wbg.__wbg_style_fcef2171d2192afa = function() { return logError(function (arg0) {
          var ret = getObject(arg0).style;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_pushState_f772e11155235e9c = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
          var v0 = getCachedStringFromWasm0(arg2, arg3);
          var v1 = getCachedStringFromWasm0(arg4, arg5);
          getObject(arg0).pushState(getObject(arg1), v0, v1);
      }, arguments) };
      imports.wbg.__wbg_settype_f777a49b612d94f0 = function() { return logError(function (arg0, arg1, arg2) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          getObject(arg0).type = v0;
      }, arguments) };
      imports.wbg.__wbg_sheet_6b235d2f91d4d2c1 = function() { return logError(function (arg0) {
          var ret = getObject(arg0).sheet;
          return isLikeNone(ret) ? 0 : addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_href_6561bfe6ed15034d = function() { return handleError(function (arg0, arg1) {
          var ret = getObject(arg1).href;
          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;
      }, arguments) };
      imports.wbg.__wbg_appendChild_d318db34c4559916 = function() { return handleError(function (arg0, arg1) {
          var ret = getObject(arg0).appendChild(getObject(arg1));
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_setclassName_7e8ab705edf23973 = function() { return logError(function (arg0, arg1, arg2) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          getObject(arg0).className = v0;
      }, arguments) };
      imports.wbg.__wbg_classList_b666640fdfbcc8ab = function() { return logError(function (arg0) {
          var ret = getObject(arg0).classList;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_setAttribute_1b533bf07966de55 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          var v1 = getCachedStringFromWasm0(arg3, arg4);
          getObject(arg0).setAttribute(v0, v1);
      }, arguments) };
      imports.wbg.__wbg_instanceof_HtmlElement_df66c8b4a687aa43 = function() { return logError(function (arg0) {
          var ret = getObject(arg0) instanceof HTMLElement;
          _assertBoolean(ret);
          return ret;
      }, arguments) };
      imports.wbg.__wbg_style_c88e323890d3a091 = function() { return logError(function (arg0) {
          var ret = getObject(arg0).style;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_log_3445347661d4505e = function() { return logError(function (arg0) {
          console.log(getObject(arg0));
      }, arguments) };
      imports.wbg.__wbg_getPropertyValue_a3980b6b5e7fd8a9 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
          var v0 = getCachedStringFromWasm0(arg2, arg3);
          var ret = getObject(arg1).getPropertyValue(v0);
          var ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
          var len1 = WASM_VECTOR_LEN;
          getInt32Memory0()[arg0 / 4 + 1] = len1;
          getInt32Memory0()[arg0 / 4 + 0] = ptr1;
      }, arguments) };
      imports.wbg.__wbg_removeProperty_150229ec3a3550ad = function() { return handleError(function (arg0, arg1, arg2, arg3) {
          var v0 = getCachedStringFromWasm0(arg2, arg3);
          var ret = getObject(arg1).removeProperty(v0);
          var ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
          var len1 = WASM_VECTOR_LEN;
          getInt32Memory0()[arg0 / 4 + 1] = len1;
          getInt32Memory0()[arg0 / 4 + 0] = ptr1;
      }, arguments) };
      imports.wbg.__wbg_setProperty_389eb1a127ad49a5 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          var v1 = getCachedStringFromWasm0(arg3, arg4);
          var v2 = getCachedStringFromWasm0(arg5, arg6);
          getObject(arg0).setProperty(v0, v1, v2);
      }, arguments) };
      imports.wbg.__wbg_set_5357fedb30848723 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          var v1 = getCachedStringFromWasm0(arg3, arg4);
          getObject(arg0).set(v0, v1);
      }, arguments) };
      imports.wbg.__wbg_instanceof_Response_e1b11afbefa5b563 = function() { return logError(function (arg0) {
          var ret = getObject(arg0) instanceof Response;
          _assertBoolean(ret);
          return ret;
      }, arguments) };
      imports.wbg.__wbg_json_88cc6d5cf8f61121 = function() { return handleError(function (arg0) {
          var ret = getObject(arg0).json();
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_hash_603da0097048f9b2 = function() { return logError(function (arg0, arg1) {
          var ret = getObject(arg1).hash;
          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;
      }, arguments) };
      imports.wbg.__wbg_new_3f48783ae4f87f8f = function() { return handleError(function (arg0, arg1) {
          var v0 = getCachedStringFromWasm0(arg0, arg1);
          var ret = new URL(v0);
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_add_f36d97e1d70d27b0 = function() { return handleError(function (arg0, arg1, arg2) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          getObject(arg0).add(v0);
      }, arguments) };
      imports.wbg.__wbg_remove_89670e56a41482a8 = function() { return handleError(function (arg0, arg1, arg2) {
          var v0 = getCachedStringFromWasm0(arg1, arg2);
          getObject(arg0).remove(v0);
      }, arguments) };
      imports.wbg.__wbg_newnoargs_be86524d73f67598 = function() { return logError(function (arg0, arg1) {
          var v0 = getCachedStringFromWasm0(arg0, arg1);
          var ret = new Function(v0);
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_call_888d259a5fefc347 = function() { return handleError(function (arg0, arg1) {
          var ret = getObject(arg0).call(getObject(arg1));
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_new_0b83d3df67ecb33e = function() { return logError(function () {
          var ret = new Object();
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_resolve_d23068002f584f22 = function() { return logError(function (arg0) {
          var ret = Promise.resolve(getObject(arg0));
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_then_2fcac196782070cc = function() { return logError(function (arg0, arg1) {
          var ret = getObject(arg0).then(getObject(arg1));
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_then_8c2d62e8ae5978f7 = function() { return logError(function (arg0, arg1, arg2) {
          var ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_globalThis_3f735a5746d41fbd = function() { return handleError(function () {
          var ret = globalThis.globalThis;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_self_c6fbdfc2918d5e58 = function() { return handleError(function () {
          var ret = self.self;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_window_baec038b5ab35c54 = function() { return handleError(function () {
          var ret = window.window;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbg_global_1bc0b39582740e95 = function() { return handleError(function () {
          var ret = global.global;
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbindgen_is_undefined = function(arg0) {
          var ret = getObject(arg0) === undefined;
          _assertBoolean(ret);
          return ret;
      };
      imports.wbg.__wbg_set_82a4e8a85e31ac42 = function() { return handleError(function (arg0, arg1, arg2) {
          var ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
          _assertBoolean(ret);
          return ret;
      }, arguments) };
      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_object_drop_ref = function(arg0) {
          takeObject(arg0);
      };
      imports.wbg.__wbindgen_throw = function(arg0, arg1) {
          throw new Error(getStringFromWasm0(arg0, arg1));
      };
      imports.wbg.__wbindgen_rethrow = function(arg0) {
          throw takeObject(arg0);
      };
      imports.wbg.__wbindgen_closure_wrapper1996 = function() { return logError(function (arg0, arg1, arg2) {
          var ret = makeMutClosure(arg0, arg1, 87, __wbg_adapter_20);
          return addHeapObject(ret);
      }, arguments) };
      imports.wbg.__wbindgen_closure_wrapper2546 = function() { return logError(function (arg0, arg1, arg2) {
          var ret = makeMutClosure(arg0, arg1, 105, __wbg_adapter_23);
          return addHeapObject(ret);
      }, arguments) };
  
      if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
          input = fetch(input);
      }
  
  
  
      const { instance, module } = await load(await input, imports);
  
      wasm = instance.exports;
      init.__wbindgen_wasm_module = module;
      wasm.__wbindgen_start();
      return wasm;
      }
  
      init("js/assets/MyDiet-47c5c616.wasm").catch(console.error);
  
  })();
  //# sourceMappingURL=index.js.map
  