text: let wasm;
  const { TextDecoder } = require(String.raw`util`);
  
  const heap = new Array(32);
  
  heap.fill(undefined);
  
  heap.push(undefined, null, true, false);
  
  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 getObject(idx) { return heap[idx]; }
  
  let heap_next = heap.length;
  
  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;
  }
  /**
  * @param {any} value
  * @returns {any}
  */
  module.exports.load_resource_to_js = function(value) {
      try {
          const ret = wasm.load_resource_to_js(addBorrowedObject(value));
          return takeObject(ret);
      } finally {
          heap[stack_pointer++] = undefined;
      }
  };
  
  let WASM_VECTOR_LEN = 0;
  
  let cachegetNodeBufferMemory = null;
  function getNodeBufferMemory() {
      if (cachegetNodeBufferMemory === null || cachegetNodeBufferMemory.buffer !== wasm.memory.buffer) {
          cachegetNodeBufferMemory = Buffer.from(wasm.memory.buffer);
      }
      return cachegetNodeBufferMemory;
  }
  
  function passStringToWasm(arg) {
  
      const size = Buffer.byteLength(arg);
      const ptr = wasm.__wbindgen_malloc(size);
      getNodeBufferMemory().write(arg, ptr, size);
      WASM_VECTOR_LEN = size;
      return ptr;
  }
  
  let cachegetInt32Memory = null;
  function getInt32Memory() {
      if (cachegetInt32Memory === null || cachegetInt32Memory.buffer !== wasm.memory.buffer) {
          cachegetInt32Memory = new Int32Array(wasm.memory.buffer);
      }
      return cachegetInt32Memory;
  }
  
  let cachedTextDecoder = new TextDecoder('utf-8');
  
  let cachegetUint8Memory = null;
  function getUint8Memory() {
      if (cachegetUint8Memory === null || cachegetUint8Memory.buffer !== wasm.memory.buffer) {
          cachegetUint8Memory = new Uint8Array(wasm.memory.buffer);
      }
      return cachegetUint8Memory;
  }
  
  function getStringFromWasm(ptr, len) {
      return cachedTextDecoder.decode(getUint8Memory().subarray(ptr, ptr + len));
  }
  
  function addHeapObject(obj) {
      if (heap_next === heap.length) heap.push(heap.length + 1);
      const idx = heap_next;
      heap_next = heap[idx];
  
      heap[idx] = obj;
      return idx;
  }
  
  module.exports.__wbindgen_json_serialize = function(arg0, arg1) {
      const ret = JSON.stringify(getObject(arg1));
      const ret0 = passStringToWasm(ret);
      const ret1 = WASM_VECTOR_LEN;
      getInt32Memory()[arg0 / 4 + 0] = ret0;
      getInt32Memory()[arg0 / 4 + 1] = ret1;
  };
  
  module.exports.__wbg_log_a00b613c13e28fc4 = function(arg0, arg1) {
      console.log(getStringFromWasm(arg0, arg1));
  };
  
  module.exports.__wbindgen_json_parse = function(arg0, arg1) {
      const ret = JSON.parse(getStringFromWasm(arg0, arg1));
      return addHeapObject(ret);
  };
  wasm = require('./runtime_engine_bg');
  
  