autumnplot-gl 4.0.0-beta → 4.1.0

package/dist/812.autumnplot-gl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"812.autumnplot-gl.js","mappings":"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CA,iBACA,sBACA,sBACA,cACA,aACA,SACA,aACA,eACA,WACA,UACA,WACA,YACA,YACA,YACA,YACA,eACA,gBACA,iBACA,aACA,gBACA,gBACA,UACA,oBACA,aACA,yBACA,kBACA,mBACA,uBACA,sBACA,mBACA,YACA,cACA,YACA,cACA,YACA,kBACA,oBACA,aACA,cACA,eACA,aACA,WACA,QACA,QACA,gBACA,iBACA,mBACA,0BACA,oBACA,iBACA,qBACA,cACA,iBACA,iBACA,SACA,SACA,SACA,eACA,qBACA,mBACA,gBACA,gBACA,kBACA,sBACA,qBACA,2BACA,yBACA,kBACA,wBACA,qBACA,6BACA,6BACA,0BACA,6BACA,iCACA,yCACA,4BACA,oCACA,oBACA,iCACA,yCACA,gCACA,wCACA,6BACA,qCACA,0BACA,mCACA,wBACA,eACA,wCACA,sBACA,iCACA,yCACA,wCACA,qBACA,gCACA,wCACA,6BACA,uBACA,+BACA,oCACA,uBACA,UACA,+BACA,uBACA,uBACA,eACA,eACA,4BACA,gBACA,iBACA,yBACA,yBACA,uBACA,iBACA,sBACA,wBACA,uBACA,aACA,cACA,gBACA,sBACA,kCACA,cACA,kBACA,mBACA,yBACA,uBACA,aACA,mBACA,YACA,oBACA,eACA,sBACA,yBACA,oBACA,sCACA,uCACA,kCACA,gCACA,qBACA,gCACA,iCACA,iCACA,4BACA,0BACA,6CACA,uBACA,iCACA,+BACA,eACA,6BACA,qBACA,eACA,cACA,WACA,sBACA,qBACA,WACA,WACA,aACA,sBACA,2BACA,cACA,mBACA,4BACA,8BACA,uBACA,4BACA,4BACA,2BACA,2BACA,sCACA,yCACA,yBACA,oBACA,iCACA,gBACA,qBACA,kBACA,kBACA,kBACA,mBACA,cACA,8BACA,sBACA,mBACA,kBACA,6BACA,kBACA,gBACA,eACA,SACA,SACA,wBACA,oBAEoBxG,QAxtEtB,SAA8BsI,GACH,oBAAdE,YAA8BtI,OAAOC,yBAAyBqI,WAAYF,IACnFpI,OAAOE,eAAeoI,WAAYF,EAAK,CACrCH,cAAc,EACd,GAAA9H,GAGE,IAAIkI,EAAM,KAAKD,mJAIX4Z,EAAgB5Z,EACf4Z,EAAcrhB,WAAW,OAC5BqhB,EAAgB,IAAM5Z,GAExBC,GAAO,8CAA8C2Z,MACjD9Z,EAA4BE,KAC9BC,GAAO,4FAETE,GAASF,EAEX,IAKJG,EAAwBJ,EAC1B,GA+rEwB,CACtB,MACA,cACA,YACA,eACA,YACA,eACA,mBACA,sBACA,MACA,MACA,WACA,QACA,aACA,cACA,mBACA,mBACA,6BACA,YACA,eACA,aACA,cACA,cACA,aACA,aACA,MACA,qBACA,kBACA,gCACA,6BACA,cACA,MACA,YACA,UACA,SACA,WACA,qBACA,UACA,gBACA,eACA,UACA,YACA,gBACA,mBACA,sBACA,WACA,WACA,OACA,UACA,cACA,oBACA,eACA,oBACA,eACA,kBACA,eACA,gBACA,gBACA,mBACA,gBACA,gBACA,mBACA,WACA,qBACA,wBACA,4BACA,0BACA,eACA,aACA,sBACA,aACA,yBACA,gBACA,kBACA,gBACA,oBACA,4BACA,6BACA,6BACA,sBACA,UACA,8BACA,OACA,WACA,iBACA,0BACA,gBACA,kBACA,cACA,KACA,oBACA,QACA,MACA,SACA,SACA,uBACA,4BACA,0BACA,KACA,KACA,OACA,MACA,OACA,WACA,MACA,UACA,eACA,sBACA,QACA,WACA,gBACA,eACA,qBACA,oBACA,kBACA,uBACA,mBACA,qBACA,sBACA,qBACA,gCACA,mBACA,wBACA,mBACA,cACA,kBACA,sBACA,wBACA,sBACA,kBACA,mBACA,mBACA,sBACA,YACA,wBACA,sBACA,qBACA,sBACA,cACA,sBACA,aACA,sBACA,qBACA,eACA,8BACA,4BACA,cACA,iBACA,UACA,uBACA,0BACA,uBACA,uBACA,gBACA,gBACA,iBACA,gBACA,gBACA,aACA,sBACA,oBACA,QACA,oBACA,oBACA,sBACA,wBACA,oBAEgBtI,QAAQ0I,GAM1BpD,EAAwB,SAAS6c,IAE1BlN,IAAW4M,KACX5M,KAA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","sources":["webpack://apgl/webpack/universalModuleDefinition","webpack://apgl/./src/cpp/marchingsquares.js","webpack://apgl/webpack/bootstrap","webpack://apgl/webpack/runtime/compat get default export","webpack://apgl/webpack/runtime/define property getters","webpack://apgl/webpack/runtime/global","webpack://apgl/webpack/runtime/hasOwnProperty shorthand","webpack://apgl/webpack/runtime/publicPath","webpack://apgl/./node_modules/comlink/dist/esm/comlink.mjs","webpack://apgl/./src/WasmInterface.ts","webpack://apgl/./src/ContourCreator.worker.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"apgl\"] = factory();\n\telse\n\t\troot[\"apgl\"] = factory();\n})(this, () => {\nreturn ","\nvar Module = (() => {\n  var _scriptName = typeof document != 'undefined' ? document.currentScript?.src : undefined;\n  \n  return (\nfunction(moduleArg = {}) {\n  var moduleRtn;\n\n// include: shell.js\n// The Module object: Our interface to the outside world. We import\n// and export values on it. There are various ways Module can be used:\n// 1. Not defined. We create it here\n// 2. A function parameter, function(moduleArg) => Promise<Module>\n// 3. pre-run appended it, var Module = {}; ..generated code..\n// 4. External script tag defines var Module.\n// We need to check if Module already exists (e.g. case 3 above).\n// Substitution will be replaced with actual code on later stage of the build,\n// this way Closure Compiler will not mangle it (e.g. case 4. above).\n// Note that if you want to run closure, and also to use Module\n// after the generated code, you will need to define   var Module = {};\n// before the code. Then that object will be used in the code, and you\n// can continue to use Module afterwards as well.\nvar Module = moduleArg;\n\n// Set up the promise that indicates the Module is initialized\nvar readyPromiseResolve, readyPromiseReject;\nvar readyPromise = new Promise((resolve, reject) => {\n  readyPromiseResolve = resolve;\n  readyPromiseReject = reject;\n});\n[\"getExceptionMessage\",\"incrementExceptionRefcount\",\"decrementExceptionRefcount\",\"_memory\",\"___indirect_function_table\",\"onRuntimeInitialized\"].forEach((prop) => {\n  if (!Object.getOwnPropertyDescriptor(readyPromise, prop)) {\n    Object.defineProperty(readyPromise, prop, {\n      get: () => abort('You are getting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),\n      set: () => abort('You are setting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),\n    });\n  }\n});\n\n// Determine the runtime environment we are in. You can customize this by\n// setting the ENVIRONMENT setting at compile time (see settings.js).\n\nvar ENVIRONMENT_IS_WEB = true;\nvar ENVIRONMENT_IS_WORKER = false;\nvar ENVIRONMENT_IS_NODE = false;\nvar ENVIRONMENT_IS_SHELL = false;\n\nif (Module['ENVIRONMENT']) {\n  throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');\n}\n\n// --pre-jses are emitted after the Module integration code, so that they can\n// refer to Module (if they choose; they can also define Module)\n\n\n// Sometimes an existing Module object exists with properties\n// meant to overwrite the default module functionality. Here\n// we collect those properties and reapply _after_ we configure\n// the current environment's defaults to avoid having to be so\n// defensive during initialization.\nvar moduleOverrides = Object.assign({}, Module);\n\nvar arguments_ = [];\nvar thisProgram = './this.program';\nvar quit_ = (status, toThrow) => {\n  throw toThrow;\n};\n\n// `/` should be present at the end if `scriptDirectory` is not empty\nvar scriptDirectory = '';\nfunction locateFile(path) {\n  if (Module['locateFile']) {\n    return Module['locateFile'](path, scriptDirectory);\n  }\n  return scriptDirectory + path;\n}\n\n// Hooks that are implemented differently in different runtime environments.\nvar readAsync, readBinary;\n\nif (ENVIRONMENT_IS_SHELL) {\n\n  if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');\n\n} else\n\n// Note that this includes Node.js workers when relevant (pthreads is enabled).\n// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and\n// ENVIRONMENT_IS_NODE.\nif (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {\n  if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled\n    scriptDirectory = self.location.href;\n  } else if (typeof document != 'undefined' && document.currentScript) { // web\n    scriptDirectory = document.currentScript.src;\n  }\n  // When MODULARIZE, this JS may be executed later, after document.currentScript\n  // is gone, so we saved it, and we use it here instead of any other info.\n  if (_scriptName) {\n    scriptDirectory = _scriptName;\n  }\n  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.\n  // otherwise, slice off the final part of the url to find the script directory.\n  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,\n  // and scriptDirectory will correctly be replaced with an empty string.\n  // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),\n  // they are removed because they could contain a slash.\n  if (scriptDirectory.startsWith('blob:')) {\n    scriptDirectory = '';\n  } else {\n    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/')+1);\n  }\n\n  if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');\n\n  {\n// include: web_or_worker_shell_read.js\nreadAsync = (url) => {\n    assert(!isFileURI(url), \"readAsync does not work with file:// URLs\");\n    return fetch(url, { credentials: 'same-origin' })\n      .then((response) => {\n        if (response.ok) {\n          return response.arrayBuffer();\n        }\n        return Promise.reject(new Error(response.status + ' : ' + response.url));\n      })\n  };\n// end include: web_or_worker_shell_read.js\n  }\n} else\n{\n  throw new Error('environment detection error');\n}\n\nvar out = Module['print'] || console.log.bind(console);\nvar err = Module['printErr'] || console.error.bind(console);\n\n// Merge back in the overrides\nObject.assign(Module, moduleOverrides);\n// Free the object hierarchy contained in the overrides, this lets the GC\n// reclaim data used.\nmoduleOverrides = null;\ncheckIncomingModuleAPI();\n\n// Emit code to handle expected values on the Module object. This applies Module.x\n// to the proper local x. This has two benefits: first, we only emit it if it is\n// expected to arrive, and second, by using a local everywhere else that can be\n// minified.\n\nif (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_');\n\nif (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram');\n\nif (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_');\n\n// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message\n// Assertions on removed incoming Module JS APIs.\nassert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['read'] == 'undefined', 'Module.read option was removed');\nassert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');\nassert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');\nassert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)');\nassert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');\nlegacyModuleProp('asm', 'wasmExports');\nlegacyModuleProp('readAsync', 'readAsync');\nlegacyModuleProp('readBinary', 'readBinary');\nlegacyModuleProp('setWindowTitle', 'setWindowTitle');\nvar IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';\nvar PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';\nvar WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';\nvar FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js';\nvar ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js';\nvar JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js';\nvar OPFS = 'OPFS is no longer included by default; build with -lopfs.js';\n\nvar NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';\n\nassert(!ENVIRONMENT_IS_WORKER, 'worker environment detected but not enabled at build time.  Add `worker` to `-sENVIRONMENT` to enable.');\n\nassert(!ENVIRONMENT_IS_NODE, 'node environment detected but not enabled at build time.  Add `node` to `-sENVIRONMENT` to enable.');\n\nassert(!ENVIRONMENT_IS_SHELL, 'shell environment detected but not enabled at build time.  Add `shell` to `-sENVIRONMENT` to enable.');\n\n// end include: shell.js\n\n// include: preamble.js\n// === Preamble library stuff ===\n\n// Documentation for the public APIs defined in this file must be updated in:\n//    site/source/docs/api_reference/preamble.js.rst\n// A prebuilt local version of the documentation is available at:\n//    site/build/text/docs/api_reference/preamble.js.txt\n// You can also build docs locally as HTML or other formats in site/\n// An online HTML version (which may be of a different version of Emscripten)\n//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html\n\nvar wasmBinary; \nif (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary');\n\nif (typeof WebAssembly != 'object') {\n  err('no native wasm support detected');\n}\n\n// Wasm globals\n\nvar wasmMemory;\n\n//========================================\n// Runtime essentials\n//========================================\n\n// whether we are quitting the application. no code should run after this.\n// set in exit() and abort()\nvar ABORT = false;\n\n// set by exit() and abort().  Passed to 'onExit' handler.\n// NOTE: This is also used as the process return code code in shell environments\n// but only when noExitRuntime is false.\nvar EXITSTATUS;\n\n// In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we\n// don't define it at all in release modes.  This matches the behaviour of\n// MINIMAL_RUNTIME.\n// TODO(sbc): Make this the default even without STRICT enabled.\n/** @type {function(*, string=)} */\nfunction assert(condition, text) {\n  if (!condition) {\n    abort('Assertion failed' + (text ? ': ' + text : ''));\n  }\n}\n\n// We used to include malloc/free by default in the past. Show a helpful error in\n// builds with assertions.\n\n// Memory management\n\nvar HEAP,\n/** @type {!Int8Array} */\n  HEAP8,\n/** @type {!Uint8Array} */\n  HEAPU8,\n/** @type {!Int16Array} */\n  HEAP16,\n/** @type {!Uint16Array} */\n  HEAPU16,\n/** @type {!Int32Array} */\n  HEAP32,\n/** @type {!Uint32Array} */\n  HEAPU32,\n/** @type {!Float32Array} */\n  HEAPF32,\n/** @type {!Float64Array} */\n  HEAPF64;\n\n// include: runtime_shared.js\nfunction updateMemoryViews() {\n  var b = wasmMemory.buffer;\n  Module['HEAP8'] = HEAP8 = new Int8Array(b);\n  Module['HEAP16'] = HEAP16 = new Int16Array(b);\n  Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);\n  Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);\n  Module['HEAP32'] = HEAP32 = new Int32Array(b);\n  Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);\n  Module['HEAPF32'] = HEAPF32 = new Float32Array(b);\n  Module['HEAPF64'] = HEAPF64 = new Float64Array(b);\n}\n// end include: runtime_shared.js\nassert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time')\n\nassert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined,\n       'JS engine does not provide full typed array support');\n\n// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY\nassert(!Module['wasmMemory'], 'Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally');\nassert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically');\n\n// include: runtime_stack_check.js\n// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.\nfunction writeStackCookie() {\n  var max = _emscripten_stack_get_end();\n  assert((max & 3) == 0);\n  // If the stack ends at address zero we write our cookies 4 bytes into the\n  // stack.  This prevents interference with SAFE_HEAP and ASAN which also\n  // monitor writes to address zero.\n  if (max == 0) {\n    max += 4;\n  }\n  // The stack grow downwards towards _emscripten_stack_get_end.\n  // We write cookies to the final two words in the stack and detect if they are\n  // ever overwritten.\n  HEAPU32[((max)>>2)] = 0x02135467;\n  HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE;\n  // Also test the global address 0 for integrity.\n  HEAPU32[((0)>>2)] = 1668509029;\n}\n\nfunction checkStackCookie() {\n  if (ABORT) return;\n  var max = _emscripten_stack_get_end();\n  // See writeStackCookie().\n  if (max == 0) {\n    max += 4;\n  }\n  var cookie1 = HEAPU32[((max)>>2)];\n  var cookie2 = HEAPU32[(((max)+(4))>>2)];\n  if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) {\n    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);\n  }\n  // Also test the global address 0 for integrity.\n  if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) {\n    abort('Runtime error: The application has corrupted its heap memory area (address zero)!');\n  }\n}\n// end include: runtime_stack_check.js\n// include: runtime_assertions.js\n// Endianness check\n(function() {\n  var h16 = new Int16Array(1);\n  var h8 = new Int8Array(h16.buffer);\n  h16[0] = 0x6373;\n  if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';\n})();\n\n// end include: runtime_assertions.js\nvar __ATPRERUN__  = []; // functions called before the runtime is initialized\nvar __ATINIT__    = []; // functions called during startup\nvar __ATEXIT__    = []; // functions called during shutdown\nvar __ATPOSTRUN__ = []; // functions called after the main() is called\n\nvar runtimeInitialized = false;\n\nfunction preRun() {\n  if (Module['preRun']) {\n    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];\n    while (Module['preRun'].length) {\n      addOnPreRun(Module['preRun'].shift());\n    }\n  }\n  callRuntimeCallbacks(__ATPRERUN__);\n}\n\nfunction initRuntime() {\n  assert(!runtimeInitialized);\n  runtimeInitialized = true;\n\n  checkStackCookie();\n\n  \n  callRuntimeCallbacks(__ATINIT__);\n}\n\nfunction postRun() {\n  checkStackCookie();\n\n  if (Module['postRun']) {\n    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];\n    while (Module['postRun'].length) {\n      addOnPostRun(Module['postRun'].shift());\n    }\n  }\n\n  callRuntimeCallbacks(__ATPOSTRUN__);\n}\n\nfunction addOnPreRun(cb) {\n  __ATPRERUN__.unshift(cb);\n}\n\nfunction addOnInit(cb) {\n  __ATINIT__.unshift(cb);\n}\n\nfunction addOnExit(cb) {\n}\n\nfunction addOnPostRun(cb) {\n  __ATPOSTRUN__.unshift(cb);\n}\n\n// include: runtime_math.js\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc\n\nassert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\nassert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\nassert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\nassert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\n// end include: runtime_math.js\n// A counter of dependencies for calling run(). If we need to\n// do asynchronous work before running, increment this and\n// decrement it. Incrementing must happen in a place like\n// Module.preRun (used by emcc to add file preloading).\n// Note that you can add dependencies in preRun, even though\n// it happens right before run - run will be postponed until\n// the dependencies are met.\nvar runDependencies = 0;\nvar runDependencyWatcher = null;\nvar dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled\nvar runDependencyTracking = {};\n\nfunction getUniqueRunDependency(id) {\n  var orig = id;\n  while (1) {\n    if (!runDependencyTracking[id]) return id;\n    id = orig + Math.random();\n  }\n}\n\nfunction addRunDependency(id) {\n  runDependencies++;\n\n  Module['monitorRunDependencies']?.(runDependencies);\n\n  if (id) {\n    assert(!runDependencyTracking[id]);\n    runDependencyTracking[id] = 1;\n    if (runDependencyWatcher === null && typeof setInterval != 'undefined') {\n      // Check for missing dependencies every few seconds\n      runDependencyWatcher = setInterval(() => {\n        if (ABORT) {\n          clearInterval(runDependencyWatcher);\n          runDependencyWatcher = null;\n          return;\n        }\n        var shown = false;\n        for (var dep in runDependencyTracking) {\n          if (!shown) {\n            shown = true;\n            err('still waiting on run dependencies:');\n          }\n          err(`dependency: ${dep}`);\n        }\n        if (shown) {\n          err('(end of list)');\n        }\n      }, 10000);\n    }\n  } else {\n    err('warning: run dependency added without ID');\n  }\n}\n\nfunction removeRunDependency(id) {\n  runDependencies--;\n\n  Module['monitorRunDependencies']?.(runDependencies);\n\n  if (id) {\n    assert(runDependencyTracking[id]);\n    delete runDependencyTracking[id];\n  } else {\n    err('warning: run dependency removed without ID');\n  }\n  if (runDependencies == 0) {\n    if (runDependencyWatcher !== null) {\n      clearInterval(runDependencyWatcher);\n      runDependencyWatcher = null;\n    }\n    if (dependenciesFulfilled) {\n      var callback = dependenciesFulfilled;\n      dependenciesFulfilled = null;\n      callback(); // can add another dependenciesFulfilled\n    }\n  }\n}\n\n/** @param {string|number=} what */\nfunction abort(what) {\n  Module['onAbort']?.(what);\n\n  what = 'Aborted(' + what + ')';\n  // TODO(sbc): Should we remove printing and leave it up to whoever\n  // catches the exception?\n  err(what);\n\n  ABORT = true;\n  EXITSTATUS = 1;\n\n  // Use a wasm runtime error, because a JS error might be seen as a foreign\n  // exception, which means we'd run destructors on it. We need the error to\n  // simply make the program stop.\n  // FIXME This approach does not work in Wasm EH because it currently does not assume\n  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from\n  // a trap or not based on a hidden field within the object. So at the moment\n  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that\n  // allows this in the wasm spec.\n\n  // Suppress closure compiler warning here. Closure compiler's builtin extern\n  // definition for WebAssembly.RuntimeError claims it takes no arguments even\n  // though it can.\n  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.\n  /** @suppress {checkTypes} */\n  var e = new WebAssembly.RuntimeError(what);\n\n  readyPromiseReject(e);\n  // Throw the error whether or not MODULARIZE is set because abort is used\n  // in code paths apart from instantiation where an exception is expected\n  // to be thrown when abort is called.\n  throw e;\n}\n\n// include: memoryprofiler.js\n// end include: memoryprofiler.js\n// show errors on likely calls to FS when it was not included\nvar FS = {\n  error() {\n    abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM');\n  },\n  init() { FS.error() },\n  createDataFile() { FS.error() },\n  createPreloadedFile() { FS.error() },\n  createLazyFile() { FS.error() },\n  open() { FS.error() },\n  mkdev() { FS.error() },\n  registerDevice() { FS.error() },\n  analyzePath() { FS.error() },\n\n  ErrnoError() { FS.error() },\n};\nModule['FS_createDataFile'] = FS.createDataFile;\nModule['FS_createPreloadedFile'] = FS.createPreloadedFile;\n\n// include: URIUtils.js\n// Prefix of data URIs emitted by SINGLE_FILE and related options.\nvar dataURIPrefix = 'data:application/octet-stream;base64,';\n\n/**\n * Indicates whether filename is a base64 data URI.\n * @noinline\n */\nvar isDataURI = (filename) => filename.startsWith(dataURIPrefix);\n\n/**\n * Indicates whether filename is delivered via file protocol (as opposed to http/https)\n * @noinline\n */\nvar isFileURI = (filename) => filename.startsWith('file://');\n// end include: URIUtils.js\nfunction createExportWrapper(name, nargs) {\n  return (...args) => {\n    assert(runtimeInitialized, `native function \\`${name}\\` called before runtime initialization`);\n    var f = wasmExports[name];\n    assert(f, `exported native function \\`${name}\\` not found`);\n    // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled.\n    assert(args.length <= nargs, `native function \\`${name}\\` called with ${args.length} args but expects ${nargs}`);\n    return f(...args);\n  };\n}\n\n// include: runtime_exceptions.js\n// Base Emscripten EH error class\nclass EmscriptenEH extends Error {}\n\nclass EmscriptenSjLj extends EmscriptenEH {}\n\nclass CppException extends EmscriptenEH {\n  constructor(excPtr) {\n    super(excPtr);\n    this.excPtr = excPtr;\n    const excInfo = getExceptionMessage(excPtr);\n    this.name = excInfo[0];\n    this.message = excInfo[1];\n  }\n}\n// end include: runtime_exceptions.js\nfunction findWasmBinary() {\n    var f = 'marchingsquares.wasm';\n    if (!isDataURI(f)) {\n      return locateFile(f);\n    }\n    return f;\n}\n\nvar wasmBinaryFile;\n\nfunction getBinarySync(file) {\n  if (file == wasmBinaryFile && wasmBinary) {\n    return new Uint8Array(wasmBinary);\n  }\n  if (readBinary) {\n    return readBinary(file);\n  }\n  throw 'both async and sync fetching of the wasm failed';\n}\n\nfunction getBinaryPromise(binaryFile) {\n  // If we don't have the binary yet, load it asynchronously using readAsync.\n  if (!wasmBinary\n      ) {\n    // Fetch the binary using readAsync\n    return readAsync(binaryFile).then(\n      (response) => new Uint8Array(/** @type{!ArrayBuffer} */(response)),\n      // Fall back to getBinarySync if readAsync fails\n      () => getBinarySync(binaryFile)\n    );\n  }\n\n  // Otherwise, getBinarySync should be able to get it synchronously\n  return Promise.resolve().then(() => getBinarySync(binaryFile));\n}\n\nfunction instantiateArrayBuffer(binaryFile, imports, receiver) {\n  return getBinaryPromise(binaryFile).then((binary) => {\n    return WebAssembly.instantiate(binary, imports);\n  }).then(receiver, (reason) => {\n    err(`failed to asynchronously prepare wasm: ${reason}`);\n\n    // Warn on some common problems.\n    if (isFileURI(wasmBinaryFile)) {\n      err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);\n    }\n    abort(reason);\n  });\n}\n\nfunction instantiateAsync(binary, binaryFile, imports, callback) {\n  if (!binary &&\n      typeof WebAssembly.instantiateStreaming == 'function' &&\n      !isDataURI(binaryFile) &&\n      typeof fetch == 'function') {\n    return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {\n      // Suppress closure warning here since the upstream definition for\n      // instantiateStreaming only allows Promise<Repsponse> rather than\n      // an actual Response.\n      // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.\n      /** @suppress {checkTypes} */\n      var result = WebAssembly.instantiateStreaming(response, imports);\n\n      return result.then(\n        callback,\n        function(reason) {\n          // We expect the most common failure cause to be a bad MIME type for the binary,\n          // in which case falling back to ArrayBuffer instantiation should work.\n          err(`wasm streaming compile failed: ${reason}`);\n          err('falling back to ArrayBuffer instantiation');\n          return instantiateArrayBuffer(binaryFile, imports, callback);\n        });\n    });\n  }\n  return instantiateArrayBuffer(binaryFile, imports, callback);\n}\n\nfunction getWasmImports() {\n  // prepare imports\n  return {\n    'env': wasmImports,\n    'wasi_snapshot_preview1': wasmImports,\n  }\n}\n\n// Create the wasm instance.\n// Receives the wasm imports, returns the exports.\nfunction createWasm() {\n  var info = getWasmImports();\n  // Load the wasm module and create an instance of using native support in the JS engine.\n  // handle a generated wasm instance, receiving its exports and\n  // performing other necessary setup\n  /** @param {WebAssembly.Module=} module*/\n  function receiveInstance(instance, module) {\n    wasmExports = instance.exports;\n\n    \n\n    wasmMemory = wasmExports['memory'];\n    \n    assert(wasmMemory, 'memory not found in wasm exports');\n    updateMemoryViews();\n\n    wasmTable = wasmExports['__indirect_function_table'];\n    \n    assert(wasmTable, 'table not found in wasm exports');\n\n    addOnInit(wasmExports['__wasm_call_ctors']);\n\n    removeRunDependency('wasm-instantiate');\n    return wasmExports;\n  }\n  // wait for the pthread pool (if any)\n  addRunDependency('wasm-instantiate');\n\n  // Prefer streaming instantiation if available.\n  // Async compilation can be confusing when an error on the page overwrites Module\n  // (for example, if the order of elements is wrong, and the one defining Module is\n  // later), so we save Module and check it later.\n  var trueModule = Module;\n  function receiveInstantiationResult(result) {\n    // 'result' is a ResultObject object which has both the module and instance.\n    // receiveInstance() will swap in the exports (to Module.asm) so they can be called\n    assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?');\n    trueModule = null;\n    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.\n    // When the regression is fixed, can restore the above PTHREADS-enabled path.\n    receiveInstance(result['instance']);\n  }\n\n  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback\n  // to manually instantiate the Wasm module themselves. This allows pages to\n  // run the instantiation parallel to any other async startup actions they are\n  // performing.\n  // Also pthreads and wasm workers initialize the wasm instance through this\n  // path.\n  if (Module['instantiateWasm']) {\n    try {\n      return Module['instantiateWasm'](info, receiveInstance);\n    } catch(e) {\n      err(`Module.instantiateWasm callback failed with error: ${e}`);\n        // If instantiation fails, reject the module ready promise.\n        readyPromiseReject(e);\n    }\n  }\n\n  if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();\n\n  // If instantiation fails, reject the module ready promise.\n  instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);\n  return {}; // no exports yet; we'll fill them in later\n}\n\n// Globals used by JS i64 conversions (see makeSetValue)\nvar tempDouble;\nvar tempI64;\n\n// include: runtime_debug.js\nfunction legacyModuleProp(prop, newName, incoming=true) {\n  if (!Object.getOwnPropertyDescriptor(Module, prop)) {\n    Object.defineProperty(Module, prop, {\n      configurable: true,\n      get() {\n        let extra = incoming ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' : '';\n        abort(`\\`Module.${prop}\\` has been replaced by \\`${newName}\\`` + extra);\n\n      }\n    });\n  }\n}\n\nfunction ignoredModuleProp(prop) {\n  if (Object.getOwnPropertyDescriptor(Module, prop)) {\n    abort(`\\`Module.${prop}\\` was supplied but \\`${prop}\\` not included in INCOMING_MODULE_JS_API`);\n  }\n}\n\n// forcing the filesystem exports a few things by default\nfunction isExportedByForceFilesystem(name) {\n  return name === 'FS_createPath' ||\n         name === 'FS_createDataFile' ||\n         name === 'FS_createPreloadedFile' ||\n         name === 'FS_unlink' ||\n         name === 'addRunDependency' ||\n         // The old FS has some functionality that WasmFS lacks.\n         name === 'FS_createLazyFile' ||\n         name === 'FS_createDevice' ||\n         name === 'removeRunDependency';\n}\n\nfunction missingGlobal(sym, msg) {\n  if (typeof globalThis != 'undefined') {\n    Object.defineProperty(globalThis, sym, {\n      configurable: true,\n      get() {\n        warnOnce(`\\`${sym}\\` is not longer defined by emscripten. ${msg}`);\n        return undefined;\n      }\n    });\n  }\n}\n\nmissingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer');\nmissingGlobal('asm', 'Please use wasmExports instead');\n\nfunction missingLibrarySymbol(sym) {\n  if (typeof globalThis != 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) {\n    Object.defineProperty(globalThis, sym, {\n      configurable: true,\n      get() {\n        // Can't `abort()` here because it would break code that does runtime\n        // checks.  e.g. `if (typeof SDL === 'undefined')`.\n        var msg = `\\`${sym}\\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;\n        // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in\n        // library.js, which means $name for a JS name with no prefix, or name\n        // for a JS name like _name.\n        var librarySymbol = sym;\n        if (!librarySymbol.startsWith('_')) {\n          librarySymbol = '$' + sym;\n        }\n        msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;\n        if (isExportedByForceFilesystem(sym)) {\n          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';\n        }\n        warnOnce(msg);\n        return undefined;\n      }\n    });\n  }\n  // Any symbol that is not included from the JS library is also (by definition)\n  // not exported on the Module object.\n  unexportedRuntimeSymbol(sym);\n}\n\nfunction unexportedRuntimeSymbol(sym) {\n  if (!Object.getOwnPropertyDescriptor(Module, sym)) {\n    Object.defineProperty(Module, sym, {\n      configurable: true,\n      get() {\n        var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;\n        if (isExportedByForceFilesystem(sym)) {\n          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';\n        }\n        abort(msg);\n      }\n    });\n  }\n}\n\n// Used by XXXXX_DEBUG settings to output debug messages.\nfunction dbg(...args) {\n  // TODO(sbc): Make this configurable somehow.  Its not always convenient for\n  // logging to show up as warnings.\n  console.warn(...args);\n}\n// end include: runtime_debug.js\n// === Body ===\n// end include: preamble.js\n\n\n  /** @constructor */\n  function ExitStatus(status) {\n      this.name = 'ExitStatus';\n      this.message = `Program terminated with exit(${status})`;\n      this.status = status;\n    }\n\n  var callRuntimeCallbacks = (callbacks) => {\n      while (callbacks.length > 0) {\n        // Pass the module as the first argument.\n        callbacks.shift()(Module);\n      }\n    };\n\n  \n    /**\n     * @param {number} ptr\n     * @param {string} type\n     */\n  function getValue(ptr, type = 'i8') {\n    if (type.endsWith('*')) type = '*';\n    switch (type) {\n      case 'i1': return HEAP8[ptr];\n      case 'i8': return HEAP8[ptr];\n      case 'i16': return HEAP16[((ptr)>>1)];\n      case 'i32': return HEAP32[((ptr)>>2)];\n      case 'i64': abort('to do getValue(i64) use WASM_BIGINT');\n      case 'float': return HEAPF32[((ptr)>>2)];\n      case 'double': return HEAPF64[((ptr)>>3)];\n      case '*': return HEAPU32[((ptr)>>2)];\n      default: abort(`invalid type for getValue: ${type}`);\n    }\n  }\n\n  var noExitRuntime = Module['noExitRuntime'] || true;\n\n  var ptrToString = (ptr) => {\n      assert(typeof ptr === 'number');\n      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.\n      ptr >>>= 0;\n      return '0x' + ptr.toString(16).padStart(8, '0');\n    };\n\n  \n    /**\n     * @param {number} ptr\n     * @param {number} value\n     * @param {string} type\n     */\n  function setValue(ptr, value, type = 'i8') {\n    if (type.endsWith('*')) type = '*';\n    switch (type) {\n      case 'i1': HEAP8[ptr] = value; break;\n      case 'i8': HEAP8[ptr] = value; break;\n      case 'i16': HEAP16[((ptr)>>1)] = value; break;\n      case 'i32': HEAP32[((ptr)>>2)] = value; break;\n      case 'i64': abort('to do setValue(i64) use WASM_BIGINT');\n      case 'float': HEAPF32[((ptr)>>2)] = value; break;\n      case 'double': HEAPF64[((ptr)>>3)] = value; break;\n      case '*': HEAPU32[((ptr)>>2)] = value; break;\n      default: abort(`invalid type for setValue: ${type}`);\n    }\n  }\n\n  var stackRestore = (val) => __emscripten_stack_restore(val);\n\n  var stackSave = () => _emscripten_stack_get_current();\n\n  var warnOnce = (text) => {\n      warnOnce.shown ||= {};\n      if (!warnOnce.shown[text]) {\n        warnOnce.shown[text] = 1;\n        err(text);\n      }\n    };\n\n  var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder() : undefined;\n  \n    /**\n     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given\n     * array that contains uint8 values, returns a copy of that string as a\n     * Javascript String object.\n     * heapOrArray is either a regular array, or a JavaScript typed array view.\n     * @param {number} idx\n     * @param {number=} maxBytesToRead\n     * @return {string}\n     */\n  var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {\n      var endIdx = idx + maxBytesToRead;\n      var endPtr = idx;\n      // TextDecoder needs to know the byte length in advance, it doesn't stop on\n      // null terminator by itself.  Also, use the length info to avoid running tiny\n      // strings through TextDecoder, since .subarray() allocates garbage.\n      // (As a tiny code save trick, compare endPtr against endIdx using a negation,\n      // so that undefined means Infinity)\n      while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;\n  \n      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {\n        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));\n      }\n      var str = '';\n      // If building with TextDecoder, we have already computed the string length\n      // above, so test loop end condition against that\n      while (idx < endPtr) {\n        // For UTF8 byte structure, see:\n        // http://en.wikipedia.org/wiki/UTF-8#Description\n        // https://www.ietf.org/rfc/rfc2279.txt\n        // https://tools.ietf.org/html/rfc3629\n        var u0 = heapOrArray[idx++];\n        if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }\n        var u1 = heapOrArray[idx++] & 63;\n        if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }\n        var u2 = heapOrArray[idx++] & 63;\n        if ((u0 & 0xF0) == 0xE0) {\n          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;\n        } else {\n          if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!');\n          u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);\n        }\n  \n        if (u0 < 0x10000) {\n          str += String.fromCharCode(u0);\n        } else {\n          var ch = u0 - 0x10000;\n          str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\n        }\n      }\n      return str;\n    };\n  \n    /**\n     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the\n     * emscripten HEAP, returns a copy of that string as a Javascript String object.\n     *\n     * @param {number} ptr\n     * @param {number=} maxBytesToRead - An optional length that specifies the\n     *   maximum number of bytes to read. You can omit this parameter to scan the\n     *   string until the first 0 byte. If maxBytesToRead is passed, and the string\n     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the\n     *   string will cut short at that byte index (i.e. maxBytesToRead will not\n     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing\n     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw\n     *   JS JIT optimizations off, so it is worth to consider consistently using one\n     * @return {string}\n     */\n  var UTF8ToString = (ptr, maxBytesToRead) => {\n      assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`);\n      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';\n    };\n  var ___assert_fail = (condition, filename, line, func) => {\n      abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);\n    };\n\n  var exceptionCaught =  [];\n  \n  \n  var uncaughtExceptionCount = 0;\n  var ___cxa_begin_catch = (ptr) => {\n      var info = new ExceptionInfo(ptr);\n      if (!info.get_caught()) {\n        info.set_caught(true);\n        uncaughtExceptionCount--;\n      }\n      info.set_rethrown(false);\n      exceptionCaught.push(info);\n      ___cxa_increment_exception_refcount(info.excPtr);\n      return info.get_exception_ptr();\n    };\n\n  var exceptionLast = 0;\n  \n  class ExceptionInfo {\n      // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.\n      constructor(excPtr) {\n        this.excPtr = excPtr;\n        this.ptr = excPtr - 24;\n      }\n  \n      set_type(type) {\n        HEAPU32[(((this.ptr)+(4))>>2)] = type;\n      }\n  \n      get_type() {\n        return HEAPU32[(((this.ptr)+(4))>>2)];\n      }\n  \n      set_destructor(destructor) {\n        HEAPU32[(((this.ptr)+(8))>>2)] = destructor;\n      }\n  \n      get_destructor() {\n        return HEAPU32[(((this.ptr)+(8))>>2)];\n      }\n  \n      set_caught(caught) {\n        caught = caught ? 1 : 0;\n        HEAP8[(this.ptr)+(12)] = caught;\n      }\n  \n      get_caught() {\n        return HEAP8[(this.ptr)+(12)] != 0;\n      }\n  \n      set_rethrown(rethrown) {\n        rethrown = rethrown ? 1 : 0;\n        HEAP8[(this.ptr)+(13)] = rethrown;\n      }\n  \n      get_rethrown() {\n        return HEAP8[(this.ptr)+(13)] != 0;\n      }\n  \n      // Initialize native structure fields. Should be called once after allocated.\n      init(type, destructor) {\n        this.set_adjusted_ptr(0);\n        this.set_type(type);\n        this.set_destructor(destructor);\n      }\n  \n      set_adjusted_ptr(adjustedPtr) {\n        HEAPU32[(((this.ptr)+(16))>>2)] = adjustedPtr;\n      }\n  \n      get_adjusted_ptr() {\n        return HEAPU32[(((this.ptr)+(16))>>2)];\n      }\n  \n      // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted\n      // when the pointer is casted to some of the exception object base classes (e.g. when virtual\n      // inheritance is used). When a pointer is thrown this method should return the thrown pointer\n      // itself.\n      get_exception_ptr() {\n        // Work around a fastcomp bug, this code is still included for some reason in a build without\n        // exceptions support.\n        var isPointer = ___cxa_is_pointer_type(this.get_type());\n        if (isPointer) {\n          return HEAPU32[((this.excPtr)>>2)];\n        }\n        var adjusted = this.get_adjusted_ptr();\n        if (adjusted !== 0) return adjusted;\n        return this.excPtr;\n      }\n    }\n  \n  var ___resumeException = (ptr) => {\n      if (!exceptionLast) {\n        exceptionLast = new CppException(ptr);\n      }\n      throw exceptionLast;\n    };\n  \n  \n  var setTempRet0 = (val) => __emscripten_tempret_set(val);\n  var findMatchingCatch = (args) => {\n      var thrown =\n        exceptionLast?.excPtr;\n      if (!thrown) {\n        // just pass through the null ptr\n        setTempRet0(0);\n        return 0;\n      }\n      var info = new ExceptionInfo(thrown);\n      info.set_adjusted_ptr(thrown);\n      var thrownType = info.get_type();\n      if (!thrownType) {\n        // just pass through the thrown ptr\n        setTempRet0(0);\n        return thrown;\n      }\n  \n      // can_catch receives a **, add indirection\n      // The different catch blocks are denoted by different types.\n      // Due to inheritance, those types may not precisely match the\n      // type of the thrown object. Find one which matches, and\n      // return the type of the catch block which should be called.\n      for (var caughtType of args) {\n        if (caughtType === 0 || caughtType === thrownType) {\n          // Catch all clause matched or exactly the same type is caught\n          break;\n        }\n        var adjusted_ptr_addr = info.ptr + 16;\n        if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {\n          setTempRet0(caughtType);\n          return thrown;\n        }\n      }\n      setTempRet0(thrownType);\n      return thrown;\n    };\n  var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);\n\n  var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch([arg0]);\n\n  \n  \n  var ___cxa_throw = (ptr, type, destructor) => {\n      var info = new ExceptionInfo(ptr);\n      // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception.\n      info.init(type, destructor);\n      exceptionLast = new CppException(ptr);\n      uncaughtExceptionCount++;\n      throw exceptionLast;\n    };\n\n\n  var __abort_js = () => {\n      abort('native code called abort()');\n    };\n\n  var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {};\n\n  var embind_init_charCodes = () => {\n      var codes = new Array(256);\n      for (var i = 0; i < 256; ++i) {\n          codes[i] = String.fromCharCode(i);\n      }\n      embind_charCodes = codes;\n    };\n  var embind_charCodes;\n  var readLatin1String = (ptr) => {\n      var ret = \"\";\n      var c = ptr;\n      while (HEAPU8[c]) {\n          ret += embind_charCodes[HEAPU8[c++]];\n      }\n      return ret;\n    };\n  \n  var awaitingDependencies = {\n  };\n  \n  var registeredTypes = {\n  };\n  \n  var typeDependencies = {\n  };\n  \n  var BindingError;\n  var throwBindingError = (message) => { throw new BindingError(message); };\n  \n  \n  \n  \n  var InternalError;\n  var throwInternalError = (message) => { throw new InternalError(message); };\n  var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {\n      myTypes.forEach(function(type) {\n          typeDependencies[type] = dependentTypes;\n      });\n  \n      function onComplete(typeConverters) {\n          var myTypeConverters = getTypeConverters(typeConverters);\n          if (myTypeConverters.length !== myTypes.length) {\n              throwInternalError('Mismatched type converter count');\n          }\n          for (var i = 0; i < myTypes.length; ++i) {\n              registerType(myTypes[i], myTypeConverters[i]);\n          }\n      }\n  \n      var typeConverters = new Array(dependentTypes.length);\n      var unregisteredTypes = [];\n      var registered = 0;\n      dependentTypes.forEach((dt, i) => {\n        if (registeredTypes.hasOwnProperty(dt)) {\n          typeConverters[i] = registeredTypes[dt];\n        } else {\n          unregisteredTypes.push(dt);\n          if (!awaitingDependencies.hasOwnProperty(dt)) {\n            awaitingDependencies[dt] = [];\n          }\n          awaitingDependencies[dt].push(() => {\n            typeConverters[i] = registeredTypes[dt];\n            ++registered;\n            if (registered === unregisteredTypes.length) {\n              onComplete(typeConverters);\n            }\n          });\n        }\n      });\n      if (0 === unregisteredTypes.length) {\n        onComplete(typeConverters);\n      }\n    };\n  /** @param {Object=} options */\n  function sharedRegisterType(rawType, registeredInstance, options = {}) {\n      var name = registeredInstance.name;\n      if (!rawType) {\n        throwBindingError(`type \"${name}\" must have a positive integer typeid pointer`);\n      }\n      if (registeredTypes.hasOwnProperty(rawType)) {\n        if (options.ignoreDuplicateRegistrations) {\n          return;\n        } else {\n          throwBindingError(`Cannot register type '${name}' twice`);\n        }\n      }\n  \n      registeredTypes[rawType] = registeredInstance;\n      delete typeDependencies[rawType];\n  \n      if (awaitingDependencies.hasOwnProperty(rawType)) {\n        var callbacks = awaitingDependencies[rawType];\n        delete awaitingDependencies[rawType];\n        callbacks.forEach((cb) => cb());\n      }\n    }\n  /** @param {Object=} options */\n  function registerType(rawType, registeredInstance, options = {}) {\n      if (!('argPackAdvance' in registeredInstance)) {\n        throw new TypeError('registerType registeredInstance requires argPackAdvance');\n      }\n      return sharedRegisterType(rawType, registeredInstance, options);\n    }\n  \n  var GenericWireTypeSize = 8;\n  /** @suppress {globalThis} */\n  var __embind_register_bool = (rawType, name, trueValue, falseValue) => {\n      name = readLatin1String(name);\n      registerType(rawType, {\n          name,\n          'fromWireType': function(wt) {\n              // ambiguous emscripten ABI: sometimes return values are\n              // true or false, and sometimes integers (0 or 1)\n              return !!wt;\n          },\n          'toWireType': function(destructors, o) {\n              return o ? trueValue : falseValue;\n          },\n          'argPackAdvance': GenericWireTypeSize,\n          'readValueFromPointer': function(pointer) {\n              return this['fromWireType'](HEAPU8[pointer]);\n          },\n          destructorFunction: null, // This type does not need a destructor\n      });\n    };\n\n  \n  var emval_freelist = [];\n  \n  var emval_handles = [];\n  var __emval_decref = (handle) => {\n      if (handle > 9 && 0 === --emval_handles[handle + 1]) {\n        assert(emval_handles[handle] !== undefined, `Decref for unallocated handle.`);\n        emval_handles[handle] = undefined;\n        emval_freelist.push(handle);\n      }\n    };\n  \n  \n  \n  \n  \n  var count_emval_handles = () => {\n      return emval_handles.length / 2 - 5 - emval_freelist.length;\n    };\n  \n  var init_emval = () => {\n      // reserve 0 and some special values. These never get de-allocated.\n      emval_handles.push(\n        0, 1,\n        undefined, 1,\n        null, 1,\n        true, 1,\n        false, 1,\n      );\n      assert(emval_handles.length === 5 * 2);\n      Module['count_emval_handles'] = count_emval_handles;\n    };\n  var Emval = {\n  toValue:(handle) => {\n        if (!handle) {\n            throwBindingError('Cannot use deleted val. handle = ' + handle);\n        }\n        // handle 2 is supposed to be `undefined`.\n        assert(handle === 2 || emval_handles[handle] !== undefined && handle % 2 === 0, `invalid handle: ${handle}`);\n        return emval_handles[handle];\n      },\n  toHandle:(value) => {\n        switch (value) {\n          case undefined: return 2;\n          case null: return 4;\n          case true: return 6;\n          case false: return 8;\n          default:{\n            const handle = emval_freelist.pop() || emval_handles.length;\n            emval_handles[handle] = value;\n            emval_handles[handle + 1] = 1;\n            return handle;\n          }\n        }\n      },\n  };\n  \n  /** @suppress {globalThis} */\n  function readPointer(pointer) {\n      return this['fromWireType'](HEAPU32[((pointer)>>2)]);\n    }\n  \n  var EmValType = {\n      name: 'emscripten::val',\n      'fromWireType': (handle) => {\n        var rv = Emval.toValue(handle);\n        __emval_decref(handle);\n        return rv;\n      },\n      'toWireType': (destructors, value) => Emval.toHandle(value),\n      'argPackAdvance': GenericWireTypeSize,\n      'readValueFromPointer': readPointer,\n      destructorFunction: null, // This type does not need a destructor\n  \n      // TODO: do we need a deleteObject here?  write a test where\n      // emval is passed into JS via an interface\n    };\n  var __embind_register_emval = (rawType) => registerType(rawType, EmValType);\n\n  var embindRepr = (v) => {\n      if (v === null) {\n          return 'null';\n      }\n      var t = typeof v;\n      if (t === 'object' || t === 'array' || t === 'function') {\n          return v.toString();\n      } else {\n          return '' + v;\n      }\n    };\n  \n  var floatReadValueFromPointer = (name, width) => {\n      switch (width) {\n          case 4: return function(pointer) {\n              return this['fromWireType'](HEAPF32[((pointer)>>2)]);\n          };\n          case 8: return function(pointer) {\n              return this['fromWireType'](HEAPF64[((pointer)>>3)]);\n          };\n          default:\n              throw new TypeError(`invalid float width (${width}): ${name}`);\n      }\n    };\n  \n  \n  var __embind_register_float = (rawType, name, size) => {\n      name = readLatin1String(name);\n      registerType(rawType, {\n        name,\n        'fromWireType': (value) => value,\n        'toWireType': (destructors, value) => {\n          if (typeof value != \"number\" && typeof value != \"boolean\") {\n            throw new TypeError(`Cannot convert ${embindRepr(value)} to ${this.name}`);\n          }\n          // The VM will perform JS to Wasm value conversion, according to the spec:\n          // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue\n          return value;\n        },\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': floatReadValueFromPointer(name, size),\n        destructorFunction: null, // This type does not need a destructor\n      });\n    };\n\n  var createNamedFunction = (name, body) => Object.defineProperty(body, 'name', {\n      value: name\n    });\n  \n  var runDestructors = (destructors) => {\n      while (destructors.length) {\n        var ptr = destructors.pop();\n        var del = destructors.pop();\n        del(ptr);\n      }\n    };\n  \n  \n  function usesDestructorStack(argTypes) {\n      // Skip return value at index 0 - it's not deleted here.\n      for (var i = 1; i < argTypes.length; ++i) {\n        // The type does not define a destructor function - must use dynamic stack\n        if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {\n          return true;\n        }\n      }\n      return false;\n    }\n  \n  function newFunc(constructor, argumentList) {\n      if (!(constructor instanceof Function)) {\n        throw new TypeError(`new_ called with constructor type ${typeof(constructor)} which is not a function`);\n      }\n      /*\n       * Previously, the following line was just:\n       *   function dummy() {};\n       * Unfortunately, Chrome was preserving 'dummy' as the object's name, even\n       * though at creation, the 'dummy' has the correct constructor name.  Thus,\n       * objects created with IMVU.new would show up in the debugger as 'dummy',\n       * which isn't very helpful.  Using IMVU.createNamedFunction addresses the\n       * issue.  Doubly-unfortunately, there's no way to write a test for this\n       * behavior.  -NRD 2013.02.22\n       */\n      var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function(){});\n      dummy.prototype = constructor.prototype;\n      var obj = new dummy;\n  \n      var r = constructor.apply(obj, argumentList);\n      return (r instanceof Object) ? r : obj;\n    }\n  \n  function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {\n      var needsDestructorStack = usesDestructorStack(argTypes);\n      var argCount = argTypes.length;\n      var argsList = \"\";\n      var argsListWired = \"\";\n      for (var i = 0; i < argCount - 2; ++i) {\n        argsList += (i!==0?\", \":\"\")+\"arg\"+i;\n        argsListWired += (i!==0?\", \":\"\")+\"arg\"+i+\"Wired\";\n      }\n  \n      var invokerFnBody = `\n        return function (${argsList}) {\n        if (arguments.length !== ${argCount - 2}) {\n          throwBindingError('function ' + humanName + ' called with ' + arguments.length + ' arguments, expected ${argCount - 2}');\n        }`;\n  \n      if (needsDestructorStack) {\n        invokerFnBody += \"var destructors = [];\\n\";\n      }\n  \n      var dtorStack = needsDestructorStack ? \"destructors\" : \"null\";\n      var args1 = [\"humanName\", \"throwBindingError\", \"invoker\", \"fn\", \"runDestructors\", \"retType\", \"classParam\"];\n  \n      if (isClassMethodFunc) {\n        invokerFnBody += \"var thisWired = classParam['toWireType'](\"+dtorStack+\", this);\\n\";\n      }\n  \n      for (var i = 0; i < argCount - 2; ++i) {\n        invokerFnBody += \"var arg\"+i+\"Wired = argType\"+i+\"['toWireType'](\"+dtorStack+\", arg\"+i+\");\\n\";\n        args1.push(\"argType\"+i);\n      }\n  \n      if (isClassMethodFunc) {\n        argsListWired = \"thisWired\" + (argsListWired.length > 0 ? \", \" : \"\") + argsListWired;\n      }\n  \n      invokerFnBody +=\n          (returns || isAsync ? \"var rv = \":\"\") + \"invoker(fn\"+(argsListWired.length>0?\", \":\"\")+argsListWired+\");\\n\";\n  \n      var returnVal = returns ? \"rv\" : \"\";\n  \n      if (needsDestructorStack) {\n        invokerFnBody += \"runDestructors(destructors);\\n\";\n      } else {\n        for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.\n          var paramName = (i === 1 ? \"thisWired\" : (\"arg\"+(i - 2)+\"Wired\"));\n          if (argTypes[i].destructorFunction !== null) {\n            invokerFnBody += `${paramName}_dtor(${paramName});\\n`;\n            args1.push(`${paramName}_dtor`);\n          }\n        }\n      }\n  \n      if (returns) {\n        invokerFnBody += \"var ret = retType['fromWireType'](rv);\\n\" +\n                         \"return ret;\\n\";\n      } else {\n      }\n  \n      invokerFnBody += \"}\\n\";\n  \n      invokerFnBody = `if (arguments.length !== ${args1.length}){ throw new Error(humanName + \"Expected ${args1.length} closure arguments \" + arguments.length + \" given.\"); }\\n${invokerFnBody}`;\n      return [args1, invokerFnBody];\n    }\n  function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) {\n      // humanName: a human-readable string name for the function to be generated.\n      // argTypes: An array that contains the embind type objects for all types in the function signature.\n      //    argTypes[0] is the type object for the function return value.\n      //    argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method.\n      //    argTypes[2...] are the actual function parameters.\n      // classType: The embind type object for the class to be bound, or null if this is not a method of a class.\n      // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code.\n      // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling.\n      // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI.\n      var argCount = argTypes.length;\n  \n      if (argCount < 2) {\n        throwBindingError(\"argTypes array size mismatch! Must at least get return value and 'this' types!\");\n      }\n  \n      assert(!isAsync, 'Async bindings are only supported with JSPI.');\n  \n      var isClassMethodFunc = (argTypes[1] !== null && classType !== null);\n  \n      // Free functions with signature \"void function()\" do not need an invoker that marshalls between wire types.\n  // TODO: This omits argument count check - enable only at -O3 or similar.\n  //    if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == \"void\" && !isClassMethodFunc) {\n  //       return FUNCTION_TABLE[fn];\n  //    }\n  \n      // Determine if we need to use a dynamic stack to store the destructors for the function parameters.\n      // TODO: Remove this completely once all function invokers are being dynamically generated.\n      var needsDestructorStack = usesDestructorStack(argTypes);\n  \n      var returns = (argTypes[0].name !== \"void\");\n  \n    // Builld the arguments that will be passed into the closure around the invoker\n    // function.\n    var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];\n    for (var i = 0; i < argCount - 2; ++i) {\n      closureArgs.push(argTypes[i+2]);\n    }\n    if (!needsDestructorStack) {\n      for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.\n        if (argTypes[i].destructorFunction !== null) {\n          closureArgs.push(argTypes[i].destructorFunction);\n        }\n      }\n    }\n  \n    let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync);\n    args.push(invokerFnBody);\n    var invokerFn = newFunc(Function, args)(...closureArgs);\n      return createNamedFunction(humanName, invokerFn);\n    }\n  \n  var ensureOverloadTable = (proto, methodName, humanName) => {\n      if (undefined === proto[methodName].overloadTable) {\n        var prevFunc = proto[methodName];\n        // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.\n        proto[methodName] = function(...args) {\n          // TODO This check can be removed in -O3 level \"unsafe\" optimizations.\n          if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {\n            throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);\n          }\n          return proto[methodName].overloadTable[args.length].apply(this, args);\n        };\n        // Move the previous function into the overload table.\n        proto[methodName].overloadTable = [];\n        proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;\n      }\n    };\n  \n  /** @param {number=} numArguments */\n  var exposePublicSymbol = (name, value, numArguments) => {\n      if (Module.hasOwnProperty(name)) {\n        if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) {\n          throwBindingError(`Cannot register public name '${name}' twice`);\n        }\n  \n        // We are exposing a function with the same name as an existing function. Create an overload table and a function selector\n        // that routes between the two.\n        ensureOverloadTable(Module, name, name);\n        if (Module.hasOwnProperty(numArguments)) {\n          throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);\n        }\n        // Add the new function into the overload table.\n        Module[name].overloadTable[numArguments] = value;\n      }\n      else {\n        Module[name] = value;\n        if (undefined !== numArguments) {\n          Module[name].numArguments = numArguments;\n        }\n      }\n    };\n  \n  var heap32VectorToArray = (count, firstElement) => {\n      var array = [];\n      for (var i = 0; i < count; i++) {\n        // TODO(https://github.com/emscripten-core/emscripten/issues/17310):\n        // Find a way to hoist the `>> 2` or `>> 3` out of this loop.\n        array.push(HEAPU32[(((firstElement)+(i * 4))>>2)]);\n      }\n      return array;\n    };\n  \n  \n  /** @param {number=} numArguments */\n  var replacePublicSymbol = (name, value, numArguments) => {\n      if (!Module.hasOwnProperty(name)) {\n        throwInternalError('Replacing nonexistent public symbol');\n      }\n      // If there's an overload table for this symbol, replace the symbol in the overload table instead.\n      if (undefined !== Module[name].overloadTable && undefined !== numArguments) {\n        Module[name].overloadTable[numArguments] = value;\n      }\n      else {\n        Module[name] = value;\n        Module[name].argCount = numArguments;\n      }\n    };\n  \n  \n  \n  var dynCallLegacy = (sig, ptr, args) => {\n      sig = sig.replace(/p/g, 'i')\n      assert(('dynCall_' + sig) in Module, `bad function pointer type - dynCall function not found for sig '${sig}'`);\n      if (args?.length) {\n        // j (64-bit integer) must be passed in as two numbers [low 32, high 32].\n        assert(args.length === sig.substring(1).replace(/j/g, '--').length);\n      } else {\n        assert(sig.length == 1);\n      }\n      var f = Module['dynCall_' + sig];\n      return f(ptr, ...args);\n    };\n  \n  var wasmTableMirror = [];\n  \n  /** @type {WebAssembly.Table} */\n  var wasmTable;\n  var getWasmTableEntry = (funcPtr) => {\n      var func = wasmTableMirror[funcPtr];\n      if (!func) {\n        if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;\n        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);\n      }\n      assert(wasmTable.get(funcPtr) == func, 'JavaScript-side Wasm function table mirror is out of date!');\n      return func;\n    };\n  \n  var dynCall = (sig, ptr, args = []) => {\n      // Without WASM_BIGINT support we cannot directly call function with i64 as\n      // part of their signature, so we rely on the dynCall functions generated by\n      // wasm-emscripten-finalize\n      if (sig.includes('j')) {\n        return dynCallLegacy(sig, ptr, args);\n      }\n      assert(getWasmTableEntry(ptr), `missing table entry in dynCall: ${ptr}`);\n      var rtn = getWasmTableEntry(ptr)(...args);\n      return rtn;\n    };\n  var getDynCaller = (sig, ptr) => {\n      assert(sig.includes('j') || sig.includes('p'), 'getDynCaller should only be called with i64 sigs')\n      return (...args) => dynCall(sig, ptr, args);\n    };\n  \n  \n  var embind__requireFunction = (signature, rawFunction) => {\n      signature = readLatin1String(signature);\n  \n      function makeDynCaller() {\n        if (signature.includes('j')) {\n          return getDynCaller(signature, rawFunction);\n        }\n        return getWasmTableEntry(rawFunction);\n      }\n  \n      var fp = makeDynCaller();\n      if (typeof fp != \"function\") {\n          throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);\n      }\n      return fp;\n    };\n  \n  \n  \n  var extendError = (baseErrorType, errorName) => {\n      var errorClass = createNamedFunction(errorName, function(message) {\n        this.name = errorName;\n        this.message = message;\n  \n        var stack = (new Error(message)).stack;\n        if (stack !== undefined) {\n          this.stack = this.toString() + '\\n' +\n              stack.replace(/^Error(:[^\\n]*)?\\n/, '');\n        }\n      });\n      errorClass.prototype = Object.create(baseErrorType.prototype);\n      errorClass.prototype.constructor = errorClass;\n      errorClass.prototype.toString = function() {\n        if (this.message === undefined) {\n          return this.name;\n        } else {\n          return `${this.name}: ${this.message}`;\n        }\n      };\n  \n      return errorClass;\n    };\n  var UnboundTypeError;\n  \n  \n  \n  var getTypeName = (type) => {\n      var ptr = ___getTypeName(type);\n      var rv = readLatin1String(ptr);\n      _free(ptr);\n      return rv;\n    };\n  var throwUnboundTypeError = (message, types) => {\n      var unboundTypes = [];\n      var seen = {};\n      function visit(type) {\n        if (seen[type]) {\n          return;\n        }\n        if (registeredTypes[type]) {\n          return;\n        }\n        if (typeDependencies[type]) {\n          typeDependencies[type].forEach(visit);\n          return;\n        }\n        unboundTypes.push(type);\n        seen[type] = true;\n      }\n      types.forEach(visit);\n  \n      throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([', ']));\n    };\n  \n  \n  var getFunctionName = (signature) => {\n      signature = signature.trim();\n      const argsIndex = signature.indexOf(\"(\");\n      if (argsIndex !== -1) {\n        assert(signature[signature.length - 1] == \")\", \"Parentheses for argument names should match.\");\n        return signature.substr(0, argsIndex);\n      } else {\n        return signature;\n      }\n    };\n  var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) => {\n      var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);\n      name = readLatin1String(name);\n      name = getFunctionName(name);\n  \n      rawInvoker = embind__requireFunction(signature, rawInvoker);\n  \n      exposePublicSymbol(name, function() {\n        throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);\n      }, argCount - 1);\n  \n      whenDependentTypesAreResolved([], argTypes, (argTypes) => {\n        var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */);\n        replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1);\n        return [];\n      });\n    };\n\n  \n  var integerReadValueFromPointer = (name, width, signed) => {\n      // integers are quite common, so generate very specialized functions\n      switch (width) {\n          case 1: return signed ?\n              (pointer) => HEAP8[pointer] :\n              (pointer) => HEAPU8[pointer];\n          case 2: return signed ?\n              (pointer) => HEAP16[((pointer)>>1)] :\n              (pointer) => HEAPU16[((pointer)>>1)]\n          case 4: return signed ?\n              (pointer) => HEAP32[((pointer)>>2)] :\n              (pointer) => HEAPU32[((pointer)>>2)]\n          default:\n              throw new TypeError(`invalid integer width (${width}): ${name}`);\n      }\n    };\n  \n  \n  /** @suppress {globalThis} */\n  var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {\n      name = readLatin1String(name);\n      // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come\n      // out as 'i32 -1'. Always treat those as max u32.\n      if (maxRange === -1) {\n        maxRange = 4294967295;\n      }\n  \n      var fromWireType = (value) => value;\n  \n      if (minRange === 0) {\n        var bitshift = 32 - 8*size;\n        fromWireType = (value) => (value << bitshift) >>> bitshift;\n      }\n  \n      var isUnsignedType = (name.includes('unsigned'));\n      var checkAssertions = (value, toTypeName) => {\n        if (typeof value != \"number\" && typeof value != \"boolean\") {\n          throw new TypeError(`Cannot convert \"${embindRepr(value)}\" to ${toTypeName}`);\n        }\n        if (value < minRange || value > maxRange) {\n          throw new TypeError(`Passing a number \"${embindRepr(value)}\" from JS side to C/C++ side to an argument of type \"${name}\", which is outside the valid range [${minRange}, ${maxRange}]!`);\n        }\n      }\n      var toWireType;\n      if (isUnsignedType) {\n        toWireType = function(destructors, value) {\n          checkAssertions(value, this.name);\n          return value >>> 0;\n        }\n      } else {\n        toWireType = function(destructors, value) {\n          checkAssertions(value, this.name);\n          // The VM will perform JS to Wasm value conversion, according to the spec:\n          // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue\n          return value;\n        }\n      }\n      registerType(primitiveType, {\n        name,\n        'fromWireType': fromWireType,\n        'toWireType': toWireType,\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': integerReadValueFromPointer(name, size, minRange !== 0),\n        destructorFunction: null, // This type does not need a destructor\n      });\n    };\n\n  \n  var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {\n      var typeMapping = [\n        Int8Array,\n        Uint8Array,\n        Int16Array,\n        Uint16Array,\n        Int32Array,\n        Uint32Array,\n        Float32Array,\n        Float64Array,\n      ];\n  \n      var TA = typeMapping[dataTypeIndex];\n  \n      function decodeMemoryView(handle) {\n        var size = HEAPU32[((handle)>>2)];\n        var data = HEAPU32[(((handle)+(4))>>2)];\n        return new TA(HEAP8.buffer, data, size);\n      }\n  \n      name = readLatin1String(name);\n      registerType(rawType, {\n        name,\n        'fromWireType': decodeMemoryView,\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': decodeMemoryView,\n      }, {\n        ignoreDuplicateRegistrations: true,\n      });\n    };\n\n  \n  \n  \n  \n  var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {\n      assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`);\n      // Parameter maxBytesToWrite is not optional. Negative values, 0, null,\n      // undefined and false each don't write out any bytes.\n      if (!(maxBytesToWrite > 0))\n        return 0;\n  \n      var startIdx = outIdx;\n      var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\n        // unit, not a Unicode code point of the character! So decode\n        // UTF16->UTF32->UTF8.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description\n        // and https://www.ietf.org/rfc/rfc2279.txt\n        // and https://tools.ietf.org/html/rfc3629\n        var u = str.charCodeAt(i); // possibly a lead surrogate\n        if (u >= 0xD800 && u <= 0xDFFF) {\n          var u1 = str.charCodeAt(++i);\n          u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);\n        }\n        if (u <= 0x7F) {\n          if (outIdx >= endIdx) break;\n          heap[outIdx++] = u;\n        } else if (u <= 0x7FF) {\n          if (outIdx + 1 >= endIdx) break;\n          heap[outIdx++] = 0xC0 | (u >> 6);\n          heap[outIdx++] = 0x80 | (u & 63);\n        } else if (u <= 0xFFFF) {\n          if (outIdx + 2 >= endIdx) break;\n          heap[outIdx++] = 0xE0 | (u >> 12);\n          heap[outIdx++] = 0x80 | ((u >> 6) & 63);\n          heap[outIdx++] = 0x80 | (u & 63);\n        } else {\n          if (outIdx + 3 >= endIdx) break;\n          if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).');\n          heap[outIdx++] = 0xF0 | (u >> 18);\n          heap[outIdx++] = 0x80 | ((u >> 12) & 63);\n          heap[outIdx++] = 0x80 | ((u >> 6) & 63);\n          heap[outIdx++] = 0x80 | (u & 63);\n        }\n      }\n      // Null-terminate the pointer to the buffer.\n      heap[outIdx] = 0;\n      return outIdx - startIdx;\n    };\n  var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {\n      assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');\n      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);\n    };\n  \n  var lengthBytesUTF8 = (str) => {\n      var len = 0;\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\n        // unit, not a Unicode code point of the character! So decode\n        // UTF16->UTF32->UTF8.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        var c = str.charCodeAt(i); // possibly a lead surrogate\n        if (c <= 0x7F) {\n          len++;\n        } else if (c <= 0x7FF) {\n          len += 2;\n        } else if (c >= 0xD800 && c <= 0xDFFF) {\n          len += 4; ++i;\n        } else {\n          len += 3;\n        }\n      }\n      return len;\n    };\n  \n  \n  \n  var __embind_register_std_string = (rawType, name) => {\n      name = readLatin1String(name);\n      var stdStringIsUTF8\n      //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string<unsigned char>\n      = (name === \"std::string\");\n  \n      registerType(rawType, {\n        name,\n        // For some method names we use string keys here since they are part of\n        // the public/external API and/or used by the runtime-generated code.\n        'fromWireType'(value) {\n          var length = HEAPU32[((value)>>2)];\n          var payload = value + 4;\n  \n          var str;\n          if (stdStringIsUTF8) {\n            var decodeStartPtr = payload;\n            // Looping here to support possible embedded '0' bytes\n            for (var i = 0; i <= length; ++i) {\n              var currentBytePtr = payload + i;\n              if (i == length || HEAPU8[currentBytePtr] == 0) {\n                var maxRead = currentBytePtr - decodeStartPtr;\n                var stringSegment = UTF8ToString(decodeStartPtr, maxRead);\n                if (str === undefined) {\n                  str = stringSegment;\n                } else {\n                  str += String.fromCharCode(0);\n                  str += stringSegment;\n                }\n                decodeStartPtr = currentBytePtr + 1;\n              }\n            }\n          } else {\n            var a = new Array(length);\n            for (var i = 0; i < length; ++i) {\n              a[i] = String.fromCharCode(HEAPU8[payload + i]);\n            }\n            str = a.join('');\n          }\n  \n          _free(value);\n  \n          return str;\n        },\n        'toWireType'(destructors, value) {\n          if (value instanceof ArrayBuffer) {\n            value = new Uint8Array(value);\n          }\n  \n          var length;\n          var valueIsOfTypeString = (typeof value == 'string');\n  \n          if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {\n            throwBindingError('Cannot pass non-string to std::string');\n          }\n          if (stdStringIsUTF8 && valueIsOfTypeString) {\n            length = lengthBytesUTF8(value);\n          } else {\n            length = value.length;\n          }\n  \n          // assumes POINTER_SIZE alignment\n          var base = _malloc(4 + length + 1);\n          var ptr = base + 4;\n          HEAPU32[((base)>>2)] = length;\n          if (stdStringIsUTF8 && valueIsOfTypeString) {\n            stringToUTF8(value, ptr, length + 1);\n          } else {\n            if (valueIsOfTypeString) {\n              for (var i = 0; i < length; ++i) {\n                var charCode = value.charCodeAt(i);\n                if (charCode > 255) {\n                  _free(ptr);\n                  throwBindingError('String has UTF-16 code units that do not fit in 8 bits');\n                }\n                HEAPU8[ptr + i] = charCode;\n              }\n            } else {\n              for (var i = 0; i < length; ++i) {\n                HEAPU8[ptr + i] = value[i];\n              }\n            }\n          }\n  \n          if (destructors !== null) {\n            destructors.push(_free, base);\n          }\n          return base;\n        },\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': readPointer,\n        destructorFunction(ptr) {\n          _free(ptr);\n        },\n      });\n    };\n\n  \n  \n  \n  var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;;\n  var UTF16ToString = (ptr, maxBytesToRead) => {\n      assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!');\n      var endPtr = ptr;\n      // TextDecoder needs to know the byte length in advance, it doesn't stop on\n      // null terminator by itself.\n      // Also, use the length info to avoid running tiny strings through\n      // TextDecoder, since .subarray() allocates garbage.\n      var idx = endPtr >> 1;\n      var maxIdx = idx + maxBytesToRead / 2;\n      // If maxBytesToRead is not passed explicitly, it will be undefined, and this\n      // will always evaluate to true. This saves on code size.\n      while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;\n      endPtr = idx << 1;\n  \n      if (endPtr - ptr > 32 && UTF16Decoder)\n        return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));\n  \n      // Fallback: decode without UTF16Decoder\n      var str = '';\n  \n      // If maxBytesToRead is not passed explicitly, it will be undefined, and the\n      // for-loop's condition will always evaluate to true. The loop is then\n      // terminated on the first null char.\n      for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {\n        var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];\n        if (codeUnit == 0) break;\n        // fromCharCode constructs a character from a UTF-16 code unit, so we can\n        // pass the UTF16 string right through.\n        str += String.fromCharCode(codeUnit);\n      }\n  \n      return str;\n    };\n  \n  var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {\n      assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!');\n      assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');\n      // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.\n      maxBytesToWrite ??= 0x7FFFFFFF;\n      if (maxBytesToWrite < 2) return 0;\n      maxBytesToWrite -= 2; // Null terminator.\n      var startPtr = outPtr;\n      var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;\n      for (var i = 0; i < numCharsToWrite; ++i) {\n        // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.\n        var codeUnit = str.charCodeAt(i); // possibly a lead surrogate\n        HEAP16[((outPtr)>>1)] = codeUnit;\n        outPtr += 2;\n      }\n      // Null-terminate the pointer to the HEAP.\n      HEAP16[((outPtr)>>1)] = 0;\n      return outPtr - startPtr;\n    };\n  \n  var lengthBytesUTF16 = (str) => {\n      return str.length*2;\n    };\n  \n  var UTF32ToString = (ptr, maxBytesToRead) => {\n      assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!');\n      var i = 0;\n  \n      var str = '';\n      // If maxBytesToRead is not passed explicitly, it will be undefined, and this\n      // will always evaluate to true. This saves on code size.\n      while (!(i >= maxBytesToRead / 4)) {\n        var utf32 = HEAP32[(((ptr)+(i*4))>>2)];\n        if (utf32 == 0) break;\n        ++i;\n        // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        if (utf32 >= 0x10000) {\n          var ch = utf32 - 0x10000;\n          str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\n        } else {\n          str += String.fromCharCode(utf32);\n        }\n      }\n      return str;\n    };\n  \n  var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {\n      assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!');\n      assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');\n      // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.\n      maxBytesToWrite ??= 0x7FFFFFFF;\n      if (maxBytesToWrite < 4) return 0;\n      var startPtr = outPtr;\n      var endPtr = startPtr + maxBytesToWrite - 4;\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        var codeUnit = str.charCodeAt(i); // possibly a lead surrogate\n        if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {\n          var trailSurrogate = str.charCodeAt(++i);\n          codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);\n        }\n        HEAP32[((outPtr)>>2)] = codeUnit;\n        outPtr += 4;\n        if (outPtr + 4 > endPtr) break;\n      }\n      // Null-terminate the pointer to the HEAP.\n      HEAP32[((outPtr)>>2)] = 0;\n      return outPtr - startPtr;\n    };\n  \n  var lengthBytesUTF32 = (str) => {\n      var len = 0;\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        var codeUnit = str.charCodeAt(i);\n        if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate.\n        len += 4;\n      }\n  \n      return len;\n    };\n  var __embind_register_std_wstring = (rawType, charSize, name) => {\n      name = readLatin1String(name);\n      var decodeString, encodeString, readCharAt, lengthBytesUTF;\n      if (charSize === 2) {\n        decodeString = UTF16ToString;\n        encodeString = stringToUTF16;\n        lengthBytesUTF = lengthBytesUTF16;\n        readCharAt = (pointer) => HEAPU16[((pointer)>>1)];\n      } else if (charSize === 4) {\n        decodeString = UTF32ToString;\n        encodeString = stringToUTF32;\n        lengthBytesUTF = lengthBytesUTF32;\n        readCharAt = (pointer) => HEAPU32[((pointer)>>2)];\n      }\n      registerType(rawType, {\n        name,\n        'fromWireType': (value) => {\n          // Code mostly taken from _embind_register_std_string fromWireType\n          var length = HEAPU32[((value)>>2)];\n          var str;\n  \n          var decodeStartPtr = value + 4;\n          // Looping here to support possible embedded '0' bytes\n          for (var i = 0; i <= length; ++i) {\n            var currentBytePtr = value + 4 + i * charSize;\n            if (i == length || readCharAt(currentBytePtr) == 0) {\n              var maxReadBytes = currentBytePtr - decodeStartPtr;\n              var stringSegment = decodeString(decodeStartPtr, maxReadBytes);\n              if (str === undefined) {\n                str = stringSegment;\n              } else {\n                str += String.fromCharCode(0);\n                str += stringSegment;\n              }\n              decodeStartPtr = currentBytePtr + charSize;\n            }\n          }\n  \n          _free(value);\n  \n          return str;\n        },\n        'toWireType': (destructors, value) => {\n          if (!(typeof value == 'string')) {\n            throwBindingError(`Cannot pass non-string to C++ string type ${name}`);\n          }\n  \n          // assumes POINTER_SIZE alignment\n          var length = lengthBytesUTF(value);\n          var ptr = _malloc(4 + length + charSize);\n          HEAPU32[((ptr)>>2)] = length / charSize;\n  \n          encodeString(value, ptr + 4, length + charSize);\n  \n          if (destructors !== null) {\n            destructors.push(_free, ptr);\n          }\n          return ptr;\n        },\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': readPointer,\n        destructorFunction(ptr) {\n          _free(ptr);\n        }\n      });\n    };\n\n  \n  var __embind_register_void = (rawType, name) => {\n      name = readLatin1String(name);\n      registerType(rawType, {\n        isVoid: true, // void return values can be optimized out sometimes\n        name,\n        'argPackAdvance': 0,\n        'fromWireType': () => undefined,\n        // TODO: assert if anything else is given?\n        'toWireType': (destructors, o) => undefined,\n      });\n    };\n\n  var nowIsMonotonic = 1;\n  var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;\n\n  var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);\n\n  \n  \n  \n  var requireRegisteredType = (rawType, humanName) => {\n      var impl = registeredTypes[rawType];\n      if (undefined === impl) {\n        throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);\n      }\n      return impl;\n    };\n  \n  var emval_returnValue = (returnType, destructorsRef, handle) => {\n      var destructors = [];\n      var result = returnType['toWireType'](destructors, handle);\n      if (destructors.length) {\n        // void, primitives and any other types w/o destructors don't need to allocate a handle\n        HEAPU32[((destructorsRef)>>2)] = Emval.toHandle(destructors);\n      }\n      return result;\n    };\n  var __emval_as = (handle, returnType, destructorsRef) => {\n      handle = Emval.toValue(handle);\n      returnType = requireRegisteredType(returnType, 'emval::as');\n      return emval_returnValue(returnType, destructorsRef, handle);\n    };\n\n  var emval_methodCallers = [];\n  \n  var __emval_call = (caller, handle, destructorsRef, args) => {\n      caller = emval_methodCallers[caller];\n      handle = Emval.toValue(handle);\n      return caller(null, handle, destructorsRef, args);\n    };\n\n  var emval_symbols = {\n  };\n  \n  var getStringOrSymbol = (address) => {\n      var symbol = emval_symbols[address];\n      if (symbol === undefined) {\n        return readLatin1String(address);\n      }\n      return symbol;\n    };\n  \n  \n  var __emval_call_method = (caller, objHandle, methodName, destructorsRef, args) => {\n      caller = emval_methodCallers[caller];\n      objHandle = Emval.toValue(objHandle);\n      methodName = getStringOrSymbol(methodName);\n      return caller(objHandle, objHandle[methodName], destructorsRef, args);\n    };\n\n\n  var emval_addMethodCaller = (caller) => {\n      var id = emval_methodCallers.length;\n      emval_methodCallers.push(caller);\n      return id;\n    };\n  \n  var emval_lookupTypes = (argCount, argTypes) => {\n      var a = new Array(argCount);\n      for (var i = 0; i < argCount; ++i) {\n        a[i] = requireRegisteredType(HEAPU32[(((argTypes)+(i * 4))>>2)],\n                                     \"parameter \" + i);\n      }\n      return a;\n    };\n  \n  \n  var reflectConstruct = Reflect.construct;\n  \n  \n  var __emval_get_method_caller = (argCount, argTypes, kind) => {\n      var types = emval_lookupTypes(argCount, argTypes);\n      var retType = types.shift();\n      argCount--; // remove the shifted off return type\n  \n      var functionBody =\n        `return function (obj, func, destructorsRef, args) {\\n`;\n  \n      var offset = 0;\n      var argsList = []; // 'obj?, arg0, arg1, arg2, ... , argN'\n      if (kind === /* FUNCTION */ 0) {\n        argsList.push(\"obj\");\n      }\n      var params = [\"retType\"];\n      var args = [retType];\n      for (var i = 0; i < argCount; ++i) {\n        argsList.push(\"arg\" + i);\n        params.push(\"argType\" + i);\n        args.push(types[i]);\n        functionBody +=\n          `  var arg${i} = argType${i}.readValueFromPointer(args${offset ? \"+\" + offset : \"\"});\\n`;\n        offset += types[i]['argPackAdvance'];\n      }\n      var invoker = kind === /* CONSTRUCTOR */ 1 ? 'new func' : 'func.call';\n      functionBody +=\n        `  var rv = ${invoker}(${argsList.join(\", \")});\\n`;\n      if (!retType.isVoid) {\n        params.push(\"emval_returnValue\");\n        args.push(emval_returnValue);\n        functionBody +=\n          \"  return emval_returnValue(retType, destructorsRef, rv);\\n\";\n      }\n      functionBody +=\n        \"};\\n\";\n  \n      params.push(functionBody);\n      var invokerFunction = newFunc(Function, params)(...args);\n      var functionName = `methodCaller<(${types.map(t => t.name).join(', ')}) => ${retType.name}>`;\n      return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));\n    };\n\n  \n  var __emval_get_module_property = (name) => {\n      name = getStringOrSymbol(name);\n      return Emval.toHandle(Module[name]);\n    };\n\n  var __emval_get_property = (handle, key) => {\n      handle = Emval.toValue(handle);\n      key = Emval.toValue(key);\n      return Emval.toHandle(handle[key]);\n    };\n\n  var __emval_incref = (handle) => {\n      if (handle > 9) {\n        emval_handles[handle + 1] += 1;\n      }\n    };\n\n  var __emval_new_array = () => Emval.toHandle([]);\n\n  var __emval_new_array_from_memory_view = (view) => {\n      view = Emval.toValue(view);\n      // using for..loop is faster than Array.from\n      var a = new Array(view.length);\n      for (var i = 0; i < view.length; i++) a[i] = view[i];\n      return Emval.toHandle(a);\n    };\n\n  \n  var __emval_new_cstring = (v) => Emval.toHandle(getStringOrSymbol(v));\n\n  var __emval_new_object = () => Emval.toHandle({});\n\n  \n  \n  var __emval_run_destructors = (handle) => {\n      var destructors = Emval.toValue(handle);\n      runDestructors(destructors);\n      __emval_decref(handle);\n    };\n\n  var __emval_set_property = (handle, key, value) => {\n      handle = Emval.toValue(handle);\n      key = Emval.toValue(key);\n      value = Emval.toValue(value);\n      handle[key] = value;\n    };\n\n  \n  var __emval_take_value = (type, arg) => {\n      type = requireRegisteredType(type, '_emval_take_value');\n      var v = type['readValueFromPointer'](arg);\n      return Emval.toHandle(v);\n    };\n\n  var _emscripten_date_now = () => Date.now();\n\n  var _emscripten_get_now;\n      // Modern environment where performance.now() is supported:\n      // N.B. a shorter form \"_emscripten_get_now = performance.now;\" is\n      // unfortunately not allowed even in current browsers (e.g. FF Nightly 75).\n      _emscripten_get_now = () => performance.now();\n  ;\n\n  var getHeapMax = () =>\n      // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate\n      // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side\n      // for any code that deals with heap sizes, which would require special\n      // casing all heap size related code to treat 0 specially.\n      2147483648;\n  \n  var growMemory = (size) => {\n      var b = wasmMemory.buffer;\n      var pages = (size - b.byteLength + 65535) / 65536;\n      try {\n        // round size grow request up to wasm page size (fixed 64KB per spec)\n        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size\n        updateMemoryViews();\n        return 1 /*success*/;\n      } catch(e) {\n        err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`);\n      }\n      // implicit 0 return to save code size (caller will cast \"undefined\" into 0\n      // anyhow)\n    };\n  var _emscripten_resize_heap = (requestedSize) => {\n      var oldSize = HEAPU8.length;\n      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.\n      requestedSize >>>= 0;\n      // With multithreaded builds, races can happen (another thread might increase the size\n      // in between), so return a failure, and let the caller retry.\n      assert(requestedSize > oldSize);\n  \n      // Memory resize rules:\n      // 1.  Always increase heap size to at least the requested size, rounded up\n      //     to next page multiple.\n      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap\n      //     geometrically: increase the heap size according to\n      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most\n      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).\n      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap\n      //     linearly: increase the heap size by at least\n      //     MEMORY_GROWTH_LINEAR_STEP bytes.\n      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by\n      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest\n      // 4.  If we were unable to allocate as much memory, it may be due to\n      //     over-eager decision to excessively reserve due to (3) above.\n      //     Hence if an allocation fails, cut down on the amount of excess\n      //     growth, in an attempt to succeed to perform a smaller allocation.\n  \n      // A limit is set for how much we can grow. We should not exceed that\n      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).\n      var maxHeapSize = getHeapMax();\n      if (requestedSize > maxHeapSize) {\n        err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);\n        return false;\n      }\n  \n      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;\n  \n      // Loop through potential heap size increases. If we attempt a too eager\n      // reservation that fails, cut down on the attempted size and reserve a\n      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)\n      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {\n        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth\n        // but limit overreserving (default to capping at +96MB overgrowth at most)\n        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );\n  \n        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));\n  \n        var replacement = growMemory(newSize);\n        if (replacement) {\n  \n          return true;\n        }\n      }\n      err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);\n      return false;\n    };\n\n  var SYSCALLS = {\n  varargs:undefined,\n  getStr(ptr) {\n        var ret = UTF8ToString(ptr);\n        return ret;\n      },\n  };\n  var _fd_close = (fd) => {\n      abort('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM');\n    };\n\n  var convertI32PairToI53Checked = (lo, hi) => {\n      assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32\n      assert(hi === (hi|0));                    // hi should be a i32\n      return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN;\n    };\n  function _fd_seek(fd,offset_low, offset_high,whence,newOffset) {\n    var offset = convertI32PairToI53Checked(offset_low, offset_high);\n  \n    \n      return 70;\n    ;\n  }\n\n  var printCharBuffers = [null,[],[]];\n  \n  var printChar = (stream, curr) => {\n      var buffer = printCharBuffers[stream];\n      assert(buffer);\n      if (curr === 0 || curr === 10) {\n        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));\n        buffer.length = 0;\n      } else {\n        buffer.push(curr);\n      }\n    };\n  \n  var flush_NO_FILESYSTEM = () => {\n      // flush anything remaining in the buffers during shutdown\n      _fflush(0);\n      if (printCharBuffers[1].length) printChar(1, 10);\n      if (printCharBuffers[2].length) printChar(2, 10);\n    };\n  \n  \n  var _fd_write = (fd, iov, iovcnt, pnum) => {\n      // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0\n      var num = 0;\n      for (var i = 0; i < iovcnt; i++) {\n        var ptr = HEAPU32[((iov)>>2)];\n        var len = HEAPU32[(((iov)+(4))>>2)];\n        iov += 8;\n        for (var j = 0; j < len; j++) {\n          printChar(fd, HEAPU8[ptr+j]);\n        }\n        num += len;\n      }\n      HEAPU32[((pnum)>>2)] = num;\n      return 0;\n    };\n\n\n  var incrementExceptionRefcount = (ptr) => ___cxa_increment_exception_refcount(ptr);\n  Module['incrementExceptionRefcount'] = incrementExceptionRefcount;\n\n  var decrementExceptionRefcount = (ptr) => ___cxa_decrement_exception_refcount(ptr);\n  Module['decrementExceptionRefcount'] = decrementExceptionRefcount;\n\n  \n  \n  \n  \n  var stackAlloc = (sz) => __emscripten_stack_alloc(sz);\n  \n  var getExceptionMessageCommon = (ptr) => {\n      var sp = stackSave();\n      var type_addr_addr = stackAlloc(4);\n      var message_addr_addr = stackAlloc(4);\n      ___get_exception_message(ptr, type_addr_addr, message_addr_addr);\n      var type_addr = HEAPU32[((type_addr_addr)>>2)];\n      var message_addr = HEAPU32[((message_addr_addr)>>2)];\n      var type = UTF8ToString(type_addr);\n      _free(type_addr);\n      var message;\n      if (message_addr) {\n        message = UTF8ToString(message_addr);\n        _free(message_addr);\n      }\n      stackRestore(sp);\n      return [type, message];\n    };\n  var getExceptionMessage = (ptr) => getExceptionMessageCommon(ptr);\n  Module['getExceptionMessage'] = getExceptionMessage;\nembind_init_charCodes();\nBindingError = Module['BindingError'] = class BindingError extends Error { constructor(message) { super(message); this.name = 'BindingError'; }};\nInternalError = Module['InternalError'] = class InternalError extends Error { constructor(message) { super(message); this.name = 'InternalError'; }};\ninit_emval();;\nUnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');;\nfunction checkIncomingModuleAPI() {\n  ignoredModuleProp('fetchSettings');\n}\nvar wasmImports = {\n  /** @export */\n  __assert_fail: ___assert_fail,\n  /** @export */\n  __cxa_begin_catch: ___cxa_begin_catch,\n  /** @export */\n  __cxa_find_matching_catch_2: ___cxa_find_matching_catch_2,\n  /** @export */\n  __cxa_find_matching_catch_3: ___cxa_find_matching_catch_3,\n  /** @export */\n  __cxa_throw: ___cxa_throw,\n  /** @export */\n  __resumeException: ___resumeException,\n  /** @export */\n  _abort_js: __abort_js,\n  /** @export */\n  _embind_register_bigint: __embind_register_bigint,\n  /** @export */\n  _embind_register_bool: __embind_register_bool,\n  /** @export */\n  _embind_register_emval: __embind_register_emval,\n  /** @export */\n  _embind_register_float: __embind_register_float,\n  /** @export */\n  _embind_register_function: __embind_register_function,\n  /** @export */\n  _embind_register_integer: __embind_register_integer,\n  /** @export */\n  _embind_register_memory_view: __embind_register_memory_view,\n  /** @export */\n  _embind_register_std_string: __embind_register_std_string,\n  /** @export */\n  _embind_register_std_wstring: __embind_register_std_wstring,\n  /** @export */\n  _embind_register_void: __embind_register_void,\n  /** @export */\n  _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,\n  /** @export */\n  _emscripten_memcpy_js: __emscripten_memcpy_js,\n  /** @export */\n  _emval_as: __emval_as,\n  /** @export */\n  _emval_call: __emval_call,\n  /** @export */\n  _emval_call_method: __emval_call_method,\n  /** @export */\n  _emval_decref: __emval_decref,\n  /** @export */\n  _emval_get_method_caller: __emval_get_method_caller,\n  /** @export */\n  _emval_get_module_property: __emval_get_module_property,\n  /** @export */\n  _emval_get_property: __emval_get_property,\n  /** @export */\n  _emval_incref: __emval_incref,\n  /** @export */\n  _emval_new_array: __emval_new_array,\n  /** @export */\n  _emval_new_array_from_memory_view: __emval_new_array_from_memory_view,\n  /** @export */\n  _emval_new_cstring: __emval_new_cstring,\n  /** @export */\n  _emval_new_object: __emval_new_object,\n  /** @export */\n  _emval_run_destructors: __emval_run_destructors,\n  /** @export */\n  _emval_set_property: __emval_set_property,\n  /** @export */\n  _emval_take_value: __emval_take_value,\n  /** @export */\n  emscripten_date_now: _emscripten_date_now,\n  /** @export */\n  emscripten_get_now: _emscripten_get_now,\n  /** @export */\n  emscripten_resize_heap: _emscripten_resize_heap,\n  /** @export */\n  fd_close: _fd_close,\n  /** @export */\n  fd_seek: _fd_seek,\n  /** @export */\n  fd_write: _fd_write,\n  /** @export */\n  invoke_ii,\n  /** @export */\n  invoke_iii,\n  /** @export */\n  invoke_iiii,\n  /** @export */\n  invoke_j,\n  /** @export */\n  invoke_v,\n  /** @export */\n  invoke_vi,\n  /** @export */\n  invoke_vii,\n  /** @export */\n  invoke_viii,\n  /** @export */\n  invoke_viiii\n};\nvar wasmExports = createWasm();\nvar ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors', 0);\nvar ___getTypeName = createExportWrapper('__getTypeName', 1);\nvar _fflush = createExportWrapper('fflush', 1);\nvar _malloc = createExportWrapper('malloc', 1);\nvar _strerror = createExportWrapper('strerror', 1);\nvar _free = createExportWrapper('free', 1);\nvar _setThrew = createExportWrapper('setThrew', 2);\nvar __emscripten_tempret_set = createExportWrapper('_emscripten_tempret_set', 1);\nvar _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])();\nvar _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])();\nvar _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])();\nvar _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])();\nvar __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports['_emscripten_stack_restore'])(a0);\nvar __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'])(a0);\nvar _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])();\nvar ___cxa_free_exception = createExportWrapper('__cxa_free_exception', 1);\nvar ___cxa_increment_exception_refcount = createExportWrapper('__cxa_increment_exception_refcount', 1);\nvar ___cxa_decrement_exception_refcount = createExportWrapper('__cxa_decrement_exception_refcount', 1);\nvar ___get_exception_message = createExportWrapper('__get_exception_message', 3);\nvar ___cxa_can_catch = createExportWrapper('__cxa_can_catch', 3);\nvar ___cxa_is_pointer_type = createExportWrapper('__cxa_is_pointer_type', 1);\nvar dynCall_j = Module['dynCall_j'] = createExportWrapper('dynCall_j', 1);\nvar dynCall_jiji = Module['dynCall_jiji'] = createExportWrapper('dynCall_jiji', 5);\n\nfunction invoke_iii(index,a1,a2) {\n  var sp = stackSave();\n  try {\n    return getWasmTableEntry(index)(a1,a2);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_ii(index,a1) {\n  var sp = stackSave();\n  try {\n    return getWasmTableEntry(index)(a1);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_v(index) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)();\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_vi(index,a1) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_viii(index,a1,a2,a3) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1,a2,a3);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_iiii(index,a1,a2,a3) {\n  var sp = stackSave();\n  try {\n    return getWasmTableEntry(index)(a1,a2,a3);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_viiii(index,a1,a2,a3,a4) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1,a2,a3,a4);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_vii(index,a1,a2) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1,a2);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_j(index) {\n  var sp = stackSave();\n  try {\n    return dynCall_j(index);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\n\n// include: postamble.js\n// === Auto-generated postamble setup entry stuff ===\n\nvar missingLibrarySymbols = [\n  'writeI53ToI64',\n  'writeI53ToI64Clamped',\n  'writeI53ToI64Signaling',\n  'writeI53ToU64Clamped',\n  'writeI53ToU64Signaling',\n  'readI53FromI64',\n  'readI53FromU64',\n  'convertI32PairToI53',\n  'convertU32PairToI53',\n  'getTempRet0',\n  'zeroMemory',\n  'exitJS',\n  'isLeapYear',\n  'ydayFromDate',\n  'arraySum',\n  'addDays',\n  'strError',\n  'inetPton4',\n  'inetNtop4',\n  'inetPton6',\n  'inetNtop6',\n  'readSockaddr',\n  'writeSockaddr',\n  'initRandomFill',\n  'randomFill',\n  'emscriptenLog',\n  'readEmAsmArgs',\n  'jstoi_q',\n  'getExecutableName',\n  'listenOnce',\n  'autoResumeAudioContext',\n  'handleException',\n  'keepRuntimeAlive',\n  'runtimeKeepalivePush',\n  'runtimeKeepalivePop',\n  'callUserCallback',\n  'maybeExit',\n  'asmjsMangle',\n  'asyncLoad',\n  'alignMemory',\n  'mmapAlloc',\n  'HandleAllocator',\n  'getNativeTypeSize',\n  'STACK_SIZE',\n  'STACK_ALIGN',\n  'POINTER_SIZE',\n  'ASSERTIONS',\n  'getCFunc',\n  'ccall',\n  'cwrap',\n  'uleb128Encode',\n  'sigToWasmTypes',\n  'generateFuncType',\n  'convertJsFunctionToWasm',\n  'getEmptyTableSlot',\n  'updateTableMap',\n  'getFunctionAddress',\n  'addFunction',\n  'removeFunction',\n  'reallyNegative',\n  'unSign',\n  'strLen',\n  'reSign',\n  'formatString',\n  'intArrayFromString',\n  'intArrayToString',\n  'AsciiToString',\n  'stringToAscii',\n  'stringToNewUTF8',\n  'stringToUTF8OnStack',\n  'writeArrayToMemory',\n  'registerKeyEventCallback',\n  'maybeCStringToJsString',\n  'findEventTarget',\n  'getBoundingClientRect',\n  'fillMouseEventData',\n  'registerMouseEventCallback',\n  'registerWheelEventCallback',\n  'registerUiEventCallback',\n  'registerFocusEventCallback',\n  'fillDeviceOrientationEventData',\n  'registerDeviceOrientationEventCallback',\n  'fillDeviceMotionEventData',\n  'registerDeviceMotionEventCallback',\n  'screenOrientation',\n  'fillOrientationChangeEventData',\n  'registerOrientationChangeEventCallback',\n  'fillFullscreenChangeEventData',\n  'registerFullscreenChangeEventCallback',\n  'JSEvents_requestFullscreen',\n  'JSEvents_resizeCanvasForFullscreen',\n  'registerRestoreOldStyle',\n  'hideEverythingExceptGivenElement',\n  'restoreHiddenElements',\n  'setLetterbox',\n  'softFullscreenResizeWebGLRenderTarget',\n  'doRequestFullscreen',\n  'fillPointerlockChangeEventData',\n  'registerPointerlockChangeEventCallback',\n  'registerPointerlockErrorEventCallback',\n  'requestPointerLock',\n  'fillVisibilityChangeEventData',\n  'registerVisibilityChangeEventCallback',\n  'registerTouchEventCallback',\n  'fillGamepadEventData',\n  'registerGamepadEventCallback',\n  'registerBeforeUnloadEventCallback',\n  'fillBatteryEventData',\n  'battery',\n  'registerBatteryEventCallback',\n  'setCanvasElementSize',\n  'getCanvasElementSize',\n  'jsStackTrace',\n  'getCallstack',\n  'convertPCtoSourceLocation',\n  'getEnvStrings',\n  'checkWasiClock',\n  'wasiRightsToMuslOFlags',\n  'wasiOFlagsToMuslOFlags',\n  'createDyncallWrapper',\n  'safeSetTimeout',\n  'setImmediateWrapped',\n  'clearImmediateWrapped',\n  'polyfillSetImmediate',\n  'getPromise',\n  'makePromise',\n  'idsToPromises',\n  'makePromiseCallback',\n  'Browser_asyncPrepareDataCounter',\n  'setMainLoop',\n  'getSocketFromFD',\n  'getSocketAddress',\n  'FS_createPreloadedFile',\n  'FS_modeStringToFlags',\n  'FS_getMode',\n  'FS_stdin_getChar',\n  'FS_unlink',\n  'FS_createDataFile',\n  'FS_mkdirTree',\n  '_setNetworkCallback',\n  'heapObjectForWebGLType',\n  'toTypedArrayIndex',\n  'webgl_enable_ANGLE_instanced_arrays',\n  'webgl_enable_OES_vertex_array_object',\n  'webgl_enable_WEBGL_draw_buffers',\n  'webgl_enable_WEBGL_multi_draw',\n  'emscriptenWebGLGet',\n  'computeUnpackAlignedImageSize',\n  'colorChannelsInGlTextureFormat',\n  'emscriptenWebGLGetTexPixelData',\n  'emscriptenWebGLGetUniform',\n  'webglGetUniformLocation',\n  'webglPrepareUniformLocationsBeforeFirstUse',\n  'webglGetLeftBracePos',\n  'emscriptenWebGLGetVertexAttrib',\n  '__glGetActiveAttribOrUniform',\n  'writeGLArray',\n  'registerWebGlEventCallback',\n  'runAndAbortIfError',\n  'ALLOC_NORMAL',\n  'ALLOC_STACK',\n  'allocate',\n  'writeStringToMemory',\n  'writeAsciiToMemory',\n  'setErrNo',\n  'demangle',\n  'stackTrace',\n  'getFunctionArgsName',\n  'createJsInvokerSignature',\n  'init_embind',\n  'getBasestPointer',\n  'registerInheritedInstance',\n  'unregisterInheritedInstance',\n  'getInheritedInstance',\n  'getInheritedInstanceCount',\n  'getLiveInheritedInstances',\n  'enumReadValueFromPointer',\n  'genericPointerToWireType',\n  'constNoSmartPtrRawPointerToWireType',\n  'nonConstNoSmartPtrRawPointerToWireType',\n  'init_RegisteredPointer',\n  'RegisteredPointer',\n  'RegisteredPointer_fromWireType',\n  'runDestructor',\n  'releaseClassHandle',\n  'detachFinalizer',\n  'attachFinalizer',\n  'makeClassHandle',\n  'init_ClassHandle',\n  'ClassHandle',\n  'throwInstanceAlreadyDeleted',\n  'flushPendingDeletes',\n  'setDelayFunction',\n  'RegisteredClass',\n  'shallowCopyInternalPointer',\n  'downcastPointer',\n  'upcastPointer',\n  'validateThis',\n  'char_0',\n  'char_9',\n  'makeLegalFunctionName',\n  'emval_get_global',\n];\nmissingLibrarySymbols.forEach(missingLibrarySymbol)\n\nvar unexportedSymbols = [\n  'run',\n  'addOnPreRun',\n  'addOnInit',\n  'addOnPreMain',\n  'addOnExit',\n  'addOnPostRun',\n  'addRunDependency',\n  'removeRunDependency',\n  'out',\n  'err',\n  'callMain',\n  'abort',\n  'wasmMemory',\n  'wasmExports',\n  'writeStackCookie',\n  'checkStackCookie',\n  'convertI32PairToI53Checked',\n  'stackSave',\n  'stackRestore',\n  'stackAlloc',\n  'setTempRet0',\n  'ptrToString',\n  'getHeapMax',\n  'growMemory',\n  'ENV',\n  'MONTH_DAYS_REGULAR',\n  'MONTH_DAYS_LEAP',\n  'MONTH_DAYS_REGULAR_CUMULATIVE',\n  'MONTH_DAYS_LEAP_CUMULATIVE',\n  'ERRNO_CODES',\n  'DNS',\n  'Protocols',\n  'Sockets',\n  'timers',\n  'warnOnce',\n  'readEmAsmArgsArray',\n  'jstoi_s',\n  'dynCallLegacy',\n  'getDynCaller',\n  'dynCall',\n  'wasmTable',\n  'noExitRuntime',\n  'freeTableIndexes',\n  'functionsInTableMap',\n  'setValue',\n  'getValue',\n  'PATH',\n  'PATH_FS',\n  'UTF8Decoder',\n  'UTF8ArrayToString',\n  'UTF8ToString',\n  'stringToUTF8Array',\n  'stringToUTF8',\n  'lengthBytesUTF8',\n  'UTF16Decoder',\n  'UTF16ToString',\n  'stringToUTF16',\n  'lengthBytesUTF16',\n  'UTF32ToString',\n  'stringToUTF32',\n  'lengthBytesUTF32',\n  'JSEvents',\n  'specialHTMLTargets',\n  'findCanvasEventTarget',\n  'currentFullscreenStrategy',\n  'restoreOldWindowedStyle',\n  'UNWIND_CACHE',\n  'ExitStatus',\n  'flush_NO_FILESYSTEM',\n  'promiseMap',\n  'uncaughtExceptionCount',\n  'exceptionLast',\n  'exceptionCaught',\n  'ExceptionInfo',\n  'findMatchingCatch',\n  'getExceptionMessageCommon',\n  'incrementExceptionRefcount',\n  'decrementExceptionRefcount',\n  'getExceptionMessage',\n  'Browser',\n  'getPreloadedImageData__data',\n  'wget',\n  'SYSCALLS',\n  'preloadPlugins',\n  'FS_stdin_getChar_buffer',\n  'FS_createPath',\n  'FS_createDevice',\n  'FS_readFile',\n  'FS',\n  'FS_createLazyFile',\n  'MEMFS',\n  'TTY',\n  'PIPEFS',\n  'SOCKFS',\n  'tempFixedLengthArray',\n  'miniTempWebGLFloatBuffers',\n  'miniTempWebGLIntBuffers',\n  'GL',\n  'AL',\n  'GLUT',\n  'EGL',\n  'GLEW',\n  'IDBStore',\n  'SDL',\n  'SDL_gfx',\n  'allocateUTF8',\n  'allocateUTF8OnStack',\n  'print',\n  'printErr',\n  'InternalError',\n  'BindingError',\n  'throwInternalError',\n  'throwBindingError',\n  'registeredTypes',\n  'awaitingDependencies',\n  'typeDependencies',\n  'tupleRegistrations',\n  'structRegistrations',\n  'sharedRegisterType',\n  'whenDependentTypesAreResolved',\n  'embind_charCodes',\n  'embind_init_charCodes',\n  'readLatin1String',\n  'getTypeName',\n  'getFunctionName',\n  'heap32VectorToArray',\n  'requireRegisteredType',\n  'usesDestructorStack',\n  'createJsInvoker',\n  'UnboundTypeError',\n  'PureVirtualError',\n  'GenericWireTypeSize',\n  'EmValType',\n  'throwUnboundTypeError',\n  'ensureOverloadTable',\n  'exposePublicSymbol',\n  'replacePublicSymbol',\n  'extendError',\n  'createNamedFunction',\n  'embindRepr',\n  'registeredInstances',\n  'registeredPointers',\n  'registerType',\n  'integerReadValueFromPointer',\n  'floatReadValueFromPointer',\n  'readPointer',\n  'runDestructors',\n  'newFunc',\n  'craftInvokerFunction',\n  'embind__requireFunction',\n  'finalizationRegistry',\n  'detachFinalizer_deps',\n  'deletionQueue',\n  'delayFunction',\n  'emval_freelist',\n  'emval_handles',\n  'emval_symbols',\n  'init_emval',\n  'count_emval_handles',\n  'getStringOrSymbol',\n  'Emval',\n  'emval_returnValue',\n  'emval_lookupTypes',\n  'emval_methodCallers',\n  'emval_addMethodCaller',\n  'reflectConstruct',\n];\nunexportedSymbols.forEach(unexportedRuntimeSymbol);\n\n\n\nvar calledRun;\n\ndependenciesFulfilled = function runCaller() {\n  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)\n  if (!calledRun) run();\n  if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled\n};\n\nfunction stackCheckInit() {\n  // This is normally called automatically during __wasm_call_ctors but need to\n  // get these values before even running any of the ctors so we call it redundantly\n  // here.\n  _emscripten_stack_init();\n  // TODO(sbc): Move writeStackCookie to native to to avoid this.\n  writeStackCookie();\n}\n\nfunction run() {\n\n  if (runDependencies > 0) {\n    return;\n  }\n\n    stackCheckInit();\n\n  preRun();\n\n  // a preRun added a dependency, run will be called later\n  if (runDependencies > 0) {\n    return;\n  }\n\n  function doRun() {\n    // run may have just been called through dependencies being fulfilled just in this very frame,\n    // or while the async setStatus time below was happening\n    if (calledRun) return;\n    calledRun = true;\n    Module['calledRun'] = true;\n\n    if (ABORT) return;\n\n    initRuntime();\n\n    readyPromiseResolve(Module);\n    Module['onRuntimeInitialized']?.();\n\n    assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module[\"onRuntimeInitialized\"]');\n\n    postRun();\n  }\n\n  if (Module['setStatus']) {\n    Module['setStatus']('Running...');\n    setTimeout(function() {\n      setTimeout(function() {\n        Module['setStatus']('');\n      }, 1);\n      doRun();\n    }, 1);\n  } else\n  {\n    doRun();\n  }\n  checkStackCookie();\n}\n\nfunction checkUnflushedContent() {\n  // Compiler settings do not allow exiting the runtime, so flushing\n  // the streams is not possible. but in ASSERTIONS mode we check\n  // if there was something to flush, and if so tell the user they\n  // should request that the runtime be exitable.\n  // Normally we would not even include flush() at all, but in ASSERTIONS\n  // builds we do so just for this check, and here we see if there is any\n  // content to flush, that is, we check if there would have been\n  // something a non-ASSERTIONS build would have not seen.\n  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0\n  // mode (which has its own special function for this; otherwise, all\n  // the code is inside libc)\n  var oldOut = out;\n  var oldErr = err;\n  var has = false;\n  out = err = (x) => {\n    has = true;\n  }\n  try { // it doesn't matter if it fails\n    flush_NO_FILESYSTEM();\n  } catch(e) {}\n  out = oldOut;\n  err = oldErr;\n  if (has) {\n    warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.');\n    warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)');\n  }\n}\n\nif (Module['preInit']) {\n  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];\n  while (Module['preInit'].length > 0) {\n    Module['preInit'].pop()();\n  }\n}\n\nrun();\n\n// end include: postamble.js\n\n// include: postamble_modularize.js\n// In MODULARIZE mode we wrap the generated code in a factory function\n// and return either the Module itself, or a promise of the module.\n//\n// We assign to the `moduleRtn` global here and configure closure to see\n// this as and extern so it won't get minified.\n\nmoduleRtn = readyPromise;\n\n// Assertion for attempting to access module properties on the incoming\n// moduleArg.  In the past we used this object as the prototype of the module\n// and assigned properties to it, but now we return a distinct object.  This\n// keeps the instance private until it is ready (i.e the promise has been\n// resolved).\nfor (const prop of Object.keys(Module)) {\n  if (!(prop in moduleArg)) {\n    Object.defineProperty(moduleArg, prop, {\n      configurable: true,\n      get() {\n        abort(`Access to module property ('${prop}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`)\n      }\n    });\n  }\n}\n// end include: postamble_modularize.js\n\n\n\n  return moduleRtn;\n}\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = Module;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => Module);\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/^blob:/, \"\").replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","/**\r\n * Copyright 2019 Google Inc. All Rights Reserved.\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *     http://www.apache.org/licenses/LICENSE-2.0\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nconst proxyMarker = Symbol(\"Comlink.proxy\");\r\nconst createEndpoint = Symbol(\"Comlink.endpoint\");\r\nconst releaseProxy = Symbol(\"Comlink.releaseProxy\");\r\nconst throwMarker = Symbol(\"Comlink.thrown\");\r\nconst isObject = (val) => (typeof val === \"object\" && val !== null) || typeof val === \"function\";\r\n/**\r\n * Internal transfer handle to handle objects marked to proxy.\r\n */\r\nconst proxyTransferHandler = {\r\n    canHandle: (val) => isObject(val) && val[proxyMarker],\r\n    serialize(obj) {\r\n        const { port1, port2 } = new MessageChannel();\r\n        expose(obj, port1);\r\n        return [port2, [port2]];\r\n    },\r\n    deserialize(port) {\r\n        port.start();\r\n        return wrap(port);\r\n    },\r\n};\r\n/**\r\n * Internal transfer handler to handle thrown exceptions.\r\n */\r\nconst throwTransferHandler = {\r\n    canHandle: (value) => isObject(value) && throwMarker in value,\r\n    serialize({ value }) {\r\n        let serialized;\r\n        if (value instanceof Error) {\r\n            serialized = {\r\n                isError: true,\r\n                value: {\r\n                    message: value.message,\r\n                    name: value.name,\r\n                    stack: value.stack,\r\n                },\r\n            };\r\n        }\r\n        else {\r\n            serialized = { isError: false, value };\r\n        }\r\n        return [serialized, []];\r\n    },\r\n    deserialize(serialized) {\r\n        if (serialized.isError) {\r\n            throw Object.assign(new Error(serialized.value.message), serialized.value);\r\n        }\r\n        throw serialized.value;\r\n    },\r\n};\r\n/**\r\n * Allows customizing the serialization of certain values.\r\n */\r\nconst transferHandlers = new Map([\r\n    [\"proxy\", proxyTransferHandler],\r\n    [\"throw\", throwTransferHandler],\r\n]);\r\nfunction expose(obj, ep = self) {\r\n    ep.addEventListener(\"message\", function callback(ev) {\r\n        if (!ev || !ev.data) {\r\n            return;\r\n        }\r\n        const { id, type, path } = Object.assign({ path: [] }, ev.data);\r\n        const argumentList = (ev.data.argumentList || []).map(fromWireValue);\r\n        let returnValue;\r\n        try {\r\n            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\r\n            const rawValue = path.reduce((obj, prop) => obj[prop], obj);\r\n            switch (type) {\r\n                case \"GET\" /* GET */:\r\n                    {\r\n                        returnValue = rawValue;\r\n                    }\r\n                    break;\r\n                case \"SET\" /* SET */:\r\n                    {\r\n                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\r\n                        returnValue = true;\r\n                    }\r\n                    break;\r\n                case \"APPLY\" /* APPLY */:\r\n                    {\r\n                        returnValue = rawValue.apply(parent, argumentList);\r\n                    }\r\n                    break;\r\n                case \"CONSTRUCT\" /* CONSTRUCT */:\r\n                    {\r\n                        const value = new rawValue(...argumentList);\r\n                        returnValue = proxy(value);\r\n                    }\r\n                    break;\r\n                case \"ENDPOINT\" /* ENDPOINT */:\r\n                    {\r\n                        const { port1, port2 } = new MessageChannel();\r\n                        expose(obj, port2);\r\n                        returnValue = transfer(port1, [port1]);\r\n                    }\r\n                    break;\r\n                case \"RELEASE\" /* RELEASE */:\r\n                    {\r\n                        returnValue = undefined;\r\n                    }\r\n                    break;\r\n                default:\r\n                    return;\r\n            }\r\n        }\r\n        catch (value) {\r\n            returnValue = { value, [throwMarker]: 0 };\r\n        }\r\n        Promise.resolve(returnValue)\r\n            .catch((value) => {\r\n            return { value, [throwMarker]: 0 };\r\n        })\r\n            .then((returnValue) => {\r\n            const [wireValue, transferables] = toWireValue(returnValue);\r\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\r\n            if (type === \"RELEASE\" /* RELEASE */) {\r\n                // detach and deactive after sending release response above.\r\n                ep.removeEventListener(\"message\", callback);\r\n                closeEndPoint(ep);\r\n            }\r\n        });\r\n    });\r\n    if (ep.start) {\r\n        ep.start();\r\n    }\r\n}\r\nfunction isMessagePort(endpoint) {\r\n    return endpoint.constructor.name === \"MessagePort\";\r\n}\r\nfunction closeEndPoint(endpoint) {\r\n    if (isMessagePort(endpoint))\r\n        endpoint.close();\r\n}\r\nfunction wrap(ep, target) {\r\n    return createProxy(ep, [], target);\r\n}\r\nfunction throwIfProxyReleased(isReleased) {\r\n    if (isReleased) {\r\n        throw new Error(\"Proxy has been released and is not useable\");\r\n    }\r\n}\r\nfunction createProxy(ep, path = [], target = function () { }) {\r\n    let isProxyReleased = false;\r\n    const proxy = new Proxy(target, {\r\n        get(_target, prop) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            if (prop === releaseProxy) {\r\n                return () => {\r\n                    return requestResponseMessage(ep, {\r\n                        type: \"RELEASE\" /* RELEASE */,\r\n                        path: path.map((p) => p.toString()),\r\n                    }).then(() => {\r\n                        closeEndPoint(ep);\r\n                        isProxyReleased = true;\r\n                    });\r\n                };\r\n            }\r\n            if (prop === \"then\") {\r\n                if (path.length === 0) {\r\n                    return { then: () => proxy };\r\n                }\r\n                const r = requestResponseMessage(ep, {\r\n                    type: \"GET\" /* GET */,\r\n                    path: path.map((p) => p.toString()),\r\n                }).then(fromWireValue);\r\n                return r.then.bind(r);\r\n            }\r\n            return createProxy(ep, [...path, prop]);\r\n        },\r\n        set(_target, prop, rawValue) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\r\n            // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\r\n            const [value, transferables] = toWireValue(rawValue);\r\n            return requestResponseMessage(ep, {\r\n                type: \"SET\" /* SET */,\r\n                path: [...path, prop].map((p) => p.toString()),\r\n                value,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        apply(_target, _thisArg, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const last = path[path.length - 1];\r\n            if (last === createEndpoint) {\r\n                return requestResponseMessage(ep, {\r\n                    type: \"ENDPOINT\" /* ENDPOINT */,\r\n                }).then(fromWireValue);\r\n            }\r\n            // We just pretend that `bind()` didn’t happen.\r\n            if (last === \"bind\") {\r\n                return createProxy(ep, path.slice(0, -1));\r\n            }\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"APPLY\" /* APPLY */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        construct(_target, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"CONSTRUCT\" /* CONSTRUCT */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n    });\r\n    return proxy;\r\n}\r\nfunction myFlat(arr) {\r\n    return Array.prototype.concat.apply([], arr);\r\n}\r\nfunction processArguments(argumentList) {\r\n    const processed = argumentList.map(toWireValue);\r\n    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\r\n}\r\nconst transferCache = new WeakMap();\r\nfunction transfer(obj, transfers) {\r\n    transferCache.set(obj, transfers);\r\n    return obj;\r\n}\r\nfunction proxy(obj) {\r\n    return Object.assign(obj, { [proxyMarker]: true });\r\n}\r\nfunction windowEndpoint(w, context = self, targetOrigin = \"*\") {\r\n    return {\r\n        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),\r\n        addEventListener: context.addEventListener.bind(context),\r\n        removeEventListener: context.removeEventListener.bind(context),\r\n    };\r\n}\r\nfunction toWireValue(value) {\r\n    for (const [name, handler] of transferHandlers) {\r\n        if (handler.canHandle(value)) {\r\n            const [serializedValue, transferables] = handler.serialize(value);\r\n            return [\r\n                {\r\n                    type: \"HANDLER\" /* HANDLER */,\r\n                    name,\r\n                    value: serializedValue,\r\n                },\r\n                transferables,\r\n            ];\r\n        }\r\n    }\r\n    return [\r\n        {\r\n            type: \"RAW\" /* RAW */,\r\n            value,\r\n        },\r\n        transferCache.get(value) || [],\r\n    ];\r\n}\r\nfunction fromWireValue(value) {\r\n    switch (value.type) {\r\n        case \"HANDLER\" /* HANDLER */:\r\n            return transferHandlers.get(value.name).deserialize(value.value);\r\n        case \"RAW\" /* RAW */:\r\n            return value.value;\r\n    }\r\n}\r\nfunction requestResponseMessage(ep, msg, transfers) {\r\n    return new Promise((resolve) => {\r\n        const id = generateUUID();\r\n        ep.addEventListener(\"message\", function l(ev) {\r\n            if (!ev.data || !ev.data.id || ev.data.id !== id) {\r\n                return;\r\n            }\r\n            ep.removeEventListener(\"message\", l);\r\n            resolve(ev.data);\r\n        });\r\n        if (ep.start) {\r\n            ep.start();\r\n        }\r\n        ep.postMessage(Object.assign({ id }, msg), transfers);\r\n    });\r\n}\r\nfunction generateUUID() {\r\n    return new Array(4)\r\n        .fill(0)\r\n        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\r\n        .join(\"-\");\r\n}\n\nexport { createEndpoint, expose, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap };\n//# sourceMappingURL=comlink.mjs.map\n","\n// Should rename this eventually\nimport Module from './cpp/marchingsquares';\nimport { MarchingSquaresModule } from './cpp/marchingsquares';\nimport './cpp/marchingsquares.wasm';\n\nlet msm_promise: Promise<MarchingSquaresModule> | null = null;\n\ninterface InitMSModuleOpts {\n    document_script?: string;\n}\n\nfunction initMSModule(opts: InitMSModuleOpts) {\n    if (msm_promise === null) {\n        msm_promise = Module({'locateFile': (fname: string, dir: string) => (opts.document_script === undefined ? dir : opts.document_script) + fname});\n    }\n\n    return msm_promise;\n}\n\nexport {initMSModule};","\nimport * as Comlink from 'comlink';\n\nimport { GridCoords } from './grids/Grid';\nimport { ContourData, ContourableTypedArray } from \"./AutumnTypes\";\nimport { initMSModule } from \"./WasmInterface\";\nimport { MarchingSquaresModule } from './cpp/marchingsquares';\n\nlet _msm: MarchingSquaresModule | null = null;\n\nasync function init(wasm_base_url: string | undefined) {\n    _msm = await initMSModule({document_script: wasm_base_url});\n}\n\n/** Options for contouring data via {@link RawScalarField.getContours | RawScalarField.getContours()} */\ninterface FieldContourOpts {\n    /**\n     * The interval at which to create contours. The field will be contoured at this interval from its minimum to its maximum.\n     */\n    interval?: number;\n\n    /**\n     * Contour the field at these specific levels.\n     */\n    levels?: number[];\n\n    /**\n     * Add triangles in the contouring, which takes longer and generates more detailed (not necessarily smoother or better) contours\n     */\n    quad_as_tri?: boolean;\n}\n\nasync function contourCreator(data: ContourableTypedArray, grid_coords: GridCoords, opts: FieldContourOpts) {\n    if (opts.interval === undefined && opts.levels === undefined) {\n        throw \"Must supply either an interval or levels to contourCreator()\"\n    }\n\n    const interval = opts.interval === undefined ? 0 : opts.interval;\n    const quad_as_tri = opts.quad_as_tri === undefined ? false : opts.quad_as_tri;\n\n    const msm = _msm === null ? await initMSModule({}) : _msm;\n    _msm = msm;\n\n    const getContourLevels = data instanceof Float32Array ? msm.getContourLevelsFloat32 : msm.getContourLevelsFloat16;\n    const makeContours = data instanceof Float32Array ? msm.makeContoursFloat32 : msm.makeContoursFloat16;\n\n    const levels = opts.levels === undefined ? getContourLevels(data, grid_coords.x.length, grid_coords.y.length, interval) : opts.levels;\n    const contours = makeContours(data, grid_coords.x, grid_coords.y, levels, quad_as_tri);\n\n    return contours as ContourData;\n}\n\nconst ep_interface = {\n    'contourCreator': contourCreator,\n    'init': init,\n}\n\ntype ContourCreatorWorker = typeof ep_interface;\n\nComlink.expose(ep_interface);\n\nexport type {ContourCreatorWorker, FieldContourOpts}\n"],"names":["root","factory","exports","module","define","amd","this","_scriptName","Module","document","currentScript","src","undefined","moduleArg","moduleRtn","readyPromiseResolve","readyPromiseReject","readyPromise","Promise","resolve","reject","forEach","prop","Object","getOwnPropertyDescriptor","defineProperty","get","abort","set","Error","readAsync","moduleOverrides","assign","scriptDirectory","startsWith","substr","replace","lastIndexOf","window","importScripts","url","assert","isFileURI","fetch","credentials","then","response","ok","arrayBuffer","status","wasmBinary","wasmMemory","out","console","log","bind","err","error","legacyModuleProp","WebAssembly","HEAP8","HEAPU8","HEAP16","HEAPU16","HEAP32","HEAPU32","HEAPF32","HEAPF64","ABORT","condition","text","updateMemoryViews","b","buffer","Int8Array","Int16Array","Uint8Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","checkStackCookie","max","_emscripten_stack_get_end","cookie1","cookie2","ptrToString","prototype","subarray","h16","h8","__ATPRERUN__","__ATINIT__","__ATPOSTRUN__","runtimeInitialized","addOnPreRun","cb","unshift","addOnPostRun","Math","imul","fround","clz32","trunc","runDependencies","runDependencyWatcher","dependenciesFulfilled","runDependencyTracking","what","e","RuntimeError","FS","init","createDataFile","createPreloadedFile","createLazyFile","open","mkdev","registerDevice","analyzePath","ErrnoError","wasmBinaryFile","isDataURI","filename","createExportWrapper","name","nargs","args","f","wasmExports","length","EmscriptenEH","CppException","constructor","excPtr","super","excInfo","getExceptionMessage","message","getBinarySync","file","instantiateArrayBuffer","binaryFile","imports","receiver","getBinaryPromise","binary","instantiate","reason","newName","incoming","configurable","isExportedByForceFilesystem","missingGlobal","sym","msg","globalThis","warnOnce","unexportedRuntimeSymbol","callRuntimeCallbacks","callbacks","shift","ptr","toString","padStart","stackRestore","val","__emscripten_stack_restore","stackSave","_emscripten_stack_get_current","shown","UTF8Decoder","TextDecoder","UTF8ArrayToString","heapOrArray","idx","maxBytesToRead","endIdx","endPtr","decode","str","u0","u1","u2","String","fromCharCode","ch","UTF8ToString","exceptionCaught","exceptionLast","ExceptionInfo","set_type","type","get_type","set_destructor","destructor","get_destructor","set_caught","caught","get_caught","set_rethrown","rethrown","get_rethrown","set_adjusted_ptr","adjustedPtr","get_adjusted_ptr","get_exception_ptr","___cxa_is_pointer_type","adjusted","embind_charCodes","BindingError","InternalError","setTempRet0","__emscripten_tempret_set","findMatchingCatch","thrown","info","thrownType","caughtType","adjusted_ptr_addr","___cxa_can_catch","readLatin1String","ret","c","awaitingDependencies","registeredTypes","typeDependencies","throwBindingError","throwInternalError","registerType","rawType","registeredInstance","options","TypeError","hasOwnProperty","ignoreDuplicateRegistrations","sharedRegisterType","emval_freelist","emval_handles","__emval_decref","handle","push","Emval","value","pop","readPointer","pointer","EmValType","rv","destructors","destructorFunction","embindRepr","v","t","floatReadValueFromPointer","width","createNamedFunction","body","runDestructors","del","usesDestructorStack","argTypes","i","newFunc","argumentList","Function","dummy","obj","r","apply","wasmTable","UnboundTypeError","_emscripten_get_now","ensureOverloadTable","proto","methodName","humanName","overloadTable","prevFunc","argCount","wasmTableMirror","getWasmTableEntry","funcPtr","func","embind__requireFunction","signature","rawFunction","sig","fp","includes","substring","dynCallLegacy","dynCall","getTypeName","___getTypeName","_free","integerReadValueFromPointer","signed","UTF16Decoder","UTF16ToString","maxIdx","codeUnit","stringToUTF16","outPtr","maxBytesToWrite","startPtr","numCharsToWrite","charCodeAt","lengthBytesUTF16","UTF32ToString","utf32","stringToUTF32","lengthBytesUTF32","len","requireRegisteredType","impl","emval_returnValue","returnType","destructorsRef","result","emval_methodCallers","emval_symbols","getStringOrSymbol","address","symbol","Reflect","construct","performance","now","growMemory","size","pages","byteLength","grow","printCharBuffers","printChar","stream","curr","___cxa_increment_exception_refcount","___cxa_decrement_exception_refcount","baseErrorType","errorClass","stackAlloc","sz","__emscripten_stack_alloc","sp","type_addr_addr","message_addr_addr","___get_exception_message","type_addr","message_addr","getExceptionMessageCommon","codes","Array","embind_init_charCodes","stack","create","calledRun","wasmImports","__assert_fail","line","__cxa_begin_catch","__cxa_find_matching_catch_2","__cxa_find_matching_catch_3","arg0","__cxa_throw","__resumeException","_abort_js","_embind_register_bigint","primitiveType","minRange","maxRange","_embind_register_bool","trueValue","falseValue","wt","o","_embind_register_emval","_embind_register_float","_embind_register_function","rawArgTypesAddr","rawInvoker","fn","isAsync","count","firstElement","array","heap32VectorToArray","argsIndex","trim","indexOf","getFunctionName","numArguments","exposePublicSymbol","types","unboundTypes","seen","visit","map","join","throwUnboundTypeError","myTypes","dependentTypes","onComplete","typeConverters","myTypeConverters","invokerArgsArray","concat","slice","replacePublicSymbol","classType","cppInvokerFunc","cppTargetFunc","isClassMethodFunc","needsDestructorStack","returns","closureArgs","invokerFnBody","argsList","argsListWired","dtorStack","args1","paramName","createJsInvoker","invokerFn","craftInvokerFunction","getTypeConverters","unregisteredTypes","registered","dt","whenDependentTypesAreResolved","_embind_register_integer","fromWireType","bitshift","isUnsignedType","checkAssertions","toTypeName","_embind_register_memory_view","dataTypeIndex","TA","decodeMemoryView","data","_embind_register_std_string","stdStringIsUTF8","payload","decodeStartPtr","currentBytePtr","stringSegment","a","ArrayBuffer","valueIsOfTypeString","Uint8ClampedArray","lengthBytesUTF8","base","_malloc","heap","outIdx","startIdx","u","stringToUTF8Array","charCode","_embind_register_std_wstring","charSize","decodeString","encodeString","readCharAt","lengthBytesUTF","_embind_register_void","isVoid","_emscripten_get_now_is_monotonic","_emscripten_memcpy_js","dest","num","copyWithin","_emval_as","_emval_call","caller","_emval_call_method","objHandle","_emval_decref","_emval_get_method_caller","kind","emval_lookupTypes","retType","functionBody","offset","params","id","invokerFunction","functionName","_emval_get_module_property","_emval_get_property","key","_emval_incref","_emval_new_array","_emval_new_array_from_memory_view","view","_emval_new_cstring","_emval_new_object","_emval_run_destructors","_emval_set_property","_emval_take_value","arg","emscripten_date_now","Date","emscripten_get_now","emscripten_resize_heap","requestedSize","oldSize","maxHeapSize","alignUp","x","multiple","cutDown","overGrownHeapSize","min","newSize","fd_close","fd","fd_seek","offset_low","offset_high","whence","newOffset","lo","hi","fd_write","iov","iovcnt","pnum","j","invoke_ii","index","a1","_setThrew","invoke_iii","a2","invoke_iiii","a3","invoke_j","dynCall_j","invoke_v","invoke_vi","invoke_vii","invoke_viii","invoke_viiii","a4","receiveInstance","instance","clearInterval","callback","removeRunDependency","setInterval","dep","path","trueModule","instantiateStreaming","catch","createWasm","_emscripten_stack_init","a0","run","doRun","postRun","preRun","setTimeout","librarySymbol","runCaller","keys","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","n","getter","__esModule","d","definition","enumerable","g","call","scriptUrl","location","tagName","toUpperCase","scripts","getElementsByTagName","test","p","proxyMarker","Symbol","createEndpoint","releaseProxy","throwMarker","isObject","transferHandlers","Map","canHandle","serialize","port1","port2","MessageChannel","expose","deserialize","port","start","createProxy","target","serialized","isError","ep","self","addEventListener","ev","fromWireValue","returnValue","parent","reduce","rawValue","proxy","transfers","transferCache","transfer","wireValue","transferables","toWireValue","postMessage","removeEventListener","closeEndPoint","endpoint","isMessagePort","close","throwIfProxyReleased","isReleased","isProxyReleased","Proxy","_target","requestResponseMessage","_thisArg","rawArgumentList","last","processArguments","processed","arr","WeakMap","handler","serializedValue","fill","floor","random","Number","MAX_SAFE_INTEGER","l","msm_promise","initMSModule","opts","fname","dir","document_script","_msm","async","grid_coords","interval","levels","quad_as_tri","msm","getContourLevels","getContourLevelsFloat32","getContourLevelsFloat16","makeContours","makeContoursFloat32","makeContoursFloat16","y","wasm_base_url"],"sourceRoot":""}

package/dist/983.autumnplot-gl.js

@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.apgl=t():e.apgl=t()}(this,()=>(()=>{"use strict";const e=Symbol("Comlink.proxy"),t=Symbol("Comlink.endpoint"),r=Symbol("Comlink.releaseProxy"),s=Symbol("Comlink.thrown"),n=e=>"object"==typeof e&&null!==e||"function"==typeof e,o=new Map([["proxy",{canHandle:t=>n(t)&&t[e],serialize(e){const{port1:t,port2:r}=new MessageChannel;return a(e,t),[r,[r]]},deserialize:e=>(e.start(),f(e,[],undefined))}],["throw",{canHandle:e=>n(e)&&s in e,serialize({value:e}){let t;return t=e instanceof Error?{isError:!0,value:{message:e.message,name:e.name,stack:e.stack}}:{isError:!1,value:e},[t,[]]},deserialize(e){if(e.isError)throw Object.assign(new Error(e.value.message),e.value);throw e.value}}]]);function a(t,r=self){r.addEventListener("message",function n(o){if(!o||!o.data)return;const{id:c,type:f,path:u}=Object.assign({path:[]},o.data),h=(o.data.argumentList||[]).map(v);let m;try{const r=u.slice(0,-1).reduce((e,t)=>e[t],t),s=u.reduce((e,t)=>e[t],t);switch(f){case"GET":m=s;break;case"SET":r[u.slice(-1)[0]]=v(o.data.value),m=!0;break;case"APPLY":m=s.apply(r,h);break;case"CONSTRUCT":m=function(t){return Object.assign(t,{[e]:!0})}(new s(...h));break;case"ENDPOINT":{const{port1:e,port2:r}=new MessageChannel;a(t,r),m=function(e,t){return l.set(e,t),e}(e,[e])}break;case"RELEASE":m=void 0;break;default:return}}catch(e){m={value:e,[s]:0}}Promise.resolve(m).catch(e=>({value:e,[s]:0})).then(e=>{const[t,s]=d(e);r.postMessage(Object.assign(Object.assign({},t),{id:c}),s),"RELEASE"===f&&(r.removeEventListener("message",n),i(r))})}),r.start&&r.start()}function i(e){(function(e){return"MessagePort"===e.constructor.name})(e)&&e.close()}function c(e){if(e)throw new Error("Proxy has been released and is not useable")}function f(e,s=[],n=function(){}){let o=!1;const a=new Proxy(n,{get(t,n){if(c(o),n===r)return()=>h(e,{type:"RELEASE",path:s.map(e=>e.toString())}).then(()=>{i(e),o=!0});if("then"===n){if(0===s.length)return{then:()=>a};const t=h(e,{type:"GET",path:s.map(e=>e.toString())}).then(v);return t.then.bind(t)}return f(e,[...s,n])},set(t,r,n){c(o);const[a,i]=d(n);return h(e,{type:"SET",path:[...s,r].map(e=>e.toString()),value:a},i).then(v)},apply(r,n,a){c(o);const i=s[s.length-1];if(i===t)return h(e,{type:"ENDPOINT"}).then(v);if("bind"===i)return f(e,s.slice(0,-1));const[l,d]=u(a);return h(e,{type:"APPLY",path:s.map(e=>e.toString()),argumentList:l},d).then(v)},construct(t,r){c(o);const[n,a]=u(r);return h(e,{type:"CONSTRUCT",path:s.map(e=>e.toString()),argumentList:n},a).then(v)}});return a}function u(e){const t=e.map(d);return[t.map(e=>e[0]),(r=t.map(e=>e[1]),Array.prototype.concat.apply([],r))];var r}const l=new WeakMap;function d(e){for(const[t,r]of o)if(r.canHandle(e)){const[s,n]=r.serialize(e);return[{type:"HANDLER",name:t,value:s},n]}return[{type:"RAW",value:e},l.get(e)||[]]}function v(e){switch(e.type){case"HANDLER":return o.get(e.name).deserialize(e.value);case"RAW":return e.value}}function h(e,t,r){return new Promise(s=>{const n=new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-");e.addEventListener("message",function t(r){r.data&&r.data.id&&r.data.id===n&&(e.removeEventListener("message",t),s(r.data))}),e.start&&e.start(),e.postMessage(Object.assign({id:n},t),r)})}function m(e){const t=Math.sin(e*Math.PI/180),r=(180-90/Math.PI*Math.log((1+t)/(1-t)))/360;return Math.min(1.5,Math.max(-.5,r))}class p{constructor(e,t){if(isNaN(e)||isNaN(t))this.lng=NaN,this.lat=NaN;else if(this.lng=+e,this.lat=+t,this.lat>90||this.lat<-90)throw new Error("Invalid LngLat latitude value: must be between -90 and 90")}toMercatorCoord(){return isNaN(this.lng)||isNaN(this.lng)?{x:NaN,y:NaN}:{x:(e=this.lng,(180+e)/360),y:m(this.lat)};var e}static fromMercatorCoord(e,t){return isNaN(e)||isNaN(t)?new p(NaN,NaN):new p(function(e){return 360*e-180}(e),function(e){return 180*Math.atan(Math.sinh((180-360*e)*Math.PI/180))/Math.PI}(t))}}return a({makeBBElements:function(e,t,r,s,n,o){const a=r.filter(e=>e<=o).length,i=2*a;let c=new Float32Array(2*a),f=new Float32Array(i),u=0,l=0;for(let a=0;a<n;a++)for(let i=0;i<s;i++){const d=a*s+i,v=e[d],h=t[d],m=r[d];if(m>o||void 0===h||void 0===v)continue;const y=new p(h,v).toMercatorCoord();c[u+0]=y.x,c[u+1]=y.y,f[l+0]=Math.min(i/(s-1),.99999)+m,f[l+1]=a/(n-1),u+=2,l+=2}return{pts:c,tex_coords:f}},makeDomainVerticesAndTexCoords:function(e,t,r,s,n,o){const a=new Float32Array(4*(r-1)*(s+1)).fill(0),i=new Float32Array(4*(r-1)*(s+1)).fill(0);let c=0,f=0;for(let u=0;u<r-1;u++)for(let l=0;l<s;l++){const d=u+l*r,v=new p(t[d],e[d]).toMercatorCoord(),h=new p(t[d+1],e[d+1]).toMercatorCoord(),m=u/(r-1)*(1-2*n)+n,y=(u+1)/(r-1)*(1-2*n)+n,g=l/(s-1)*(1-2*o)+o;0==l&&(a[c]=v.x,a[c+1]=v.y,c+=2,i[f]=m,i[f+1]=g,f+=2),a[c]=v.x,a[c+1]=v.y,a[c+2]=h.x,a[c+3]=h.y,c+=4,i[f]=m,i[f+1]=g,i[f+2]=y,i[f+3]=g,f+=4,l==s-1&&(a[c]=h.x,a[c+1]=h.y,c+=2,i[f]=y,i[f+1]=g,f+=2)}return{vertices:a,tex_coords:i}},makePolyLines:function(e){if(0==e.length||0==e[0].vertices.length)return{vertices:new Float32Array([]),extrusion:new Float32Array([])};const t=Object.fromEntries(Object.entries(e[0]).map(([e,t])=>{let r;return r="number"==typeof t||"number"==typeof t[0]?1:t[0].length,[e,r]}));t.extrusion=2,t.vertices+=1;const r=4*e.map(e=>e.vertices.length).reduce((e,t)=>e+t)-2*e.length,s=Object.fromEntries(Object.entries(t).map(([e,t])=>[e,r*t]));let n={vertices:new Float32Array(s.vertices),extrusion:new Float32Array(s.extrusion)};"offsets"in e[0]&&(n.offsets=new Float32Array(s.offsets)),"data"in e[0]&&(n.data=new Float32Array(s.data)),"zoom"in e[0]&&(n.zoom=new Float32Array(s.zoom));let o=Object.fromEntries(Object.keys(s).map(e=>[e,0]));const a=(e,t,r)=>{const s=t[0]-e[0],n=t[1]-e[1],o=Math.hypot(s,n),a=-s/o;return[n/o,r?-a:a]};return e.forEach(e=>{const t=e.vertices.map(e=>{const t=new p(...e).toMercatorCoord();return[t.x,t.y]});if(0==e.vertices.length)return;const r=void 0!==e.offsets,s=void 0!==e.offsets?e.offsets:t;let i,c,f,u=t[0],l=(t[1],s[0]),d=s[1],v=1e-4,[h,m]=a(l,d,!r);n.vertices[o.vertices++]=u[0],n.vertices[o.vertices++]=u[1],n.vertices[o.vertices++]=v,n.extrusion[o.extrusion++]=h,n.extrusion[o.extrusion++]=m;for(let e=1;e<t.length;e++)u=t[e],i=t[e-1],l=s[e],c=s[e-1],[h,m]=a(c,l,!r),f=v,v+=Math.hypot(t[e-1][0]-t[e][0],t[e-1][1]-t[e][1]),n.vertices[o.vertices++]=i[0],n.vertices[o.vertices++]=i[1],n.vertices[o.vertices++]=-f,n.vertices[o.vertices++]=i[0],n.vertices[o.vertices++]=i[1],n.vertices[o.vertices++]=f,n.vertices[o.vertices++]=u[0],n.vertices[o.vertices++]=u[1],n.vertices[o.vertices++]=-v,n.vertices[o.vertices++]=u[0],n.vertices[o.vertices++]=u[1],n.vertices[o.vertices++]=v,n.extrusion[o.extrusion++]=h,n.extrusion[o.extrusion++]=m,n.extrusion[o.extrusion++]=-h,n.extrusion[o.extrusion++]=-m,n.extrusion[o.extrusion++]=h,n.extrusion[o.extrusion++]=m,n.extrusion[o.extrusion++]=-h,n.extrusion[o.extrusion++]=-m;if(n.vertices[o.vertices++]=u[0],n.vertices[o.vertices++]=u[1],n.vertices[o.vertices++]=v,n.extrusion[o.extrusion++]=-h,n.extrusion[o.extrusion++]=-m,void 0!==n.offsets&&void 0!==e.offsets){const t=e.offsets;let r,s=t[0];n.offsets[o.offsets++]=s[0],n.offsets[o.offsets++]=s[1];for(let e=1;e<t.length;e++)s=t[e],r=t[e-1],n.offsets[o.offsets++]=r[0],n.offsets[o.offsets++]=r[1],n.offsets[o.offsets++]=r[0],n.offsets[o.offsets++]=r[1],n.offsets[o.offsets++]=s[0],n.offsets[o.offsets++]=s[1],n.offsets[o.offsets++]=s[0],n.offsets[o.offsets++]=s[1];n.offsets[o.offsets++]=s[0],n.offsets[o.offsets++]=s[1]}if(void 0!==n.data&&void 0!==e.data){const t=e.data;let r,s=t[0];n.data[o.data++]=s;for(let e=1;e<t.length;e++)s=t[e],r=t[e-1],n.data[o.data++]=r,n.data[o.data++]=r,n.data[o.data++]=s,n.data[o.data++]=s;n.data[o.data++]=s}if(void 0!==n.zoom&&void 0!==e.zoom)for(let r=0;r<4*t.length-2;r++)n.zoom[o.zoom++]=e.zoom}),n}}),{}})());
+//# sourceMappingURL=983.autumnplot-gl.js.map