From 6fd5849adec050392302b2257feff1889e56a831 Mon Sep 17 00:00:00 2001 From: Till Riedel Date: Sat, 12 Jul 2025 14:14:09 +0200 Subject: [PATCH 1/3] add predictor to rollup --- dist/index.browser.esm.js | 347 ++++++++++++++++++++++++++++++++++++- dist/index.browser.js | 353 +++++++++++++++++++++++++++++++++++++- dist/index.esm.js | 350 ++++++++++++++++++++++++++++++++++++- dist/index.js | 352 ++++++++++++++++++++++++++++++++++++- package-lock.json | 19 +- package.json | 2 +- rollup.config.mjs | 18 +- src/index.js | 7 +- 8 files changed, 1414 insertions(+), 34 deletions(-) mode change 100644 => 100755 dist/index.browser.esm.js mode change 100644 => 100755 dist/index.browser.js mode change 100644 => 100755 dist/index.esm.js mode change 100644 => 100755 dist/index.js diff --git a/dist/index.browser.esm.js b/dist/index.browser.esm.js old mode 100644 new mode 100755 index d5786f4..ae8f969 --- a/dist/index.browser.esm.js +++ b/dist/index.browser.esm.js @@ -1,3 +1,6 @@ +import require$$0 from 'path'; +import require$$1 from 'fs'; + var axios$2 = {exports: {}}; var axios$1 = {exports: {}}; @@ -2375,6 +2378,347 @@ function requireAxios () { return axios$2.exports; } +/** + * + * @param {number} x + * @param {number} y + * @param {number} a + * @returns {number} + */ + const lerp = (x, y, a) => x * (1 - a) + y * a; + /** + * in place + * @param {(number | null)[]} arr + * @param {number | undefined} l value for entries before first known, if undefined first known + * @param {number | undefined} r value for entries after last known, if undefined last known + * @return {number[]} + */ + const interpolateLinear = (arr, l, r) => { + let leftmost = l; + let nullCount = 0; + + for (let i = 0; i < arr.length;) { + if (arr[i] !== null) { + for (let j = 0; j < nullCount; j++) { + arr[i - (nullCount - j)] = typeof leftmost !== 'undefined' ? lerp(leftmost, arr[i], (j + 1) / (nullCount + 1)) : arr[i]; + } + nullCount = 0; + + leftmost = arr[i]; + i++; + continue; + } + for (; arr[i] === null; i++) { + nullCount++; + } + } + for (let j = 0; j < nullCount; j++) { + arr[arr.length - (nullCount - j)] = leftmost; + } + }; + +var edgeFel = {exports: {}}; + +var hasRequiredEdgeFel; + +function requireEdgeFel () { + if (hasRequiredEdgeFel) return edgeFel.exports; + hasRequiredEdgeFel = 1; + (function (module, exports) { + var Module = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( + function(Module) { + Module = Module || {}; + + var Module=typeof Module!="undefined"?Module:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise(function(resolve,reject){readyPromiseResolve=resolve;readyPromiseReject=reject;});var moduleOverrides=Object.assign({},Module);var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary;var fs;var nodePath;var requireNodeFS;if(ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){scriptDirectory=require$$0.dirname(scriptDirectory)+"/";}else {scriptDirectory=__dirname+"/";}requireNodeFS=()=>{if(!nodePath){fs=require$$1;nodePath=require$$0;}};read_=function shell_read(filename,binary){var ret=tryParseAsDataURI(filename);if(ret){return binary?ret:ret.toString()}requireNodeFS();filename=nodePath["normalize"](filename);return fs.readFileSync(filename,binary?undefined:"utf8")};readBinary=filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret);}return ret};readAsync=(filename,onload,onerror)=>{var ret=tryParseAsDataURI(filename);if(ret){onload(ret);}requireNodeFS();filename=nodePath["normalize"](filename);fs.readFile(filename,function(err,data){if(err)onerror(err);else onload(data.buffer);});};if(process["argv"].length>1){process["argv"][1].replace(/\\/g,"/");}process["argv"].slice(2);process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});process["on"]("unhandledRejection",function(reason){throw reason});Module["inspect"]=function(){return "[Emscripten Module object]"};}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href;}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src;}if(_scriptDir){scriptDirectory=_scriptDir;}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1);}else {scriptDirectory="";}{read_=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}};}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror();};xhr.onerror=onerror;xhr.send(null);};}}else;Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])Module["arguments"];if(Module["thisProgram"])Module["thisProgram"];if(Module["quit"])Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];Module["noExitRuntime"]||true;if(typeof WebAssembly!="object"){abort("no native wasm support detected");}var wasmMemory;var ABORT=false;function assert(condition,text){if(!condition){abort(text);}}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(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))}else {var str="";while(idx>10,56320|ch&1023);}}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=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}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i=55296&&u<=57343)u=65536+((u&1023)<<10)|str.charCodeAt(++i)&1023;if(u<=127)++len;else if(u<=2047)len+=2;else if(u<=65535)len+=3;else len+=4;}return len}var UTF16Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf-16le"):undefined;function UTF16ToString(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))}else {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}}function stringToUTF16(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2;}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(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}function stringToUTF32(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=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}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4;}return len}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferAndViews(buf){buffer=buf;Module["HEAP8"]=HEAP8=new Int8Array(buf);Module["HEAP16"]=HEAP16=new Int16Array(buf);Module["HEAP32"]=HEAP32=new Int32Array(buf);Module["HEAPU8"]=HEAPU8=new Uint8Array(buf);Module["HEAPU16"]=HEAPU16=new Uint16Array(buf);Module["HEAPU32"]=HEAPU32=new Uint32Array(buf);Module["HEAPF32"]=HEAPF32=new Float32Array(buf);Module["HEAPF64"]=HEAPF64=new Float64Array(buf);}Module["INITIAL_MEMORY"]||16777216;var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift());}}callRuntimeCallbacks(__ATPRERUN__);}function initRuntime(){callRuntimeCallbacks(__ATINIT__);}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift());}}callRuntimeCallbacks(__ATPOSTRUN__);}function addOnPreRun(cb){__ATPRERUN__.unshift(cb);}function addOnInit(cb){__ATINIT__.unshift(cb);}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb);}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback();}}}function abort(what){{if(Module["onAbort"]){Module["onAbort"](what);}}what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}function isFileURI(filename){return filename.startsWith("file://")}var wasmBinaryFile;wasmBinaryFile="data:application/octet-stream;base64,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";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile);}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}else {throw "both async and sync fetching of the wasm failed"}}catch(err){abort(err);}}function getBinaryPromise(){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"&&!isFileURI(wasmBinaryFile)){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){if(!response["ok"]){throw "failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()}).catch(function(){return getBinary(wasmBinaryFile)})}else {if(readAsync){return new Promise(function(resolve,reject){readAsync(wasmBinaryFile,function(response){resolve(new Uint8Array(response));},reject);})}}}return Promise.resolve().then(function(){return getBinary(wasmBinaryFile)})}function createWasm(){var info={"a":asmLibraryArg};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["u"];updateGlobalBufferAndViews(wasmMemory.buffer);wasmTable=Module["asm"]["x"];addOnInit(Module["asm"]["v"]);removeRunDependency();}addRunDependency();function receiveInstantiationResult(result){receiveInstance(result["instance"]);}function instantiateArrayBuffer(receiver){return getBinaryPromise().then(function(binary){return WebAssembly.instantiate(binary,info)}).then(function(instance){return instance}).then(receiver,function(reason){err("failed to asynchronously prepare wasm: "+reason);abort(reason);})}function instantiateAsync(){if(!wasmBinary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(wasmBinaryFile)&&!isFileURI(wasmBinaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){var result=WebAssembly.instantiateStreaming(response,info);return result.then(receiveInstantiationResult,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(receiveInstantiationResult)})})}else {return instantiateArrayBuffer(receiveInstantiationResult)}}if(Module["instantiateWasm"]){try{var exports=Module["instantiateWasm"](info,receiveInstance);return exports}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}instantiateAsync().catch(readyPromiseReject);return {}}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func=="number"){if(callback.arg===undefined){getWasmTableEntry(func)();}else {getWasmTableEntry(func)(callback.arg);}}else {func(callback.arg===undefined?null:callback.arg);}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr);}return func}function ___cxa_allocate_exception(size){return _malloc(size+24)+24}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type;};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor;};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount;};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught;};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown;};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false);};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1;};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr;};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){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};}function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);throw ptr}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+size)}}function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i);}embind_charCodes=codes;}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]];}return ret}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var char_0=48;var char_9=57;function makeLegalFunctionName(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}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return new Function("body","return function "+name+"() {\n"+' "use strict";'+" return body.apply(this, arguments);\n"+"};\n")(body)}function extendError(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}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function whenDependentTypesAreResolved(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{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);}}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError('type "'+name+'" must have a positive integer typeid pointer');}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else {throwBindingError("Cannot register type '"+name+"' twice");}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb());}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return !!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8;}else if(size===2){heap=HEAP16;}else if(size===4){heap=HEAP32;}else {throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null});}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;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}function shallowCopyInternalPointer(o){return {count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted");}var finalizationRegistry=false;function detachFinalizer(handle){}function runDestructor($$){if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr);}else {$$.ptrType.registeredClass.rawDestructor($$.ptr);}}function releaseClassHandle($$){$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$);}}function downcastPointer(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)}var registeredPointers={};function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k]);}}return rv}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]();}}var delayFunction=undefined;function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes);}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction;}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined");}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass;}return ptr}function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}function makeClassHandle(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}}))}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})}}function attachFinalizer(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)}function ClassHandle_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}}function ClassHandle_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;}}function ClassHandle_isDeleted(){return !this.$$.ptr}function ClassHandle_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}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater;}function ClassHandle(){}function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError("Function '"+humanName+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+proto[methodName].overloadTable+")!");}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc;}}function exposePublicSymbol(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;}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[];}function upcastPointer(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}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name);}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr);}return ptr}else {return 0}}if(!handle.$$){throwBindingError('Cannot pass "'+_embind_repr(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(function(){clonedHandle["delete"]();}));if(destructors!==null){destructors.push(this.rawDestructor,ptr);}}break;default:throwBindingError("Unsupporting sharing policy");}}return ptr}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}if(handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+handle.$$.ptrType.name+" to parameter type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr);}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr);}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]();}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType;}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&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}else {this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}}else {this["toWireType"]=genericPointerToWireType;}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol");}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value;}else {Module[name]=value;Module[name].argCount=numArguments;}}function dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(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}var UnboundTypeError=undefined;function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function throwUnboundTypeError(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([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast);}if(downcast){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]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype;}else {basePrototype=ClassHandle.prototype;}var constructor=createNamedFunction(legalFunctionName,function(){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[arguments.length];if(undefined===body){throw new BindingError("Tried to invoke ctor of "+name+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(registeredClass.constructor_body).toString()+") parameters instead!")}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);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]});}function heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i>2)+i]);}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr);}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(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,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return []});return []});}function new_(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}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc){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=false;for(var i=1;i0?", ":"")+argsListWired;}invokerFnBody+=(returns?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n";}else {for(var i=isClassMethodFunc?1:2;i4&&0===--emval_handle_array[handle].refcount){emval_handle_array[handle]=undefined;emval_free_list.push(handle);}}function count_emval_handles(){var count=0;for(var i=5;i{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle);}return emval_handle_array[handle].value},toHandle:value=>{switch(value){case undefined:return 1;case null:return 2;case true:return 3;case false:return 4;default:{var handle=emval_free_list.length?emval_free_list.pop():emval_handle_array.length;emval_handle_array[handle]={refcount:1,value:value};return handle}}}};function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null});}function _embind_repr(v){if(v===null){return "null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else {return ""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null});}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>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":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null});}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true});}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var str;if(stdStringIsUTF8){var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+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;ilengthBytesUTF8(value);}else {getLength=()=>value.length;}var length=getLength();var ptr=_malloc(4+length+1);HEAPU32[ptr>>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr+4,length+1);}else {if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits");}HEAPU8[ptr+4+i]=charCode;}}else {for(var i=0;iHEAPU16;shift=1;}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>HEAPU32;shift=2;}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==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":function(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>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr);}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr);}});}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}});}function __emval_incref(handle){if(handle>4){emval_handle_array[handle].refcount+=1;}}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType));}return impl}function __emval_take_value(type,argv){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](argv);return Emval.toHandle(v)}function _abort(){abort("");}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num);}function abortOnCannotGrowMemory(requestedSize){abort("OOM");}function _emscripten_resize_heap(requestedSize){HEAPU8.length;abortOnCannotGrowMemory();}embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();function intArrayToString(array){var ret=[];for(var i=0;i255){chr&=255;}ret.push(String.fromCharCode(chr));}return ret.join("")}var decodeBase64=typeof atob=="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2);}if(enc4!==64){output=output+String.fromCharCode(chr3);}}while(i0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun();}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("");},1);doRun();},1);}else {doRun();}}Module["run"]=run;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()();}}run(); + + + return Module.ready + } + ); + })(); + module.exports = Module; +} (edgeFel)); + return edgeFel.exports; +} + +requireEdgeFel(); + +const Module = requireEdgeFel()(); +let _cachedFel; + +const arrToVector = async (arr, type = 'float') => { + const v = new ((await Module)[`vector${type}`])(); + for (const val of arr) { + v.push_back(val); + } + return v; +}; + +const vectorToArr = (vector) => new Array(vector.size()).fill(0).map((_, i) => vector.get(i)); + +const objToMap = async (obj, type = 'float') => { + const m = new ((await Module)[`mapstring${type}`])(); + for (const [key, val] of Object.entries(obj)) { + m.set(key, val); + } + return m; +}; + +const mapToObj = (map) => { + const obj = {}; + const keys = vectorToArr(map.keys()); + for (const key of keys) { + obj[key] = map.get(key); + } + return obj +}; + +const extractSome = async (features, inArr, params) => { + const values = await arrToVector(inArr); + const delegate = await _getFel(); + const ret = delegate.extractSome(features, values, params); + const retObj = mapToObj(ret); + values.delete(); + ret.delete(); + return retObj; +}; + +const _getFel = async () => { + if (_cachedFel) return _cachedFel; + + _cachedFel = new ((await Module).ExtractionDelegate)(); + return _getFel() +}; + +function cache(fn){ + var NO_RESULT = Symbol("cache"); + var res = NO_RESULT; + return function () { + if(res === NO_RESULT) return (res = fn.apply(this, arguments)); + return res; + }; +} + +const PredictorError = class PredictorError extends Error {}; + +// max number (STORE_MAX_DATAPOINT_FACTOR * windowSize) of unmerged datapoints to store in the store, rest is pruned +const STORE_MAX_DATAPOINT_FACTOR = 10; + +/** + * @namespace + * @property {(input: number[]) => number[]} predictor + * @property {string[]} sensors + * @property {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @property {string[]} labels + * @property {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + */ +const Predictor = class Predictor { + /** + * Predictor + * @param {(input: number[]) => number[]} predictor + * @param {string[]} sensors + * @param {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @param {string[]} labels + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @param {{ windowingMode: "time" | "sample" }} options + */ + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + /** @type {(input: number[]) => number[]} */ + this.predictor = predictor; + /** @type {string[]} */ + this.sensors = sensors; + /** @type {number} */ + this.windowSize = Math.abs(windowSize); + /** @type {string[]} */ + this.labels = labels; + /** @type {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} */ + this.scaler = scaler; + + /** @type {boolean} */ + this.windowModeMs = windowSize < 0 || windowingMode === "time"; + this.lastPruneTime = 0; + this.lastAddTime = 0; + + /** @type {{ [sensorName: string]: [number, number][] }} sensorName: [timestamp, value][] */ + this.store = this.sensors.reduce((acc, cur) => { + acc[cur] = []; + return acc; + }, {}); + } + + /** + * addDatapoint + * @param {string} sensorName + * @param {number} value + * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated + */ + addDatapoint = (sensorName, value, time = null) => { + if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); + if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); + if (time === null) time = Date.now(); + + this.lastAddTime = time; + this.store[sensorName].push([time, value]); + + this._updateStore(); + } + + /** + * keeps the store from filling indefinitely + * skips pruning if we are within a constant factor of target + * @private + */ + _updateStore() { + if (this.windowModeMs) { + if (this.lastPruneTime + (STORE_MAX_DATAPOINT_FACTOR * this.windowSize) > this.lastAddTime) { + return; + } + + this.lastPruneTime = this.lastAddTime; + for (const sensorName of this.sensors) { + this.store[sensorName] = Predictor._sliceByTime(this.store[sensorName], this.lastAddTime - this.windowSize); + } + } else { + for (const sensorName of this.sensors) { + if (this.store[sensorName].length > this.windowSize * STORE_MAX_DATAPOINT_FACTOR * 2) { + this.store[sensorName] = this.store[sensorName].slice(-STORE_MAX_DATAPOINT_FACTOR * this.windowSize); + } + } + } + } + + predict = async () => { + const samples = Predictor._merge(this.store, this.sensors); + // const interpolated = Predictor._interpolate(samples, this.sensors.length) // interpolation is somehow broken? + + let window; + if (this.windowModeMs) { + window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + } else { + window = samples.slice(-this.windowSize); + if (window.length < this.windowSize) { + throw new PredictorError("Not enough samples") + } + } + + const [featNames, feats] = await Predictor._extract(window, this.sensors.length, this.scaler); + + const pred = this.predictor(feats); + return { + prediction: this.labels[pred.reduce((iMax, x, i, arr) => x > arr[iMax] ? i : iMax, 0)], + result: pred, + } + } + + /** + * Keeps only entries created after certain time + * @param {((number | null)[])[]} samples [time, ...values][] + * @param {number} keepSince Date timestamp, only entries with the same or later timestamps are kept in the result + * @return {((number | null)[])[]} + */ + static _sliceByTime(samples, keepSince) { + return samples.filter(([time]) => time >= keepSince) + } + + /** + * @param {{ [sensorName: string]: [number, number][] }} store + * @param {string[]} sensors + * @return {((number | null)[])[]} ((number | null)[]): [time, ...values], values in the ordering of this.sensors, null for missing values + */ + static _merge(store, sensors) { + /** @type {{ [time: number]: { [sensorName: string]: number } }} */ + const out = {}; + for (const sensorName of sensors) { + for (const [time, value] of store[sensorName]) { + out[time] = out[time] || {}; + out[time][sensorName] = value; + } + } + return Object.entries(out).map(([time, values]) => { + const arr = [time]; + for (const sensorName of sensors) { + arr.push(values[sensorName] || null); + } + return arr; + }).sort((a, b) => parseInt(a[0]) - parseInt(b[0])); + } + + /** + * from pandas: ‘linear’: Ignore the index and treat the values as *equally* spaced. + * @param {((number | null)[])[]} frame + * @param {number} sensorsLength + * @return {(number[])[]} + */ + static _interpolate(frame, sensorsLength) { + const lists = []; + for (let i = 0; i < sensorsLength; i++) { + const sensorValues = frame.map(x => x[i+1]); + interpolateLinear(sensorValues); + lists[i] = sensorValues; + } + + return frame.map(([time], i) => { + const arr = [time]; + for (let j = 0; j < sensorsLength; j++) { + arr.push(lists[j][i]); + } + return arr; + }) + } + + /** + * + * @param {(number[])[]} frame + * @param {number} sensorsLength + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @returns {number[]} + */ + static async _extract(frame, sensorsLength, scaler) { + // cache these + const felParams = await Predictor.felParams(); + const felFeaturesTSfresh = await Predictor.felFeaturesTSfresh(); + + const feats = []; // [features, values] + for (let i = 0; i < sensorsLength; i++) { + const toF = frame.map(x => x[i+1]); // +1, because [0] is time in the frame + const featureMap = await extractSome(felFeaturesTSfresh, toF, felParams); + for (const [feat, val] of Object.entries(featureMap)) { + feats.push([[i, feat], val]); + } + } + // sort features with the same sort as the server + feats.sort(([[aI, aFeat]], [[bI, bFeat]]) => { + if (aI !== bI) return aI - bI; + return Predictor.featuresTSfresh.indexOf(aFeat) - Predictor.featuresTSfresh.indexOf(bFeat) + }); + if (scaler) { + for (let i = 0; i < feats.length; i++) { + feats[i][1] = (feats[i][1] - scaler["center"][i]) / scaler["scale"][i]; + } + } + return [feats.map(x => x[0].join('__')), feats.map(x => x[1])] + } +}; + +/** @type {string[]} features */ +Predictor.featuresTSfresh = [ + "sum", + "median", + "mean", + "length", + "std_dev", + "var", + "root_mean_square", + "max", + "abs_max", + "min" +]; +Predictor.felParams = cache(() => objToMap({"mean_n_abs_max_n": 8, "change_quantile_lower": -0.1, "change_quantile_upper": 0.1, "change_quantile_aggr": 0, "range_count_lower": -1, "range_count_upper": 1, "count_above_x": 0, "count_below_x": 0, "quantile_q": 0.5, "autocorrelation_lag": 1})); +Predictor.felFeaturesTSfresh = cache(() => arrToVector(Predictor.featuresTSfresh, 'string')); + const axios = requireAxios(); const UPLOAD_INTERVAL = 5 * 1000; @@ -2539,7 +2883,8 @@ async function datasetCollector( const edgeML = { datasetCollector: datasetCollector, - sendDataset: sendDataset + sendDataset: sendDataset, + Predictor: Predictor }; diff --git a/dist/index.browser.js b/dist/index.browser.js old mode 100644 new mode 100755 index 9e2a2e5..c23d9d5 --- a/dist/index.browser.js +++ b/dist/index.browser.js @@ -1,6 +1,11 @@ -var edgeML = (function () { +var edgeML = (function (require$$0, require$$1) { 'use strict'; + function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + + var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); + var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1); + var axios$2 = {exports: {}}; var axios$1 = {exports: {}}; @@ -2378,6 +2383,347 @@ var edgeML = (function () { return axios$2.exports; } + /** + * + * @param {number} x + * @param {number} y + * @param {number} a + * @returns {number} + */ + const lerp = (x, y, a) => x * (1 - a) + y * a; + /** + * in place + * @param {(number | null)[]} arr + * @param {number | undefined} l value for entries before first known, if undefined first known + * @param {number | undefined} r value for entries after last known, if undefined last known + * @return {number[]} + */ + const interpolateLinear = (arr, l, r) => { + let leftmost = l; + let nullCount = 0; + + for (let i = 0; i < arr.length;) { + if (arr[i] !== null) { + for (let j = 0; j < nullCount; j++) { + arr[i - (nullCount - j)] = typeof leftmost !== 'undefined' ? lerp(leftmost, arr[i], (j + 1) / (nullCount + 1)) : arr[i]; + } + nullCount = 0; + + leftmost = arr[i]; + i++; + continue; + } + for (; arr[i] === null; i++) { + nullCount++; + } + } + for (let j = 0; j < nullCount; j++) { + arr[arr.length - (nullCount - j)] = leftmost; + } + }; + + var edgeFel = {exports: {}}; + + var hasRequiredEdgeFel; + + function requireEdgeFel () { + if (hasRequiredEdgeFel) return edgeFel.exports; + hasRequiredEdgeFel = 1; + (function (module, exports) { + var Module = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( + function(Module) { + Module = Module || {}; + + var Module=typeof Module!="undefined"?Module:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise(function(resolve,reject){readyPromiseResolve=resolve;readyPromiseReject=reject;});var moduleOverrides=Object.assign({},Module);var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary;var fs;var nodePath;var requireNodeFS;if(ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){scriptDirectory=require$$0__default["default"].dirname(scriptDirectory)+"/";}else {scriptDirectory=__dirname+"/";}requireNodeFS=()=>{if(!nodePath){fs=require$$1__default["default"];nodePath=require$$0__default["default"];}};read_=function shell_read(filename,binary){var ret=tryParseAsDataURI(filename);if(ret){return binary?ret:ret.toString()}requireNodeFS();filename=nodePath["normalize"](filename);return fs.readFileSync(filename,binary?undefined:"utf8")};readBinary=filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret);}return ret};readAsync=(filename,onload,onerror)=>{var ret=tryParseAsDataURI(filename);if(ret){onload(ret);}requireNodeFS();filename=nodePath["normalize"](filename);fs.readFile(filename,function(err,data){if(err)onerror(err);else onload(data.buffer);});};if(process["argv"].length>1){process["argv"][1].replace(/\\/g,"/");}process["argv"].slice(2);process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});process["on"]("unhandledRejection",function(reason){throw reason});Module["inspect"]=function(){return "[Emscripten Module object]"};}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href;}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src;}if(_scriptDir){scriptDirectory=_scriptDir;}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1);}else {scriptDirectory="";}{read_=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}};}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror();};xhr.onerror=onerror;xhr.send(null);};}}else;Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])Module["arguments"];if(Module["thisProgram"])Module["thisProgram"];if(Module["quit"])Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];Module["noExitRuntime"]||true;if(typeof WebAssembly!="object"){abort("no native wasm support detected");}var wasmMemory;var ABORT=false;function assert(condition,text){if(!condition){abort(text);}}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(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))}else {var str="";while(idx>10,56320|ch&1023);}}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=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}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i=55296&&u<=57343)u=65536+((u&1023)<<10)|str.charCodeAt(++i)&1023;if(u<=127)++len;else if(u<=2047)len+=2;else if(u<=65535)len+=3;else len+=4;}return len}var UTF16Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf-16le"):undefined;function UTF16ToString(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))}else {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}}function stringToUTF16(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2;}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(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}function stringToUTF32(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=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}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4;}return len}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferAndViews(buf){buffer=buf;Module["HEAP8"]=HEAP8=new Int8Array(buf);Module["HEAP16"]=HEAP16=new Int16Array(buf);Module["HEAP32"]=HEAP32=new Int32Array(buf);Module["HEAPU8"]=HEAPU8=new Uint8Array(buf);Module["HEAPU16"]=HEAPU16=new Uint16Array(buf);Module["HEAPU32"]=HEAPU32=new Uint32Array(buf);Module["HEAPF32"]=HEAPF32=new Float32Array(buf);Module["HEAPF64"]=HEAPF64=new Float64Array(buf);}Module["INITIAL_MEMORY"]||16777216;var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift());}}callRuntimeCallbacks(__ATPRERUN__);}function initRuntime(){callRuntimeCallbacks(__ATINIT__);}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift());}}callRuntimeCallbacks(__ATPOSTRUN__);}function addOnPreRun(cb){__ATPRERUN__.unshift(cb);}function addOnInit(cb){__ATINIT__.unshift(cb);}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb);}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback();}}}function abort(what){{if(Module["onAbort"]){Module["onAbort"](what);}}what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}function isFileURI(filename){return filename.startsWith("file://")}var wasmBinaryFile;wasmBinaryFile="data:application/octet-stream;base64,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";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile);}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}else {throw "both async and sync fetching of the wasm failed"}}catch(err){abort(err);}}function getBinaryPromise(){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"&&!isFileURI(wasmBinaryFile)){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){if(!response["ok"]){throw "failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()}).catch(function(){return getBinary(wasmBinaryFile)})}else {if(readAsync){return new Promise(function(resolve,reject){readAsync(wasmBinaryFile,function(response){resolve(new Uint8Array(response));},reject);})}}}return Promise.resolve().then(function(){return getBinary(wasmBinaryFile)})}function createWasm(){var info={"a":asmLibraryArg};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["u"];updateGlobalBufferAndViews(wasmMemory.buffer);wasmTable=Module["asm"]["x"];addOnInit(Module["asm"]["v"]);removeRunDependency();}addRunDependency();function receiveInstantiationResult(result){receiveInstance(result["instance"]);}function instantiateArrayBuffer(receiver){return getBinaryPromise().then(function(binary){return WebAssembly.instantiate(binary,info)}).then(function(instance){return instance}).then(receiver,function(reason){err("failed to asynchronously prepare wasm: "+reason);abort(reason);})}function instantiateAsync(){if(!wasmBinary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(wasmBinaryFile)&&!isFileURI(wasmBinaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){var result=WebAssembly.instantiateStreaming(response,info);return result.then(receiveInstantiationResult,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(receiveInstantiationResult)})})}else {return instantiateArrayBuffer(receiveInstantiationResult)}}if(Module["instantiateWasm"]){try{var exports=Module["instantiateWasm"](info,receiveInstance);return exports}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}instantiateAsync().catch(readyPromiseReject);return {}}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func=="number"){if(callback.arg===undefined){getWasmTableEntry(func)();}else {getWasmTableEntry(func)(callback.arg);}}else {func(callback.arg===undefined?null:callback.arg);}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr);}return func}function ___cxa_allocate_exception(size){return _malloc(size+24)+24}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type;};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor;};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount;};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught;};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown;};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false);};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1;};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr;};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){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};}function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);throw ptr}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+size)}}function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i);}embind_charCodes=codes;}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]];}return ret}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var char_0=48;var char_9=57;function makeLegalFunctionName(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}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return new Function("body","return function "+name+"() {\n"+' "use strict";'+" return body.apply(this, arguments);\n"+"};\n")(body)}function extendError(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}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function whenDependentTypesAreResolved(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{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);}}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError('type "'+name+'" must have a positive integer typeid pointer');}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else {throwBindingError("Cannot register type '"+name+"' twice");}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb());}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return !!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8;}else if(size===2){heap=HEAP16;}else if(size===4){heap=HEAP32;}else {throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null});}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;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}function shallowCopyInternalPointer(o){return {count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted");}var finalizationRegistry=false;function detachFinalizer(handle){}function runDestructor($$){if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr);}else {$$.ptrType.registeredClass.rawDestructor($$.ptr);}}function releaseClassHandle($$){$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$);}}function downcastPointer(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)}var registeredPointers={};function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k]);}}return rv}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]();}}var delayFunction=undefined;function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes);}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction;}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined");}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass;}return ptr}function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}function makeClassHandle(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}}))}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})}}function attachFinalizer(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)}function ClassHandle_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}}function ClassHandle_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;}}function ClassHandle_isDeleted(){return !this.$$.ptr}function ClassHandle_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}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater;}function ClassHandle(){}function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError("Function '"+humanName+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+proto[methodName].overloadTable+")!");}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc;}}function exposePublicSymbol(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;}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[];}function upcastPointer(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}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name);}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr);}return ptr}else {return 0}}if(!handle.$$){throwBindingError('Cannot pass "'+_embind_repr(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(function(){clonedHandle["delete"]();}));if(destructors!==null){destructors.push(this.rawDestructor,ptr);}}break;default:throwBindingError("Unsupporting sharing policy");}}return ptr}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}if(handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+handle.$$.ptrType.name+" to parameter type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr);}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr);}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]();}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType;}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&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}else {this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}}else {this["toWireType"]=genericPointerToWireType;}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol");}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value;}else {Module[name]=value;Module[name].argCount=numArguments;}}function dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(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}var UnboundTypeError=undefined;function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function throwUnboundTypeError(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([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast);}if(downcast){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]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype;}else {basePrototype=ClassHandle.prototype;}var constructor=createNamedFunction(legalFunctionName,function(){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[arguments.length];if(undefined===body){throw new BindingError("Tried to invoke ctor of "+name+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(registeredClass.constructor_body).toString()+") parameters instead!")}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);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]});}function heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i>2)+i]);}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr);}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(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,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return []});return []});}function new_(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}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc){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=false;for(var i=1;i0?", ":"")+argsListWired;}invokerFnBody+=(returns?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n";}else {for(var i=isClassMethodFunc?1:2;i4&&0===--emval_handle_array[handle].refcount){emval_handle_array[handle]=undefined;emval_free_list.push(handle);}}function count_emval_handles(){var count=0;for(var i=5;i{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle);}return emval_handle_array[handle].value},toHandle:value=>{switch(value){case undefined:return 1;case null:return 2;case true:return 3;case false:return 4;default:{var handle=emval_free_list.length?emval_free_list.pop():emval_handle_array.length;emval_handle_array[handle]={refcount:1,value:value};return handle}}}};function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null});}function _embind_repr(v){if(v===null){return "null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else {return ""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null});}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>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":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null});}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true});}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var str;if(stdStringIsUTF8){var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+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;ilengthBytesUTF8(value);}else {getLength=()=>value.length;}var length=getLength();var ptr=_malloc(4+length+1);HEAPU32[ptr>>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr+4,length+1);}else {if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits");}HEAPU8[ptr+4+i]=charCode;}}else {for(var i=0;iHEAPU16;shift=1;}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>HEAPU32;shift=2;}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==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":function(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>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr);}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr);}});}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}});}function __emval_incref(handle){if(handle>4){emval_handle_array[handle].refcount+=1;}}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType));}return impl}function __emval_take_value(type,argv){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](argv);return Emval.toHandle(v)}function _abort(){abort("");}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num);}function abortOnCannotGrowMemory(requestedSize){abort("OOM");}function _emscripten_resize_heap(requestedSize){HEAPU8.length;abortOnCannotGrowMemory();}embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();function intArrayToString(array){var ret=[];for(var i=0;i255){chr&=255;}ret.push(String.fromCharCode(chr));}return ret.join("")}var decodeBase64=typeof atob=="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2);}if(enc4!==64){output=output+String.fromCharCode(chr3);}}while(i0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun();}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("");},1);doRun();},1);}else {doRun();}}Module["run"]=run;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()();}}run(); + + + return Module.ready + } + ); + })(); + module.exports = Module; + } (edgeFel)); + return edgeFel.exports; + } + + requireEdgeFel(); + + const Module = requireEdgeFel()(); + let _cachedFel; + + const arrToVector = async (arr, type = 'float') => { + const v = new ((await Module)[`vector${type}`])(); + for (const val of arr) { + v.push_back(val); + } + return v; + }; + + const vectorToArr = (vector) => new Array(vector.size()).fill(0).map((_, i) => vector.get(i)); + + const objToMap = async (obj, type = 'float') => { + const m = new ((await Module)[`mapstring${type}`])(); + for (const [key, val] of Object.entries(obj)) { + m.set(key, val); + } + return m; + }; + + const mapToObj = (map) => { + const obj = {}; + const keys = vectorToArr(map.keys()); + for (const key of keys) { + obj[key] = map.get(key); + } + return obj + }; + + const extractSome = async (features, inArr, params) => { + const values = await arrToVector(inArr); + const delegate = await _getFel(); + const ret = delegate.extractSome(features, values, params); + const retObj = mapToObj(ret); + values.delete(); + ret.delete(); + return retObj; + }; + + const _getFel = async () => { + if (_cachedFel) return _cachedFel; + + _cachedFel = new ((await Module).ExtractionDelegate)(); + return _getFel() + }; + + function cache(fn){ + var NO_RESULT = Symbol("cache"); + var res = NO_RESULT; + return function () { + if(res === NO_RESULT) return (res = fn.apply(this, arguments)); + return res; + }; + } + + const PredictorError = class PredictorError extends Error {}; + + // max number (STORE_MAX_DATAPOINT_FACTOR * windowSize) of unmerged datapoints to store in the store, rest is pruned + const STORE_MAX_DATAPOINT_FACTOR = 10; + + /** + * @namespace + * @property {(input: number[]) => number[]} predictor + * @property {string[]} sensors + * @property {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @property {string[]} labels + * @property {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + */ + const Predictor = class Predictor { + /** + * Predictor + * @param {(input: number[]) => number[]} predictor + * @param {string[]} sensors + * @param {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @param {string[]} labels + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @param {{ windowingMode: "time" | "sample" }} options + */ + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + /** @type {(input: number[]) => number[]} */ + this.predictor = predictor; + /** @type {string[]} */ + this.sensors = sensors; + /** @type {number} */ + this.windowSize = Math.abs(windowSize); + /** @type {string[]} */ + this.labels = labels; + /** @type {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} */ + this.scaler = scaler; + + /** @type {boolean} */ + this.windowModeMs = windowSize < 0 || windowingMode === "time"; + this.lastPruneTime = 0; + this.lastAddTime = 0; + + /** @type {{ [sensorName: string]: [number, number][] }} sensorName: [timestamp, value][] */ + this.store = this.sensors.reduce((acc, cur) => { + acc[cur] = []; + return acc; + }, {}); + } + + /** + * addDatapoint + * @param {string} sensorName + * @param {number} value + * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated + */ + addDatapoint = (sensorName, value, time = null) => { + if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); + if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); + if (time === null) time = Date.now(); + + this.lastAddTime = time; + this.store[sensorName].push([time, value]); + + this._updateStore(); + } + + /** + * keeps the store from filling indefinitely + * skips pruning if we are within a constant factor of target + * @private + */ + _updateStore() { + if (this.windowModeMs) { + if (this.lastPruneTime + (STORE_MAX_DATAPOINT_FACTOR * this.windowSize) > this.lastAddTime) { + return; + } + + this.lastPruneTime = this.lastAddTime; + for (const sensorName of this.sensors) { + this.store[sensorName] = Predictor._sliceByTime(this.store[sensorName], this.lastAddTime - this.windowSize); + } + } else { + for (const sensorName of this.sensors) { + if (this.store[sensorName].length > this.windowSize * STORE_MAX_DATAPOINT_FACTOR * 2) { + this.store[sensorName] = this.store[sensorName].slice(-STORE_MAX_DATAPOINT_FACTOR * this.windowSize); + } + } + } + } + + predict = async () => { + const samples = Predictor._merge(this.store, this.sensors); + // const interpolated = Predictor._interpolate(samples, this.sensors.length) // interpolation is somehow broken? + + let window; + if (this.windowModeMs) { + window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + } else { + window = samples.slice(-this.windowSize); + if (window.length < this.windowSize) { + throw new PredictorError("Not enough samples") + } + } + + const [featNames, feats] = await Predictor._extract(window, this.sensors.length, this.scaler); + + const pred = this.predictor(feats); + return { + prediction: this.labels[pred.reduce((iMax, x, i, arr) => x > arr[iMax] ? i : iMax, 0)], + result: pred, + } + } + + /** + * Keeps only entries created after certain time + * @param {((number | null)[])[]} samples [time, ...values][] + * @param {number} keepSince Date timestamp, only entries with the same or later timestamps are kept in the result + * @return {((number | null)[])[]} + */ + static _sliceByTime(samples, keepSince) { + return samples.filter(([time]) => time >= keepSince) + } + + /** + * @param {{ [sensorName: string]: [number, number][] }} store + * @param {string[]} sensors + * @return {((number | null)[])[]} ((number | null)[]): [time, ...values], values in the ordering of this.sensors, null for missing values + */ + static _merge(store, sensors) { + /** @type {{ [time: number]: { [sensorName: string]: number } }} */ + const out = {}; + for (const sensorName of sensors) { + for (const [time, value] of store[sensorName]) { + out[time] = out[time] || {}; + out[time][sensorName] = value; + } + } + return Object.entries(out).map(([time, values]) => { + const arr = [time]; + for (const sensorName of sensors) { + arr.push(values[sensorName] || null); + } + return arr; + }).sort((a, b) => parseInt(a[0]) - parseInt(b[0])); + } + + /** + * from pandas: ‘linear’: Ignore the index and treat the values as *equally* spaced. + * @param {((number | null)[])[]} frame + * @param {number} sensorsLength + * @return {(number[])[]} + */ + static _interpolate(frame, sensorsLength) { + const lists = []; + for (let i = 0; i < sensorsLength; i++) { + const sensorValues = frame.map(x => x[i+1]); + interpolateLinear(sensorValues); + lists[i] = sensorValues; + } + + return frame.map(([time], i) => { + const arr = [time]; + for (let j = 0; j < sensorsLength; j++) { + arr.push(lists[j][i]); + } + return arr; + }) + } + + /** + * + * @param {(number[])[]} frame + * @param {number} sensorsLength + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @returns {number[]} + */ + static async _extract(frame, sensorsLength, scaler) { + // cache these + const felParams = await Predictor.felParams(); + const felFeaturesTSfresh = await Predictor.felFeaturesTSfresh(); + + const feats = []; // [features, values] + for (let i = 0; i < sensorsLength; i++) { + const toF = frame.map(x => x[i+1]); // +1, because [0] is time in the frame + const featureMap = await extractSome(felFeaturesTSfresh, toF, felParams); + for (const [feat, val] of Object.entries(featureMap)) { + feats.push([[i, feat], val]); + } + } + // sort features with the same sort as the server + feats.sort(([[aI, aFeat]], [[bI, bFeat]]) => { + if (aI !== bI) return aI - bI; + return Predictor.featuresTSfresh.indexOf(aFeat) - Predictor.featuresTSfresh.indexOf(bFeat) + }); + if (scaler) { + for (let i = 0; i < feats.length; i++) { + feats[i][1] = (feats[i][1] - scaler["center"][i]) / scaler["scale"][i]; + } + } + return [feats.map(x => x[0].join('__')), feats.map(x => x[1])] + } + }; + + /** @type {string[]} features */ + Predictor.featuresTSfresh = [ + "sum", + "median", + "mean", + "length", + "std_dev", + "var", + "root_mean_square", + "max", + "abs_max", + "min" + ]; + Predictor.felParams = cache(() => objToMap({"mean_n_abs_max_n": 8, "change_quantile_lower": -0.1, "change_quantile_upper": 0.1, "change_quantile_aggr": 0, "range_count_lower": -1, "range_count_upper": 1, "count_above_x": 0, "count_below_x": 0, "quantile_q": 0.5, "autocorrelation_lag": 1})); + Predictor.felFeaturesTSfresh = cache(() => arrToVector(Predictor.featuresTSfresh, 'string')); + const axios = requireAxios(); const UPLOAD_INTERVAL = 5 * 1000; @@ -2542,10 +2888,11 @@ var edgeML = (function () { const edgeML = { datasetCollector: datasetCollector, - sendDataset: sendDataset + sendDataset: sendDataset, + Predictor: Predictor }; return edgeML; -})(); +})(require$$0, require$$1); diff --git a/dist/index.esm.js b/dist/index.esm.js old mode 100644 new mode 100755 index d8c569e..83b9fc3 --- a/dist/index.esm.js +++ b/dist/index.esm.js @@ -7,7 +7,7 @@ import require$$1 from 'tty'; import require$$1$1 from 'util'; import require$$0$1 from 'os'; import require$$8 from 'zlib'; -import require$$1$3 from 'path'; +import require$$0$3 from 'path'; import require$$6 from 'fs'; var axios$2 = {exports: {}}; @@ -14780,7 +14780,7 @@ function requireMimeTypes () { */ var db = requireMimeDb(); - var extname = require$$1$3.extname; + var extname = require$$0$3.extname; /** * Module variables. @@ -15446,7 +15446,7 @@ function requireForm_data () { hasRequiredForm_data = 1; var CombinedStream = requireCombined_stream(); var util = require$$1$1; - var path = require$$1$3; + var path = require$$0$3; var http = require$$1$2; var https = require$$2; var parseUrl = require$$0$2.parse; @@ -16887,6 +16887,347 @@ function requireAxios () { return axios$2.exports; } +/** + * + * @param {number} x + * @param {number} y + * @param {number} a + * @returns {number} + */ + const lerp = (x, y, a) => x * (1 - a) + y * a; + /** + * in place + * @param {(number | null)[]} arr + * @param {number | undefined} l value for entries before first known, if undefined first known + * @param {number | undefined} r value for entries after last known, if undefined last known + * @return {number[]} + */ + const interpolateLinear = (arr, l, r) => { + let leftmost = l; + let nullCount = 0; + + for (let i = 0; i < arr.length;) { + if (arr[i] !== null) { + for (let j = 0; j < nullCount; j++) { + arr[i - (nullCount - j)] = typeof leftmost !== 'undefined' ? lerp(leftmost, arr[i], (j + 1) / (nullCount + 1)) : arr[i]; + } + nullCount = 0; + + leftmost = arr[i]; + i++; + continue; + } + for (; arr[i] === null; i++) { + nullCount++; + } + } + for (let j = 0; j < nullCount; j++) { + arr[arr.length - (nullCount - j)] = leftmost; + } + }; + +var edgeFel = {exports: {}}; + +var hasRequiredEdgeFel; + +function requireEdgeFel () { + if (hasRequiredEdgeFel) return edgeFel.exports; + hasRequiredEdgeFel = 1; + (function (module, exports) { + var Module = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( + function(Module) { + Module = Module || {}; + + var Module=typeof Module!="undefined"?Module:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise(function(resolve,reject){readyPromiseResolve=resolve;readyPromiseReject=reject;});var moduleOverrides=Object.assign({},Module);var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary;var fs;var nodePath;var requireNodeFS;if(ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){scriptDirectory=require$$0$3.dirname(scriptDirectory)+"/";}else {scriptDirectory=__dirname+"/";}requireNodeFS=()=>{if(!nodePath){fs=require$$6;nodePath=require$$0$3;}};read_=function shell_read(filename,binary){var ret=tryParseAsDataURI(filename);if(ret){return binary?ret:ret.toString()}requireNodeFS();filename=nodePath["normalize"](filename);return fs.readFileSync(filename,binary?undefined:"utf8")};readBinary=filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret);}return ret};readAsync=(filename,onload,onerror)=>{var ret=tryParseAsDataURI(filename);if(ret){onload(ret);}requireNodeFS();filename=nodePath["normalize"](filename);fs.readFile(filename,function(err,data){if(err)onerror(err);else onload(data.buffer);});};if(process["argv"].length>1){process["argv"][1].replace(/\\/g,"/");}process["argv"].slice(2);process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});process["on"]("unhandledRejection",function(reason){throw reason});Module["inspect"]=function(){return "[Emscripten Module object]"};}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href;}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src;}if(_scriptDir){scriptDirectory=_scriptDir;}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1);}else {scriptDirectory="";}{read_=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}};}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror();};xhr.onerror=onerror;xhr.send(null);};}}else;Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])Module["arguments"];if(Module["thisProgram"])Module["thisProgram"];if(Module["quit"])Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];Module["noExitRuntime"]||true;if(typeof WebAssembly!="object"){abort("no native wasm support detected");}var wasmMemory;var ABORT=false;function assert(condition,text){if(!condition){abort(text);}}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(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))}else {var str="";while(idx>10,56320|ch&1023);}}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=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}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i=55296&&u<=57343)u=65536+((u&1023)<<10)|str.charCodeAt(++i)&1023;if(u<=127)++len;else if(u<=2047)len+=2;else if(u<=65535)len+=3;else len+=4;}return len}var UTF16Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf-16le"):undefined;function UTF16ToString(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))}else {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}}function stringToUTF16(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2;}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(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}function stringToUTF32(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=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}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4;}return len}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferAndViews(buf){buffer=buf;Module["HEAP8"]=HEAP8=new Int8Array(buf);Module["HEAP16"]=HEAP16=new Int16Array(buf);Module["HEAP32"]=HEAP32=new Int32Array(buf);Module["HEAPU8"]=HEAPU8=new Uint8Array(buf);Module["HEAPU16"]=HEAPU16=new Uint16Array(buf);Module["HEAPU32"]=HEAPU32=new Uint32Array(buf);Module["HEAPF32"]=HEAPF32=new Float32Array(buf);Module["HEAPF64"]=HEAPF64=new Float64Array(buf);}Module["INITIAL_MEMORY"]||16777216;var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift());}}callRuntimeCallbacks(__ATPRERUN__);}function initRuntime(){callRuntimeCallbacks(__ATINIT__);}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift());}}callRuntimeCallbacks(__ATPOSTRUN__);}function addOnPreRun(cb){__ATPRERUN__.unshift(cb);}function addOnInit(cb){__ATINIT__.unshift(cb);}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb);}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback();}}}function abort(what){{if(Module["onAbort"]){Module["onAbort"](what);}}what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}function isFileURI(filename){return filename.startsWith("file://")}var wasmBinaryFile;wasmBinaryFile="data:application/octet-stream;base64,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";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile);}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}else {throw "both async and sync fetching of the wasm failed"}}catch(err){abort(err);}}function getBinaryPromise(){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"&&!isFileURI(wasmBinaryFile)){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){if(!response["ok"]){throw "failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()}).catch(function(){return getBinary(wasmBinaryFile)})}else {if(readAsync){return new Promise(function(resolve,reject){readAsync(wasmBinaryFile,function(response){resolve(new Uint8Array(response));},reject);})}}}return Promise.resolve().then(function(){return getBinary(wasmBinaryFile)})}function createWasm(){var info={"a":asmLibraryArg};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["u"];updateGlobalBufferAndViews(wasmMemory.buffer);wasmTable=Module["asm"]["x"];addOnInit(Module["asm"]["v"]);removeRunDependency();}addRunDependency();function receiveInstantiationResult(result){receiveInstance(result["instance"]);}function instantiateArrayBuffer(receiver){return getBinaryPromise().then(function(binary){return WebAssembly.instantiate(binary,info)}).then(function(instance){return instance}).then(receiver,function(reason){err("failed to asynchronously prepare wasm: "+reason);abort(reason);})}function instantiateAsync(){if(!wasmBinary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(wasmBinaryFile)&&!isFileURI(wasmBinaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){var result=WebAssembly.instantiateStreaming(response,info);return result.then(receiveInstantiationResult,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(receiveInstantiationResult)})})}else {return instantiateArrayBuffer(receiveInstantiationResult)}}if(Module["instantiateWasm"]){try{var exports=Module["instantiateWasm"](info,receiveInstance);return exports}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}instantiateAsync().catch(readyPromiseReject);return {}}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func=="number"){if(callback.arg===undefined){getWasmTableEntry(func)();}else {getWasmTableEntry(func)(callback.arg);}}else {func(callback.arg===undefined?null:callback.arg);}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr);}return func}function ___cxa_allocate_exception(size){return _malloc(size+24)+24}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type;};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor;};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount;};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught;};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown;};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false);};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1;};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr;};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){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};}function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);throw ptr}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+size)}}function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i);}embind_charCodes=codes;}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]];}return ret}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var char_0=48;var char_9=57;function makeLegalFunctionName(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}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return new Function("body","return function "+name+"() {\n"+' "use strict";'+" return body.apply(this, arguments);\n"+"};\n")(body)}function extendError(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}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function whenDependentTypesAreResolved(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{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);}}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError('type "'+name+'" must have a positive integer typeid pointer');}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else {throwBindingError("Cannot register type '"+name+"' twice");}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb());}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return !!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8;}else if(size===2){heap=HEAP16;}else if(size===4){heap=HEAP32;}else {throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null});}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;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}function shallowCopyInternalPointer(o){return {count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted");}var finalizationRegistry=false;function detachFinalizer(handle){}function runDestructor($$){if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr);}else {$$.ptrType.registeredClass.rawDestructor($$.ptr);}}function releaseClassHandle($$){$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$);}}function downcastPointer(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)}var registeredPointers={};function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k]);}}return rv}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]();}}var delayFunction=undefined;function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes);}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction;}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined");}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass;}return ptr}function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}function makeClassHandle(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}}))}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})}}function attachFinalizer(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)}function ClassHandle_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}}function ClassHandle_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;}}function ClassHandle_isDeleted(){return !this.$$.ptr}function ClassHandle_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}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater;}function ClassHandle(){}function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError("Function '"+humanName+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+proto[methodName].overloadTable+")!");}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc;}}function exposePublicSymbol(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;}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[];}function upcastPointer(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}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name);}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr);}return ptr}else {return 0}}if(!handle.$$){throwBindingError('Cannot pass "'+_embind_repr(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(function(){clonedHandle["delete"]();}));if(destructors!==null){destructors.push(this.rawDestructor,ptr);}}break;default:throwBindingError("Unsupporting sharing policy");}}return ptr}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}if(handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+handle.$$.ptrType.name+" to parameter type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr);}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr);}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]();}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType;}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&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}else {this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}}else {this["toWireType"]=genericPointerToWireType;}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol");}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value;}else {Module[name]=value;Module[name].argCount=numArguments;}}function dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(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}var UnboundTypeError=undefined;function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function throwUnboundTypeError(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([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast);}if(downcast){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]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype;}else {basePrototype=ClassHandle.prototype;}var constructor=createNamedFunction(legalFunctionName,function(){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[arguments.length];if(undefined===body){throw new BindingError("Tried to invoke ctor of "+name+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(registeredClass.constructor_body).toString()+") parameters instead!")}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);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]});}function heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i>2)+i]);}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr);}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(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,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return []});return []});}function new_(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}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc){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=false;for(var i=1;i0?", ":"")+argsListWired;}invokerFnBody+=(returns?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n";}else {for(var i=isClassMethodFunc?1:2;i4&&0===--emval_handle_array[handle].refcount){emval_handle_array[handle]=undefined;emval_free_list.push(handle);}}function count_emval_handles(){var count=0;for(var i=5;i{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle);}return emval_handle_array[handle].value},toHandle:value=>{switch(value){case undefined:return 1;case null:return 2;case true:return 3;case false:return 4;default:{var handle=emval_free_list.length?emval_free_list.pop():emval_handle_array.length;emval_handle_array[handle]={refcount:1,value:value};return handle}}}};function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null});}function _embind_repr(v){if(v===null){return "null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else {return ""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null});}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>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":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null});}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true});}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var str;if(stdStringIsUTF8){var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+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;ilengthBytesUTF8(value);}else {getLength=()=>value.length;}var length=getLength();var ptr=_malloc(4+length+1);HEAPU32[ptr>>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr+4,length+1);}else {if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits");}HEAPU8[ptr+4+i]=charCode;}}else {for(var i=0;iHEAPU16;shift=1;}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>HEAPU32;shift=2;}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==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":function(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>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr);}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr);}});}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}});}function __emval_incref(handle){if(handle>4){emval_handle_array[handle].refcount+=1;}}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType));}return impl}function __emval_take_value(type,argv){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](argv);return Emval.toHandle(v)}function _abort(){abort("");}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num);}function abortOnCannotGrowMemory(requestedSize){abort("OOM");}function _emscripten_resize_heap(requestedSize){HEAPU8.length;abortOnCannotGrowMemory();}embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();function intArrayToString(array){var ret=[];for(var i=0;i255){chr&=255;}ret.push(String.fromCharCode(chr));}return ret.join("")}var decodeBase64=typeof atob=="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2);}if(enc4!==64){output=output+String.fromCharCode(chr3);}}while(i0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun();}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("");},1);doRun();},1);}else {doRun();}}Module["run"]=run;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()();}}run(); + + + return Module.ready + } + ); + })(); + module.exports = Module; +} (edgeFel)); + return edgeFel.exports; +} + +requireEdgeFel(); + +const Module = requireEdgeFel()(); +let _cachedFel; + +const arrToVector = async (arr, type = 'float') => { + const v = new ((await Module)[`vector${type}`])(); + for (const val of arr) { + v.push_back(val); + } + return v; +}; + +const vectorToArr = (vector) => new Array(vector.size()).fill(0).map((_, i) => vector.get(i)); + +const objToMap = async (obj, type = 'float') => { + const m = new ((await Module)[`mapstring${type}`])(); + for (const [key, val] of Object.entries(obj)) { + m.set(key, val); + } + return m; +}; + +const mapToObj = (map) => { + const obj = {}; + const keys = vectorToArr(map.keys()); + for (const key of keys) { + obj[key] = map.get(key); + } + return obj +}; + +const extractSome = async (features, inArr, params) => { + const values = await arrToVector(inArr); + const delegate = await _getFel(); + const ret = delegate.extractSome(features, values, params); + const retObj = mapToObj(ret); + values.delete(); + ret.delete(); + return retObj; +}; + +const _getFel = async () => { + if (_cachedFel) return _cachedFel; + + _cachedFel = new ((await Module).ExtractionDelegate)(); + return _getFel() +}; + +function cache(fn){ + var NO_RESULT = Symbol("cache"); + var res = NO_RESULT; + return function () { + if(res === NO_RESULT) return (res = fn.apply(this, arguments)); + return res; + }; +} + +const PredictorError = class PredictorError extends Error {}; + +// max number (STORE_MAX_DATAPOINT_FACTOR * windowSize) of unmerged datapoints to store in the store, rest is pruned +const STORE_MAX_DATAPOINT_FACTOR = 10; + +/** + * @namespace + * @property {(input: number[]) => number[]} predictor + * @property {string[]} sensors + * @property {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @property {string[]} labels + * @property {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + */ +const Predictor = class Predictor { + /** + * Predictor + * @param {(input: number[]) => number[]} predictor + * @param {string[]} sensors + * @param {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @param {string[]} labels + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @param {{ windowingMode: "time" | "sample" }} options + */ + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + /** @type {(input: number[]) => number[]} */ + this.predictor = predictor; + /** @type {string[]} */ + this.sensors = sensors; + /** @type {number} */ + this.windowSize = Math.abs(windowSize); + /** @type {string[]} */ + this.labels = labels; + /** @type {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} */ + this.scaler = scaler; + + /** @type {boolean} */ + this.windowModeMs = windowSize < 0 || windowingMode === "time"; + this.lastPruneTime = 0; + this.lastAddTime = 0; + + /** @type {{ [sensorName: string]: [number, number][] }} sensorName: [timestamp, value][] */ + this.store = this.sensors.reduce((acc, cur) => { + acc[cur] = []; + return acc; + }, {}); + } + + /** + * addDatapoint + * @param {string} sensorName + * @param {number} value + * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated + */ + addDatapoint = (sensorName, value, time = null) => { + if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); + if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); + if (time === null) time = Date.now(); + + this.lastAddTime = time; + this.store[sensorName].push([time, value]); + + this._updateStore(); + } + + /** + * keeps the store from filling indefinitely + * skips pruning if we are within a constant factor of target + * @private + */ + _updateStore() { + if (this.windowModeMs) { + if (this.lastPruneTime + (STORE_MAX_DATAPOINT_FACTOR * this.windowSize) > this.lastAddTime) { + return; + } + + this.lastPruneTime = this.lastAddTime; + for (const sensorName of this.sensors) { + this.store[sensorName] = Predictor._sliceByTime(this.store[sensorName], this.lastAddTime - this.windowSize); + } + } else { + for (const sensorName of this.sensors) { + if (this.store[sensorName].length > this.windowSize * STORE_MAX_DATAPOINT_FACTOR * 2) { + this.store[sensorName] = this.store[sensorName].slice(-STORE_MAX_DATAPOINT_FACTOR * this.windowSize); + } + } + } + } + + predict = async () => { + const samples = Predictor._merge(this.store, this.sensors); + // const interpolated = Predictor._interpolate(samples, this.sensors.length) // interpolation is somehow broken? + + let window; + if (this.windowModeMs) { + window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + } else { + window = samples.slice(-this.windowSize); + if (window.length < this.windowSize) { + throw new PredictorError("Not enough samples") + } + } + + const [featNames, feats] = await Predictor._extract(window, this.sensors.length, this.scaler); + + const pred = this.predictor(feats); + return { + prediction: this.labels[pred.reduce((iMax, x, i, arr) => x > arr[iMax] ? i : iMax, 0)], + result: pred, + } + } + + /** + * Keeps only entries created after certain time + * @param {((number | null)[])[]} samples [time, ...values][] + * @param {number} keepSince Date timestamp, only entries with the same or later timestamps are kept in the result + * @return {((number | null)[])[]} + */ + static _sliceByTime(samples, keepSince) { + return samples.filter(([time]) => time >= keepSince) + } + + /** + * @param {{ [sensorName: string]: [number, number][] }} store + * @param {string[]} sensors + * @return {((number | null)[])[]} ((number | null)[]): [time, ...values], values in the ordering of this.sensors, null for missing values + */ + static _merge(store, sensors) { + /** @type {{ [time: number]: { [sensorName: string]: number } }} */ + const out = {}; + for (const sensorName of sensors) { + for (const [time, value] of store[sensorName]) { + out[time] = out[time] || {}; + out[time][sensorName] = value; + } + } + return Object.entries(out).map(([time, values]) => { + const arr = [time]; + for (const sensorName of sensors) { + arr.push(values[sensorName] || null); + } + return arr; + }).sort((a, b) => parseInt(a[0]) - parseInt(b[0])); + } + + /** + * from pandas: ‘linear’: Ignore the index and treat the values as *equally* spaced. + * @param {((number | null)[])[]} frame + * @param {number} sensorsLength + * @return {(number[])[]} + */ + static _interpolate(frame, sensorsLength) { + const lists = []; + for (let i = 0; i < sensorsLength; i++) { + const sensorValues = frame.map(x => x[i+1]); + interpolateLinear(sensorValues); + lists[i] = sensorValues; + } + + return frame.map(([time], i) => { + const arr = [time]; + for (let j = 0; j < sensorsLength; j++) { + arr.push(lists[j][i]); + } + return arr; + }) + } + + /** + * + * @param {(number[])[]} frame + * @param {number} sensorsLength + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @returns {number[]} + */ + static async _extract(frame, sensorsLength, scaler) { + // cache these + const felParams = await Predictor.felParams(); + const felFeaturesTSfresh = await Predictor.felFeaturesTSfresh(); + + const feats = []; // [features, values] + for (let i = 0; i < sensorsLength; i++) { + const toF = frame.map(x => x[i+1]); // +1, because [0] is time in the frame + const featureMap = await extractSome(felFeaturesTSfresh, toF, felParams); + for (const [feat, val] of Object.entries(featureMap)) { + feats.push([[i, feat], val]); + } + } + // sort features with the same sort as the server + feats.sort(([[aI, aFeat]], [[bI, bFeat]]) => { + if (aI !== bI) return aI - bI; + return Predictor.featuresTSfresh.indexOf(aFeat) - Predictor.featuresTSfresh.indexOf(bFeat) + }); + if (scaler) { + for (let i = 0; i < feats.length; i++) { + feats[i][1] = (feats[i][1] - scaler["center"][i]) / scaler["scale"][i]; + } + } + return [feats.map(x => x[0].join('__')), feats.map(x => x[1])] + } +}; + +/** @type {string[]} features */ +Predictor.featuresTSfresh = [ + "sum", + "median", + "mean", + "length", + "std_dev", + "var", + "root_mean_square", + "max", + "abs_max", + "min" +]; +Predictor.felParams = cache(() => objToMap({"mean_n_abs_max_n": 8, "change_quantile_lower": -0.1, "change_quantile_upper": 0.1, "change_quantile_aggr": 0, "range_count_lower": -1, "range_count_upper": 1, "count_above_x": 0, "count_below_x": 0, "quantile_q": 0.5, "autocorrelation_lag": 1})); +Predictor.felFeaturesTSfresh = cache(() => arrToVector(Predictor.featuresTSfresh, 'string')); + const axios = requireAxios(); const UPLOAD_INTERVAL = 5 * 1000; @@ -17051,7 +17392,8 @@ async function datasetCollector( const edgeML = { datasetCollector: datasetCollector, - sendDataset: sendDataset + sendDataset: sendDataset, + Predictor: Predictor }; diff --git a/dist/index.js b/dist/index.js old mode 100644 new mode 100755 index d224ba2..f0371a2 --- a/dist/index.js +++ b/dist/index.js @@ -9,7 +9,7 @@ var require$$1 = require('tty'); var require$$1$1 = require('util'); var require$$0$1 = require('os'); var require$$8 = require('zlib'); -var require$$1$3 = require('path'); +var require$$0$3 = require('path'); var require$$6 = require('fs'); function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } @@ -23,7 +23,7 @@ var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1); var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1); var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$1); var require$$8__default = /*#__PURE__*/_interopDefaultLegacy(require$$8); -var require$$1__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$1$3); +var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3); var require$$6__default = /*#__PURE__*/_interopDefaultLegacy(require$$6); var axios$2 = {exports: {}}; @@ -14796,7 +14796,7 @@ function requireMimeTypes () { */ var db = requireMimeDb(); - var extname = require$$1__default$3["default"].extname; + var extname = require$$0__default$2["default"].extname; /** * Module variables. @@ -15462,7 +15462,7 @@ function requireForm_data () { hasRequiredForm_data = 1; var CombinedStream = requireCombined_stream(); var util = require$$1__default$1["default"]; - var path = require$$1__default$3["default"]; + var path = require$$0__default$2["default"]; var http = require$$1__default$2["default"]; var https = require$$2__default["default"]; var parseUrl = require$$0__default$1["default"].parse; @@ -16903,6 +16903,347 @@ function requireAxios () { return axios$2.exports; } +/** + * + * @param {number} x + * @param {number} y + * @param {number} a + * @returns {number} + */ + const lerp = (x, y, a) => x * (1 - a) + y * a; + /** + * in place + * @param {(number | null)[]} arr + * @param {number | undefined} l value for entries before first known, if undefined first known + * @param {number | undefined} r value for entries after last known, if undefined last known + * @return {number[]} + */ + const interpolateLinear = (arr, l, r) => { + let leftmost = l; + let nullCount = 0; + + for (let i = 0; i < arr.length;) { + if (arr[i] !== null) { + for (let j = 0; j < nullCount; j++) { + arr[i - (nullCount - j)] = typeof leftmost !== 'undefined' ? lerp(leftmost, arr[i], (j + 1) / (nullCount + 1)) : arr[i]; + } + nullCount = 0; + + leftmost = arr[i]; + i++; + continue; + } + for (; arr[i] === null; i++) { + nullCount++; + } + } + for (let j = 0; j < nullCount; j++) { + arr[arr.length - (nullCount - j)] = leftmost; + } + }; + +var edgeFel = {exports: {}}; + +var hasRequiredEdgeFel; + +function requireEdgeFel () { + if (hasRequiredEdgeFel) return edgeFel.exports; + hasRequiredEdgeFel = 1; + (function (module, exports) { + var Module = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( + function(Module) { + Module = Module || {}; + + var Module=typeof Module!="undefined"?Module:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise(function(resolve,reject){readyPromiseResolve=resolve;readyPromiseReject=reject;});var moduleOverrides=Object.assign({},Module);var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary;var fs;var nodePath;var requireNodeFS;if(ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){scriptDirectory=require$$0__default$2["default"].dirname(scriptDirectory)+"/";}else {scriptDirectory=__dirname+"/";}requireNodeFS=()=>{if(!nodePath){fs=require$$6__default["default"];nodePath=require$$0__default$2["default"];}};read_=function shell_read(filename,binary){var ret=tryParseAsDataURI(filename);if(ret){return binary?ret:ret.toString()}requireNodeFS();filename=nodePath["normalize"](filename);return fs.readFileSync(filename,binary?undefined:"utf8")};readBinary=filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret);}return ret};readAsync=(filename,onload,onerror)=>{var ret=tryParseAsDataURI(filename);if(ret){onload(ret);}requireNodeFS();filename=nodePath["normalize"](filename);fs.readFile(filename,function(err,data){if(err)onerror(err);else onload(data.buffer);});};if(process["argv"].length>1){process["argv"][1].replace(/\\/g,"/");}process["argv"].slice(2);process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});process["on"]("unhandledRejection",function(reason){throw reason});Module["inspect"]=function(){return "[Emscripten Module object]"};}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href;}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src;}if(_scriptDir){scriptDirectory=_scriptDir;}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1);}else {scriptDirectory="";}{read_=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}};}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror();};xhr.onerror=onerror;xhr.send(null);};}}else;Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])Module["arguments"];if(Module["thisProgram"])Module["thisProgram"];if(Module["quit"])Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];Module["noExitRuntime"]||true;if(typeof WebAssembly!="object"){abort("no native wasm support detected");}var wasmMemory;var ABORT=false;function assert(condition,text){if(!condition){abort(text);}}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(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))}else {var str="";while(idx>10,56320|ch&1023);}}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=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}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i=55296&&u<=57343)u=65536+((u&1023)<<10)|str.charCodeAt(++i)&1023;if(u<=127)++len;else if(u<=2047)len+=2;else if(u<=65535)len+=3;else len+=4;}return len}var UTF16Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf-16le"):undefined;function UTF16ToString(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))}else {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}}function stringToUTF16(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2;}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(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}function stringToUTF32(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647;}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=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}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4;}return len}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferAndViews(buf){buffer=buf;Module["HEAP8"]=HEAP8=new Int8Array(buf);Module["HEAP16"]=HEAP16=new Int16Array(buf);Module["HEAP32"]=HEAP32=new Int32Array(buf);Module["HEAPU8"]=HEAPU8=new Uint8Array(buf);Module["HEAPU16"]=HEAPU16=new Uint16Array(buf);Module["HEAPU32"]=HEAPU32=new Uint32Array(buf);Module["HEAPF32"]=HEAPF32=new Float32Array(buf);Module["HEAPF64"]=HEAPF64=new Float64Array(buf);}Module["INITIAL_MEMORY"]||16777216;var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift());}}callRuntimeCallbacks(__ATPRERUN__);}function initRuntime(){callRuntimeCallbacks(__ATINIT__);}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift());}}callRuntimeCallbacks(__ATPOSTRUN__);}function addOnPreRun(cb){__ATPRERUN__.unshift(cb);}function addOnInit(cb){__ATINIT__.unshift(cb);}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb);}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies);}if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback();}}}function abort(what){{if(Module["onAbort"]){Module["onAbort"](what);}}what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}function isFileURI(filename){return filename.startsWith("file://")}var wasmBinaryFile;wasmBinaryFile="data:application/octet-stream;base64,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";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile);}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}else {throw "both async and sync fetching of the wasm failed"}}catch(err){abort(err);}}function getBinaryPromise(){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"&&!isFileURI(wasmBinaryFile)){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){if(!response["ok"]){throw "failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()}).catch(function(){return getBinary(wasmBinaryFile)})}else {if(readAsync){return new Promise(function(resolve,reject){readAsync(wasmBinaryFile,function(response){resolve(new Uint8Array(response));},reject);})}}}return Promise.resolve().then(function(){return getBinary(wasmBinaryFile)})}function createWasm(){var info={"a":asmLibraryArg};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["u"];updateGlobalBufferAndViews(wasmMemory.buffer);wasmTable=Module["asm"]["x"];addOnInit(Module["asm"]["v"]);removeRunDependency();}addRunDependency();function receiveInstantiationResult(result){receiveInstance(result["instance"]);}function instantiateArrayBuffer(receiver){return getBinaryPromise().then(function(binary){return WebAssembly.instantiate(binary,info)}).then(function(instance){return instance}).then(receiver,function(reason){err("failed to asynchronously prepare wasm: "+reason);abort(reason);})}function instantiateAsync(){if(!wasmBinary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(wasmBinaryFile)&&!isFileURI(wasmBinaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){var result=WebAssembly.instantiateStreaming(response,info);return result.then(receiveInstantiationResult,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(receiveInstantiationResult)})})}else {return instantiateArrayBuffer(receiveInstantiationResult)}}if(Module["instantiateWasm"]){try{var exports=Module["instantiateWasm"](info,receiveInstance);return exports}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}instantiateAsync().catch(readyPromiseReject);return {}}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func=="number"){if(callback.arg===undefined){getWasmTableEntry(func)();}else {getWasmTableEntry(func)(callback.arg);}}else {func(callback.arg===undefined?null:callback.arg);}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr);}return func}function ___cxa_allocate_exception(size){return _malloc(size+24)+24}function ExceptionInfo(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24;this.set_type=function(type){HEAPU32[this.ptr+4>>2]=type;};this.get_type=function(){return HEAPU32[this.ptr+4>>2]};this.set_destructor=function(destructor){HEAPU32[this.ptr+8>>2]=destructor;};this.get_destructor=function(){return HEAPU32[this.ptr+8>>2]};this.set_refcount=function(refcount){HEAP32[this.ptr>>2]=refcount;};this.set_caught=function(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught;};this.get_caught=function(){return HEAP8[this.ptr+12>>0]!=0};this.set_rethrown=function(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown;};this.get_rethrown=function(){return HEAP8[this.ptr+13>>0]!=0};this.init=function(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor);this.set_refcount(0);this.set_caught(false);this.set_rethrown(false);};this.add_ref=function(){var value=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=value+1;};this.release_ref=function(){var prev=HEAP32[this.ptr>>2];HEAP32[this.ptr>>2]=prev-1;return prev===1};this.set_adjusted_ptr=function(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr;};this.get_adjusted_ptr=function(){return HEAPU32[this.ptr+16>>2]};this.get_exception_ptr=function(){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};}function ___cxa_throw(ptr,type,destructor){var info=new ExceptionInfo(ptr);info.init(type,destructor);throw ptr}function __embind_register_bigint(primitiveType,name,size,minRange,maxRange){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+size)}}function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i);}embind_charCodes=codes;}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]];}return ret}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var char_0=48;var char_9=57;function makeLegalFunctionName(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}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return new Function("body","return function "+name+"() {\n"+' "use strict";'+" return body.apply(this, arguments);\n"+"};\n")(body)}function extendError(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}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function whenDependentTypesAreResolved(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{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);}}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError('type "'+name+'" must have a positive integer typeid pointer');}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else {throwBindingError("Cannot register type '"+name+"' twice");}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb());}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return !!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8;}else if(size===2){heap=HEAP16;}else if(size===4){heap=HEAP32;}else {throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null});}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;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}function shallowCopyInternalPointer(o){return {count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted");}var finalizationRegistry=false;function detachFinalizer(handle){}function runDestructor($$){if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr);}else {$$.ptrType.registeredClass.rawDestructor($$.ptr);}}function releaseClassHandle($$){$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$);}}function downcastPointer(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)}var registeredPointers={};function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k]);}}return rv}var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]();}}var delayFunction=undefined;function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes);}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction;}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined");}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass;}return ptr}function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}function makeClassHandle(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}}))}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})}}function attachFinalizer(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)}function ClassHandle_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}}function ClassHandle_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;}}function ClassHandle_isDeleted(){return !this.$$.ptr}function ClassHandle_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}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater;}function ClassHandle(){}function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError("Function '"+humanName+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+proto[methodName].overloadTable+")!");}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc;}}function exposePublicSymbol(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;}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[];}function upcastPointer(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}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name);}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr);}return ptr}else {return 0}}if(!handle.$$){throwBindingError('Cannot pass "'+_embind_repr(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(function(){clonedHandle["delete"]();}));if(destructors!==null){destructors.push(this.rawDestructor,ptr);}}break;default:throwBindingError("Unsupporting sharing policy");}}return ptr}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 "'+_embind_repr(handle)+'" as a '+this.name);}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name);}if(handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+handle.$$.ptrType.name+" to parameter type "+this.name);}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr);}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr);}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]();}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType;}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&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}else {this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null;}}else {this["toWireType"]=genericPointerToWireType;}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol");}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value;}else {Module[name]=value;Module[name].argCount=numArguments;}}function dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=0;Object.assign(argCache,arguments);return dynCall(sig,ptr,argCache)}}function embind__requireFunction(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}var UnboundTypeError=undefined;function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function throwUnboundTypeError(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([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast);}if(downcast){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]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype;}else {basePrototype=ClassHandle.prototype;}var constructor=createNamedFunction(legalFunctionName,function(){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[arguments.length];if(undefined===body){throw new BindingError("Tried to invoke ctor of "+name+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(registeredClass.constructor_body).toString()+") parameters instead!")}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);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]});}function heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i>2)+i]);}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr);}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){assert(argCount>0);var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(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,function(argTypes){argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return []});return []});}function new_(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}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc){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=false;for(var i=1;i0?", ":"")+argsListWired;}invokerFnBody+=(returns?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n";}else {for(var i=isClassMethodFunc?1:2;i4&&0===--emval_handle_array[handle].refcount){emval_handle_array[handle]=undefined;emval_free_list.push(handle);}}function count_emval_handles(){var count=0;for(var i=5;i{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle);}return emval_handle_array[handle].value},toHandle:value=>{switch(value){case undefined:return 1;case null:return 2;case true:return 3;case false:return 4;default:{var handle=emval_free_list.length?emval_free_list.pop():emval_handle_array.length;emval_handle_array[handle]={refcount:1,value:value};return handle}}}};function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":function(destructors,value){return Emval.toHandle(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null});}function _embind_repr(v){if(v===null){return "null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else {return ""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null});}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>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":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null});}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true});}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var str;if(stdStringIsUTF8){var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+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;ilengthBytesUTF8(value);}else {getLength=()=>value.length;}var length=getLength();var ptr=_malloc(4+length+1);HEAPU32[ptr>>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr+4,length+1);}else {if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits");}HEAPU8[ptr+4+i]=charCode;}}else {for(var i=0;iHEAPU16;shift=1;}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=()=>HEAPU32;shift=2;}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==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":function(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>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr);}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr);}});}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}});}function __emval_incref(handle){if(handle>4){emval_handle_array[handle].refcount+=1;}}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType));}return impl}function __emval_take_value(type,argv){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](argv);return Emval.toHandle(v)}function _abort(){abort("");}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num);}function abortOnCannotGrowMemory(requestedSize){abort("OOM");}function _emscripten_resize_heap(requestedSize){HEAPU8.length;abortOnCannotGrowMemory();}embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();function intArrayToString(array){var ret=[];for(var i=0;i255){chr&=255;}ret.push(String.fromCharCode(chr));}return ret.join("")}var decodeBase64=typeof atob=="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2);}if(enc4!==64){output=output+String.fromCharCode(chr3);}}while(i0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun();}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("");},1);doRun();},1);}else {doRun();}}Module["run"]=run;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()();}}run(); + + + return Module.ready + } + ); + })(); + module.exports = Module; +} (edgeFel)); + return edgeFel.exports; +} + +requireEdgeFel(); + +const Module = requireEdgeFel()(); +let _cachedFel; + +const arrToVector = async (arr, type = 'float') => { + const v = new ((await Module)[`vector${type}`])(); + for (const val of arr) { + v.push_back(val); + } + return v; +}; + +const vectorToArr = (vector) => new Array(vector.size()).fill(0).map((_, i) => vector.get(i)); + +const objToMap = async (obj, type = 'float') => { + const m = new ((await Module)[`mapstring${type}`])(); + for (const [key, val] of Object.entries(obj)) { + m.set(key, val); + } + return m; +}; + +const mapToObj = (map) => { + const obj = {}; + const keys = vectorToArr(map.keys()); + for (const key of keys) { + obj[key] = map.get(key); + } + return obj +}; + +const extractSome = async (features, inArr, params) => { + const values = await arrToVector(inArr); + const delegate = await _getFel(); + const ret = delegate.extractSome(features, values, params); + const retObj = mapToObj(ret); + values.delete(); + ret.delete(); + return retObj; +}; + +const _getFel = async () => { + if (_cachedFel) return _cachedFel; + + _cachedFel = new ((await Module).ExtractionDelegate)(); + return _getFel() +}; + +function cache(fn){ + var NO_RESULT = Symbol("cache"); + var res = NO_RESULT; + return function () { + if(res === NO_RESULT) return (res = fn.apply(this, arguments)); + return res; + }; +} + +const PredictorError = class PredictorError extends Error {}; + +// max number (STORE_MAX_DATAPOINT_FACTOR * windowSize) of unmerged datapoints to store in the store, rest is pruned +const STORE_MAX_DATAPOINT_FACTOR = 10; + +/** + * @namespace + * @property {(input: number[]) => number[]} predictor + * @property {string[]} sensors + * @property {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @property {string[]} labels + * @property {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + */ +const Predictor = class Predictor { + /** + * Predictor + * @param {(input: number[]) => number[]} predictor + * @param {string[]} sensors + * @param {number} windowSize if positive, n last merged entries are used as a window, if negative, the absolute value is used as the window length in milliseconds + * @param {string[]} labels + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @param {{ windowingMode: "time" | "sample" }} options + */ + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + /** @type {(input: number[]) => number[]} */ + this.predictor = predictor; + /** @type {string[]} */ + this.sensors = sensors; + /** @type {number} */ + this.windowSize = Math.abs(windowSize); + /** @type {string[]} */ + this.labels = labels; + /** @type {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} */ + this.scaler = scaler; + + /** @type {boolean} */ + this.windowModeMs = windowSize < 0 || windowingMode === "time"; + this.lastPruneTime = 0; + this.lastAddTime = 0; + + /** @type {{ [sensorName: string]: [number, number][] }} sensorName: [timestamp, value][] */ + this.store = this.sensors.reduce((acc, cur) => { + acc[cur] = []; + return acc; + }, {}); + } + + /** + * addDatapoint + * @param {string} sensorName + * @param {number} value + * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated + */ + addDatapoint = (sensorName, value, time = null) => { + if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); + if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); + if (time === null) time = Date.now(); + + this.lastAddTime = time; + this.store[sensorName].push([time, value]); + + this._updateStore(); + } + + /** + * keeps the store from filling indefinitely + * skips pruning if we are within a constant factor of target + * @private + */ + _updateStore() { + if (this.windowModeMs) { + if (this.lastPruneTime + (STORE_MAX_DATAPOINT_FACTOR * this.windowSize) > this.lastAddTime) { + return; + } + + this.lastPruneTime = this.lastAddTime; + for (const sensorName of this.sensors) { + this.store[sensorName] = Predictor._sliceByTime(this.store[sensorName], this.lastAddTime - this.windowSize); + } + } else { + for (const sensorName of this.sensors) { + if (this.store[sensorName].length > this.windowSize * STORE_MAX_DATAPOINT_FACTOR * 2) { + this.store[sensorName] = this.store[sensorName].slice(-STORE_MAX_DATAPOINT_FACTOR * this.windowSize); + } + } + } + } + + predict = async () => { + const samples = Predictor._merge(this.store, this.sensors); + // const interpolated = Predictor._interpolate(samples, this.sensors.length) // interpolation is somehow broken? + + let window; + if (this.windowModeMs) { + window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + } else { + window = samples.slice(-this.windowSize); + if (window.length < this.windowSize) { + throw new PredictorError("Not enough samples") + } + } + + const [featNames, feats] = await Predictor._extract(window, this.sensors.length, this.scaler); + + const pred = this.predictor(feats); + return { + prediction: this.labels[pred.reduce((iMax, x, i, arr) => x > arr[iMax] ? i : iMax, 0)], + result: pred, + } + } + + /** + * Keeps only entries created after certain time + * @param {((number | null)[])[]} samples [time, ...values][] + * @param {number} keepSince Date timestamp, only entries with the same or later timestamps are kept in the result + * @return {((number | null)[])[]} + */ + static _sliceByTime(samples, keepSince) { + return samples.filter(([time]) => time >= keepSince) + } + + /** + * @param {{ [sensorName: string]: [number, number][] }} store + * @param {string[]} sensors + * @return {((number | null)[])[]} ((number | null)[]): [time, ...values], values in the ordering of this.sensors, null for missing values + */ + static _merge(store, sensors) { + /** @type {{ [time: number]: { [sensorName: string]: number } }} */ + const out = {}; + for (const sensorName of sensors) { + for (const [time, value] of store[sensorName]) { + out[time] = out[time] || {}; + out[time][sensorName] = value; + } + } + return Object.entries(out).map(([time, values]) => { + const arr = [time]; + for (const sensorName of sensors) { + arr.push(values[sensorName] || null); + } + return arr; + }).sort((a, b) => parseInt(a[0]) - parseInt(b[0])); + } + + /** + * from pandas: ‘linear’: Ignore the index and treat the values as *equally* spaced. + * @param {((number | null)[])[]} frame + * @param {number} sensorsLength + * @return {(number[])[]} + */ + static _interpolate(frame, sensorsLength) { + const lists = []; + for (let i = 0; i < sensorsLength; i++) { + const sensorValues = frame.map(x => x[i+1]); + interpolateLinear(sensorValues); + lists[i] = sensorValues; + } + + return frame.map(([time], i) => { + const arr = [time]; + for (let j = 0; j < sensorsLength; j++) { + arr.push(lists[j][i]); + } + return arr; + }) + } + + /** + * + * @param {(number[])[]} frame + * @param {number} sensorsLength + * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler + * @returns {number[]} + */ + static async _extract(frame, sensorsLength, scaler) { + // cache these + const felParams = await Predictor.felParams(); + const felFeaturesTSfresh = await Predictor.felFeaturesTSfresh(); + + const feats = []; // [features, values] + for (let i = 0; i < sensorsLength; i++) { + const toF = frame.map(x => x[i+1]); // +1, because [0] is time in the frame + const featureMap = await extractSome(felFeaturesTSfresh, toF, felParams); + for (const [feat, val] of Object.entries(featureMap)) { + feats.push([[i, feat], val]); + } + } + // sort features with the same sort as the server + feats.sort(([[aI, aFeat]], [[bI, bFeat]]) => { + if (aI !== bI) return aI - bI; + return Predictor.featuresTSfresh.indexOf(aFeat) - Predictor.featuresTSfresh.indexOf(bFeat) + }); + if (scaler) { + for (let i = 0; i < feats.length; i++) { + feats[i][1] = (feats[i][1] - scaler["center"][i]) / scaler["scale"][i]; + } + } + return [feats.map(x => x[0].join('__')), feats.map(x => x[1])] + } +}; + +/** @type {string[]} features */ +Predictor.featuresTSfresh = [ + "sum", + "median", + "mean", + "length", + "std_dev", + "var", + "root_mean_square", + "max", + "abs_max", + "min" +]; +Predictor.felParams = cache(() => objToMap({"mean_n_abs_max_n": 8, "change_quantile_lower": -0.1, "change_quantile_upper": 0.1, "change_quantile_aggr": 0, "range_count_lower": -1, "range_count_upper": 1, "count_above_x": 0, "count_below_x": 0, "quantile_q": 0.5, "autocorrelation_lag": 1})); +Predictor.felFeaturesTSfresh = cache(() => arrToVector(Predictor.featuresTSfresh, 'string')); + const axios = requireAxios(); const UPLOAD_INTERVAL = 5 * 1000; @@ -17067,7 +17408,8 @@ async function datasetCollector( const edgeML = { datasetCollector: datasetCollector, - sendDataset: sendDataset + sendDataset: sendDataset, + Predictor: Predictor }; diff --git a/package-lock.json b/package-lock.json index dc437dc..38ba05f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "edge-ml", - "version": "4.0.0", + "version": "4.0.1", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "edge-ml", - "version": "3.1.0", + "version": "4.0.1", "license": "MIT", "dependencies": { "axios": "^0.27.2" @@ -17,7 +17,7 @@ "@rollup/plugin-node-resolve": "^13.3.0", "husky": "^7.0.4", "jest": "^28.0.3", - "rollup": "^2.75.7", + "rollup": "^2.79.2", "rollup-plugin-copy": "^3.4.0", "rollup-plugin-polyfill-node": "^0.10.0" } @@ -3552,10 +3552,11 @@ } }, "node_modules/rollup": { - "version": "2.75.7", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.75.7.tgz", - "integrity": "sha512-VSE1iy0eaAYNCxEXaleThdFXqZJ42qDBatAwrfnPlENEZ8erQ+0LYX4JXOLPceWfZpV1VtZwZ3dFCuOZiSyFtQ==", + "version": "2.79.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.2.tgz", + "integrity": "sha512-fS6iqSPZDs3dr/y7Od6y5nha8dW1YnbgtsyotCVvoFGKbERG++CVRFv1meyGDE1SNItQA8BrnCw7ScdAhRJ3XQ==", "dev": true, + "license": "MIT", "bin": { "rollup": "dist/bin/rollup" }, @@ -6711,9 +6712,9 @@ } }, "rollup": { - "version": "2.75.7", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.75.7.tgz", - "integrity": "sha512-VSE1iy0eaAYNCxEXaleThdFXqZJ42qDBatAwrfnPlENEZ8erQ+0LYX4JXOLPceWfZpV1VtZwZ3dFCuOZiSyFtQ==", + "version": "2.79.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.2.tgz", + "integrity": "sha512-fS6iqSPZDs3dr/y7Od6y5nha8dW1YnbgtsyotCVvoFGKbERG++CVRFv1meyGDE1SNItQA8BrnCw7ScdAhRJ3XQ==", "dev": true, "requires": { "fsevents": "~2.3.2" diff --git a/package.json b/package.json index 8f9003d..3b1760b 100644 --- a/package.json +++ b/package.json @@ -24,7 +24,7 @@ "@rollup/plugin-node-resolve": "^13.3.0", "husky": "^7.0.4", "jest": "^28.0.3", - "rollup": "^2.75.7", + "rollup": "^2.79.2", "rollup-plugin-copy": "^3.4.0", "rollup-plugin-polyfill-node": "^0.10.0" } diff --git a/rollup.config.mjs b/rollup.config.mjs index f0b5c08..7a4adf5 100644 --- a/rollup.config.mjs +++ b/rollup.config.mjs @@ -4,17 +4,17 @@ import commonjs from '@rollup/plugin-commonjs'; import { nodeResolve } from '@rollup/plugin-node-resolve'; import nodePolyfills from 'rollup-plugin-polyfill-node'; import json from '@rollup/plugin-json'; -// import copy from 'rollup-plugin-copy' +import copy from 'rollup-plugin-copy' import { readFileSync } from 'fs'; const pkg = JSON.parse(readFileSync('./package.json')) -// const copyOpts = { -// targets: [ -// { src: 'src/vendor/edge-fel/edge-fel.wasm', dest: 'dist' } -// ] -// } +const copyOpts = { + targets: [ + { src: 'src/vendor/edge-fel/edge-fel.wasm', dest: 'dist' } + ] + } export default [ // browser-friendly builds @@ -31,7 +31,7 @@ export default [ format: 'es' }], plugins: [ - // copy(copyOpts), + copy(copyOpts), nodeResolve({ preferBuiltins: true, browser: true }), commonjs({ transformMixedEsModules: true, include: ["src/**", "node_modules/**"], strictRequires: true }), // so Rollup can convert to ES module ] @@ -50,10 +50,10 @@ export default [ { file: pkg.module, format: 'es' } // from package.json ], plugins: [ - // copy(copyOpts), + copy(copyOpts), nodeResolve(), json(), commonjs({ transformMixedEsModules: true, include: ["src/**", "node_modules/**"], strictRequires: true }), // so Rollup can convert to ES module ] }, -]; \ No newline at end of file +]; diff --git a/src/index.js b/src/index.js index 8f1f338..0fc0afe 100644 --- a/src/index.js +++ b/src/index.js @@ -1,3 +1,5 @@ +import { Predictor } from './predictor/index.js'; + const axios = require("axios") const UPLOAD_INTERVAL = 5 * 1000; @@ -170,8 +172,9 @@ async function datasetCollector( const edgeML = { datasetCollector: datasetCollector, - sendDataset: sendDataset + sendDataset: sendDataset, + Predictor: Predictor }; -export default edgeML; \ No newline at end of file +export default edgeML; From 811de1bc371c0dec11c211f59ad7d3db5565c4f2 Mon Sep 17 00:00:00 2001 From: Till Riedel Date: Sun, 13 Jul 2025 10:08:50 +0200 Subject: [PATCH 2/3] unify interface --- dist/index.browser.esm.js | 41 ++++++++++++++++++++++++++------------- dist/index.browser.js | 41 ++++++++++++++++++++++++++------------- dist/index.esm.js | 41 ++++++++++++++++++++++++++------------- dist/index.js | 41 ++++++++++++++++++++++++++------------- src/index.js | 15 +++++++------- src/predictor/index.js | 28 ++++++++++++++++++++------ 6 files changed, 141 insertions(+), 66 deletions(-) diff --git a/dist/index.browser.esm.js b/dist/index.browser.esm.js index ae8f969..9d03ff8 100755 --- a/dist/index.browser.esm.js +++ b/dist/index.browser.esm.js @@ -2524,8 +2524,9 @@ const Predictor = class Predictor { * @param {string[]} labels * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler * @param {{ windowingMode: "time" | "sample" }} options + * @param {boolean} useDeviceTime - True if you want to use timestamps generated by the server */ - constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample", useDeviceTime = false } = {}) { /** @type {(input: number[]) => number[]} */ this.predictor = predictor; /** @type {string[]} */ @@ -2539,6 +2540,9 @@ const Predictor = class Predictor { /** @type {boolean} */ this.windowModeMs = windowSize < 0 || windowingMode === "time"; + /** @type {boolean} */ + this.useDeviceTime = useDeviceTime; + this.lastPruneTime = 0; this.lastAddTime = 0; @@ -2550,15 +2554,24 @@ const Predictor = class Predictor { } /** - * addDatapoint + * addDataPoint + * @param {number} time - The timestamp assigned to the datapoint * @param {string} sensorName * @param {number} value - * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated */ - addDatapoint = (sensorName, value, time = null) => { + addDataPoint = (time, sensorName, value) => { if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); - if (time === null) time = Date.now(); + // TODO: see #16 use if (time === null) time = Date.now() + if (!this.useDeviceTime && typeof time !== "number") { + throw new Error("Provide a valid timestamp"); + } + if (this.useDeviceTime) { + time = Date.now(); + } + + //TODO: see #17 no clue why see Collector + value = Math.round(value * 100) / 100; this.lastAddTime = time; this.store[sensorName].push([time, value]); @@ -2597,6 +2610,9 @@ const Predictor = class Predictor { let window; if (this.windowModeMs) { window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + if (window.length < 1 ) { + throw new PredictorError("Not enough samples") + } } else { window = samples.slice(-this.windowSize); if (window.length < this.windowSize) { @@ -2800,15 +2816,14 @@ async function datasetCollector( var timeSeries = timeSeries; /** - * Uploads a vlaue for a specific timestamp to a datasets timeSeries with name sensorName - * @param {string} name - The name of the timeSeries to upload the value to + * Uploads a value for a specific timestamp to a dataset's timeSeries with name sensorName + * @param {string} sensorName - The name of the timeSeries to upload the value to * @param {number} value - The datapoint to upload * @param {number} time - The timestamp assigned to the datapoint - * @returns A Promise indicating success or failure of upload */ - function addDataPoint(time, name, value) { + function addDataPoint(time, sensorName, value) { - if (!timeSeries.includes(name)) { + if (!timeSeries.includes(sensorName)) { throw Error("invalid time-series name") } if (typeof value !== "number") { @@ -2824,14 +2839,14 @@ async function datasetCollector( value = Math.round(value * 100) / 100; - if (dataStore.data.every((elm) => elm.name !== name)) { + if (dataStore.data.every((elm) => elm.name !== sensorName)) { dataStore.data.push({ - name: name, + name: sensorName, data: [[time, value]], }); } else { const idx = dataStore.data.findIndex( - (elm) => elm.name === name + (elm) => elm.name === sensorName ); dataStore.data[idx].data.push([time, value]); diff --git a/dist/index.browser.js b/dist/index.browser.js index c23d9d5..5bf1a30 100755 --- a/dist/index.browser.js +++ b/dist/index.browser.js @@ -2529,8 +2529,9 @@ var edgeML = (function (require$$0, require$$1) { * @param {string[]} labels * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler * @param {{ windowingMode: "time" | "sample" }} options + * @param {boolean} useDeviceTime - True if you want to use timestamps generated by the server */ - constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample", useDeviceTime = false } = {}) { /** @type {(input: number[]) => number[]} */ this.predictor = predictor; /** @type {string[]} */ @@ -2544,6 +2545,9 @@ var edgeML = (function (require$$0, require$$1) { /** @type {boolean} */ this.windowModeMs = windowSize < 0 || windowingMode === "time"; + /** @type {boolean} */ + this.useDeviceTime = useDeviceTime; + this.lastPruneTime = 0; this.lastAddTime = 0; @@ -2555,15 +2559,24 @@ var edgeML = (function (require$$0, require$$1) { } /** - * addDatapoint + * addDataPoint + * @param {number} time - The timestamp assigned to the datapoint * @param {string} sensorName * @param {number} value - * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated */ - addDatapoint = (sensorName, value, time = null) => { + addDataPoint = (time, sensorName, value) => { if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); - if (time === null) time = Date.now(); + // TODO: see #16 use if (time === null) time = Date.now() + if (!this.useDeviceTime && typeof time !== "number") { + throw new Error("Provide a valid timestamp"); + } + if (this.useDeviceTime) { + time = Date.now(); + } + + //TODO: see #17 no clue why see Collector + value = Math.round(value * 100) / 100; this.lastAddTime = time; this.store[sensorName].push([time, value]); @@ -2602,6 +2615,9 @@ var edgeML = (function (require$$0, require$$1) { let window; if (this.windowModeMs) { window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + if (window.length < 1 ) { + throw new PredictorError("Not enough samples") + } } else { window = samples.slice(-this.windowSize); if (window.length < this.windowSize) { @@ -2805,15 +2821,14 @@ var edgeML = (function (require$$0, require$$1) { var timeSeries = timeSeries; /** - * Uploads a vlaue for a specific timestamp to a datasets timeSeries with name sensorName - * @param {string} name - The name of the timeSeries to upload the value to + * Uploads a value for a specific timestamp to a dataset's timeSeries with name sensorName + * @param {string} sensorName - The name of the timeSeries to upload the value to * @param {number} value - The datapoint to upload * @param {number} time - The timestamp assigned to the datapoint - * @returns A Promise indicating success or failure of upload */ - function addDataPoint(time, name, value) { + function addDataPoint(time, sensorName, value) { - if (!timeSeries.includes(name)) { + if (!timeSeries.includes(sensorName)) { throw Error("invalid time-series name") } if (typeof value !== "number") { @@ -2829,14 +2844,14 @@ var edgeML = (function (require$$0, require$$1) { value = Math.round(value * 100) / 100; - if (dataStore.data.every((elm) => elm.name !== name)) { + if (dataStore.data.every((elm) => elm.name !== sensorName)) { dataStore.data.push({ - name: name, + name: sensorName, data: [[time, value]], }); } else { const idx = dataStore.data.findIndex( - (elm) => elm.name === name + (elm) => elm.name === sensorName ); dataStore.data[idx].data.push([time, value]); diff --git a/dist/index.esm.js b/dist/index.esm.js index 83b9fc3..a3508e6 100755 --- a/dist/index.esm.js +++ b/dist/index.esm.js @@ -17033,8 +17033,9 @@ const Predictor = class Predictor { * @param {string[]} labels * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler * @param {{ windowingMode: "time" | "sample" }} options + * @param {boolean} useDeviceTime - True if you want to use timestamps generated by the server */ - constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample", useDeviceTime = false } = {}) { /** @type {(input: number[]) => number[]} */ this.predictor = predictor; /** @type {string[]} */ @@ -17048,6 +17049,9 @@ const Predictor = class Predictor { /** @type {boolean} */ this.windowModeMs = windowSize < 0 || windowingMode === "time"; + /** @type {boolean} */ + this.useDeviceTime = useDeviceTime; + this.lastPruneTime = 0; this.lastAddTime = 0; @@ -17059,15 +17063,24 @@ const Predictor = class Predictor { } /** - * addDatapoint + * addDataPoint + * @param {number} time - The timestamp assigned to the datapoint * @param {string} sensorName * @param {number} value - * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated */ - addDatapoint = (sensorName, value, time = null) => { + addDataPoint = (time, sensorName, value) => { if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); - if (time === null) time = Date.now(); + // TODO: see #16 use if (time === null) time = Date.now() + if (!this.useDeviceTime && typeof time !== "number") { + throw new Error("Provide a valid timestamp"); + } + if (this.useDeviceTime) { + time = Date.now(); + } + + //TODO: see #17 no clue why see Collector + value = Math.round(value * 100) / 100; this.lastAddTime = time; this.store[sensorName].push([time, value]); @@ -17106,6 +17119,9 @@ const Predictor = class Predictor { let window; if (this.windowModeMs) { window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + if (window.length < 1 ) { + throw new PredictorError("Not enough samples") + } } else { window = samples.slice(-this.windowSize); if (window.length < this.windowSize) { @@ -17309,15 +17325,14 @@ async function datasetCollector( var timeSeries = timeSeries; /** - * Uploads a vlaue for a specific timestamp to a datasets timeSeries with name sensorName - * @param {string} name - The name of the timeSeries to upload the value to + * Uploads a value for a specific timestamp to a dataset's timeSeries with name sensorName + * @param {string} sensorName - The name of the timeSeries to upload the value to * @param {number} value - The datapoint to upload * @param {number} time - The timestamp assigned to the datapoint - * @returns A Promise indicating success or failure of upload */ - function addDataPoint(time, name, value) { + function addDataPoint(time, sensorName, value) { - if (!timeSeries.includes(name)) { + if (!timeSeries.includes(sensorName)) { throw Error("invalid time-series name") } if (typeof value !== "number") { @@ -17333,14 +17348,14 @@ async function datasetCollector( value = Math.round(value * 100) / 100; - if (dataStore.data.every((elm) => elm.name !== name)) { + if (dataStore.data.every((elm) => elm.name !== sensorName)) { dataStore.data.push({ - name: name, + name: sensorName, data: [[time, value]], }); } else { const idx = dataStore.data.findIndex( - (elm) => elm.name === name + (elm) => elm.name === sensorName ); dataStore.data[idx].data.push([time, value]); diff --git a/dist/index.js b/dist/index.js index f0371a2..d0d84ee 100755 --- a/dist/index.js +++ b/dist/index.js @@ -17049,8 +17049,9 @@ const Predictor = class Predictor { * @param {string[]} labels * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler * @param {{ windowingMode: "time" | "sample" }} options + * @param {boolean} useDeviceTime - True if you want to use timestamps generated by the server */ - constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample", useDeviceTime = false } = {}) { /** @type {(input: number[]) => number[]} */ this.predictor = predictor; /** @type {string[]} */ @@ -17064,6 +17065,9 @@ const Predictor = class Predictor { /** @type {boolean} */ this.windowModeMs = windowSize < 0 || windowingMode === "time"; + /** @type {boolean} */ + this.useDeviceTime = useDeviceTime; + this.lastPruneTime = 0; this.lastAddTime = 0; @@ -17075,15 +17079,24 @@ const Predictor = class Predictor { } /** - * addDatapoint + * addDataPoint + * @param {number} time - The timestamp assigned to the datapoint * @param {string} sensorName * @param {number} value - * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated */ - addDatapoint = (sensorName, value, time = null) => { + addDataPoint = (time, sensorName, value) => { if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); - if (time === null) time = Date.now(); + // TODO: see #16 use if (time === null) time = Date.now() + if (!this.useDeviceTime && typeof time !== "number") { + throw new Error("Provide a valid timestamp"); + } + if (this.useDeviceTime) { + time = Date.now(); + } + + //TODO: see #17 no clue why see Collector + value = Math.round(value * 100) / 100; this.lastAddTime = time; this.store[sensorName].push([time, value]); @@ -17122,6 +17135,9 @@ const Predictor = class Predictor { let window; if (this.windowModeMs) { window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize); + if (window.length < 1 ) { + throw new PredictorError("Not enough samples") + } } else { window = samples.slice(-this.windowSize); if (window.length < this.windowSize) { @@ -17325,15 +17341,14 @@ async function datasetCollector( var timeSeries = timeSeries; /** - * Uploads a vlaue for a specific timestamp to a datasets timeSeries with name sensorName - * @param {string} name - The name of the timeSeries to upload the value to + * Uploads a value for a specific timestamp to a dataset's timeSeries with name sensorName + * @param {string} sensorName - The name of the timeSeries to upload the value to * @param {number} value - The datapoint to upload * @param {number} time - The timestamp assigned to the datapoint - * @returns A Promise indicating success or failure of upload */ - function addDataPoint(time, name, value) { + function addDataPoint(time, sensorName, value) { - if (!timeSeries.includes(name)) { + if (!timeSeries.includes(sensorName)) { throw Error("invalid time-series name") } if (typeof value !== "number") { @@ -17349,14 +17364,14 @@ async function datasetCollector( value = Math.round(value * 100) / 100; - if (dataStore.data.every((elm) => elm.name !== name)) { + if (dataStore.data.every((elm) => elm.name !== sensorName)) { dataStore.data.push({ - name: name, + name: sensorName, data: [[time, value]], }); } else { const idx = dataStore.data.findIndex( - (elm) => elm.name === name + (elm) => elm.name === sensorName ); dataStore.data[idx].data.push([time, value]); diff --git a/src/index.js b/src/index.js index 0fc0afe..7c33ea2 100644 --- a/src/index.js +++ b/src/index.js @@ -82,15 +82,14 @@ async function datasetCollector( var timeSeries = timeSeries; /** - * Uploads a vlaue for a specific timestamp to a datasets timeSeries with name sensorName - * @param {string} name - The name of the timeSeries to upload the value to + * Uploads a value for a specific timestamp to a dataset's timeSeries with name sensorName + * @param {string} sensorName - The name of the timeSeries to upload the value to * @param {number} value - The datapoint to upload * @param {number} time - The timestamp assigned to the datapoint - * @returns A Promise indicating success or failure of upload */ - function addDataPoint(time, name, value) { + function addDataPoint(time, sensorName, value) { - if (!timeSeries.includes(name)) { + if (!timeSeries.includes(sensorName)) { throw Error("invalid time-series name") } @@ -110,14 +109,14 @@ async function datasetCollector( value = Math.round(value * 100) / 100; - if (dataStore.data.every((elm) => elm.name !== name)) { + if (dataStore.data.every((elm) => elm.name !== sensorName)) { dataStore.data.push({ - name: name, + name: sensorName, data: [[time, value]], }); } else { const idx = dataStore.data.findIndex( - (elm) => elm.name === name + (elm) => elm.name === sensorName ); dataStore.data[idx].data.push([time, value]); diff --git a/src/predictor/index.js b/src/predictor/index.js index a4f69af..23d1547 100644 --- a/src/predictor/index.js +++ b/src/predictor/index.js @@ -32,8 +32,9 @@ export const Predictor = class Predictor { * @param {string[]} labels * @param {{ center: { [featureName: string]: number }, scale: { [featureName: string]: number } }} scaler * @param {{ windowingMode: "time" | "sample" }} options + * @param {boolean} useDeviceTime - True if you want to use timestamps generated by the server */ - constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample" } = {}) { + constructor(predictor, sensors, windowSize, labels, scaler, { windowingMode = "sample", useDeviceTime = false } = {}) { /** @type {(input: number[]) => number[]} */ this.predictor = predictor; /** @type {string[]} */ @@ -47,6 +48,9 @@ export const Predictor = class Predictor { /** @type {boolean} */ this.windowModeMs = windowSize < 0 || windowingMode === "time" + /** @type {boolean} */ + this.useDeviceTime = useDeviceTime + this.lastPruneTime = 0; this.lastAddTime = 0; @@ -58,15 +62,24 @@ export const Predictor = class Predictor { } /** - * addDatapoint + * addDataPoint + * @param {number} time - The timestamp assigned to the datapoint * @param {string} sensorName * @param {number} value - * @param {number | null} time use a predefined timestamp, or null if the timestamp should be generated */ - addDatapoint = (sensorName, value, time = null) => { + addDataPoint = (time, sensorName, value) => { if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); - if (time === null) time = Date.now() + // TODO: see #16 use if (time === null) time = Date.now() + if (!this.useDeviceTime && typeof time !== "number") { + throw new Error("Provide a valid timestamp"); + } + if (this.useDeviceTime) { + time = Date.now(); + } + + //TODO: see #17 no clue why see Collector + value = Math.round(value * 100) / 100; this.lastAddTime = time this.store[sensorName].push([time, value]); @@ -105,6 +118,9 @@ export const Predictor = class Predictor { let window; if (this.windowModeMs) { window = Predictor._sliceByTime(samples, this.lastAddTime - this.windowSize) + if (window.length < 1 ) { + throw new PredictorError("Not enough samples") + } } else { window = samples.slice(-this.windowSize) if (window.length < this.windowSize) { @@ -225,4 +241,4 @@ Predictor.featuresTSfresh = [ "min" ] Predictor.felParams = cache(() => objToMap({"mean_n_abs_max_n": 8, "change_quantile_lower": -0.1, "change_quantile_upper": 0.1, "change_quantile_aggr": 0, "range_count_lower": -1, "range_count_upper": 1, "count_above_x": 0, "count_below_x": 0, "quantile_q": 0.5, "autocorrelation_lag": 1})) -Predictor.felFeaturesTSfresh = cache(() => arrToVector(Predictor.featuresTSfresh, 'string')) \ No newline at end of file +Predictor.felFeaturesTSfresh = cache(() => arrToVector(Predictor.featuresTSfresh, 'string')) From 450f82776d6a1ad2ed88d4bf5cf788a149e9d000 Mon Sep 17 00:00:00 2001 From: Till Riedel Date: Sun, 13 Jul 2025 10:56:39 +0200 Subject: [PATCH 3/3] modify examples to DataPoint (and fix some other occurences) --- .../predictionExample.js | 10 +++++----- examples/example-prediction-web/index.html | 19 ++++++++++--------- examples/example-shake/sampleModeExample.js | 10 +++++----- examples/example-shake/timeModeExample.js | 10 +++++----- src/index.js | 2 +- src/predictor/index.js | 4 ++-- 6 files changed, 28 insertions(+), 27 deletions(-) diff --git a/examples/example-prediction-node/predictionExample.js b/examples/example-prediction-node/predictionExample.js index 3219d35..641acb6 100644 --- a/examples/example-prediction-node/predictionExample.js +++ b/examples/example-prediction-node/predictionExample.js @@ -20,9 +20,9 @@ const p = new Predictor( */ // setInterval(() => { -// p.addDatapoint('AccelerometerX', getAccelerometerX()) -// p.addDatapoint('AccelerometerY', getAccelerometerY()) -// p.addDatapoint('AccelerometerZ', getAccelerometerZ()) +// p.addDataPoint(Date.now(),'AccelerometerX', getAccelerometerX()) +// p.addDataPoint(Date.now(),'AccelerometerY', getAccelerometerY()) +// p.addDataPoint(Date.now(),'AccelerometerZ', getAccelerometerZ()) // p.predict() // .then(x => x) @@ -41,7 +41,7 @@ async function runner() { for (const { time: ti, ...valObjs } of test) { const time = parseInt(ti); for (const [key, valStr] of Object.entries(valObjs)) { - p.addDatapoint(key, parseInt(valStr), time) + p.addDataPoint(time, key, parseInt(valStr)) } try { @@ -71,4 +71,4 @@ function csvToArray(str, delimiter = ",") { function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); -} \ No newline at end of file +} diff --git a/examples/example-prediction-web/index.html b/examples/example-prediction-web/index.html index 28877d0..49788f0 100644 --- a/examples/example-prediction-web/index.html +++ b/examples/example-prediction-web/index.html @@ -35,17 +35,18 @@

devicemotion

- \ No newline at end of file + diff --git a/examples/example-shake/sampleModeExample.js b/examples/example-shake/sampleModeExample.js index ec8b43c..a5bd18d 100644 --- a/examples/example-shake/sampleModeExample.js +++ b/examples/example-shake/sampleModeExample.js @@ -23,9 +23,9 @@ const p = new Predictor( */ // setInterval(() => { -// p.addDatapoint('AccelerometerX', getAccelerometerX()) -// p.addDatapoint('AccelerometerY', getAccelerometerY()) -// p.addDatapoint('AccelerometerZ', getAccelerometerZ()) +// p.addDataPoint(Date.now(), 'AccelerometerX', getAccelerometerX()) +// p.addDataPoint(Date.now(), 'AccelerometerY', getAccelerometerY()) +// p.addDataPoint(Date.now(), 'AccelerometerZ', getAccelerometerZ()) // p.predict() // .then(x => x) @@ -44,7 +44,7 @@ async function runner() { for (const { time: ti, ...valObjs } of test) { const time = parseInt(ti); for (const [key, valStr] of Object.entries(valObjs)) { - p.addDatapoint(key, parseInt(valStr), time) + p.addDataPoint(time, key, parseInt(valStr)) } try { @@ -74,4 +74,4 @@ function csvToArray(str, delimiter = ",") { function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); -} \ No newline at end of file +} diff --git a/examples/example-shake/timeModeExample.js b/examples/example-shake/timeModeExample.js index 1b8382b..3018d8e 100644 --- a/examples/example-shake/timeModeExample.js +++ b/examples/example-shake/timeModeExample.js @@ -23,9 +23,9 @@ const p = new Predictor( */ // setInterval(() => { -// p.addDatapoint('AccelerometerX', getAccelerometerX()) -// p.addDatapoint('AccelerometerY', getAccelerometerY()) -// p.addDatapoint('AccelerometerZ', getAccelerometerZ()) +// p.addDataPoint(Date.now(), 'AccelerometerX', getAccelerometerX()) +// p.addDataPoint(Date.now(), 'AccelerometerY', getAccelerometerY()) +// p.addDataPoint(Date.now(), 'AccelerometerZ', getAccelerometerZ()) // p.predict() // .then(x => x) @@ -44,7 +44,7 @@ async function runner() { for (const { time: ti, ...valObjs } of test) { const time = parseInt(ti); for (const [key, valStr] of Object.entries(valObjs)) { - p.addDatapoint(key, parseInt(valStr), time) + p.addDataPoint(time, key, parseInt(valStr)) } try { @@ -74,4 +74,4 @@ function csvToArray(str, delimiter = ",") { function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); -} \ No newline at end of file +} diff --git a/src/index.js b/src/index.js index 7c33ea2..effa977 100644 --- a/src/index.js +++ b/src/index.js @@ -97,7 +97,7 @@ async function datasetCollector( throw new Error(error); } if (typeof value !== "number") { - throw new Error("Datapoint is not a number"); + throw new Error("DataPoint value is not a number"); } if (!useDeviceTime && typeof time !== "number") { throw new Error("Provide a valid timestamp"); diff --git a/src/predictor/index.js b/src/predictor/index.js index 23d1547..c283c83 100644 --- a/src/predictor/index.js +++ b/src/predictor/index.js @@ -68,11 +68,11 @@ export const Predictor = class Predictor { * @param {number} value */ addDataPoint = (time, sensorName, value) => { - if (typeof value !== 'number') throw new TypeError('Datapoint is not a number'); + if (typeof value !== 'number') throw new TypeError('DataPoint value is not a number'); if (!this.sensors.includes(sensorName)) throw new TypeError('Sensor is not valid'); // TODO: see #16 use if (time === null) time = Date.now() if (!this.useDeviceTime && typeof time !== "number") { - throw new Error("Provide a valid timestamp"); + throw new TypeError("Provide a valid timestamp"); } if (this.useDeviceTime) { time = Date.now();