text: 
  // Bindings utilities
  
  function WrapperObject() {
  }
  WrapperObject.prototype = Object.create(WrapperObject.prototype);
  WrapperObject.prototype.constructor = WrapperObject;
  WrapperObject.prototype.__class__ = WrapperObject;
  WrapperObject.__cache__ = {};
  Module['WrapperObject'] = WrapperObject;
  
  function getCache(__class__) {
    return (__class__ || WrapperObject).__cache__;
  }
  Module['getCache'] = getCache;
  
  function wrapPointer(ptr, __class__) {
    var cache = getCache(__class__);
    var ret = cache[ptr];
    if (ret) return ret;
    ret = Object.create((__class__ || WrapperObject).prototype);
    ret.ptr = ptr;
    return cache[ptr] = ret;
  }
  Module['wrapPointer'] = wrapPointer;
  
  function castObject(obj, __class__) {
    return wrapPointer(obj.ptr, __class__);
  }
  Module['castObject'] = castObject;
  
  Module['NULL'] = wrapPointer(0);
  
  function destroy(obj) {
    if (!obj['__destroy__']) throw 'Error: Cannot destroy object. (Did you create it yourself?)';
    obj['__destroy__']();
    // Remove from cache, so the object can be GC'd and refs added onto it released
    delete getCache(obj.__class__)[obj.ptr];
  }
  Module['destroy'] = destroy;
  
  function compare(obj1, obj2) {
    return obj1.ptr === obj2.ptr;
  }
  Module['compare'] = compare;
  
  function getPointer(obj) {
    return obj.ptr;
  }
  Module['getPointer'] = getPointer;
  
  function getClass(obj) {
    return obj.__class__;
  }
  Module['getClass'] = getClass;
  
  // Converts big (string or array) values into a C-style storage, in temporary space
  
  var ensureCache = {
    buffer: 0,  // the main buffer of temporary storage
    size: 0,   // the size of buffer
    pos: 0,    // the next free offset in buffer
    temps: [], // extra allocations
    needed: 0, // the total size we need next time
  
    prepare: function() {
      if (ensureCache.needed) {
        // clear the temps
        for (var i = 0; i < ensureCache.temps.length; i++) {
          Module['_free'](ensureCache.temps[i]);
        }
        ensureCache.temps.length = 0;
        // prepare to allocate a bigger buffer
        Module['_free'](ensureCache.buffer);
        ensureCache.buffer = 0;
        ensureCache.size += ensureCache.needed;
        // clean up
        ensureCache.needed = 0;
      }
      if (!ensureCache.buffer) { // happens first time, or when we need to grow
        ensureCache.size += 128; // heuristic, avoid many small grow events
        ensureCache.buffer = Module['_malloc'](ensureCache.size);
        assert(ensureCache.buffer);
      }
      ensureCache.pos = 0;
    },
    alloc: function(array, view) {
      assert(ensureCache.buffer);
      var bytes = view.BYTES_PER_ELEMENT;
      var len = array.length * bytes;
      len = (len + 7) & -8; // keep things aligned to 8 byte boundaries
      var ret;
      if (ensureCache.pos + len >= ensureCache.size) {
        // we failed to allocate in the buffer, ensureCache time around :(
        assert(len > 0); // null terminator, at least
        ensureCache.needed += len;
        ret = Module['_malloc'](len);
        ensureCache.temps.push(ret);
      } else {
        // we can allocate in the buffer
        ret = ensureCache.buffer + ensureCache.pos;
        ensureCache.pos += len;
      }
      return ret;
    },
    copy: function(array, view, offset) {
      var offsetShifted = offset;
      var bytes = view.BYTES_PER_ELEMENT;
      switch (bytes) {
        case 2: offsetShifted >>= 1; break;
        case 4: offsetShifted >>= 2; break;
        case 8: offsetShifted >>= 3; break;
      }
      for (var i = 0; i < array.length; i++) {
        view[offsetShifted + i] = array[i];
      }
    },
  };
  
  function ensureString(value) {
    if (typeof value === 'string') {
      var intArray = intArrayFromString(value);
      var offset = ensureCache.alloc(intArray, HEAP8);
      ensureCache.copy(intArray, HEAP8, offset);
      return offset;
    }
    return value;
  }
  function ensureInt8(value) {
    if (typeof value === 'object') {
      var offset = ensureCache.alloc(value, HEAP8);
      ensureCache.copy(value, HEAP8, offset);
      return offset;
    }
    return value;
  }
  function ensureInt16(value) {
    if (typeof value === 'object') {
      var offset = ensureCache.alloc(value, HEAP16);
      ensureCache.copy(value, HEAP16, offset);
      return offset;
    }
    return value;
  }
  function ensureInt32(value) {
    if (typeof value === 'object') {
      var offset = ensureCache.alloc(value, HEAP32);
      ensureCache.copy(value, HEAP32, offset);
      return offset;
    }
    return value;
  }
  function ensureFloat32(value) {
    if (typeof value === 'object') {
      var offset = ensureCache.alloc(value, HEAPF32);
      ensureCache.copy(value, HEAPF32, offset);
      return offset;
    }
    return value;
  }
  function ensureFloat64(value) {
    if (typeof value === 'object') {
      var offset = ensureCache.alloc(value, HEAPF64);
      ensureCache.copy(value, HEAPF64, offset);
      return offset;
    }
    return value;
  }
  
  
  // WebIDL
  /** @suppress {undefinedVars, duplicate} */function WebIDL(arg0, arg1) {
    if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
    if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
    this.ptr = _emscripten_bind_WebIDL_WebIDL_2(arg0, arg1);
    getCache(WebIDL)[this.ptr] = this;
  };;
  WebIDL.prototype = Object.create(WrapperObject.prototype);
  WebIDL.prototype.constructor = WebIDL;
  WebIDL.prototype.__class__ = WebIDL;
  WebIDL.__cache__ = {};
  Module['WebIDL'] = WebIDL;
  
  WebIDL.prototype['getValueXByValue'] = WebIDL.prototype.getValueXByValue = /** @suppress {undefinedVars, duplicate} */function() {
    var self = this.ptr;
    return _emscripten_bind_WebIDL_getValueXByValue_0(self);
  };;
  
  WebIDL.prototype['passThroughByReference'] = WebIDL.prototype.passThroughByReference = /** @suppress {undefinedVars, duplicate} */function(arg0) {
    var self = this.ptr;
    if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
    return wrapPointer(_emscripten_bind_WebIDL_passThroughByReference_1(self, arg0), WebIDL);
  };;
  
    WebIDL.prototype['get_x'] = WebIDL.prototype.get_x = /** @suppress {undefinedVars, duplicate} */function() {
    var self = this.ptr;
    return _emscripten_bind_WebIDL_get_x_0(self);
  };
    WebIDL.prototype['get_y'] = WebIDL.prototype.get_y = /** @suppress {undefinedVars, duplicate} */function() {
    var self = this.ptr;
    return _emscripten_bind_WebIDL_get_y_0(self);
  };
      WebIDL.prototype['set_y'] = WebIDL.prototype.set_y = /** @suppress {undefinedVars, duplicate} */function(arg0) {
    var self = this.ptr;
    if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
    _emscripten_bind_WebIDL_set_y_1(self, arg0);
  };
    WebIDL.prototype['__destroy__'] = WebIDL.prototype.__destroy__ = /** @suppress {undefinedVars, duplicate} */function() {
    var self = this.ptr;
    _emscripten_bind_WebIDL___destroy___0(self);
  };
  // VoidPtr
  function VoidPtr() { throw "cannot construct a VoidPtr, no constructor in IDL" }
  VoidPtr.prototype = Object.create(WrapperObject.prototype);
  VoidPtr.prototype.constructor = VoidPtr;
  VoidPtr.prototype.__class__ = VoidPtr;
  VoidPtr.__cache__ = {};
  Module['VoidPtr'] = VoidPtr;
  
    VoidPtr.prototype['__destroy__'] = VoidPtr.prototype.__destroy__ = /** @suppress {undefinedVars, duplicate} */function() {
    var self = this.ptr;
    _emscripten_bind_VoidPtr___destroy___0(self);
  };
  (function() {
    function setupEnums() {
      
    }
    if (Module['calledRun']) setupEnums();
    else addOnPreMain(setupEnums);
  })();
  