Function bodies 165 total

      get_caught() {
        return HEAP8[this.ptr + 12 >>> 0] != 0
      }

      set_rethrown(rethrown) {
        rethrown = rethrown ? 1 : 0;
        HEAP8[this.ptr + 13 >>> 0] = rethrown
      }

      get_rethrown() {
        return HEAP8[this.ptr + 13 >>> 0] != 0
      }

      init(type, destructor) {
        this.set_adjusted_ptr(0);
        this.set_type(type);
        this.set_destructor(destructor)
      }

      set_adjusted_ptr(adjustedPtr) {
        HEAPU32[this.ptr + 16 >>> 2 >>> 0] = adjustedPtr
      }

      get_adjusted_ptr() {
        return HEAPU32[this.ptr + 16 >>> 2 >>> 0]
      }

    function ___cxa_throw(ptr, type, destructor) {
      ptr >>>= 0;
      type >>>= 0;
      destructor >>>= 0;
      var info = new ExceptionInfo(ptr);
      info.init(type, destructor);
      exceptionLast = ptr;
      uncaughtExceptionCount++;
      throw exceptionLast
    }

    function readPointer(pointer) {
      return this['fromWireType'](HEAPU32[pointer >>> 2 >>> 0])
    }

        class InternalError extends Error {
      constructor(message) {
        super(message);
        this.name = 'InternalError'
      }
    };

      constructor(message) {
        super(message);
        this.name = 'InternalError'
      }

          function onComplete(typeConverters) {
            var myTypeConverters = getTypeConverters(typeConverters);
            if (myTypeConverters.length !== myTypes.length) {
              throwInternalError('Mismatched type converter count')
            }
            for (var i = 0; i < myTypes.length; ++i) {
              registerType(myTypes[i], myTypeConverters[i])
            }
          }

        class BindingError extends Error {
      constructor(message) {
        super(message);
        this.name = 'BindingError'
      }
    };

      constructor(message) {
        super(message);
        this.name = 'BindingError'
      }

    function sharedRegisterType(rawType, registeredInstance, options = {}) {
      var name = registeredInstance.name;
      if (!rawType) {
        throwBindingError(
            `type "${name}" must have a positive integer typeid pointer`)
      }
      if (registeredTypes.hasOwnProperty(rawType)) {
        if (options.ignoreDuplicateRegistrations) {
          return
        } else {
          throwBindingError(`Cannot register type '${name}' twice`)
        }
      }
      registeredTypes[rawType] = registeredInstance;
      delete typeDependencies[rawType];
      if (awaitingDependencies.hasOwnProperty(rawType)) {
        var callbacks = awaitingDependencies[rawType];
        delete awaitingDependencies[rawType];
        callbacks.forEach(cb => cb())
      }
    }

    function registerType(rawType, registeredInstance, options = {}) {
      return sharedRegisterType(rawType, registeredInstance, options)
    }

    function __embind_register_bigint(
        primitiveType, name, size, minRange, maxRange) {
      primitiveType >>>= 0;
      name >>>= 0;
      size >>>= 0;
      name = readLatin1String(name);
      var isUnsignedType = name.indexOf('u') != -1;
      if (isUnsignedType) {
        maxRange = (1n << 64n) - 1n
      }
      registerType(primitiveType, {
        name,
        fromWireType: value => value,
        toWireType: function(destructors, value) {
          if (typeof value != 'bigint' && typeof value != 'number') {
            throw new TypeError(
                `Cannot convert "${embindRepr(value)}" to ${this.name}`)
          }
          if (typeof value == 'number') {
            value = BigInt(value)
          }
          return value
        },
        argPackAdvance: GenericWireTypeSize,
        readValueFromPointer:
            integerReadValueFromPointer(name, size, !isUnsignedType),
        destructorFunction: null
      })
    }

    function __embind_register_bool(rawType, name, trueValue, falseValue) {
      rawType >>>= 0;
      name >>>= 0;
      name = readLatin1String(name);
      registerType(rawType, {
        name,
        fromWireType: function(wt) {
          return !!wt
        },
        toWireType: function(destructors, o) {
          return o ? trueValue : falseValue
        },
        argPackAdvance: GenericWireTypeSize,
        readValueFromPointer: function(pointer) {
          return this['fromWireType'](HEAPU8[pointer >>> 0])
        },
        destructorFunction: null
      })
    }

      function getInstanceTypeName(handle) {
        return handle.$$.ptrType.registeredClass.name
      }

    function RegisteredClass(
        name, constructor, instancePrototype, rawDestructor, baseClass,
        getActualType, upcast, downcast) {
      this.name = name;
      this.constructor = constructor;
      this.instancePrototype = instancePrototype;
      this.rawDestructor = rawDestructor;
      this.baseClass = baseClass;
      this.getActualType = getActualType;
      this.upcast = upcast;
      this.downcast = downcast;
      this.pureVirtualFunctions = []
    }

    function constNoSmartPtrRawPointerToWireType(destructors, handle) {
      if (handle === null) {
        if (this.isReference) {
          throwBindingError(`null is not a valid ${this.name}`)
        }
        return 0
      }
      if (!handle.$$) {
        throwBindingError(
            `Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
      }
      if (!handle.$$.ptr) {
        throwBindingError(
            `Cannot pass deleted object as a pointer of type ${this.name}`)
      }
      var handleClass = handle.$$.ptrType.registeredClass;
      var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
      return ptr
    }

    function genericPointerToWireType(destructors, handle) {
      var ptr;
      if (handle === null) {
        if (this.isReference) {
          throwBindingError(`null is not a valid ${this.name}`)
        }
        if (this.isSmartPointer) {
          ptr = this.rawConstructor();
          if (destructors !== null) {
            destructors.push(this.rawDestructor, ptr)
          }
          return ptr
        } else {
          return 0
        }
      }
      if (!handle || !handle.$$) {
        throwBindingError(
            `Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
      }
      if (!handle.$$.ptr) {
        throwBindingError(
            `Cannot pass deleted object as a pointer of type ${this.name}`)
      }
      if (!this.isConst && handle.$$.ptrType.isConst) {
        throwBindingError(`Cannot convert argument of type ${
            handle.$$.smartPtrType ?
                handle.$$.smartPtrType.name :
                handle.$$.ptrType.name} to parameter type

    function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
      if (handle === null) {
        if (this.isReference) {
          throwBindingError(`null is not a valid ${this.name}`)
        }
        return 0
      }
      if (!handle.$$) {
        throwBindingError(
            `Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
      }
      if (!handle.$$.ptr) {
        throwBindingError(
            `Cannot pass deleted object as a pointer of type ${this.name}`)
      }
      if (handle.$$.ptrType.isConst) {
        throwBindingError(`Cannot convert argument of type ${
            handle.$$.ptrType.name} to parameter type ${this.name}`)
      }
      var handleClass = handle.$$.ptrType.registeredClass;
      var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
      return ptr
    }

    function RegisteredPointer_fromWireType(ptr) {
      var rawPointer = this.getPointee(ptr);
      if (!rawPointer) {
        this.destructor(ptr);
        return null
      }
      var registeredInstance =
          getInheritedInstance(this.registeredClass, rawPointer);
      if (undefined !== registeredInstance) {
        if (0 === registeredInstance.$$.count.value) {
          registeredInstance.$$.ptr = rawPointer;
          registeredInstance.$$.smartPtr = ptr;
          return registeredInstance['clone']()
        } else {
          var rv = registeredInstance['clone']();
          this.destructor(ptr);
          return rv
        }
      }
      function makeDefaultHandle() {
        if (this.isSmartPointer) {
          return makeClassHandle(this.registeredClass.instancePrototype, {
            ptrType: this.pointeeType,
            ptr: rawPointer,
            smartPtrType: this,
            smartPtr: ptr
          })
        } else {
          return makeClassHandle(
    

      function makeDefaultHandle() {
        if (this.isSmartPointer) {
          return makeClassHandle(this.registeredClass.instancePrototype, {
            ptrType: this.pointeeType,
            ptr: rawPointer,
            smartPtrType: this,
            smartPtr: ptr
          })
        } else {
          return makeClassHandle(
              this.registeredClass.instancePrototype, {ptrType: this, ptr})
        }
      }

    function RegisteredPointer(
        name, registeredClass, isReference, isConst, isSmartPointer,
        pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare,
        rawDestructor) {
      this.name = name;
      this.registeredClass = registeredClass;
      this.isReference = isReference;
      this.isConst = isConst;
      this.isSmartPointer = isSmartPointer;
      this.pointeeType = pointeeType;
      this.sharingPolicy = sharingPolicy;
      this.rawGetPointee = rawGetPointee;
      this.rawConstructor = rawConstructor;
      this.rawShare = rawShare;
      this.rawDestructor = rawDestructor;
      if (!isSmartPointer && registeredClass.baseClass === undefined) {
        if (isConst) {
          this['toWireType'] = constNoSmartPtrRawPointerToWireType;
          this.destructorFunction = null
        } else {
          this['toWireType'] = nonConstNoSmartPtrRawPointerToWireType;
          this.destructorFunction = null
        }
      } else {
        this['toW

      function makeDynCaller() {
        if (signature.includes('p')) {
          return getDynCaller(signature, rawFunction, isAsync)
        }
        var rtn = getWasmTableEntry(rawFunction);
        return rtn
      }

      function visit(type) {
        if (seen[type]) {
          return
        }
        if (registeredTypes[type]) {
          return
        }
        if (typeDependencies[type]) {
          typeDependencies[type].forEach(visit);
          return
        }
        unboundTypes.push(type);
        seen[type] = true
      }

    function __embind_register_class(
        rawType, rawPointerType, rawConstPointerType, baseClassRawType,
        getActualTypeSignature, getActualType, upcastSignature, upcast,
        downcastSignature, downcast, name, destructorSignature, rawDestructor) {
      rawType >>>= 0;
      rawPointerType >>>= 0;
      rawConstPointerType >>>= 0;
      baseClassRawType >>>= 0;
      getActualTypeSignature >>>= 0;
      getActualType >>>= 0;
      upcastSignature >>>= 0;
      upcast >>>= 0;
      downcastSignature >>>= 0;
      downcast >>>= 0;
      name >>>= 0;
      destructorSignature >>>= 0;
      rawDestructor >>>= 0;
      name = readLatin1String(name);
      getActualType =
          embind__requireFunction(getActualTypeSignature, getActualType);
      upcast &&= embind__requireFunction(upcastSignature, upcast);
      downcast &&= embind__requireFunction(downcastSignature, downcast);
      rawDestructor =
          embind__requireFunction(destructorSignature, rawDestructor);
   

    function usesDestructorStack(argTypes) {
      for (var i = 1; i < argTypes.length; ++i) {
        if (argTypes[i] !== null &&
            argTypes[i].destructorFunction === undefined) {
          return true
        }
      }
      return false
    }

    function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
      var needsDestructorStack = usesDestructorStack(argTypes);
      var argCount = argTypes.length - 2;
      var argsList = [];
      var argsListWired = ['fn'];
      if (isClassMethodFunc) {
        argsListWired.push('thisWired')
      }
      for (var i = 0; i < argCount; ++i) {
        argsList.push(`arg${i}`);
        argsListWired.push(`arg${i}Wired`)
      }
      argsList = argsList.join(',');
      argsListWired = argsListWired.join(',');
      var invokerFnBody = `return function (${argsList}) {\n`;
      if (needsDestructorStack) {
        invokerFnBody += 'var destructors = [];\n'
      }
      var dtorStack = needsDestructorStack ? 'destructors' : 'null';
      var args1 = [
        'humanName', 'throwBindingError', 'invoker', 'fn', 'runDestructors',
        'retType', 'classParam'
      ];
      if (isClassMethodFunc) {
        invokerFnBody +=
            `var thisWired = classParam['toWire

    function craftInvokerFunction(
        humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc,
        isAsync) {
      var argCount = argTypes.length;
      if (argCount < 2) {
        throwBindingError(
            'argTypes array size mismatch! Must at least get return value and \'this\' types!')
      }
      var isClassMethodFunc = argTypes[1] !== null && classType !== null;
      var needsDestructorStack = usesDestructorStack(argTypes);
      var returns = argTypes[0].name !== 'void';
      var closureArgs = [
        humanName, throwBindingError, cppInvokerFunc, cppTargetFunc,
        runDestructors, argTypes[0], argTypes[1]
      ];
      for (var i = 0; i < argCount - 2; ++i) {
        closureArgs.push(argTypes[i + 2])
      }
      if (!needsDestructorStack) {
        for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
          if (argTypes[i].destructorFunction !== null) {
            closureArgs.push(argTypes[i].destructorFunction)
          }
  

        function unboundTypesHandler() {
          throwUnboundTypeError(
              `Cannot call ${humanName} due to unbound types`, rawArgTypes)
        }

    function __emval_decref(handle) {
      handle >>>= 0;
      if (handle > 9 && 0 === --emval_handles[handle + 1]) {
        emval_handles[handle] = undefined;
        emval_freelist.push(handle)
      }
    }

    function __embind_register_emval(rawType) {
      rawType >>>= 0;
      return registerType(rawType, EmValType)
    }

    function __embind_register_enum(rawType, name, size, isSigned) {
      rawType >>>= 0;
      name >>>= 0;
      size >>>= 0;
      name = readLatin1String(name);
      function ctor() {}
      ctor.values = {};
      registerType(rawType, {
        name,
        constructor: ctor,
        fromWireType: function(c) {
          return this.constructor.values[c]
        },
        toWireType: (destructors, c) => c.value,
        argPackAdvance: GenericWireTypeSize,
        readValueFromPointer: enumReadValueFromPointer(name, size, isSigned),
        destructorFunction: null
      });
      exposePublicSymbol(name, ctor)
    }

    function __embind_register_enum_value(rawEnumType, name, enumValue) {
      rawEnumType >>>= 0;
      name >>>= 0;
      var enumType = requireRegisteredType(rawEnumType, 'enum');
      name = readLatin1String(name);
      var Enum = enumType.constructor;
      var Value = Object.create(enumType.constructor.prototype, {
        value: {value: enumValue},
        constructor: {
          value: createNamedFunction(`${enumType.name}_${name}`, function() {})
        }
      });
      Enum.values[enumValue] = Value;
      Enum[name] = Value
    }

    function __embind_register_function(
        name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync,
        isNonnullReturn) {
      name >>>= 0;
      rawArgTypesAddr >>>= 0;
      signature >>>= 0;
      rawInvoker >>>= 0;
      fn >>>= 0;
      var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
      name = readLatin1String(name);
      name = getFunctionName(name);
      rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync);
      exposePublicSymbol(name, function() {
        throwUnboundTypeError(
            `Cannot call ${name} due to unbound types`, argTypes)
      }, argCount - 1);
      whenDependentTypesAreResolved([], argTypes, argTypes => {
        var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
        replacePublicSymbol(
            name,
            craftInvokerFunction(
                name, invokerArgsArray, null, rawInvoker, fn, isAsync),
            argCount - 1);
        return []
      })
    }

    function __embind_register_integer(
        primitiveType, name, size, minRange, maxRange) {
      primitiveType >>>= 0;
      name >>>= 0;
      size >>>= 0;
      name = readLatin1String(name);
      if (maxRange === -1) {
        maxRange = 4294967295
      }
      var fromWireType = value => value;
      if (minRange === 0) {
        var bitshift = 32 - 8 * size;
        fromWireType = value => value << bitshift >>> bitshift
      }
      var isUnsignedType = name.includes('unsigned');
      var checkAssertions = (value, toTypeName) => {};
      var toWireType;
      if (isUnsignedType) {
        toWireType = function(destructors, value) {
          checkAssertions(value, this.name);
          return value >>> 0
        }
      } else {
        toWireType = function(destructors, value) {
          checkAssertions(value, this.name);
          return value
        }
      }
      registerType(primitiveType, {
        name,
        fromWireType,
        toWireType,
        argPack

    function __embind_register_memory_view(rawType, dataTypeIndex, name) {
      rawType >>>= 0;
      name >>>= 0;
      var typeMapping = [
        Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array,
        Float32Array, Float64Array, BigInt64Array, BigUint64Array
      ];
      var TA = typeMapping[dataTypeIndex];
      function decodeMemoryView(handle) {
        var size = HEAPU32[handle >>> 2 >>> 0];
        var data = HEAPU32[handle + 4 >>> 2 >>> 0];
        return new TA(HEAP8.buffer, data, size)
      }
      name = readLatin1String(name);
      registerType(
          rawType, {
            name,
            fromWireType: decodeMemoryView,
            argPackAdvance: GenericWireTypeSize,
            readValueFromPointer: decodeMemoryView
          },
          {ignoreDuplicateRegistrations: true})
    }

      function decodeMemoryView(handle) {
        var size = HEAPU32[handle >>> 2 >>> 0];
        var data = HEAPU32[handle + 4 >>> 2 >>> 0];
        return new TA(HEAP8.buffer, data, size)
      }

    function __embind_register_optional(rawOptionalType, rawType) {
      rawOptionalType >>>= 0;
      rawType >>>= 0;
      registerType(rawOptionalType, EmValOptionalType)
    }

    function __embind_register_std_string(rawType, name) {
      rawType >>>= 0;
      name >>>= 0;
      name = readLatin1String(name);
      var stdStringIsUTF8 = true;
      registerType(rawType, {
        name,
        fromWireType(value) {
          var length = HEAPU32[value >>> 2 >>> 0];
          var payload = value + 4;
          var str;
          if (stdStringIsUTF8) {
            var decodeStartPtr = payload;
            for (var i = 0; i <= length; ++i) {
              var currentBytePtr = payload + i;
              if (i == length || HEAPU8[currentBytePtr >>> 0] == 0) {
                var maxRead = currentBytePtr - decodeStartPtr;
                var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
                if (str === undefined) {
                  str = stringSegment
                } else {
                  str += String.fromCharCode(0);
                  str += stringSegment
                }
                decodeStartPtr = currentBytePtr + 1
         

    function __embind_register_value_object(
        rawType, name, constructorSignature, rawConstructor,
        destructorSignature, rawDestructor) {
      rawType >>>= 0;
      name >>>= 0;
      constructorSignature >>>= 0;
      rawConstructor >>>= 0;
      destructorSignature >>>= 0;
      rawDestructor >>>= 0;
      structRegistrations[rawType] = {
        name: readLatin1String(name),
        rawConstructor:
            embind__requireFunction(constructorSignature, rawConstructor),
        rawDestructor:
            embind__requireFunction(destructorSignature, rawDestructor),
        fields: []
      }
    }

    function __embind_register_value_object_field(
        structType, fieldName, getterReturnType, getterSignature, getter,
        getterContext, setterArgumentType, setterSignature, setter,
        setterContext) {
      structType >>>= 0;
      fieldName >>>= 0;
      getterReturnType >>>= 0;
      getterSignature >>>= 0;
      getter >>>= 0;
      getterContext >>>= 0;
      setterArgumentType >>>= 0;
      setterSignature >>>= 0;
      setter >>>= 0;
      setterContext >>>= 0;
      structRegistrations[structType].fields.push({
        fieldName: readLatin1String(fieldName),
        getterReturnType,
        getter: embind__requireFunction(getterSignature, getter),
        getterContext,
        setterArgumentType,
        setter: embind__requireFunction(setterSignature, setter),
        setterContext
      })
    }

    function __emval_as(handle, returnType, destructorsRef) {
      handle >>>= 0;
      returnType >>>= 0;
      destructorsRef >>>= 0;
      handle = Emval.toValue(handle);
      returnType = requireRegisteredType(returnType, 'emval::as');
      return emval_returnValue(returnType, destructorsRef, handle)
    }

    function __emval_call_method(
        caller, objHandle, methodName, destructorsRef, args) {
      caller >>>= 0;
      objHandle >>>= 0;
      methodName >>>= 0;
      destructorsRef >>>= 0;
      args >>>= 0;
      caller = emval_methodCallers[caller];
      objHandle = Emval.toValue(objHandle);
      methodName = getStringOrSymbol(methodName);
      return caller(objHandle, objHandle[methodName], destructorsRef, args)
    }

    function __emval_equals(first, second) {
      first >>>= 0;
      second >>>= 0;
      first = Emval.toValue(first);
      second = Emval.toValue(second);
      return first == second
    }

    function __emval_get_method_caller(argCount, argTypes, kind) {
      argTypes >>>= 0;
      var types = emval_lookupTypes(argCount, argTypes);
      var retType = types.shift();
      argCount--;
      var functionBody =
          `return function (obj, func, destructorsRef, args) {\n`;
      var offset = 0;
      var argsList = [];
      if (kind === 0) {
        argsList.push('obj')
      }
      var params = ['retType'];
      var args = [retType];
      for (var i = 0; i < argCount; ++i) {
        argsList.push(`arg${i}`);
        params.push(`argType${i}`);
        args.push(types[i]);
        functionBody += `  var arg${i} = argType${i}.readValueFromPointer(args${
            offset ? '+' + offset : ''});\n`;
        offset += types[i].argPackAdvance
      }
      var invoker = kind === 1 ? 'new func' : 'func.call';
      functionBody += `  var rv = ${invoker}(${argsList.join(', ')});\n`;
      if (!retType.isVoid) {
        params.push('emval_returnValue');
        args.push

    function __emval_get_property(handle, key) {
      handle >>>= 0;
      key >>>= 0;
      handle = Emval.toValue(handle);
      key = Emval.toValue(key);
      return Emval.toHandle(handle[key])
    }

    function __emval_incref(handle) {
      handle >>>= 0;
      if (handle > 9) {
        emval_handles[handle + 1] += 1
      }
    }