📄 `basis_transcoder.js`¶

📊 Analysis Summary¶

Metric	Count
🔧 Functions	351
🧱 Classes	2
📊 Variables & Constants	220
⚡ Async/Await Patterns	4

📚 Table of Contents¶

Variables & Constants
Async/Await Patterns
Functions
Classes

🛠️ File Location:¶

📂 examples/jsm/libs/basis/basis_transcoder.js

Variables & Constants¶

Name	Type	Kind	Value	Exported
`_scriptName`	`any`	let/var	`typeof document != 'undefined' ? document.currentScript?.src : undefined`	✗
`moduleRtn`	`any`	let/var	`not shown`	✗
`Module`	`{}`	let/var	`moduleArg`	✗
`readyPromiseResolve`	`any`	let/var	`not shown`	✗
`readyPromiseReject`	`any`	let/var	`not shown`	✗
`readyPromise`	`Promise<any>`	let/var	`new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject...`	✗
`ENVIRONMENT_IS_WEB`	`boolean`	let/var	`typeof window=="object"`	✗
`ENVIRONMENT_IS_WORKER`	`boolean`	let/var	`typeof importScripts=="function"`	✗
`ENVIRONMENT_IS_NODE`	`boolean`	let/var	`typeof process=="object"&&typeof process.versions=="object"&&typeof process.v...`	✗
`arguments_`	`any[]`	let/var	`[]`	✗
`thisProgram`	`string`	let/var	`"./this.program"`	✗
`scriptDirectory`	`string`	let/var	`""`	✗
`readAsync`	`any`	let/var	`not shown`	✗
`readBinary`	`any`	let/var	`not shown`	✗
`xhr`	`XMLHttpRequest`	let/var	`new XMLHttpRequest`	✗
`xhr`	`XMLHttpRequest`	let/var	`new XMLHttpRequest`	✗
`out`	`any`	let/var	`Module["print"]\\|\\|console.log.bind(console)`	✗
`err`	`any`	let/var	`Module["printErr"]\\|\\|console.error.bind(console)`	✗
`wasmBinary`	`any`	let/var	`not shown`	✗
`wasmMemory`	`any`	let/var	`not shown`	✗
`ABORT`	`boolean`	let/var	`false`	✗
`EXITSTATUS`	`any`	let/var	`not shown`	✗
`HEAP8`	`any`	let/var	`not shown`	✗
`HEAPU8`	`any`	let/var	`not shown`	✗
`HEAP16`	`any`	let/var	`not shown`	✗
`HEAPU16`	`any`	let/var	`not shown`	✗
`HEAP32`	`any`	let/var	`not shown`	✗
`HEAPU32`	`any`	let/var	`not shown`	✗
`HEAPF32`	`any`	let/var	`not shown`	✗
`HEAPF64`	`any`	let/var	`not shown`	✗
`b`	`any`	let/var	`wasmMemory.buffer`	✗
`__ATPRERUN__`	`any[]`	let/var	`[]`	✗
`__ATINIT__`	`any[]`	let/var	`[]`	✗
`__ATPOSTRUN__`	`any[]`	let/var	`[]`	✗
`runtimeInitialized`	`boolean`	let/var	`false`	✗
`runDependencies`	`number`	let/var	`0`	✗
`runDependencyWatcher`	`any`	let/var	`null`	✗
`dependenciesFulfilled`	`any`	let/var	`null`	✗
`callback`	`any`	let/var	`dependenciesFulfilled`	✗
`e`	`RuntimeError`	let/var	`new WebAssembly.RuntimeError(what)`	✗
`dataURIPrefix`	`string`	let/var	`"data:application/octet-stream;base64,"`	✗
`f`	`string`	let/var	`"basis_transcoder.wasm"`	✗
`wasmBinaryFile`	`any`	let/var	`not shown`	✗
`noExitRuntime`	`any`	let/var	`Module["noExitRuntime"]\\|\\|true`	✗
`exceptionLast`	`number`	let/var	`0`	✗
`uncaughtExceptionCount`	`number`	let/var	`0`	✗
`info`	`ExceptionInfo`	let/var	`new ExceptionInfo(ptr)`	✗
`structRegistrations`	`{}`	let/var	`{}`	✗
`awaitingDependencies`	`{}`	let/var	`{}`	✗
`registeredTypes`	`{}`	let/var	`{}`	✗
`typeDependencies`	`{}`	let/var	`{}`	✗
`InternalError`	`any`	let/var	`not shown`	✗
`typeConverters`	`any[]`	let/var	`new Array(dependentTypes.length)`	✗
`unregisteredTypes`	`any[]`	let/var	`[]`	✗
`registered`	`number`	let/var	`0`	✗
`reg`	`any`	let/var	`structRegistrations[structType]`	✗
`rawConstructor`	`any`	let/var	`reg.rawConstructor`	✗
`rawDestructor`	`any`	let/var	`reg.rawDestructor`	✗
`fieldRecords`	`any`	let/var	`reg.fields`	✗
`fields`	`{}`	let/var	`{}`	✗
`fieldName`	`any`	let/var	`field.fieldName`	✗
`getterReturnType`	`any`	let/var	`fieldTypes[i]`	✗
`getter`	`any`	let/var	`field.getter`	✗
`getterContext`	`any`	let/var	`field.getterContext`	✗
`setterArgumentType`	`any`	let/var	`fieldTypes[i+fieldRecords.length]`	✗
`setter`	`any`	let/var	`field.setter`	✗
`setterContext`	`any`	let/var	`field.setterContext`	✗
`destructors`	`any[]`	let/var	`[]`	✗
`rv`	`{}`	let/var	`{}`	✗
`codes`	`any[]`	let/var	`new Array(256)`	✗
`embind_charCodes`	`any`	let/var	`not shown`	✗
`ret`	`string`	let/var	`""`	✗
`c`	`any`	let/var	`ptr`	✗
`BindingError`	`any`	let/var	`not shown`	✗
`name`	`any`	let/var	`registeredInstance.name`	✗
`callbacks`	`any`	let/var	`awaitingDependencies[rawType]`	✗
`GenericWireTypeSize`	`number`	let/var	`8`	✗
`finalizationRegistry`	`boolean`	let/var	`false`	✗
`toDelete`	`boolean`	let/var	`0===$$.count.value`	✗
`registeredPointers`	`{}`	let/var	`{}`	✗
`rv`	`any[]`	let/var	`[]`	✗
`deletionQueue`	`any[]`	let/var	`[]`	✗
`delayFunction`	`any`	let/var	`not shown`	✗
`registeredInstances`	`{}`	let/var	`{}`	✗
`hasSmartPtrType`	`boolean`	let/var	`!!record.smartPtrType`	✗
`hasSmartPtr`	`boolean`	let/var	`!!record.smartPtr`	✗
`registeredPointerRecord`	`any`	let/var	`registeredPointers[actualType]`	✗
`toType`	`any`	let/var	`not shown`	✗
`$$`	`any`	let/var	`handle.$$`	✗
`hasSmartPtr`	`boolean`	let/var	`!!$$.smartPtr`	✗
`info`	`{ $$: any; }`	let/var	`{$$:$$}`	✗
`leftClass`	`any`	let/var	`this.$$.ptrType.registeredClass`	✗
`left`	`any`	let/var	`this.$$.ptr`	✗
`rightClass`	`any`	let/var	`other.$$.ptrType.registeredClass`	✗
`right`	`any`	let/var	`other.$$.ptr`	✗
`prevFunc`	`any`	let/var	`proto[methodName]`	✗
`char_0`	`number`	let/var	`48`	✗
`char_9`	`number`	let/var	`57`	✗
`handleClass`	`any`	let/var	`handle.$$.ptrType.registeredClass`	✗
`ptr`	`any`	let/var	`not shown`	✗
`handleClass`	`any`	let/var	`handle.$$.ptrType.registeredClass`	✗
`handleClass`	`any`	let/var	`handle.$$.ptrType.registeredClass`	✗
`f`	`any`	let/var	`Module["dynCall_"+sig]`	✗
`wasmTableMirror`	`any[]`	let/var	`[]`	✗
`wasmTable`	`any`	let/var	`not shown`	✗
`func`	`any`	let/var	`wasmTableMirror[funcPtr]`	✗
`stack`	`string`	let/var	`new Error(message).stack`	✗
`UnboundTypeError`	`any`	let/var	`not shown`	✗
`unboundTypes`	`any[]`	let/var	`[]`	✗
`seen`	`{}`	let/var	`{}`	✗
`baseClass`	`any`	let/var	`not shown`	✗
`basePrototype`	`any`	let/var	`not shown`	✗
`body`	`any`	let/var	`registeredClass.constructor_body[args.length]`	✗
`registeredClass`	`RegisteredClass`	let/var	`new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClas...`	✗
`referenceConverter`	`RegisteredPointer`	let/var	`new RegisteredPointer(name,registeredClass,true,false,false)`	✗
`pointerConverter`	`RegisteredPointer`	let/var	`new RegisteredPointer(name+"*",registeredClass,false,false,false)`	✗
`constPointerConverter`	`RegisteredPointer`	let/var	`new RegisteredPointer(name+" const*",registeredClass,false,true,false)`	✗
`array`	`any[]`	let/var	`[]`	✗
`obj`	`any`	let/var	`new dummy`	✗
`argCount`	`any`	let/var	`argTypes.length`	✗
`argsList`	`string`	let/var	`""`	✗
`argsListWired`	`string`	let/var	`""`	✗
`invokerFnBody`	`string`	let/var	`\n return function (${argsList}) {\n if (arguments.length !== ${argCount-2})...	✗
`dtorStack`	`string`	let/var	`needsDestructorStack?"destructors":"null"`	✗
`args1`	`string[]`	let/var	`["humanName","throwBindingError","invoker","fn","runDestructors","retType","c...`	✗
`paramName`	`string`	let/var	`i===1?"thisWired":"arg"+(i-2)+"Wired"`	✗
`argCount`	`any`	let/var	`argTypes.length`	✗
`isClassMethodFunc`	`boolean`	let/var	`argTypes[1]!==null&&classType!==null`	✗
`returns`	`boolean`	let/var	`argTypes[0].name!=="void"`	✗
`closureArgs`	`any[]`	let/var	`[humanName,throwBindingError,cppInvokerFunc,cppTargetFunc,runDestructors,argT...`	✗
`humanName`	`string`	let/var	`constructor ${classType.name}`	✗
`humanName`	`string`	let/var	`${classType.name}.${methodName}`	✗
`proto`	`any`	let/var	`classType.registeredClass.instancePrototype`	✗
`method`	`any`	let/var	`proto[methodName]`	✗
`emval_freelist`	`any[]`	let/var	`[]`	✗
`emval_handles`	`any[]`	let/var	`[]`	✗
`handle`	`any`	let/var	`emval_freelist.pop()\\|\\|emval_handles.length`	✗
`Emval`	`{ toValue: (handle: any) => any; toHa...`	let/var	`{toValue:handle=>{if(!handle){throwBindingError("Cannot use deleted val. hand...`	✗
`EmValType`	`{ name: string; fromWireType: (handle...`	let/var	`{name:"emscripten::val",fromWireType:handle=>{var rv=Emval.toValue(handle);__...`	✗
`impl`	`any`	let/var	`registeredTypes[rawType]`	✗
`Enum`	`any`	let/var	`enumType.constructor`	✗
`t`	`"string" \\| "number" \\| "bigint" \\| "...`	let/var	`typeof v`	✗
`bitshift`	`number`	let/var	`32-8*size`	✗
`toWireType`	`any`	let/var	`not shown`	✗
`typeMapping`	`(Int8ArrayConstructor \\| Uint8ArrayCo...`	let/var	`[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Ar...`	✗
`TA`	`Int8ArrayConstructor \\| Uint8ArrayCon...`	let/var	`typeMapping[dataTypeIndex]`	✗
`size`	`any`	let/var	`HEAPU32[handle>>2]`	✗
`data`	`any`	let/var	`HEAPU32[handle+4>>2]`	✗
`startIdx`	`any`	let/var	`outIdx`	✗
`endIdx`	`number`	let/var	`outIdx+maxBytesToWrite-1`	✗
`len`	`number`	let/var	`0`	✗
`UTF8Decoder`	`TextDecoder`	let/var	`typeof TextDecoder!="undefined"?new TextDecoder:undefined`	✗
`endIdx`	`any`	let/var	`idx+maxBytesToRead`	✗
`endPtr`	`any`	let/var	`idx`	✗
`str`	`string`	let/var	`""`	✗
`u0`	`any`	let/var	`heapOrArray[idx++]`	✗
`u1`	`number`	let/var	`heapOrArray[idx++]&63`	✗
`u2`	`number`	let/var	`heapOrArray[idx++]&63`	✗
`ch`	`number`	let/var	`u0-65536`	✗
`stdStringIsUTF8`	`boolean`	let/var	`name==="std::string"`	✗
`length`	`any`	let/var	`HEAPU32[value>>2]`	✗
`payload`	`any`	let/var	`value+4`	✗
`str`	`any`	let/var	`not shown`	✗
`decodeStartPtr`	`any`	let/var	`payload`	✗
`currentBytePtr`	`any`	let/var	`payload+i`	✗
`maxRead`	`number`	let/var	`currentBytePtr-decodeStartPtr`	✗
`a`	`any[]`	let/var	`new Array(length)`	✗
`length`	`any`	let/var	`not shown`	✗
`valueIsOfTypeString`	`boolean`	let/var	`typeof value=="string"`	✗
`ptr`	`any`	let/var	`base+4`	✗
`UTF16Decoder`	`TextDecoder`	let/var	`typeof TextDecoder!="undefined"?new TextDecoder("utf-16le"):undefined`	✗
`endPtr`	`any`	let/var	`ptr`	✗
`idx`	`number`	let/var	`endPtr>>1`	✗
`maxIdx`	`number`	let/var	`idx+maxBytesToRead/2`	✗
`str`	`string`	let/var	`""`	✗
`codeUnit`	`any`	let/var	`HEAP16[ptr+i*2>>1]`	✗
`startPtr`	`any`	let/var	`outPtr`	✗
`numCharsToWrite`	`any`	let/var	`maxBytesToWrite<str.length*2?maxBytesToWrite/2:str.length`	✗
`i`	`number`	let/var	`0`	✗
`str`	`string`	let/var	`""`	✗
`utf32`	`any`	let/var	`HEAP32[ptr+i*4>>2]`	✗
`ch`	`number`	let/var	`utf32-65536`	✗
`startPtr`	`any`	let/var	`outPtr`	✗
`endPtr`	`number`	let/var	`startPtr+maxBytesToWrite-4`	✗
`len`	`number`	let/var	`0`	✗
`decodeString`	`any`	let/var	`not shown`	✗
`encodeString`	`any`	let/var	`not shown`	✗
`readCharAt`	`any`	let/var	`not shown`	✗
`lengthBytesUTF`	`any`	let/var	`not shown`	✗
`length`	`any`	let/var	`HEAPU32[value>>2]`	✗
`str`	`any`	let/var	`not shown`	✗
`decodeStartPtr`	`any`	let/var	`value+4`	✗
`currentBytePtr`	`any`	let/var	`value+4+i*charSize`	✗
`maxReadBytes`	`number`	let/var	`currentBytePtr-decodeStartPtr`	✗
`destructors`	`any[]`	let/var	`[]`	✗
`emval_methodCallers`	`any[]`	let/var	`[]`	✗
`emval_symbols`	`{}`	let/var	`{}`	✗
`symbol`	`any`	let/var	`emval_symbols[address]`	✗
`id`	`number`	let/var	`emval_methodCallers.length`	✗
`a`	`any[]`	let/var	`new Array(argCount)`	✗
`reflectConstruct`	`{ <A extends readonly any[], R>(targe...`	let/var	`Reflect.construct`	✗
`functionBody`	`string`	let/var	`return function (obj, func, destructorsRef, args) {\n`	✗
`offset`	`number`	let/var	`0`	✗
`argsList`	`any[]`	let/var	`[]`	✗
`params`	`string[]`	let/var	`["retType"]`	✗
`args`	`any[]`	let/var	`[retType]`	✗
`invoker`	`string`	let/var	`kind===1?"new func":"func.call"`	✗
`functionName`	`string`	let/var	`methodCaller<(${types.map(t=>t.name).join(", ")}) => ${retType.name}>`	✗
`b`	`any`	let/var	`wasmMemory.buffer`	✗
`pages`	`number`	let/var	`(size-b.byteLength+65535)/65536`	✗
`oldSize`	`any`	let/var	`HEAPU8.length`	✗
`overGrownHeapSize`	`number`	let/var	`oldSize*(1+.2/cutDown)`	✗
`printCharBuffers`	`any[][]`	let/var	`[null,[],[]]`	✗
`buffer`	`any[]`	let/var	`printCharBuffers[stream]`	✗
`num`	`number`	let/var	`0`	✗
`ptr`	`any`	let/var	`HEAPU32[iov>>2]`	✗
`len`	`any`	let/var	`HEAPU32[iov+4>>2]`	✗
`wasmImports`	`{ K: (ptr: any, type: any, destructor...`	let/var	`{K:___cxa_throw,G:__abort_js,s:__embind_finalize_value_object,C:__embind_regi...`	✗
`dynCall_jiji`	`(a0: any, a1: any, a2: any, a3: any, ...`	let/var	`Module["dynCall_jiji"]=(a0,a1,a2,a3,a4)=>(dynCall_jiji=Module["dynCall_jiji"]...`	✗
`calledRun`	`any`	let/var	`not shown`	✗

Async/Await Patterns¶

Type	Function	Await Expressions	Promise Chains
promise-chain	`getBinaryPromise`	none	readAsync(binaryFile).then, Promise.resolve().then, Promise.resolve
promise-chain	`instantiateArrayBuffer`	none	getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then, getBinaryPromise(binaryFile).then
promise-chain	`instantiateAsync`	none	fetch(binaryFile,{credentials:"same-origin"}).then, result.then
promise-chain	`createWasm`	none	instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch

Functions¶

`quit_(status: any, toThrow: any): never`¶

Parameters:

status any
toThrow any

Returns: never

Code

(status,toThrow)=>{throw toThrow}

`locateFile(path: any): any`¶

Parameters:

path any

Returns: any

Calls:

complex_call_884

Code

function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}

`updateMemoryViews(): void`¶

Returns: void

Code

function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b)}

`preRun(): void`¶

Returns: void

Calls:

addOnPreRun
Module["preRun"].shift
callRuntimeCallbacks

Code

function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}

`initRuntime(): void`¶

Returns: void

Calls:

callRuntimeCallbacks

Code

function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}

`postRun(): void`¶

Returns: void

Calls:

addOnPostRun
Module["postRun"].shift
callRuntimeCallbacks

Code

function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}

`addOnPreRun(cb: any): void`¶

Parameters:

cb any

Returns: void

Calls:

__ATPRERUN__.unshift

Code

function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}

`addOnInit(cb: any): void`¶

Parameters:

cb any

Returns: void

Calls:

__ATINIT__.unshift

Code

function addOnInit(cb){__ATINIT__.unshift(cb)}

`addOnPostRun(cb: any): void`¶

Parameters:

cb any

Returns: void

Calls:

__ATPOSTRUN__.unshift

Code

function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}

`addRunDependency(id: any): void`¶

Parameters:

id any

Returns: void

Calls:

complex_call_4572

Code

function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}

`removeRunDependency(id: any): void`¶

Parameters:

id any

Returns: void

Calls:

complex_call_4675
clearInterval
callback

Code

function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}

`abort(what: any): void`¶

Parameters:

what any

Returns: void

Calls:

complex_call_4966
err
readyPromiseReject

Code

function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}

`isDataURI(filename: any): any`¶

Parameters:

filename any

Returns: any

Calls:

filename.startsWith

Code

filename=>filename.startsWith(dataURIPrefix)

`isFileURI(filename: any): any`¶

Parameters:

filename any

Returns: any

Calls:

filename.startsWith

Code

filename=>filename.startsWith("file://")

`findWasmBinary(): any`¶

Returns: any

Calls:

isDataURI
locateFile

Code

function findWasmBinary(){var f="basis_transcoder.wasm";if(!isDataURI(f)){return locateFile(f)}return f}

`getBinarySync(file: any): any`¶

Parameters:

file any

Returns: any

Calls:

readBinary

Code

function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}

`getBinaryPromise(binaryFile: any): any`¶

Parameters:

binaryFile any

Returns: any

Calls:

readAsync(binaryFile).then
getBinarySync
Promise.resolve().then

Code

function getBinaryPromise(binaryFile){if(!wasmBinary){return readAsync(binaryFile).then(response=>new Uint8Array(response),()=>getBinarySync(binaryFile))}return Promise.resolve().then(()=>getBinarySync(binaryFile))}

`instantiateArrayBuffer(binaryFile: any, imports: any, receiver: any): any`¶

Parameters:

binaryFile any
imports any
receiver any

Returns: any

Calls:

getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then
err
abort

Code

function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then(receiver,reason=>{err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)})}

`instantiateAsync(binary: any, binaryFile: any, imports: any, callback: any): any`¶

Parameters:

binary any
binaryFile any
imports any
callback any

Returns: any

Calls:

isDataURI
isFileURI
fetch(binaryFile,{credentials:"same-origin"}).then
WebAssembly.instantiateStreaming
result.then
err
instantiateArrayBuffer

Code

function instantiateAsync(binary,binaryFile,imports,callback){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{var result=WebAssembly.instantiateStreaming(response,imports);return result.then(callback,function(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(binaryFile,imports,callback)})})}return instantiateArrayBuffer(binaryFile,imports,callback)}

`getWasmImports(): { a: { K: (ptr: any, type: any, destructor: any) => never; G: () => void; s: (structType: any) => void; C: (primitiveType: any, name: any, size: any, minRange: any, maxRange: any) => void; I: (rawType: any, name: any, trueValue: any, falseValue: any) => void; ... 31 more ...; y: (fd: any, iov: any, iovcnt: any, pnum...`¶

Returns: { a: { K: (ptr: any, type: any, destructor: any) => never; G: () => void; s: (structType: any) => void; C: (primitiveType: any, name: any, size: any, minRange: any, maxRange: any) => void; I: (rawType: any, name: any, trueValue: any, falseValue: any) => void; ... 31 more ...; y: (fd: any, iov: any, iovcnt: any, pnum...

Code

function getWasmImports(){return{a:wasmImports}}

`createWasm(): any`¶

Returns: any

Calls:

getWasmImports
updateMemoryViews
addOnInit
removeRunDependency
addRunDependency
receiveInstance
complex_call_7226
err
readyPromiseReject
findWasmBinary
instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch

Code

function createWasm(){var info=getWasmImports();function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["L"];updateMemoryViews();wasmTable=wasmExports["P"];addOnInit(wasmExports["M"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);readyPromiseReject(e)}}if(!wasmBinaryFile)wasmBinaryFile=findWasmBinary();instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch(readyPromiseReject);return{}}

`receiveInstance(instance: any, module: any): any`¶

Parameters:

instance any
module any

Returns: any

Calls:

updateMemoryViews
addOnInit
removeRunDependency

Code

function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["L"];updateMemoryViews();wasmTable=wasmExports["P"];addOnInit(wasmExports["M"]);removeRunDependency("wasm-instantiate");return wasmExports}

`receiveInstantiationResult(result: any): void`¶

Parameters:

result any

Returns: void

Calls:

receiveInstance

Code

function receiveInstantiationResult(result){receiveInstance(result["instance"])}

`callRuntimeCallbacks(callbacks: any): void`¶

Parameters:

callbacks any

Returns: void

Calls:

complex_call_7594

Code

callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}}

`ExceptionInfo.set_type(type: any): void`¶

Parameters:

type any

Returns: void

Code

set_type(type){HEAPU32[this.ptr+4>>2]=type}

`ExceptionInfo.get_type(): any`¶

Returns: any

Code

get_type(){return HEAPU32[this.ptr+4>>2]}

`ExceptionInfo.set_destructor(destructor: any): void`¶

Parameters:

destructor any

Returns: void

Code

set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}

`ExceptionInfo.get_destructor(): any`¶

Returns: any

Code

get_destructor(){return HEAPU32[this.ptr+8>>2]}

`ExceptionInfo.set_caught(caught: any): void`¶

Parameters:

caught any

Returns: void

Code

set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}

`ExceptionInfo.get_caught(): boolean`¶

Returns: boolean

Code

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

`ExceptionInfo.set_rethrown(rethrown: any): void`¶

Parameters:

rethrown any

Returns: void

Code

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

`ExceptionInfo.get_rethrown(): boolean`¶

Returns: boolean

Code

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

`ExceptionInfo.init(type: any, destructor: any): void`¶

Parameters:

type any
destructor any

Returns: void

Calls:

this.set_adjusted_ptr
this.set_type
this.set_destructor

Code

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

`ExceptionInfo.set_adjusted_ptr(adjustedPtr: any): void`¶

Parameters:

adjustedPtr any

Returns: void

Code

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

`ExceptionInfo.get_adjusted_ptr(): any`¶

Returns: any

Code

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

`ExceptionInfo.get_exception_ptr(): any`¶

Returns: any

Calls:

___cxa_is_pointer_type
this.get_type
this.get_adjusted_ptr

Code

get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}

`___cxa_throw(ptr: any, type: any, destructor: any): never`¶

Parameters:

ptr any
type any
destructor any

Returns: never

Calls:

info.init

Code

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

`__abort_js(): void`¶

Returns: void

Calls:

abort

Code

()=>{abort("")}

`runDestructors(destructors: any): void`¶

Parameters:

destructors any

Returns: void

Calls:

destructors.pop
del

Code

destructors=>{while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}

`readPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_9015

Code

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

`throwInternalError(message: any): never`¶

Parameters:

message any

Returns: never

Code

message=>{throw new InternalError(message)}

`whenDependentTypesAreResolved(myTypes: any, dependentTypes: any, getTypeConverters: any): void`¶

Parameters:

myTypes any
dependentTypes any
getTypeConverters any

Returns: void

Calls:

myTypes.forEach
getTypeConverters
throwInternalError
registerType
dependentTypes.forEach
registeredTypes.hasOwnProperty
unregisteredTypes.push
awaitingDependencies.hasOwnProperty
awaitingDependencies[dt].push
onComplete

Code

(myTypes,dependentTypes,getTypeConverters)=>{myTypes.forEach(function(type){typeDependencies[type]=dependentTypes});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])}}var typeConverters=new Array(dependentTypes.length);var unregisteredTypes=[];var registered=0;dependentTypes.forEach((dt,i)=>{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}

`onComplete(typeConverters: any): void`¶

Parameters:

typeConverters any

Returns: void

Calls:

getTypeConverters
throwInternalError
registerType

Code

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])}}

`__embind_finalize_value_object(structType: any): void`¶

Parameters:

structType any

Returns: void

Calls:

fieldRecords.map(field=>field.getterReturnType).concat
fieldRecords.map
whenDependentTypesAreResolved
fieldRecords.forEach
complex_call_10907
getter
setter
complex_call_11027
runDestructors
fields[i].read
rawDestructor
rawConstructor
fields[fieldName].write
destructors.push

Code

structType=>{var reg=structRegistrations[structType];delete structRegistrations[structType];var rawConstructor=reg.rawConstructor;var rawDestructor=reg.rawDestructor;var fieldRecords=reg.fields;var fieldTypes=fieldRecords.map(field=>field.getterReturnType).concat(fieldRecords.map(field=>field.setterArgumentType));whenDependentTypesAreResolved([structType],fieldTypes,fieldTypes=>{var fields={};fieldRecords.forEach((field,i)=>{var fieldName=field.fieldName;var getterReturnType=fieldTypes[i];var getter=field.getter;var getterContext=field.getterContext;var setterArgumentType=fieldTypes[i+fieldRecords.length];var setter=field.setter;var setterContext=field.setterContext;fields[fieldName]={read:ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr)),write:(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}}});return[{name:reg.name,fromWireType:ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv},toWireType:(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr},argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,destructorFunction:rawDestructor}]})}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`__embind_register_bigint(primitiveType: any, name: any, size: any, minRange: any, maxRange: any): void`¶

Parameters:

primitiveType any
name any
size any
minRange any
maxRange any

Returns: void

Code

(primitiveType,name,size,minRange,maxRange)=>{}

`embind_init_charCodes(): void`¶

Returns: void

Calls:

String.fromCharCode

Code

()=>{var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i)}embind_charCodes=codes}

`readLatin1String(ptr: any): string`¶

Parameters:

ptr any

Returns: string

Code

ptr=>{var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]]}return ret}

`throwBindingError(message: any): never`¶

Parameters:

message any

Returns: never

Code

message=>{throw new BindingError(message)}

`sharedRegisterType(rawType: any, registeredInstance: any, options: {}): void`¶

Parameters:

rawType any
registeredInstance any
options {}

Returns: void

Calls:

throwBindingError
registeredTypes.hasOwnProperty
awaitingDependencies.hasOwnProperty
callbacks.forEach
cb

Code

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())}}

`registerType(rawType: any, registeredInstance: any, options: {}): void`¶

Parameters:

rawType any
registeredInstance any
options {}

Returns: void

Calls:

sharedRegisterType

Code

function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}return sharedRegisterType(rawType,registeredInstance,options)}

`__embind_register_bool(rawType: any, name: any, trueValue: any, falseValue: any): void`¶

Parameters:

rawType any
name any
trueValue any
falseValue any

Returns: void

Calls:

readLatin1String
registerType
complex_call_13234

Code

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

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`shallowCopyInternalPointer(o: any): { count: any; deleteScheduled: any; preservePointerOnDelete: any; ptr: any; ptrType: any; smartPtr: any; smartPtrType: any; }`¶

Parameters:

o any

Returns: { count: any; deleteScheduled: any; preservePointerOnDelete: any; ptr: any; ptrType: any; smartPtr: any; smartPtrType: any; }

Code

o=>({count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType})

`throwInstanceAlreadyDeleted(obj: any): void`¶

Parameters:

obj any

Returns: void

Calls:

throwBindingError
getInstanceTypeName

Code

obj=>{function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted")}

`getInstanceTypeName(handle: any): any`¶

Parameters:

handle any

Returns: any

Code

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

`detachFinalizer(handle: any): void`¶

Parameters:

handle any

Returns: void

Code

handle=>{}

`runDestructor($$: any): void`¶

Parameters:

$$ any

Returns: void

Calls:

$$.smartPtrType.rawDestructor
$$.ptrType.registeredClass.rawDestructor

Code

$$=>{if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr)}else{$$.ptrType.registeredClass.rawDestructor($$.ptr)}}

`releaseClassHandle($$: any): void`¶

Parameters:

$$ any

Returns: void

Calls:

runDestructor

Code

$$=>{$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$)}}

`downcastPointer(ptr: any, ptrClass: any, desiredClass: any): any`¶

Parameters:

ptr any
ptrClass any
desiredClass any

Returns: any

Calls:

downcastPointer
desiredClass.downcast

Code

(ptr,ptrClass,desiredClass)=>{if(ptrClass===desiredClass){return ptr}if(undefined===desiredClass.baseClass){return null}var rv=downcastPointer(ptr,ptrClass,desiredClass.baseClass);if(rv===null){return null}return desiredClass.downcast(rv)}

`getInheritedInstanceCount(): number`¶

Returns: number

Code

()=>Object.keys(registeredInstances).length

`getLiveInheritedInstances(): any[]`¶

Returns: any[]

Calls:

registeredInstances.hasOwnProperty
rv.push

Code

()=>{var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k])}}return rv}

`flushPendingDeletes(): void`¶

Returns: void

Calls:

deletionQueue.pop
complex_call_14677

Code

()=>{while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}

`setDelayFunction(fn: any): void`¶

Parameters:

fn any

Returns: void

Calls:

delayFunction

Code

fn=>{delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes)}}

`init_embind(): void`¶

Returns: void

Code

()=>{Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction}

`getBasestPointer(class_: any, ptr: any): any`¶

Parameters:

class_ any
ptr any

Returns: any

Calls:

throwBindingError
class_.upcast

Code

(class_,ptr)=>{if(ptr===undefined){throwBindingError("ptr should not be undefined")}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass}return ptr}

`getInheritedInstance(class_: any, ptr: any): any`¶

Parameters:

class_ any
ptr any

Returns: any

Calls:

getBasestPointer

Code

(class_,ptr)=>{ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}

`makeClassHandle(prototype: any, record: any): any`¶

Parameters:

prototype any
record any

Returns: any

Calls:

throwInternalError
attachFinalizer
Object.create

Code

(prototype,record)=>{if(!record.ptrType||!record.ptr){throwInternalError("makeClassHandle requires ptr and ptrType")}var hasSmartPtrType=!!record.smartPtrType;var hasSmartPtr=!!record.smartPtr;if(hasSmartPtrType!==hasSmartPtr){throwInternalError("Both smartPtrType and smartPtr must be specified")}record.count={value:1};return attachFinalizer(Object.create(prototype,{$$:{value:record,writable:true}}))}

`RegisteredPointer_fromWireType(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

this.getPointee
this.destructor
getInheritedInstance
complex_call_16182
complex_call_16224
makeClassHandle
this.registeredClass.getActualType
makeDefaultHandle.call
downcastPointer

Code

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(this.registeredClass.instancePrototype,{ptrType:this,ptr:ptr})}}var actualType=this.registeredClass.getActualType(rawPointer);var registeredPointerRecord=registeredPointers[actualType];if(!registeredPointerRecord){return makeDefaultHandle.call(this)}var toType;if(this.isConst){toType=registeredPointerRecord.constPointerType}else{toType=registeredPointerRecord.pointerType}var dp=downcastPointer(rawPointer,this.registeredClass,toType.registeredClass);if(dp===null){return makeDefaultHandle.call(this)}if(this.isSmartPointer){return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp})}}

`makeDefaultHandle(): any`¶

Returns: any

Calls:

makeClassHandle

Code

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:ptr})}}

`attachFinalizer(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

releaseClassHandle
finalizationRegistry.register
finalizationRegistry.unregister
attachFinalizer

Code

handle=>{if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.unregister(handle);return attachFinalizer(handle)}

`init_ClassHandle(): void`¶

Returns: void

Calls:

Object.assign
leftClass.upcast
rightClass.upcast
throwInstanceAlreadyDeleted
attachFinalizer
Object.create
Object.getPrototypeOf
shallowCopyInternalPointer
throwBindingError
detachFinalizer
releaseClassHandle
deletionQueue.push
delayFunction

Code

()=>{Object.assign(ClassHandle.prototype,{isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;other.$$=other.$$;var rightClass=other.$$.ptrType.registeredClass;var right=other.$$.ptr;while(leftClass.baseClass){left=leftClass.upcast(left);leftClass=leftClass.baseClass}while(rightClass.baseClass){right=rightClass.upcast(right);rightClass=rightClass.baseClass}return leftClass===rightClass&&left===right},clone(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.preservePointerOnDelete){this.$$.count.value+=1;return this}else{var clone=attachFinalizer(Object.create(Object.getPrototypeOf(this),{$$:{value:shallowCopyInternalPointer(this.$$)}}));clone.$$.count.value+=1;clone.$$.deleteScheduled=false;return clone}},delete(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}detachFinalizer(this);releaseClassHandle(this.$$);if(!this.$$.preservePointerOnDelete){this.$$.smartPtr=undefined;this.$$.ptr=undefined}},isDeleted(){return!this.$$.ptr},deleteLater(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}deletionQueue.push(this);if(deletionQueue.length===1&&delayFunction){delayFunction(flushPendingDeletes)}this.$$.deleteScheduled=true;return this}})}

`ClassHandle(): void`¶

Returns: void

Code

function ClassHandle(){}

`createNamedFunction(name: any, body: any): any`¶

Parameters:

name any
body any

Returns: any

Calls:

Object.defineProperty

Code

(name,body)=>Object.defineProperty(body,"name",{value:name})

`ensureOverloadTable(proto: any, methodName: any, humanName: any): void`¶

Parameters:

proto any
methodName any
humanName any

Returns: void

Calls:

proto[methodName].overloadTable.hasOwnProperty
throwBindingError
proto[methodName].overloadTable[args.length].apply

Code

(proto,methodName,humanName)=>{if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(...args){if(!proto[methodName].overloadTable.hasOwnProperty(args.length)){throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`)}return proto[methodName].overloadTable[args.length].apply(this,args)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc}}

`exposePublicSymbol(name: any, value: any, numArguments: any): void`¶

Parameters:

name any
value any
numArguments any

Returns: void

Calls:

Module.hasOwnProperty
throwBindingError
ensureOverloadTable

Code

(name,value,numArguments)=>{if(Module.hasOwnProperty(name)){if(undefined===numArguments||undefined!==Module[name].overloadTable&&undefined!==Module[name].overloadTable[numArguments]){throwBindingError(`Cannot register public name '${name}' twice`)}ensureOverloadTable(Module,name,name);if(Module.hasOwnProperty(numArguments)){throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`)}Module[name].overloadTable[numArguments]=value}else{Module[name]=value;if(undefined!==numArguments){Module[name].numArguments=numArguments}}}

`makeLegalFunctionName(name: any): any`¶

Parameters:

name any

Returns: any

Calls:

name.replace
name.charCodeAt

Code

name=>{if(undefined===name){return"_unknown"}name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return`_${name}`}return name}

`RegisteredClass(name: any, constructor: any, instancePrototype: any, rawDestructor: any, baseClass: any, getActualType: any, upcast: any, downcast: any): void`¶

Parameters:

name any
constructor any
instancePrototype any
rawDestructor any
baseClass any
getActualType any
upcast any
downcast any

Returns: void

Code

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=[]}

`upcastPointer(ptr: any, ptrClass: any, desiredClass: any): any`¶

Parameters:

ptr any
ptrClass any
desiredClass any

Returns: any

Calls:

throwBindingError
ptrClass.upcast

Code

(ptr,ptrClass,desiredClass)=>{while(ptrClass!==desiredClass){if(!ptrClass.upcast){throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`)}ptr=ptrClass.upcast(ptr);ptrClass=ptrClass.baseClass}return ptr}

`constNoSmartPtrRawPointerToWireType(destructors: any, handle: any): any`¶

Parameters:

destructors any
handle any

Returns: any

Calls:

throwBindingError
embindRepr
upcastPointer

Code

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}

`genericPointerToWireType(destructors: any, handle: any): any`¶

Parameters:

destructors any
handle any

Returns: any

Calls:

throwBindingError
this.rawConstructor
destructors.push
embindRepr
upcastPointer
complex_call_23236
this.rawShare
Emval.toHandle
complex_call_23295

Code

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 ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);if(this.isSmartPointer){if(undefined===handle.$$.smartPtr){throwBindingError("Passing raw pointer to smart pointer is illegal")}switch(this.sharingPolicy){case 0:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}break;case 1:ptr=handle.$$.smartPtr;break;case 2:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{var clonedHandle=handle["clone"]();ptr=this.rawShare(ptr,Emval.toHandle(()=>clonedHandle["delete"]()));if(destructors!==null){destructors.push(this.rawDestructor,ptr)}}break;default:throwBindingError("Unsupporting sharing policy")}}return ptr}

`nonConstNoSmartPtrRawPointerToWireType(destructors: any, handle: any): any`¶

Parameters:

destructors any
handle any

Returns: any

Calls:

throwBindingError
embindRepr
upcastPointer

Code

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}

`init_RegisteredPointer(): void`¶

Returns: void

Calls:

Object.assign
this.rawGetPointee
this.rawDestructor

Code

()=>{Object.assign(RegisteredPointer.prototype,{getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr)}return ptr},destructor(ptr){this.rawDestructor?.(ptr)},argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,fromWireType:RegisteredPointer_fromWireType})}

`RegisteredPointer(name: any, registeredClass: any, isReference: any, isConst: any, isSmartPointer: any, pointeeType: any, sharingPolicy: any, rawGetPointee: any, rawConstructor: any, rawShare: any, rawDestructor: any): void`¶

Parameters:

name any
registeredClass any
isReference any
isConst any
isSmartPointer any
pointeeType any
sharingPolicy any
rawGetPointee any
rawConstructor any
rawShare any
rawDestructor any

Returns: void

Code

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["toWireType"]=genericPointerToWireType}}

`replacePublicSymbol(name: any, value: any, numArguments: any): void`¶

Parameters:

name any
value any
numArguments any

Returns: void

Calls:

Module.hasOwnProperty
throwInternalError

Code

(name,value,numArguments)=>{if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistent public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}}

`dynCallLegacy(sig: any, ptr: any, args: any): any`¶

Parameters:

sig any
ptr any
args any

Returns: any

Calls:

sig.replace
f

Code

(sig,ptr,args)=>{sig=sig.replace(/p/g,"i");var f=Module["dynCall_"+sig];return f(ptr,...args)}

`getWasmTableEntry(funcPtr: any): any`¶

Parameters:

funcPtr any

Returns: any

Calls:

wasmTable.get

Code

funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func}

`dynCall(sig: any, ptr: any, args: any[]): any`¶

Parameters:

sig any
ptr any
args any[]

Returns: any

Calls:

sig.includes
dynCallLegacy
complex_call_25966

Code

(sig,ptr,args=[])=>{if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}var rtn=getWasmTableEntry(ptr)(...args);return rtn}

`getDynCaller(sig: any, ptr: any): (...args: any[]) => any`¶

Parameters:

sig any
ptr any

Returns: (...args: any[]) => any

Code

(sig,ptr)=>(...args)=>dynCall(sig,ptr,args)

`embind__requireFunction(signature: any, rawFunction: any): any`¶

Parameters:

signature any
rawFunction any

Returns: any

Calls:

readLatin1String
signature.includes
getDynCaller
getWasmTableEntry
makeDynCaller
throwBindingError

Code

(signature,rawFunction)=>{signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();if(typeof fp!="function"){throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`)}return fp}

`makeDynCaller(): any`¶

Returns: any

Calls:

signature.includes
getDynCaller
getWasmTableEntry

Code

function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}

`extendError(baseErrorType: any, errorName: any): any`¶

Parameters:

baseErrorType any
errorName any

Returns: any

Calls:

createNamedFunction
this.toString
stack.replace
Object.create

Code

(baseErrorType,errorName)=>{var errorClass=createNamedFunction(errorName,function(message){this.name=errorName;this.message=message;var stack=new Error(message).stack;if(stack!==undefined){this.stack=this.toString()+"\n"+stack.replace(/^Error(:[^\n]*)?\n/,"")}});errorClass.prototype=Object.create(baseErrorType.prototype);errorClass.prototype.constructor=errorClass;errorClass.prototype.toString=function(){if(this.message===undefined){return this.name}else{return`${this.name}: ${this.message}`}};return errorClass}

`getTypeName(type: any): string`¶

Parameters:

type any

Returns: string

Calls:

___getTypeName
readLatin1String
_free

Code

type=>{var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}

`throwUnboundTypeError(message: any, types: any): never`¶

Parameters:

message any
types any

Returns: never

Calls:

typeDependencies[type].forEach
unboundTypes.push
types.forEach
unboundTypes.map(getTypeName).join

Code

(message,types)=>{var unboundTypes=[];var seen={};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}types.forEach(visit);throw new UnboundTypeError(`${message}: `+unboundTypes.map(getTypeName).join([", "]))}

`visit(type: any): void`¶

Parameters:

type any

Returns: void

Calls:

typeDependencies[type].forEach
unboundTypes.push

Code

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}

`__embind_register_class(rawType: any, rawPointerType: any, rawConstPointerType: any, baseClassRawType: any, getActualTypeSignature: any, getActualType: any, upcastSignature: any, upcast: any, downcastSignature: any, downcast: any, name: any, destructorSignature: any, rawDestructor: any): void`¶

Parameters:

rawType any
rawPointerType any
rawConstPointerType any
baseClassRawType any
getActualTypeSignature any
getActualType any
upcastSignature any
upcast any
downcastSignature any
downcast any
name any
destructorSignature any
rawDestructor any

Returns: void

Calls:

readLatin1String
embind__requireFunction
makeLegalFunctionName
exposePublicSymbol
throwUnboundTypeError
whenDependentTypesAreResolved
createNamedFunction
Object.getPrototypeOf
Object.keys(registeredClass.constructor_body).toString
body.apply
Object.create
registeredClass.baseClass.__derivedClasses.push
replacePublicSymbol

Code

(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor)=>{name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);upcast&&=embind__requireFunction(upcastSignature,upcast);downcast&&=embind__requireFunction(downcastSignature,downcast);rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);var legalFunctionName=makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName,function(){throwUnboundTypeError(`Cannot construct ${name} due to unbound types`,[baseClassRawType])});whenDependentTypesAreResolved([rawType,rawPointerType,rawConstPointerType],baseClassRawType?[baseClassRawType]:[],base=>{base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype}else{basePrototype=ClassHandle.prototype}var constructor=createNamedFunction(name,function(...args){if(Object.getPrototypeOf(this)!==instancePrototype){throw new BindingError("Use 'new' to construct "+name)}if(undefined===registeredClass.constructor_body){throw new BindingError(name+" has no accessible constructor")}var body=registeredClass.constructor_body[args.length];if(undefined===body){throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`)}return body.apply(this,args)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);if(registeredClass.baseClass){registeredClass.baseClass.__derivedClasses??=[];registeredClass.baseClass.__derivedClasses.push(registeredClass)}var referenceConverter=new RegisteredPointer(name,registeredClass,true,false,false);var pointerConverter=new RegisteredPointer(name+"*",registeredClass,false,false,false);var constPointerConverter=new RegisteredPointer(name+" const*",registeredClass,false,true,false);registeredPointers[rawType]={pointerType:pointerConverter,constPointerType:constPointerConverter};replacePublicSymbol(legalFunctionName,constructor);return[referenceConverter,pointerConverter,constPointerConverter]})}

`heap32VectorToArray(count: any, firstElement: any): any[]`¶

Parameters:

count any
firstElement any

Returns: any[]

Calls:

array.push

Code

(count,firstElement)=>{var array=[];for(var i=0;i<count;i++){array.push(HEAPU32[firstElement+i*4>>2])}return array}

`usesDestructorStack(argTypes: any): boolean`¶

Parameters:

argTypes any

Returns: boolean

Code

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

`newFunc(constructor: any, argumentList: any): any`¶

Parameters:

constructor any
argumentList any

Returns: any

Calls:

createNamedFunction
constructor.apply

Code

function newFunc(constructor,argumentList){if(!(constructor instanceof Function)){throw new TypeError(`new_ called with constructor type ${typeof constructor} which is not a function`)}var dummy=createNamedFunction(constructor.name||"unknownFunctionName",function(){});dummy.prototype=constructor.prototype;var obj=new dummy;var r=constructor.apply(obj,argumentList);return r instanceof Object?r:obj}

`createJsInvoker(argTypes: any, isClassMethodFunc: any, returns: any, isAsync: any): (string | string[])[]`¶

Parameters:

argTypes any
isClassMethodFunc any
returns any
isAsync any

Returns: (string | string[])[]

Calls:

usesDestructorStack
args1.push

Code

function createJsInvoker(argTypes,isClassMethodFunc,returns,isAsync){var needsDestructorStack=usesDestructorStack(argTypes);var argCount=argTypes.length;var argsList="";var argsListWired="";for(var i=0;i<argCount-2;++i){argsList+=(i!==0?", ":"")+"arg"+i;argsListWired+=(i!==0?", ":"")+"arg"+i+"Wired"}var invokerFnBody=`\n        return function (${argsList}) {\n        if (arguments.length !== ${argCount-2}) {\n          throwBindingError('function ' + humanName + ' called with ' + arguments.length + ' arguments, expected ${argCount-2}');\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['toWireType']("+dtorStack+", this);\n"}for(var i=0;i<argCount-2;++i){invokerFnBody+="var arg"+i+"Wired = argType"+i+"['toWireType']("+dtorStack+", arg"+i+");\n";args1.push("argType"+i)}if(isClassMethodFunc){argsListWired="thisWired"+(argsListWired.length>0?", ":"")+argsListWired}invokerFnBody+=(returns||isAsync?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n"}else{for(var i=isClassMethodFunc?1:2;i<argTypes.length;++i){var paramName=i===1?"thisWired":"arg"+(i-2)+"Wired";if(argTypes[i].destructorFunction!==null){invokerFnBody+=`${paramName}_dtor(${paramName});\n`;args1.push(`${paramName}_dtor`)}}}if(returns){invokerFnBody+="var ret = retType['fromWireType'](rv);\n"+"return ret;\n"}else{}invokerFnBody+="}\n";return[args1,invokerFnBody]}

`craftInvokerFunction(humanName: any, argTypes: any, classType: any, cppInvokerFunc: any, cppTargetFunc: any, isAsync: any): any`¶

Parameters:

humanName any
argTypes any
classType any
cppInvokerFunc any
cppTargetFunc any
isAsync any

Returns: any

Calls:

throwBindingError
usesDestructorStack
closureArgs.push
createJsInvoker
args.push
complex_call_33218
createNamedFunction

Code

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)}}}let[args,invokerFnBody]=createJsInvoker(argTypes,isClassMethodFunc,returns,isAsync);args.push(invokerFnBody);var invokerFn=newFunc(Function,args)(...closureArgs);return createNamedFunction(humanName,invokerFn)}

`__embind_register_class_constructor(rawClassType: any, argCount: any, rawArgTypesAddr: any, invokerSignature: any, invoker: any, rawConstructor: any): void`¶

Parameters:

rawClassType any
argCount any
rawArgTypesAddr any
invokerSignature any
invoker any
rawConstructor any

Returns: void

Calls:

heap32VectorToArray
embind__requireFunction
whenDependentTypesAreResolved
throwUnboundTypeError
argTypes.splice
craftInvokerFunction

Code

(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor)=>{var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],classType=>{classType=classType[0];var humanName=`constructor ${classType.name}`;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount-1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`)}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`,rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,argTypes=>{argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})}

`getFunctionName(signature: any): any`¶

Parameters:

signature any

Returns: any

Calls:

signature.trim
signature.indexOf
signature.substr

Code

signature=>{signature=signature.trim();const argsIndex=signature.indexOf("(");if(argsIndex!==-1){return signature.substr(0,argsIndex)}else{return signature}}

`__embind_register_class_function(rawClassType: any, methodName: any, argCount: any, rawArgTypesAddr: any, invokerSignature: any, rawInvoker: any, context: any, isPureVirtual: any, isAsync: any): void`¶

Parameters:

rawClassType any
methodName any
argCount any
rawArgTypesAddr any
invokerSignature any
rawInvoker any
context any
isPureVirtual any
isAsync any

Returns: void

Calls:

heap32VectorToArray
readLatin1String
getFunctionName
embind__requireFunction
whenDependentTypesAreResolved
methodName.startsWith
methodName.substring
classType.registeredClass.pureVirtualFunctions.push
throwUnboundTypeError
ensureOverloadTable
craftInvokerFunction

Code

(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,context,isPureVirtual,isAsync)=>{var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);methodName=getFunctionName(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],classType=>{classType=classType[0];var humanName=`${classType.name}.${methodName}`;if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}if(isPureVirtual){classType.registeredClass.pureVirtualFunctions.push(methodName)}function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}var proto=classType.registeredClass.instancePrototype;var method=proto[methodName];if(undefined===method||undefined===method.overloadTable&&method.className!==classType.name&&method.argCount===argCount-2){unboundTypesHandler.argCount=argCount-2;unboundTypesHandler.className=classType.name;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-2]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,argTypes=>{var memberFunction=craftInvokerFunction(humanName,argTypes,classType,rawInvoker,context,isAsync);if(undefined===proto[methodName].overloadTable){memberFunction.argCount=argCount-2;proto[methodName]=memberFunction}else{proto[methodName].overloadTable[argCount-2]=memberFunction}return[]});return[]})}

`unboundTypesHandler(): void`¶

Returns: void

Calls:

throwUnboundTypeError

Code

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

`__embind_register_constant(name: any, type: any, value: any): void`¶

Parameters:

name any
type any
value any

Returns: void

Calls:

readLatin1String
whenDependentTypesAreResolved
complex_call_36365

Code

(name,type,value)=>{name=readLatin1String(name);whenDependentTypesAreResolved([],[type],type=>{type=type[0];Module[name]=type["fromWireType"](value);return[]})}

`__emval_decref(handle: any): void`¶

Parameters:

handle any

Returns: void

Calls:

emval_freelist.push

Code

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

`count_emval_handles(): number`¶

Returns: number

Code

()=>emval_handles.length/2-5-emval_freelist.length

`init_emval(): void`¶

Returns: void

Calls:

emval_handles.push

Code

()=>{emval_handles.push(0,1,undefined,1,null,1,true,1,false,1);Module["count_emval_handles"]=count_emval_handles}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`__embind_register_emval(rawType: any): void`¶

Parameters:

rawType any

Returns: void

Calls:

registerType

Code

rawType=>registerType(rawType,EmValType)

`enumReadValueFromPointer(name: any, width: any, signed: any): (pointer: any) => any`¶

Parameters:

name any
width any
signed any

Returns: (pointer: any) => any

Calls:

complex_call_37618
complex_call_37681
complex_call_37766
complex_call_37833
complex_call_37922
complex_call_37989

Code

(name,width,signed)=>{switch(width){case 1:return signed?function(pointer){return this["fromWireType"](HEAP8[pointer])}:function(pointer){return this["fromWireType"](HEAPU8[pointer])};case 2:return signed?function(pointer){return this["fromWireType"](HEAP16[pointer>>1])}:function(pointer){return this["fromWireType"](HEAPU16[pointer>>1])};case 4:return signed?function(pointer){return this["fromWireType"](HEAP32[pointer>>2])}:function(pointer){return this["fromWireType"](HEAPU32[pointer>>2])};default:throw new TypeError(`invalid integer width (${width}): ${name}`)}}

`__embind_register_enum(rawType: any, name: any, size: any, isSigned: any): void`¶

Parameters:

rawType any
name any
size any
isSigned any

Returns: void

Calls:

readLatin1String
registerType
enumReadValueFromPointer
exposePublicSymbol

Code

(rawType,name,size,isSigned)=>{name=readLatin1String(name);function ctor(){}ctor.values={};registerType(rawType,{name: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)}

`ctor(): void`¶

Returns: void

Code

function ctor(){}

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`requireRegisteredType(rawType: any, humanName: any): any`¶

Parameters:

rawType any
humanName any

Returns: any

Calls:

throwBindingError
getTypeName

Code

(rawType,humanName)=>{var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`)}return impl}

`__embind_register_enum_value(rawEnumType: any, name: any, enumValue: any): void`¶

Parameters:

rawEnumType any
name any
enumValue any

Returns: void

Calls:

requireRegisteredType
readLatin1String
Object.create
createNamedFunction

Code

(rawEnumType,name,enumValue)=>{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}

`embindRepr(v: any): any`¶

Parameters:

v any

Returns: any

Calls:

v.toString

Code

v=>{if(v===null){return"null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else{return""+v}}

`floatReadValueFromPointer(name: any, width: any): (pointer: any) => any`¶

Parameters:

name any
width any

Returns: (pointer: any) => any

Calls:

complex_call_39348
complex_call_39430

Code

(name,width)=>{switch(width){case 4:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 8:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError(`invalid float width (${width}): ${name}`)}}

`__embind_register_float(rawType: any, name: any, size: any): void`¶

Parameters:

rawType any
name any
size any

Returns: void

Calls:

readLatin1String
registerType
floatReadValueFromPointer

Code

(rawType,name,size)=>{name=readLatin1String(name);registerType(rawType,{name:name,fromWireType:value=>value,toWireType:(destructors,value)=>value,argPackAdvance:GenericWireTypeSize,readValueFromPointer:floatReadValueFromPointer(name,size),destructorFunction:null})}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`__embind_register_function(name: any, argCount: any, rawArgTypesAddr: any, signature: any, rawInvoker: any, fn: any, isAsync: any): void`¶

Parameters:

name any
argCount any
rawArgTypesAddr any
signature any
rawInvoker any
fn any
isAsync any

Returns: void

Calls:

heap32VectorToArray
readLatin1String
getFunctionName
embind__requireFunction
exposePublicSymbol
throwUnboundTypeError
whenDependentTypesAreResolved
[argTypes[0],null].concat
argTypes.slice
replacePublicSymbol
craftInvokerFunction

Code

(name,argCount,rawArgTypesAddr,signature,rawInvoker,fn,isAsync)=>{var argTypes=heap32VectorToArray(argCount,rawArgTypesAddr);name=readLatin1String(name);name=getFunctionName(name);rawInvoker=embind__requireFunction(signature,rawInvoker);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[]})}

`integerReadValueFromPointer(name: any, width: any, signed: any): (pointer: any) => any`¶

Parameters:

name any
width any
signed any

Returns: (pointer: any) => any

Code

(name,width,signed)=>{switch(width){case 1:return signed?pointer=>HEAP8[pointer]:pointer=>HEAPU8[pointer];case 2:return signed?pointer=>HEAP16[pointer>>1]:pointer=>HEAPU16[pointer>>1];case 4:return signed?pointer=>HEAP32[pointer>>2]:pointer=>HEAPU32[pointer>>2];default:throw new TypeError(`invalid integer width (${width}): ${name}`)}}

`__embind_register_integer(primitiveType: any, name: any, size: any, minRange: any, maxRange: any): void`¶

Parameters:

primitiveType any
name any
size any
minRange any
maxRange any

Returns: void

Calls:

readLatin1String
name.includes
checkAssertions
registerType
integerReadValueFromPointer

Code

(primitiveType,name,size,minRange,maxRange)=>{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:name,fromWireType:fromWireType,toWireType:toWireType,argPackAdvance:GenericWireTypeSize,readValueFromPointer:integerReadValueFromPointer(name,size,minRange!==0),destructorFunction:null})}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`checkAssertions(value: any, toTypeName: any): void`¶

Parameters:

value any
toTypeName any

Returns: void

Code

(value,toTypeName)=>{}

`__embind_register_memory_view(rawType: any, dataTypeIndex: any, name: any): void`¶

Parameters:

rawType any
dataTypeIndex any
name any

Returns: void

Calls:

readLatin1String
registerType

Code

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

`decodeMemoryView(handle: any): Float32Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Float64Array<...> | Uint8Array<...> | Int8Array<...> | Int16Array<...>`¶

Parameters:

handle any

Code

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

`stringToUTF8Array(str: any, heap: any, outIdx: any, maxBytesToWrite: any): number`¶

Parameters:

str any
heap any
outIdx any
maxBytesToWrite any

Returns: number

Calls:

str.charCodeAt

Code

(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx}

`stringToUTF8(str: any, outPtr: any, maxBytesToWrite: any): number`¶

Parameters:

str any
outPtr any
maxBytesToWrite any

Returns: number

Calls:

stringToUTF8Array

Code

(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)

`lengthBytesUTF8(str: any): number`¶

Parameters:

str any

Returns: number

Calls:

str.charCodeAt

Code

str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len}

`UTF8ArrayToString(heapOrArray: any, idx: any, maxBytesToRead: any): string`¶

Parameters:

heapOrArray any
idx any
maxBytesToRead any

Returns: string

Calls:

UTF8Decoder.decode
heapOrArray.subarray
String.fromCharCode

Code

(heapOrArray,idx,maxBytesToRead)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str}

`UTF8ToString(ptr: any, maxBytesToRead: any): string`¶

Parameters:

ptr any
maxBytesToRead any

Returns: string

Code

(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""

`__embind_register_std_string(rawType: any, name: any): void`¶

Parameters:

rawType any
name any

Returns: void

Calls:

readLatin1String
registerType
UTF8ToString
String.fromCharCode
a.join
_free
throwBindingError
lengthBytesUTF8
_malloc
stringToUTF8
value.charCodeAt
destructors.push

Code

(rawType,name)=>{name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,fromWireType(value){var length=HEAPU32[value>>2];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){var maxRead=currentBytePtr-decodeStartPtr;var stringSegment=UTF8ToString(decodeStartPtr,maxRead);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}}else{var a=new Array(length);for(var i=0;i<length;++i){a[i]=String.fromCharCode(HEAPU8[payload+i])}str=a.join("")}_free(value);return str},toWireType(destructors,value){if(value instanceof ArrayBuffer){value=new Uint8Array(value)}var length;var valueIsOfTypeString=typeof value=="string";if(!(valueIsOfTypeString||value instanceof Uint8Array||value instanceof Uint8ClampedArray||value instanceof Int8Array)){throwBindingError("Cannot pass non-string to std::string")}if(stdStringIsUTF8&&valueIsOfTypeString){length=lengthBytesUTF8(value)}else{length=value.length}var base=_malloc(4+length+1);var ptr=base+4;HEAPU32[base>>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr,length+1)}else{if(valueIsOfTypeString){for(var i=0;i<length;++i){var charCode=value.charCodeAt(i);if(charCode>255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+i]=charCode}}else{for(var i=0;i<length;++i){HEAPU8[ptr+i]=value[i]}}}if(destructors!==null){destructors.push(_free,base)}return base},argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,destructorFunction(ptr){_free(ptr)}})}

`UTF16ToString(ptr: any, maxBytesToRead: any): string`¶

Parameters:

ptr any
maxBytesToRead any

Returns: string

Calls:

UTF16Decoder.decode
HEAPU8.subarray
String.fromCharCode

Code

(ptr,maxBytesToRead)=>{var endPtr=ptr;var idx=endPtr>>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder)return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr));var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit)}return str}

`stringToUTF16(str: any, outPtr: any, maxBytesToWrite: any): number`¶

Parameters:

str any
outPtr any
maxBytesToWrite any

Returns: number

Calls:

str.charCodeAt

Code

(str,outPtr,maxBytesToWrite)=>{maxBytesToWrite??=2147483647;if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite<str.length*2?maxBytesToWrite/2:str.length;for(var i=0;i<numCharsToWrite;++i){var codeUnit=str.charCodeAt(i);HEAP16[outPtr>>1]=codeUnit;outPtr+=2}HEAP16[outPtr>>1]=0;return outPtr-startPtr}

`lengthBytesUTF16(str: any): number`¶

Parameters:

str any

Returns: number

Code

str=>str.length*2

`UTF32ToString(ptr: any, maxBytesToRead: any): string`¶

Parameters:

ptr any
maxBytesToRead any

Returns: string

Calls:

String.fromCharCode

Code

(ptr,maxBytesToRead)=>{var i=0;var str="";while(!(i>=maxBytesToRead/4)){var utf32=HEAP32[ptr+i*4>>2];if(utf32==0)break;++i;if(utf32>=65536){var ch=utf32-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}else{str+=String.fromCharCode(utf32)}}return str}

`stringToUTF32(str: any, outPtr: any, maxBytesToWrite: any): number`¶

Parameters:

str any
outPtr any
maxBytesToWrite any

Returns: number

Calls:

str.charCodeAt

Code

(str,outPtr,maxBytesToWrite)=>{maxBytesToWrite??=2147483647;if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i<str.length;++i){var codeUnit=str.charCodeAt(i);if(codeUnit>=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr}

`lengthBytesUTF32(str: any): number`¶

Parameters:

str any

Returns: number

Calls:

str.charCodeAt

Code

str=>{var len=0;for(var i=0;i<str.length;++i){var codeUnit=str.charCodeAt(i);if(codeUnit>=55296&&codeUnit<=57343)++i;len+=4}return len}

`__embind_register_std_wstring(rawType: any, charSize: any, name: any): void`¶

Parameters:

rawType any
charSize any
name any

Returns: void

Calls:

readLatin1String
registerType
readCharAt
decodeString
String.fromCharCode
_free
throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(rawType,charSize,name)=>{name=readLatin1String(name);var decodeString,encodeString,readCharAt,lengthBytesUTF;if(charSize===2){decodeString=UTF16ToString;encodeString=stringToUTF16;lengthBytesUTF=lengthBytesUTF16;readCharAt=pointer=>HEAPU16[pointer>>1]}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;readCharAt=pointer=>HEAPU32[pointer>>2]}registerType(rawType,{name:name,fromWireType:value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str},toWireType:(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr},argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,destructorFunction(ptr){_free(ptr)}})}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`__embind_register_value_object(rawType: any, name: any, constructorSignature: any, rawConstructor: any, destructorSignature: any, rawDestructor: any): void`¶

Parameters:

rawType any
name any
constructorSignature any
rawConstructor any
destructorSignature any
rawDestructor any

Returns: void

Calls:

readLatin1String
embind__requireFunction

Code

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

`__embind_register_value_object_field(structType: any, fieldName: any, getterReturnType: any, getterSignature: any, getter: any, getterContext: any, setterArgumentType: any, setterSignature: any, setter: any, setterContext: any): void`¶

Parameters:

structType any
fieldName any
getterReturnType any
getterSignature any
getter any
getterContext any
setterArgumentType any
setterSignature any
setter any
setterContext any

Returns: void

Calls:

structRegistrations[structType].fields.push
readLatin1String
embind__requireFunction

Code

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

`__embind_register_void(rawType: any, name: any): void`¶

Parameters:

rawType any
name any

Returns: void

Calls:

readLatin1String
registerType

Code

(rawType,name)=>{name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,argPackAdvance:0,fromWireType:()=>undefined,toWireType:(destructors,o)=>undefined})}

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

`__emscripten_memcpy_js(dest: any, src: any, num: any): any`¶

Parameters:

dest any
src any
num any

Returns: any

Calls:

HEAPU8.copyWithin

Code

(dest,src,num)=>HEAPU8.copyWithin(dest,src,src+num)

`emval_returnValue(returnType: any, destructorsRef: any, handle: any): any`¶

Parameters:

returnType any
destructorsRef any
handle any

Returns: any

Calls:

complex_call_50190
Emval.toHandle

Code

(returnType,destructorsRef,handle)=>{var destructors=[];var result=returnType["toWireType"](destructors,handle);if(destructors.length){HEAPU32[destructorsRef>>2]=Emval.toHandle(destructors)}return result}

`__emval_as(handle: any, returnType: any, destructorsRef: any): any`¶

Parameters:

handle any
returnType any
destructorsRef any

Returns: any

Calls:

Emval.toValue
requireRegisteredType
emval_returnValue

Code

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

`__emval_call(caller: any, handle: any, destructorsRef: any, args: any): any`¶

Parameters:

caller any
handle any
destructorsRef any
args any

Returns: any

Calls:

Emval.toValue
caller

Code

(caller,handle,destructorsRef,args)=>{caller=emval_methodCallers[caller];handle=Emval.toValue(handle);return caller(null,handle,destructorsRef,args)}

`getStringOrSymbol(address: any): any`¶

Parameters:

address any

Returns: any

Calls:

readLatin1String

Code

address=>{var symbol=emval_symbols[address];if(symbol===undefined){return readLatin1String(address)}return symbol}

`__emval_call_method(caller: any, objHandle: any, methodName: any, destructorsRef: any, args: any): any`¶

Parameters:

caller any
objHandle any
methodName any
destructorsRef any
args any

Returns: any

Calls:

Emval.toValue
getStringOrSymbol
caller

Code

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

`emval_get_global(): any`¶

Returns: any

Calls:

complex_call_51216

Code

()=>{if(typeof globalThis=="object"){return globalThis}return function(){return Function}()("return this")()}

`__emval_get_global(name: any): any`¶

Parameters:

name any

Returns: any

Calls:

Emval.toHandle
emval_get_global
getStringOrSymbol

Code

name=>{if(name===0){return Emval.toHandle(emval_get_global())}else{name=getStringOrSymbol(name);return Emval.toHandle(emval_get_global()[name])}}

`emval_addMethodCaller(caller: any): number`¶

Parameters:

caller any

Returns: number

Calls:

emval_methodCallers.push

Code

caller=>{var id=emval_methodCallers.length;emval_methodCallers.push(caller);return id}

`emval_lookupTypes(argCount: any, argTypes: any): any[]`¶

Parameters:

argCount any
argTypes any

Returns: any[]

Calls:

requireRegisteredType

Code

(argCount,argTypes)=>{var a=new Array(argCount);for(var i=0;i<argCount;++i){a[i]=requireRegisteredType(HEAPU32[argTypes+i*4>>2],"parameter "+i)}return a}

`__emval_get_method_caller(argCount: any, argTypes: any, kind: any): number`¶

Parameters:

argCount any
argTypes any
kind any

Returns: number

Calls:

emval_lookupTypes
types.shift
argsList.push
params.push
args.push
argsList.join
complex_call_52641
types.map(t=>t.name).join
emval_addMethodCaller
createNamedFunction

Code

(argCount,argTypes,kind)=>{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(emval_returnValue);functionBody+="  return emval_returnValue(retType, destructorsRef, rv);\n"}functionBody+="};\n";params.push(functionBody);var invokerFunction=newFunc(Function,params)(...args);var functionName=`methodCaller<(${types.map(t=>t.name).join(", ")}) => ${retType.name}>`;return emval_addMethodCaller(createNamedFunction(functionName,invokerFunction))}

`__emval_get_module_property(name: any): any`¶

Parameters:

name any

Returns: any

Calls:

getStringOrSymbol
Emval.toHandle

Code

name=>{name=getStringOrSymbol(name);return Emval.toHandle(Module[name])}

`__emval_get_property(handle: any, key: any): any`¶

Parameters:

handle any
key any

Returns: any

Calls:

Emval.toValue
Emval.toHandle

Code

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

`__emval_incref(handle: any): void`¶

Parameters:

handle any

Returns: void

Code

handle=>{if(handle>9){emval_handles[handle+1]+=1}}

`__emval_new_cstring(v: any): any`¶

Parameters:

v any

Returns: any

Calls:

Emval.toHandle

Code

v=>Emval.toHandle(getStringOrSymbol(v))

`__emval_run_destructors(handle: any): void`¶

Parameters:

handle any

Returns: void

Calls:

Emval.toValue
runDestructors
__emval_decref

Code

handle=>{var destructors=Emval.toValue(handle);runDestructors(destructors);__emval_decref(handle)}

`getHeapMax(): number`¶

Returns: number

Code

()=>2147483648

`growMemory(size: any): number`¶

Parameters:

size any

Returns: number

Calls:

wasmMemory.grow
updateMemoryViews

Code

size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}}

`_emscripten_resize_heap(requestedSize: any): boolean`¶

Parameters:

requestedSize any

Returns: boolean

Calls:

getHeapMax
Math.min
alignUp
Math.max
growMemory

Code

requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}var alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false}

`alignUp(x: any, multiple: any): any`¶

Parameters:

x any
multiple any

Returns: any

Code

(x,multiple)=>x+(multiple-x%multiple)%multiple

`_fd_close(fd: any): number`¶

Parameters:

fd any

Returns: number

Code

fd=>52

`convertI32PairToI53Checked(lo: any, hi: any): number`¶

Parameters:

lo any
hi any

Returns: number

Code

(lo,hi)=>hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN

`_fd_seek(fd: any, offset_low: any, offset_high: any, whence: any, newOffset: any): number`¶

Parameters:

fd any
offset_low any
offset_high any
whence any
newOffset any

Returns: number

Calls:

convertI32PairToI53Checked

Code

function _fd_seek(fd,offset_low,offset_high,whence,newOffset){var offset=convertI32PairToI53Checked(offset_low,offset_high);return 70}

`printChar(stream: any, curr: any): void`¶

Parameters:

stream any
curr any

Returns: void

Calls:

complex_call_54445
UTF8ArrayToString
buffer.push

Code

(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer,0));buffer.length=0}else{buffer.push(curr)}}

`_fd_write(fd: any, iov: any, iovcnt: any, pnum: any): number`¶

Parameters:

fd any
iov any
iovcnt any
pnum any

Returns: number

Calls:

printChar

Code

(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0}

`___wasm_call_ctors(): any`¶

Returns: any

Calls:

complex_call_56194

Code

()=>(___wasm_call_ctors=wasmExports["M"])()

`___getTypeName(a0: any): any`¶

Parameters:

a0 any

Returns: any

Calls:

complex_call_56257

Code

a0=>(___getTypeName=wasmExports["N"])(a0)

`_malloc(a0: any): any`¶

Parameters:

a0 any

Returns: any

Calls:

complex_call_56311

Code

a0=>(_malloc=wasmExports["O"])(a0)

`_free(a0: any): any`¶

Parameters:

a0 any

Returns: any

Calls:

complex_call_56356

Code

a0=>(_free=wasmExports["Q"])(a0)

`___cxa_is_pointer_type(a0: any): any`¶

Parameters:

a0 any

Returns: any

Calls:

complex_call_56416

Code

a0=>(___cxa_is_pointer_type=wasmExports["R"])(a0)

`run(): void`¶

Returns: void

Calls:

preRun
initRuntime
readyPromiseResolve
complex_call_56932
postRun
complex_call_57001
setTimeout
complex_call_57079
doRun

Code

function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}

`doRun(): void`¶

Returns: void

Calls:

initRuntime
readyPromiseResolve
complex_call_56932
postRun

Code

function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);Module["onRuntimeInitialized"]?.();postRun()}

`ExceptionInfo.set_type(type: any): void`¶

Parameters:

type any

Returns: void

Code

set_type(type){HEAPU32[this.ptr+4>>2]=type}

`ExceptionInfo.get_type(): any`¶

Returns: any

Code

get_type(){return HEAPU32[this.ptr+4>>2]}

`ExceptionInfo.set_destructor(destructor: any): void`¶

Parameters:

destructor any

Returns: void

Code

set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}

`ExceptionInfo.get_destructor(): any`¶

Returns: any

Code

get_destructor(){return HEAPU32[this.ptr+8>>2]}

`ExceptionInfo.set_caught(caught: any): void`¶

Parameters:

caught any

Returns: void

Code

set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}

`ExceptionInfo.get_caught(): boolean`¶

Returns: boolean

Code

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

`ExceptionInfo.set_rethrown(rethrown: any): void`¶

Parameters:

rethrown any

Returns: void

Code

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

`ExceptionInfo.get_rethrown(): boolean`¶

Returns: boolean

Code

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

`ExceptionInfo.init(type: any, destructor: any): void`¶

Parameters:

type any
destructor any

Returns: void

Calls:

this.set_adjusted_ptr
this.set_type
this.set_destructor

Code

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

`ExceptionInfo.set_adjusted_ptr(adjustedPtr: any): void`¶

Parameters:

adjustedPtr any

Returns: void

Code

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

`ExceptionInfo.get_adjusted_ptr(): any`¶

Returns: any

Code

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

`ExceptionInfo.get_exception_ptr(): any`¶

Returns: any

Calls:

___cxa_is_pointer_type
this.get_type
this.get_adjusted_ptr

Code

get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`read(ptr: any): any`¶

Parameters:

ptr any

Returns: any

Calls:

complex_call_10907

Code

ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr))

`write(ptr: any, o: any): void`¶

Parameters:

ptr any
o any

Returns: void

Calls:

setter
complex_call_11027
runDestructors

Code

(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`fromWireType(ptr: any): {}`¶

Parameters:

ptr any

Returns: {}

Calls:

fields[i].read
rawDestructor

Code

ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Calls:

rawConstructor
fields[fieldName].write
destructors.push

Code

(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr}

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`fromWireType(wt: any): boolean`¶

Parameters:

wt any

Returns: boolean

Code

function(wt){return!!wt}

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

function(destructors,o){return o?trueValue:falseValue}

`readValueFromPointer(pointer: any): any`¶

Parameters:

pointer any

Returns: any

Calls:

complex_call_13234

Code

function(pointer){return this["fromWireType"](HEAPU8[pointer])}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`toValue(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

throwBindingError

Code

handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]}

`toHandle(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

emval_freelist.pop

Code

value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(handle: any): any`¶

Parameters:

handle any

Returns: any

Calls:

Emval.toValue
__emval_decref

Code

handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

Emval.toHandle

Code

(destructors,value)=>Emval.toHandle(value)

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`fromWireType(c: any): any`¶

Parameters:

c any

Returns: any

Code

function(c){return this.constructor.values[c]}

`toWireType(destructors: any, c: any): any`¶

Parameters:

destructors any
c any

Returns: any

Code

(destructors,c)=>c.value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Code

value=>value

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Code

(destructors,value)=>value

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`fromWireType(value: any): any`¶

Parameters:

value any

Returns: any

Calls:

readCharAt
decodeString
String.fromCharCode
_free

Code

value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str}

`toWireType(destructors: any, value: any): any`¶

Parameters:

destructors any
value any

Returns: any

Calls:

throwBindingError
lengthBytesUTF
_malloc
encodeString
destructors.push

Code

(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr}

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

`fromWireType(): any`¶

Returns: any

Code

()=>undefined

`toWireType(destructors: any, o: any): any`¶

Parameters:

destructors any
o any

Returns: any

Code

(destructors,o)=>undefined

Classes¶

`ExceptionInfo`¶

Class Code

class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=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]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}

Methods¶

`set_type(type: any): void`¶

Code

set_type(type){HEAPU32[this.ptr+4>>2]=type}

`get_type(): any`¶

Code

get_type(){return HEAPU32[this.ptr+4>>2]}

`set_destructor(destructor: any): void`¶

Code

set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}

`get_destructor(): any`¶

Code

get_destructor(){return HEAPU32[this.ptr+8>>2]}

`set_caught(caught: any): void`¶

Code

set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}

`get_caught(): boolean`¶

Code

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

`set_rethrown(rethrown: any): void`¶

Code

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

`get_rethrown(): boolean`¶

Code

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

`init(type: any, destructor: any): void`¶

Code

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

`set_adjusted_ptr(adjustedPtr: any): void`¶

Code

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

`get_adjusted_ptr(): any`¶

Code

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

`get_exception_ptr(): any`¶

Code

get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}

`ExceptionInfo`¶

Class Code

class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=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]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}

Methods¶

`set_type(type: any): void`¶

Code

set_type(type){HEAPU32[this.ptr+4>>2]=type}

`get_type(): any`¶

Code

get_type(){return HEAPU32[this.ptr+4>>2]}

`set_destructor(destructor: any): void`¶

Code

set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}

`get_destructor(): any`¶

Code

get_destructor(){return HEAPU32[this.ptr+8>>2]}

`set_caught(caught: any): void`¶

Code

set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}

`get_caught(): boolean`¶

Code

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

`set_rethrown(rethrown: any): void`¶

Code

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

`get_rethrown(): boolean`¶

Code

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

`init(type: any, destructor: any): void`¶

Code

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

`set_adjusted_ptr(adjustedPtr: any): void`¶

Code

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

`get_adjusted_ptr(): any`¶

Code

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

`get_exception_ptr(): any`¶

Code

get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}

📄 basis_transcoder.js¶

📊 Analysis Summary¶

📚 Table of Contents¶

🛠️ File Location:¶

Variables & Constants¶

Async/Await Patterns¶

Functions¶

quit_(status: any, toThrow: any): never¶

locateFile(path: any): any¶

updateMemoryViews(): void¶

preRun(): void¶

initRuntime(): void¶

postRun(): void¶

addOnPreRun(cb: any): void¶

addOnInit(cb: any): void¶

addOnPostRun(cb: any): void¶

addRunDependency(id: any): void¶

removeRunDependency(id: any): void¶

abort(what: any): void¶

isDataURI(filename: any): any¶

isFileURI(filename: any): any¶

findWasmBinary(): any¶

getBinarySync(file: any): any¶

getBinaryPromise(binaryFile: any): any¶

instantiateArrayBuffer(binaryFile: any, imports: any, receiver: any): any¶

instantiateAsync(binary: any, binaryFile: any, imports: any, callback: any): any¶

createWasm(): any¶

receiveInstance(instance: any, module: any): any¶

receiveInstantiationResult(result: any): void¶

callRuntimeCallbacks(callbacks: any): void¶

ExceptionInfo.set_type(type: any): void¶

ExceptionInfo.get_type(): any¶

ExceptionInfo.set_destructor(destructor: any): void¶

ExceptionInfo.get_destructor(): any¶

ExceptionInfo.set_caught(caught: any): void¶

ExceptionInfo.get_caught(): boolean¶

ExceptionInfo.set_rethrown(rethrown: any): void¶

ExceptionInfo.get_rethrown(): boolean¶

ExceptionInfo.init(type: any, destructor: any): void¶

ExceptionInfo.set_adjusted_ptr(adjustedPtr: any): void¶

ExceptionInfo.get_adjusted_ptr(): any¶

ExceptionInfo.get_exception_ptr(): any¶

___cxa_throw(ptr: any, type: any, destructor: any): never¶

__abort_js(): void¶

runDestructors(destructors: any): void¶

readPointer(pointer: any): any¶

throwInternalError(message: any): never¶

whenDependentTypesAreResolved(myTypes: any, dependentTypes: any, getTypeConverters: any): void¶

onComplete(typeConverters: any): void¶

__embind_finalize_value_object(structType: any): void¶

read(ptr: any): any¶

write(ptr: any, o: any): void¶

read(ptr: any): any¶

write(ptr: any, o: any): void¶

fromWireType(ptr: any): {}¶

toWireType(destructors: any, o: any): any¶

fromWireType(ptr: any): {}¶

toWireType(destructors: any, o: any): any¶

read(ptr: any): any¶

write(ptr: any, o: any): void¶

read(ptr: any): any¶

write(ptr: any, o: any): void¶

fromWireType(ptr: any): {}¶

toWireType(destructors: any, o: any): any¶

fromWireType(ptr: any): {}¶

toWireType(destructors: any, o: any): any¶

__embind_register_bigint(primitiveType: any, name: any, size: any, minRange: any, maxRange: any): void¶

embind_init_charCodes(): void¶

readLatin1String(ptr: any): string¶

throwBindingError(message: any): never¶

sharedRegisterType(rawType: any, registeredInstance: any, options: {}): void¶

registerType(rawType: any, registeredInstance: any, options: {}): void¶

__embind_register_bool(rawType: any, name: any, trueValue: any, falseValue: any): void¶

fromWireType(wt: any): boolean¶

toWireType(destructors: any, o: any): any¶

readValueFromPointer(pointer: any): any¶

fromWireType(wt: any): boolean¶

toWireType(destructors: any, o: any): any¶

readValueFromPointer(pointer: any): any¶

fromWireType(wt: any): boolean¶

📄 `basis_transcoder.js`¶

`quit_(status: any, toThrow: any): never`¶

`locateFile(path: any): any`¶

`updateMemoryViews(): void`¶

`preRun(): void`¶

`initRuntime(): void`¶

`postRun(): void`¶

`addOnPreRun(cb: any): void`¶

`addOnInit(cb: any): void`¶

`addOnPostRun(cb: any): void`¶

`addRunDependency(id: any): void`¶

`removeRunDependency(id: any): void`¶

`abort(what: any): void`¶

`isDataURI(filename: any): any`¶

`isFileURI(filename: any): any`¶

`findWasmBinary(): any`¶

`getBinarySync(file: any): any`¶

`getBinaryPromise(binaryFile: any): any`¶

`instantiateArrayBuffer(binaryFile: any, imports: any, receiver: any): any`¶

`instantiateAsync(binary: any, binaryFile: any, imports: any, callback: any): any`¶

`createWasm(): any`¶

`receiveInstance(instance: any, module: any): any`¶

`receiveInstantiationResult(result: any): void`¶

`callRuntimeCallbacks(callbacks: any): void`¶

`ExceptionInfo.set_type(type: any): void`¶

`ExceptionInfo.get_type(): any`¶

`ExceptionInfo.set_destructor(destructor: any): void`¶

`ExceptionInfo.get_destructor(): any`¶

`ExceptionInfo.set_caught(caught: any): void`¶

`ExceptionInfo.get_caught(): boolean`¶

`ExceptionInfo.set_rethrown(rethrown: any): void`¶

`ExceptionInfo.get_rethrown(): boolean`¶

`ExceptionInfo.init(type: any, destructor: any): void`¶

`ExceptionInfo.set_adjusted_ptr(adjustedPtr: any): void`¶

`ExceptionInfo.get_adjusted_ptr(): any`¶

`ExceptionInfo.get_exception_ptr(): any`¶

`___cxa_throw(ptr: any, type: any, destructor: any): never`¶

`__abort_js(): void`¶

`runDestructors(destructors: any): void`¶

`readPointer(pointer: any): any`¶

`throwInternalError(message: any): never`¶

`whenDependentTypesAreResolved(myTypes: any, dependentTypes: any, getTypeConverters: any): void`¶

`onComplete(typeConverters: any): void`¶

`__embind_finalize_value_object(structType: any): void`¶

`read(ptr: any): any`¶

`write(ptr: any, o: any): void`¶

`read(ptr: any): any`¶

`write(ptr: any, o: any): void`¶

`fromWireType(ptr: any): {}`¶

`toWireType(destructors: any, o: any): any`¶

`fromWireType(ptr: any): {}`¶

`toWireType(destructors: any, o: any): any`¶

`read(ptr: any): any`¶

`write(ptr: any, o: any): void`¶

`read(ptr: any): any`¶

`write(ptr: any, o: any): void`¶

`fromWireType(ptr: any): {}`¶

`toWireType(destructors: any, o: any): any`¶

`fromWireType(ptr: any): {}`¶

`toWireType(destructors: any, o: any): any`¶

`__embind_register_bigint(primitiveType: any, name: any, size: any, minRange: any, maxRange: any): void`¶

`embind_init_charCodes(): void`¶

`readLatin1String(ptr: any): string`¶

`throwBindingError(message: any): never`¶

`sharedRegisterType(rawType: any, registeredInstance: any, options: {}): void`¶

`registerType(rawType: any, registeredInstance: any, options: {}): void`¶

`__embind_register_bool(rawType: any, name: any, trueValue: any, falseValue: any): void`¶

`fromWireType(wt: any): boolean`¶

`toWireType(destructors: any, o: any): any`¶

`readValueFromPointer(pointer: any): any`¶

`fromWireType(wt: any): boolean`¶

`toWireType(destructors: any, o: any): any`¶

`readValueFromPointer(pointer: any): any`¶

`fromWireType(wt: any): boolean`¶

`toWireType(destructors: any, o: any): any`¶

`readValueFromPointer(pointer: any): any`¶

`fromWireType(wt: any): boolean`¶

`toWireType(destructors: any, o: any): any`¶

`readValueFromPointer(pointer: any): any`¶

`shallowCopyInternalPointer(o: any): { count: any; deleteScheduled: any; preservePointerOnDelete: any; ptr: any; ptrType: any; smartPtr: any; smartPtrType: any; }`¶