mediainfo-node/lib/MediaInfoWasm.js

nodeJS mediainfo port

var fetch = undefined;
var MediaInfoLib = (function () {
  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;
  return (
    function (MediaInfoLib) {
      MediaInfoLib = MediaInfoLib || {};

      var Module = typeof MediaInfoLib !== 'undefined' ? MediaInfoLib : {};var readyPromiseResolve, readyPromiseReject;Module.ready = new Promise(function (resolve, reject) {readyPromiseResolve = resolve;readyPromiseReject = reject;});var moduleOverrides = {};var key;for (key in Module) {if (Module.hasOwnProperty(key)) {moduleOverrides[key] = Module[key];}} var arguments_ = [];var thisProgram = './this.program';var quit_ = function (status, toThrow) {throw toThrow;};var ENVIRONMENT_IS_WEB = typeof window === 'object';var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string';var scriptDirectory = '';function locateFile(path) {if (Module.locateFile) {return Module.locateFile(path, scriptDirectory);} return scriptDirectory + path;} var read_, readAsync, readBinary, setWindowTitle;function logExceptionOnExit(e) {if (e instanceof ExitStatus) return;var toLog = e;err('exiting due to exception: ' + toLog);} var nodeFS;var nodePath;if (ENVIRONMENT_IS_NODE) {if (ENVIRONMENT_IS_WORKER) {scriptDirectory = require('path').dirname(scriptDirectory) + '/';} else {scriptDirectory = __dirname + '/';}read_ = function shell_read(filename, binary) {if (!nodeFS)nodeFS = require('fs');if (!nodePath)nodePath = require('path');filename = nodePath.normalize(filename);return nodeFS.readFileSync(filename, binary ? null : 'utf8');};readBinary = function readBinary(filename) {var ret = read_(filename, true);if (!ret.buffer) {ret = new Uint8Array(ret);}assert(ret.buffer);return ret;};readAsync = function readAsync(filename, onload, onerror) {if (!nodeFS)nodeFS = require('fs');if (!nodePath)nodePath = require('path');filename = nodePath.normalize(filename);nodeFS.readFile(filename, function (err, data) {if (err)onerror(err);else onload(data.buffer);});};if (process.argv.length > 1) {thisProgram = process.argv[1].replace(/\\/g, '/');}arguments_ = process.argv.slice(2);process.on('uncaughtException', function (ex) {if (!(ex instanceof ExitStatus)) {throw ex;}});process.on('unhandledRejection', function (reason) {throw reason;});quit_ = function (status, toThrow) {if (keepRuntimeAlive()) {process.exitCode = status;throw toThrow;}logExceptionOnExit(toThrow);process.exit(status);};Module.inspect = function () {return '[Emscripten Module object]';};} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {if (ENVIRONMENT_IS_WORKER) {scriptDirectory = self.location.href;} else if (typeof document !== 'undefined' && document.currentScript) {scriptDirectory = document.currentScript.src;} if (_scriptDir) {scriptDirectory = _scriptDir;} if (scriptDirectory.indexOf('blob:') !== 0) {scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1);} else {scriptDirectory = '';} {read_ = function (url) {var xhr = new XMLHttpRequest;xhr.open('GET', url, false);xhr.send(null);return xhr.responseText;};if (ENVIRONMENT_IS_WORKER) {readBinary = function (url) {var xhr = new XMLHttpRequest;xhr.open('GET', url, false);xhr.responseType = 'arraybuffer';xhr.send(null);return new Uint8Array(xhr.response);};}readAsync = function (url, onload, onerror) {var xhr = new XMLHttpRequest;xhr.open('GET', url, true);xhr.responseType = 'arraybuffer';xhr.onload = function () {if (xhr.status == 200 || xhr.status == 0 && xhr.response) {onload(xhr.response);return;}onerror();};xhr.onerror = onerror;xhr.send(null);};}setWindowTitle = function (title) {document.title = title;};} else {} var out = Module.print || console.log.bind(console);var err = Module.printErr || console.warn.bind(console);for (key in moduleOverrides) {if (moduleOverrides.hasOwnProperty(key)) {Module[key] = moduleOverrides[key];}}moduleOverrides = null;if (Module.arguments)arguments_ = Module.arguments;if (Module.thisProgram)thisProgram = Module.thisProgram;if (Module.quit)quit_ = Module.quit;var wasmBinary;if (Module.wasmBinary)wasmBinary = Module.wasmBinary;var noExitRuntime = Module.noExitRuntime || true;if (typeof WebAssembly !== 'object') {abort('no native wasm support detected');} var wasmMemory;var ABORT = false;var EXITSTATUS;function assert(condition, text) {if (!condition) {abort('Assertion failed: ' + text);}} var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;function UTF8ArrayToString(heap, idx, maxBytesToRead) {var endIdx = idx + maxBytesToRead;var endPtr = idx;while (heap[endPtr] && !(endPtr >= endIdx))++endPtr;if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {return UTF8Decoder.decode(heap.subarray(idx, endPtr));} else {var str = '';while (idx < endPtr) {var u0 = heap[idx++];if (!(u0 & 128)) {str += String.fromCharCode(u0);continue;} var u1 = heap[idx++] & 63;if ((u0 & 224) == 192) {str += String.fromCharCode((u0 & 31) << 6 | u1);continue;} var u2 = heap[idx++] & 63;if ((u0 & 240) == 224) {u0 = (u0 & 15) << 12 | u1 << 6 | u2;} else {u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++] & 63;} if (u0 < 65536) {str += String.fromCharCode(u0);} else {var ch = u0 - 65536;str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);}}} return str;} function UTF8ToString(ptr, maxBytesToRead) {return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';} function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {if (!(maxBytesToWrite > 0)) return 0;var startIdx = outIdx;var endIdx = outIdx + maxBytesToWrite - 1;for (var i = 0;i < str.length;++i) {var u = str.charCodeAt(i);if (u >= 55296 && u <= 57343) {var u1 = str.charCodeAt(++i);u = 65536 + ((u & 1023) << 10) | u1 & 1023;} if (u <= 127) {if (outIdx >= endIdx) break;heap[outIdx++] = u;} else if (u <= 2047) {if (outIdx + 1 >= endIdx) break;heap[outIdx++] = 192 | u >> 6;heap[outIdx++] = 128 | u & 63;} else if (u <= 65535) {if (outIdx + 2 >= endIdx) break;heap[outIdx++] = 224 | u >> 12;heap[outIdx++] = 128 | u >> 6 & 63;heap[outIdx++] = 128 | u & 63;} else {if (outIdx + 3 >= endIdx) break;heap[outIdx++] = 240 | u >> 18;heap[outIdx++] = 128 | u >> 12 & 63;heap[outIdx++] = 128 | u >> 6 & 63;heap[outIdx++] = 128 | u & 63;}}heap[outIdx] = 0;return outIdx - startIdx;} function stringToUTF8(str, outPtr, maxBytesToWrite) {return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);} function lengthBytesUTF8(str) {var len = 0;for (var i = 0;i < str.length;++i) {var u = str.charCodeAt(i);if (u >= 55296 && u <= 57343)u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;if (u <= 127)++len;else if (u <= 2047)len += 2;else if (u <= 65535)len += 3;else len += 4;} return len;} var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;function UTF16ToString(ptr, maxBytesToRead) {var endPtr = ptr;var idx = endPtr >> 1;var maxIdx = idx + maxBytesToRead / 2;while (!(idx >= maxIdx) && HEAPU16[idx])++idx;endPtr = idx << 1;if (endPtr - ptr > 32 && UTF16Decoder) {return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));} else {var str = '';for (var i = 0;!(i >= maxBytesToRead / 2);++i) {var codeUnit = HEAP16[ptr + i * 2 >> 1];if (codeUnit == 0) break;str += String.fromCharCode(codeUnit);} return str;}} function stringToUTF16(str, outPtr, maxBytesToWrite) {if (maxBytesToWrite === undefined) {maxBytesToWrite = 2147483647;} if (maxBytesToWrite < 2) return 0;maxBytesToWrite -= 2;var startPtr = outPtr;var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;for (var i = 0;i < numCharsToWrite;++i) {var codeUnit = str.charCodeAt(i);HEAP16[outPtr >> 1] = codeUnit;outPtr += 2;}HEAP16[outPtr >> 1] = 0;return outPtr - startPtr;} function lengthBytesUTF16(str) {return str.length * 2;} function UTF32ToString(ptr, maxBytesToRead) {var i = 0;var str = '';while (!(i >= maxBytesToRead / 4)) {var utf32 = HEAP32[ptr + i * 4 >> 2];if (utf32 == 0) break;++i;if (utf32 >= 65536) {var ch = utf32 - 65536;str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);} else {str += String.fromCharCode(utf32);}} return str;} function stringToUTF32(str, outPtr, maxBytesToWrite) {if (maxBytesToWrite === undefined) {maxBytesToWrite = 2147483647;} if (maxBytesToWrite < 4) return 0;var startPtr = outPtr;var endPtr = startPtr + maxBytesToWrite - 4;for (var i = 0;i < str.length;++i) {var codeUnit = str.charCodeAt(i);if (codeUnit >= 55296 && codeUnit <= 57343) {var trailSurrogate = str.charCodeAt(++i);codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;}HEAP32[outPtr >> 2] = codeUnit;outPtr += 4;if (outPtr + 4 > endPtr) break;}HEAP32[outPtr >> 2] = 0;return outPtr - startPtr;} function lengthBytesUTF32(str) {var len = 0;for (var i = 0;i < str.length;++i) {var codeUnit = str.charCodeAt(i);if (codeUnit >= 55296 && codeUnit <= 57343)++i;len += 4;} return len;} function allocateUTF8(str) {var size = lengthBytesUTF8(str) + 1;var ret = _malloc(size);if (ret)stringToUTF8Array(str, HEAP8, ret, size);return ret;} function writeArrayToMemory(array, buffer) {HEAP8.set(array, buffer);} function writeAsciiToMemory(str, buffer, dontAddNull) {for (var i = 0;i < str.length;++i) {HEAP8[buffer++ >> 0] = str.charCodeAt(i);} if (!dontAddNull)HEAP8[buffer >> 0] = 0;} function alignUp(x, multiple) {if (x % multiple > 0) {x += multiple - x % multiple;} return x;} var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;function updateGlobalBufferAndViews(buf) {buffer = buf;Module.HEAP8 = HEAP8 = new Int8Array(buf);Module.HEAP16 = HEAP16 = new Int16Array(buf);Module.HEAP32 = HEAP32 = new Int32Array(buf);Module.HEAPU8 = HEAPU8 = new Uint8Array(buf);Module.HEAPU16 = HEAPU16 = new Uint16Array(buf);Module.HEAPU32 = HEAPU32 = new Uint32Array(buf);Module.HEAPF32 = HEAPF32 = new Float32Array(buf);Module.HEAPF64 = HEAPF64 = new Float64Array(buf);} var INITIAL_MEMORY = Module.INITIAL_MEMORY || 33554432;var wasmTable;var __ATPRERUN__ = [];var __ATINIT__ = [];var __ATPOSTRUN__ = [];var runtimeInitialized = false;var runtimeKeepaliveCounter = 0;function keepRuntimeAlive() {return noExitRuntime || runtimeKeepaliveCounter > 0;} function preRun() {if (Module.preRun) {if (typeof Module.preRun == 'function')Module.preRun = [Module.preRun];while (Module.preRun.length) {addOnPreRun(Module.preRun.shift());}}callRuntimeCallbacks(__ATPRERUN__);} function initRuntime() {runtimeInitialized = true;callRuntimeCallbacks(__ATINIT__);} function postRun() {if (Module.postRun) {if (typeof Module.postRun == 'function')Module.postRun = [Module.postRun];while (Module.postRun.length) {addOnPostRun(Module.postRun.shift());}}callRuntimeCallbacks(__ATPOSTRUN__);} function addOnPreRun(cb) {__ATPRERUN__.unshift(cb);} function addOnInit(cb) {__ATINIT__.unshift(cb);} function addOnPostRun(cb) {__ATPOSTRUN__.unshift(cb);} var runDependencies = 0;var runDependencyWatcher = null;var dependenciesFulfilled = null;function addRunDependency(id) {runDependencies++;if (Module.monitorRunDependencies) {Module.monitorRunDependencies(runDependencies);}} function removeRunDependency(id) {runDependencies--;if (Module.monitorRunDependencies) {Module.monitorRunDependencies(runDependencies);} if (runDependencies == 0) {if (runDependencyWatcher !== null) {clearInterval(runDependencyWatcher);runDependencyWatcher = null;} if (dependenciesFulfilled) {var callback = dependenciesFulfilled;dependenciesFulfilled = null;callback();}}}Module.preloadedImages = {};Module.preloadedAudios = {};function abort(what) { {if (Module.onAbort) {Module.onAbort(what);}}what = 'Aborted(' + what + ')';err(what);ABORT = true;EXITSTATUS = 1;what += '. Build with -s ASSERTIONS=1 for more info.';var e = new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e;} var dataURIPrefix = 'data:application/octet-stream;base64,';function isDataURI(filename) {return filename.startsWith(dataURIPrefix);} function isFileURI(filename) {return filename.startsWith('file://');} var wasmBinaryFile;wasmBinaryFile = 'MediaInfoWasm.wasm';if (!isDataURI(wasmBinaryFile)) {wasmBinaryFile = locateFile(wasmBinaryFile);} function getBinary(file) {try {if (file == wasmBinaryFile && wasmBinary) {return new Uint8Array(wasmBinary);} if (readBinary) {return readBinary(file);} else {throw 'both async and sync fetching of the wasm failed';}} catch (err) {abort(err);}} function getBinaryPromise() {if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {if (typeof fetch === 'function' && !isFileURI(wasmBinaryFile)) {return fetch(wasmBinaryFile, { credentials:'same-origin' }).then(function (response) {if (!response.ok) {throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";} return response.arrayBuffer();}).catch(function () {return getBinary(wasmBinaryFile);});} else {if (readAsync) {return new Promise(function (resolve, reject) {readAsync(wasmBinaryFile, function (response) {resolve(new Uint8Array(response));}, reject);});}}} return Promise.resolve().then(function () {return getBinary(wasmBinaryFile);});} function createWasm() {var info = { 'a':asmLibraryArg };function receiveInstance(instance, module) {var exports = instance.exports;Module.asm = exports;wasmMemory = Module.asm.w;updateGlobalBufferAndViews(wasmMemory.buffer);wasmTable = Module.asm.z;addOnInit(Module.asm.x);removeRunDependency('wasm-instantiate');}addRunDependency('wasm-instantiate');function receiveInstantiationResult(result) {receiveInstance(result.instance);} function instantiateArrayBuffer(receiver) {return getBinaryPromise().then(function (binary) {return WebAssembly.instantiate(binary, info);}).then(function (instance) {return instance;}).then(receiver, function (reason) {err('failed to asynchronously prepare wasm: ' + reason);abort(reason);});} function instantiateAsync() {if (!wasmBinary && typeof WebAssembly.instantiateStreaming === 'function' && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch === 'function') {return fetch(wasmBinaryFile, { credentials:'same-origin' }).then(function (response) {var result = WebAssembly.instantiateStreaming(response, info);return result.then(receiveInstantiationResult, function (reason) {err('wasm streaming compile failed: ' + reason);err('falling back to ArrayBuffer instantiation');return instantiateArrayBuffer(receiveInstantiationResult);});});} else {return instantiateArrayBuffer(receiveInstantiationResult);}} if (Module.instantiateWasm) {try {var exports = Module.instantiateWasm(info, receiveInstance);return exports;} catch (e) {err('Module.instantiateWasm callback failed with error: ' + e);return false;}}instantiateAsync().catch(readyPromiseReject);return {};} function callRuntimeCallbacks(callbacks) {while (callbacks.length > 0) {var callback = callbacks.shift();if (typeof callback == 'function') {callback(Module);continue;} var func = callback.func;if (typeof func === 'number') {if (callback.arg === undefined) {wasmTable.get(func)();} else {wasmTable.get(func)(callback.arg);}} else {func(callback.arg === undefined ? null : callback.arg);}}} function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} function getShiftFromSize(size) {switch (size) {case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError('Unknown type size: ' + size);}} function embind_init_charCodes() {var codes = new Array(256);for (var i = 0;i < 256;++i) {codes[i] = String.fromCharCode(i);}embind_charCodes = codes;} var embind_charCodes = undefined;function readLatin1String(ptr) {var ret = '';var c = ptr;while (HEAPU8[c]) {ret += embind_charCodes[HEAPU8[c++]];} return ret;} var awaitingDependencies = {};var registeredTypes = {};var typeDependencies = {};var char_0 = 48;var char_9 = 57;function makeLegalFunctionName(name) {if (undefined === name) {return '_unknown';}name = name.replace(/[^a-zA-Z0-9_]/g, '$');var f = name.charCodeAt(0);if (f >= char_0 && f <= char_9) {return '_' + name;} else {return name;}} function createNamedFunction(name, body) {name = makeLegalFunctionName(name);return new Function('body', 'return function ' + name + '() {\n' + '    "use strict";' + '    return body.apply(this, arguments);\n' + '};\n')(body);} function extendError(baseErrorType, errorName) {var errorClass = createNamedFunction(errorName, function (message) {this.name = errorName;this.message = message;var stack = new Error(message).stack;if (stack !== undefined) {this.stack = this.toString() + '\n' + stack.replace(/^Error(:[^\n]*)?\n/, '');}});errorClass.prototype = Object.create(baseErrorType.prototype);errorClass.prototype.constructor = errorClass;errorClass.prototype.toString = function () {if (this.message === undefined) {return this.name;} else {return this.name + ': ' + this.message;}};return errorClass;} var BindingError = undefined;function throwBindingError(message) {throw new BindingError(message);} var InternalError = undefined;function throwInternalError(message) {throw new InternalError(message);} function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {myTypes.forEach(function (type) {typeDependencies[type] = dependentTypes;});function onComplete(typeConverters) {var myTypeConverters = getTypeConverters(typeConverters);if (myTypeConverters.length !== myTypes.length) {throwInternalError('Mismatched type converter count');} for (var i = 0;i < myTypes.length;++i) {registerType(myTypes[i], myTypeConverters[i]);}} var typeConverters = new Array(dependentTypes.length);var unregisteredTypes = [];var registered = 0;dependentTypes.forEach(function (dt, i) {if (registeredTypes.hasOwnProperty(dt)) {typeConverters[i] = registeredTypes[dt];} else {unregisteredTypes.push(dt);if (!awaitingDependencies.hasOwnProperty(dt)) {awaitingDependencies[dt] = [];}awaitingDependencies[dt].push(function () {typeConverters[i] = registeredTypes[dt];++registered;if (registered === unregisteredTypes.length) {onComplete(typeConverters);}});}});if (0 === unregisteredTypes.length) {onComplete(typeConverters);}} function registerType(rawType, registeredInstance, options) {options = options || {};if (!('argPackAdvance' in registeredInstance)) {throw new TypeError('registerType registeredInstance requires argPackAdvance');} var name = registeredInstance.name;if (!rawType) {throwBindingError('type "' + name + '" must have a positive integer typeid pointer');} if (registeredTypes.hasOwnProperty(rawType)) {if (options.ignoreDuplicateRegistrations) {return;} else {throwBindingError("Cannot register type '" + name + "' twice");}}registeredTypes[rawType] = registeredInstance;delete typeDependencies[rawType];if (awaitingDependencies.hasOwnProperty(rawType)) {var callbacks = awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(function (cb) {cb();});}} function __embind_register_bool(rawType, name, size, trueValue, falseValue) {var shift = getShiftFromSize(size);name = readLatin1String(name);registerType(rawType, { name:name, 'fromWireType':function (wt) {return !!wt;}, 'toWireType':function (destructors, o) {return o ? trueValue : falseValue;}, 'argPackAdvance':8, 'readValueFromPointer':function (pointer) {var heap;if (size === 1) {heap = HEAP8;} else if (size === 2) {heap = HEAP16;} else if (size === 4) {heap = HEAP32;} else {throw new TypeError('Unknown boolean type size: ' + name);} return this.fromWireType(heap[pointer >> shift]);}, destructorFunction:null });} function ClassHandle_isAliasOf(other) {if (!(this instanceof ClassHandle)) {return false;} if (!(other instanceof ClassHandle)) {return false;} var leftClass = this.$$.ptrType.registeredClass;var left = this.$$.ptr;var rightClass = other.$$.ptrType.registeredClass;var right = other.$$.ptr;while (leftClass.baseClass) {left = leftClass.upcast(left);leftClass = leftClass.baseClass;} while (rightClass.baseClass) {right = rightClass.upcast(right);rightClass = rightClass.baseClass;} return leftClass === rightClass && left === right;} function shallowCopyInternalPointer(o) {return { count:o.count, deleteScheduled:o.deleteScheduled, preservePointerOnDelete:o.preservePointerOnDelete, ptr:o.ptr, ptrType:o.ptrType, smartPtr:o.smartPtr, smartPtrType:o.smartPtrType };} function throwInstanceAlreadyDeleted(obj) {function getInstanceTypeName(handle) {return handle.$$.ptrType.registeredClass.name;}throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');} var finalizationGroup = false;function detachFinalizer(handle) {} function runDestructor($$) {if ($$.smartPtr) {$$.smartPtrType.rawDestructor($$.smartPtr);} else {$$.ptrType.registeredClass.rawDestructor($$.ptr);}} function releaseClassHandle($$) {$$.count.value -= 1;var toDelete = 0 === $$.count.value;if (toDelete) {runDestructor($$);}} function attachFinalizer(handle) {if ('undefined' === typeof FinalizationGroup) {attachFinalizer = function (handle) {return handle;};return handle;}finalizationGroup = new FinalizationGroup(function (iter) {for (var result = iter.next();!result.done;result = iter.next()) {var $$ = result.value;if (!$$.ptr) {console.warn('object already deleted: ' + $$.ptr);} else {releaseClassHandle($$);}}});attachFinalizer = function (handle) {finalizationGroup.register(handle, handle.$$, handle.$$);return handle;};detachFinalizer = function (handle) {finalizationGroup.unregister(handle.$$);};return attachFinalizer(handle);} function ClassHandle_clone() {if (!this.$$.ptr) {throwInstanceAlreadyDeleted(this);} if (this.$$.preservePointerOnDelete) {this.$$.count.value += 1;return this;} else {var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { $$:{ value:shallowCopyInternalPointer(this.$$) } }));clone.$$.count.value += 1;clone.$$.deleteScheduled = false;return clone;}} function ClassHandle_delete() {if (!this.$$.ptr) {throwInstanceAlreadyDeleted(this);} if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {throwBindingError('Object already scheduled for deletion');}detachFinalizer(this);releaseClassHandle(this.$$);if (!this.$$.preservePointerOnDelete) {this.$$.smartPtr = undefined;this.$$.ptr = undefined;}} function ClassHandle_isDeleted() {return !this.$$.ptr;} var delayFunction = undefined;var deletionQueue = [];function flushPendingDeletes() {while (deletionQueue.length) {var obj = deletionQueue.pop();obj.$$.deleteScheduled = false;obj.delete();}} function ClassHandle_deleteLater() {if (!this.$$.ptr) {throwInstanceAlreadyDeleted(this);} if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {throwBindingError('Object already scheduled for deletion');}deletionQueue.push(this);if (deletionQueue.length === 1 && delayFunction) {delayFunction(flushPendingDeletes);} this.$$.deleteScheduled = true;return this;} function init_ClassHandle() {ClassHandle.prototype.isAliasOf = ClassHandle_isAliasOf;ClassHandle.prototype.clone = ClassHandle_clone;ClassHandle.prototype.delete = ClassHandle_delete;ClassHandle.prototype.isDeleted = ClassHandle_isDeleted;ClassHandle.prototype.deleteLater = ClassHandle_deleteLater;} function ClassHandle() {} var registeredPointers = {};function ensureOverloadTable(proto, methodName, humanName) {if (undefined === proto[methodName].overloadTable) {var prevFunc = proto[methodName];proto[methodName] = function () {if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ') - expects one of (' + proto[methodName].overloadTable + ')!');} return proto[methodName].overloadTable[arguments.length].apply(this, arguments);};proto[methodName].overloadTable = [];proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;}} function exposePublicSymbol(name, value, numArguments) {if (Module.hasOwnProperty(name)) {if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {throwBindingError("Cannot register public name '" + name + "' twice");}ensureOverloadTable(Module, name, name);if (Module.hasOwnProperty(numArguments)) {throwBindingError('Cannot register multiple overloads of a function with the same number of arguments (' + numArguments + ')!');}Module[name].overloadTable[numArguments] = value;} else {Module[name] = value;if (undefined !== numArguments) {Module[name].numArguments = numArguments;}}} function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {this.name = name;this.constructor = constructor;this.instancePrototype = instancePrototype;this.rawDestructor = rawDestructor;this.baseClass = baseClass;this.getActualType = getActualType;this.upcast = upcast;this.downcast = downcast;this.pureVirtualFunctions = [];} function upcastPointer(ptr, ptrClass, desiredClass) {while (ptrClass !== desiredClass) {if (!ptrClass.upcast) {throwBindingError('Expected null or instance of ' + desiredClass.name + ', got an instance of ' + ptrClass.name);}ptr = ptrClass.upcast(ptr);ptrClass = ptrClass.baseClass;} return ptr;} function constNoSmartPtrRawPointerToWireType(destructors, handle) {if (handle === null) {if (this.isReference) {throwBindingError('null is not a valid ' + this.name);} return 0;} if (!handle.$$) {throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name);} if (!handle.$$.ptr) {throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);} var handleClass = handle.$$.ptrType.registeredClass;var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);return ptr;} function genericPointerToWireType(destructors, handle) {var ptr;if (handle === null) {if (this.isReference) {throwBindingError('null is not a valid ' + this.name);} if (this.isSmartPointer) {ptr = this.rawConstructor();if (destructors !== null) {destructors.push(this.rawDestructor, ptr);} return ptr;} else {return 0;}} if (!handle.$$) {throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name);} if (!handle.$$.ptr) {throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);} if (!this.isConst && handle.$$.ptrType.isConst) {throwBindingError('Cannot convert argument of type ' + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + ' to parameter type ' + this.name);} var handleClass = handle.$$.ptrType.registeredClass;ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);if (this.isSmartPointer) {if (undefined === handle.$$.smartPtr) {throwBindingError('Passing raw pointer to smart pointer is illegal');} switch (this.sharingPolicy) {case 0:if (handle.$$.smartPtrType === this) {ptr = handle.$$.smartPtr;} else {throwBindingError('Cannot convert argument of type ' + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + ' to parameter type ' + this.name);} break;case 1:ptr = handle.$$.smartPtr;break;case 2:if (handle.$$.smartPtrType === this) {ptr = handle.$$.smartPtr;} else {var clonedHandle = handle.clone();ptr = this.rawShare(ptr, __emval_register(function () {clonedHandle.delete();}));if (destructors !== null) {destructors.push(this.rawDestructor, ptr);}} break;default:throwBindingError('Unsupporting sharing policy');}} return ptr;} function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {if (handle === null) {if (this.isReference) {throwBindingError('null is not a valid ' + this.name);} return 0;} if (!handle.$$) {throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name);} if (!handle.$$.ptr) {throwBindingError('Cannot pass deleted object as a pointer of type ' + this.name);} if (handle.$$.ptrType.isConst) {throwBindingError('Cannot convert argument of type ' + handle.$$.ptrType.name + ' to parameter type ' + this.name);} var handleClass = handle.$$.ptrType.registeredClass;var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);return ptr;} function simpleReadValueFromPointer(pointer) {return this.fromWireType(HEAPU32[pointer >> 2]);} function RegisteredPointer_getPointee(ptr) {if (this.rawGetPointee) {ptr = this.rawGetPointee(ptr);} return ptr;} function RegisteredPointer_destructor(ptr) {if (this.rawDestructor) {this.rawDestructor(ptr);}} function RegisteredPointer_deleteObject(handle) {if (handle !== null) {handle.delete();}} function downcastPointer(ptr, ptrClass, desiredClass) {if (ptrClass === desiredClass) {return ptr;} if (undefined === desiredClass.baseClass) {return null;} var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);if (rv === null) {return null;} return desiredClass.downcast(rv);} function getInheritedInstanceCount() {return Object.keys(registeredInstances).length;} function getLiveInheritedInstances() {var rv = [];for (var k in registeredInstances) {if (registeredInstances.hasOwnProperty(k)) {rv.push(registeredInstances[k]);}} return rv;} function setDelayFunction(fn) {delayFunction = fn;if (deletionQueue.length && delayFunction) {delayFunction(flushPendingDeletes);}} function init_embind() {Module.getInheritedInstanceCount = getInheritedInstanceCount;Module.getLiveInheritedInstances = getLiveInheritedInstances;Module.flushPendingDeletes = flushPendingDeletes;Module.setDelayFunction = setDelayFunction;} var registeredInstances = {};function getBasestPointer(class_, ptr) {if (ptr === undefined) {throwBindingError('ptr should not be undefined');} while (class_.baseClass) {ptr = class_.upcast(ptr);class_ = class_.baseClass;} return ptr;} function getInheritedInstance(class_, ptr) {ptr = getBasestPointer(class_, ptr);return registeredInstances[ptr];} function makeClassHandle(prototype, record) {if (!record.ptrType || !record.ptr) {throwInternalError('makeClassHandle requires ptr and ptrType');} var hasSmartPtrType = !!record.smartPtrType;var hasSmartPtr = !!record.smartPtr;if (hasSmartPtrType !== hasSmartPtr) {throwInternalError('Both smartPtrType and smartPtr must be specified');}record.count = { value:1 };return attachFinalizer(Object.create(prototype, { $$:{ value:record } }));} function RegisteredPointer_fromWireType(ptr) {var rawPointer = this.getPointee(ptr);if (!rawPointer) {this.destructor(ptr);return null;} var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);if (undefined !== registeredInstance) {if (0 === registeredInstance.$$.count.value) {registeredInstance.$$.ptr = rawPointer;registeredInstance.$$.smartPtr = ptr;return registeredInstance.clone();} else {var rv = registeredInstance.clone();this.destructor(ptr);return rv;}} function makeDefaultHandle() {if (this.isSmartPointer) {return makeClassHandle(this.registeredClass.instancePrototype, { ptrType:this.pointeeType, ptr:rawPointer, smartPtrType:this, smartPtr:ptr });} else {return makeClassHandle(this.registeredClass.instancePrototype, { ptrType:this, ptr:ptr });}} var actualType = this.registeredClass.getActualType(rawPointer);var registeredPointerRecord = registeredPointers[actualType];if (!registeredPointerRecord) {return makeDefaultHandle.call(this);} var toType;if (this.isConst) {toType = registeredPointerRecord.constPointerType;} else {toType = registeredPointerRecord.pointerType;} var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);if (dp === null) {return makeDefaultHandle.call(this);} if (this.isSmartPointer) {return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType:toType, ptr:dp, smartPtrType:this, smartPtr:ptr });} else {return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType:toType, ptr:dp });}} function init_RegisteredPointer() {RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;RegisteredPointer.prototype.argPackAdvance = 8;RegisteredPointer.prototype.readValueFromPointer = simpleReadValueFromPointer;RegisteredPointer.prototype.deleteObject = RegisteredPointer_deleteObject;RegisteredPointer.prototype.fromWireType = RegisteredPointer_fromWireType;} function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {this.name = name;this.registeredClass = registeredClass;this.isReference = isReference;this.isConst = isConst;this.isSmartPointer = isSmartPointer;this.pointeeType = pointeeType;this.sharingPolicy = sharingPolicy;this.rawGetPointee = rawGetPointee;this.rawConstructor = rawConstructor;this.rawShare = rawShare;this.rawDestructor = rawDestructor;if (!isSmartPointer && registeredClass.baseClass === undefined) {if (isConst) {this.toWireType = constNoSmartPtrRawPointerToWireType;this.destructorFunction = null;} else {this.toWireType = nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction = null;}} else {this.toWireType = genericPointerToWireType;}} function replacePublicSymbol(name, value, numArguments) {if (!Module.hasOwnProperty(name)) {throwInternalError('Replacing nonexistant public symbol');} if (undefined !== Module[name].overloadTable && undefined !== numArguments) {Module[name].overloadTable[numArguments] = value;} else {Module[name] = value;Module[name].argCount = numArguments;}} function dynCallLegacy(sig, ptr, args) {var f = Module['dynCall_' + sig];return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);} function dynCall(sig, ptr, args) {if (sig.includes('j')) {return dynCallLegacy(sig, ptr, args);} return wasmTable.get(ptr).apply(null, args);} function getDynCaller(sig, ptr) {var argCache = [];return function () {argCache.length = arguments.length;for (var i = 0;i < arguments.length;i++) {argCache[i] = arguments[i];} return dynCall(sig, ptr, argCache);};} function embind__requireFunction(signature, rawFunction) {signature = readLatin1String(signature);function makeDynCaller() {if (signature.includes('j')) {return getDynCaller(signature, rawFunction);} return wasmTable.get(rawFunction);} var fp = makeDynCaller();if (typeof fp !== 'function') {throwBindingError('unknown function pointer with signature ' + signature + ': ' + rawFunction);} return fp;} var UnboundTypeError = undefined;function getTypeName(type) {var ptr = ___getTypeName(type);var rv = readLatin1String(ptr);_free(ptr);return rv;} function throwUnboundTypeError(message, types) {var unboundTypes = [];var seen = {};function visit(type) {if (seen[type]) {return;} if (registeredTypes[type]) {return;} if (typeDependencies[type]) {typeDependencies[type].forEach(visit);return;}unboundTypes.push(type);seen[type] = true;}types.forEach(visit);throw new UnboundTypeError(message + ': ' + unboundTypes.map(getTypeName).join([', ']));} function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {name = readLatin1String(name);getActualType = embind__requireFunction(getActualTypeSignature, getActualType);if (upcast) {upcast = embind__requireFunction(upcastSignature, upcast);} if (downcast) {downcast = embind__requireFunction(downcastSignature, downcast);}rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);var legalFunctionName = makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName, function () {throwUnboundTypeError('Cannot construct ' + name + ' due to unbound types', [baseClassRawType]);});whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function (base) {base = base[0];var baseClass;var basePrototype;if (baseClassRawType) {baseClass = base.registeredClass;basePrototype = baseClass.instancePrototype;} else {basePrototype = ClassHandle.prototype;} var constructor = createNamedFunction(legalFunctionName, function () {if (Object.getPrototypeOf(this) !== instancePrototype) {throw new BindingError("Use 'new' to construct " + name);} if (undefined === registeredClass.constructor_body) {throw new BindingError(name + ' has no accessible constructor');} var body = registeredClass.constructor_body[arguments.length];if (undefined === body) {throw new BindingError('Tried to invoke ctor of ' + name + ' with invalid number of parameters (' + arguments.length + ') - expected (' + Object.keys(registeredClass.constructor_body).toString() + ') parameters instead!');} return body.apply(this, arguments);});var instancePrototype = Object.create(basePrototype, { constructor:{ value:constructor } });constructor.prototype = instancePrototype;var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);var pointerConverter = new RegisteredPointer(name + '*', registeredClass, false, false, false);var constPointerConverter = new RegisteredPointer(name + ' const*', registeredClass, false, true, false);registeredPointers[rawType] = { pointerType:pointerConverter, constPointerType:constPointerConverter };replacePublicSymbol(legalFunctionName, constructor);return [referenceConverter, pointerConverter, constPointerConverter];});} function new_(constructor, argumentList) {if (!(constructor instanceof Function)) {throw new TypeError('new_ called with constructor type ' + typeof constructor + ' which is not a function');} var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function () {});dummy.prototype = constructor.prototype;var obj = new dummy;var r = constructor.apply(obj, argumentList);return r instanceof Object ? r : obj;} function runDestructors(destructors) {while (destructors.length) {var ptr = destructors.pop();var del = destructors.pop();del(ptr);}} function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {var argCount = argTypes.length;if (argCount < 2) {throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");} var isClassMethodFunc = argTypes[1] !== null && classType !== null;var needsDestructorStack = false;for (var i = 1;i < argTypes.length;++i) {if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {needsDestructorStack = true;break;}} var returns = argTypes[0].name !== 'void';var argsList = '';var argsListWired = '';for (var i = 0;i < argCount - 2;++i) {argsList += (i !== 0 ? ', ' : '') + 'arg' + i;argsListWired += (i !== 0 ? ', ' : '') + 'arg' + i + 'Wired';} var invokerFnBody = 'return function ' + makeLegalFunctionName(humanName) + '(' + argsList + ') {\n' + 'if (arguments.length !== ' + (argCount - 2) + ') {\n' + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + '}\n';if (needsDestructorStack) {invokerFnBody += 'var destructors = [];\n';} var dtorStack = needsDestructorStack ? 'destructors' : 'null';var args1 = ['throwBindingError', 'invoker', 'fn', 'runDestructors', 'retType', 'classParam'];var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];if (isClassMethodFunc) {invokerFnBody += 'var thisWired = classParam.toWireType(' + dtorStack + ', this);\n';} for (var i = 0;i < argCount - 2;++i) {invokerFnBody += 'var arg' + i + 'Wired = argType' + i + '.toWireType(' + dtorStack + ', arg' + i + '); // ' + argTypes[i + 2].name + '\n';args1.push('argType' + i);args2.push(argTypes[i + 2]);} if (isClassMethodFunc) {argsListWired = 'thisWired' + (argsListWired.length > 0 ? ', ' : '') + argsListWired;}invokerFnBody += (returns ? 'var rv = ' : '') + 'invoker(fn' + (argsListWired.length > 0 ? ', ' : '') + argsListWired + ');\n';if (needsDestructorStack) {invokerFnBody += 'runDestructors(destructors);\n';} else {for (var i = isClassMethodFunc ? 1 : 2;i < argTypes.length;++i) {var paramName = i === 1 ? 'thisWired' : 'arg' + (i - 2) + 'Wired';if (argTypes[i].destructorFunction !== null) {invokerFnBody += paramName + '_dtor(' + paramName + '); // ' + argTypes[i].name + '\n';args1.push(paramName + '_dtor');args2.push(argTypes[i].destructorFunction);}}} if (returns) {invokerFnBody += 'var ret = retType.fromWireType(rv);\n' + 'return ret;\n';} else {}invokerFnBody += '}\n';args1.push(invokerFnBody);var invokerFunction = new_(Function, args1).apply(null, args2);return invokerFunction;} function heap32VectorToArray(count, firstElement) {var array = [];for (var i = 0;i < count;i++) {array.push(HEAP32[(firstElement >> 2) + i]);} return array;} function __embind_register_class_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn) {var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);methodName = readLatin1String(methodName);rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);whenDependentTypesAreResolved([], [rawClassType], function (classType) {classType = classType[0];var humanName = classType.name + '.' + methodName;function unboundTypesHandler() {throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes);} if (methodName.startsWith('@@')) {methodName = Symbol[methodName.substring(2)];} var proto = classType.registeredClass.constructor;if (undefined === proto[methodName]) {unboundTypesHandler.argCount = argCount - 1;proto[methodName] = unboundTypesHandler;} else {ensureOverloadTable(proto, methodName, humanName);proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler;}whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));var func = craftInvokerFunction(humanName, invokerArgsArray, null, rawInvoker, fn);if (undefined === proto[methodName].overloadTable) {func.argCount = argCount - 1;proto[methodName] = func;} else {proto[methodName].overloadTable[argCount - 1] = func;} return [];});return [];});} function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {assert(argCount > 0);var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);invoker = embind__requireFunction(invokerSignature, invoker);whenDependentTypesAreResolved([], [rawClassType], function (classType) {classType = classType[0];var humanName = 'constructor ' + classType.name;if (undefined === classType.registeredClass.constructor_body) {classType.registeredClass.constructor_body = [];} if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) {throw new BindingError('Cannot register multiple constructors with identical number of parameters (' + (argCount - 1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!");}classType.registeredClass.constructor_body[argCount - 1] = function unboundTypeHandler() {throwUnboundTypeError('Cannot construct ' + classType.name + ' due to unbound types', rawArgTypes);};whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {argTypes.splice(1, 0, null);classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);return [];});return [];});} function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual) {var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);methodName = readLatin1String(methodName);rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);whenDependentTypesAreResolved([], [rawClassType], function (classType) {classType = classType[0];var humanName = classType.name + '.' + methodName;if (methodName.startsWith('@@')) {methodName = Symbol[methodName.substring(2)];} if (isPureVirtual) {classType.registeredClass.pureVirtualFunctions.push(methodName);} function unboundTypesHandler() {throwUnboundTypeError('Cannot call ' + humanName + ' due to unbound types', rawArgTypes);} var proto = classType.registeredClass.instancePrototype;var method = proto[methodName];if (undefined === method || undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) {unboundTypesHandler.argCount = argCount - 2;unboundTypesHandler.className = classType.name;proto[methodName] = unboundTypesHandler;} else {ensureOverloadTable(proto, methodName, humanName);proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;}whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context);if (undefined === proto[methodName].overloadTable) {memberFunction.argCount = argCount - 2;proto[methodName] = memberFunction;} else {proto[methodName].overloadTable[argCount - 2] = memberFunction;} return [];});return [];});} var emval_free_list = [];var emval_handle_array = [{}, { value:undefined }, { value:null }, { value:true }, { value:false }];function __emval_decref(handle) {if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {emval_handle_array[handle] = undefined;emval_free_list.push(handle);}} function count_emval_handles() {var count = 0;for (var i = 5;i < emval_handle_array.length;++i) {if (emval_handle_array[i] !== undefined) {++count;}} return count;} function get_first_emval() {for (var i = 5;i < emval_handle_array.length;++i) {if (emval_handle_array[i] !== undefined) {return emval_handle_array[i];}} return null;} function init_emval() {Module.count_emval_handles = count_emval_handles;Module.get_first_emval = get_first_emval;} function __emval_register(value) {switch (value) {case undefined:{return 1;} case null:{return 2;} case true:{return 3;} case false:{return 4;} default:{var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;emval_handle_array[handle] = { refcount:1, value:value };return handle;}}} function __embind_register_emval(rawType, name) {name = readLatin1String(name);registerType(rawType, { name:name, 'fromWireType':function (handle) {var rv = emval_handle_array[handle].value;__emval_decref(handle);return rv;}, 'toWireType':function (destructors, value) {return __emval_register(value);}, 'argPackAdvance':8, 'readValueFromPointer':simpleReadValueFromPointer, destructorFunction:null });} function enumReadValueFromPointer(name, shift, signed) {switch (shift) {case 0:return function (pointer) {var heap = signed ? HEAP8 : HEAPU8;return this.fromWireType(heap[pointer]);};case 1:return function (pointer) {var heap = signed ? HEAP16 : HEAPU16;return this.fromWireType(heap[pointer >> 1]);};case 2:return function (pointer) {var heap = signed ? HEAP32 : HEAPU32;return this.fromWireType(heap[pointer >> 2]);};default:throw new TypeError('Unknown integer type: ' + name);}} function __embind_register_enum(rawType, name, size, isSigned) {var shift = getShiftFromSize(size);name = readLatin1String(name);function ctor() {}ctor.values = {};registerType(rawType, { name:name, constructor:ctor, 'fromWireType':function (c) {return this.constructor.values[c];}, 'toWireType':function (destructors, c) {return c.value;}, 'argPackAdvance':8, 'readValueFromPointer':enumReadValueFromPointer(name, shift, isSigned), destructorFunction:null });exposePublicSymbol(name, ctor);} function requireRegisteredType(rawType, humanName) {var impl = registeredTypes[rawType];if (undefined === impl) {throwBindingError(humanName + ' has unknown type ' + getTypeName(rawType));} return impl;} function __embind_register_enum_value(rawEnumType, name, enumValue) {var enumType = requireRegisteredType(rawEnumType, 'enum');name = readLatin1String(name);var Enum = enumType.constructor;var Value = Object.create(enumType.constructor.prototype, { value:{ value:enumValue }, constructor:{ value:createNamedFunction(enumType.name + '_' + name, function () {}) } });Enum.values[enumValue] = Value;Enum[name] = Value;} function _embind_repr(v) {if (v === null) {return 'null';} var t = typeof v;if (t === 'object' || t === 'array' || t === 'function') {return v.toString();} else {return '' + v;}} function floatReadValueFromPointer(name, shift) {switch (shift) {case 2:return function (pointer) {return this.fromWireType(HEAPF32[pointer >> 2]);};case 3:return function (pointer) {return this.fromWireType(HEAPF64[pointer >> 3]);};default:throw new TypeError('Unknown float type: ' + name);}} function __embind_register_float(rawType, name, size) {var shift = getShiftFromSize(size);name = readLatin1String(name);registerType(rawType, { name:name, 'fromWireType':function (value) {return value;}, 'toWireType':function (destructors, value) {if (typeof value !== 'number' && typeof value !== 'boolean') {throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);} return value;}, 'argPackAdvance':8, 'readValueFromPointer':floatReadValueFromPointer(name, shift), destructorFunction:null });} function integerReadValueFromPointer(name, shift, signed) {switch (shift) {case 0:return signed ? function readS8FromPointer(pointer) {return HEAP8[pointer];} : function readU8FromPointer(pointer) {return HEAPU8[pointer];};case 1:return signed ? function readS16FromPointer(pointer) {return HEAP16[pointer >> 1];} : function readU16FromPointer(pointer) {return HEAPU16[pointer >> 1];};case 2:return signed ? function readS32FromPointer(pointer) {return HEAP32[pointer >> 2];} : function readU32FromPointer(pointer) {return HEAPU32[pointer >> 2];};default:throw new TypeError('Unknown integer type: ' + name);}} function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {name = readLatin1String(name);if (maxRange === -1) {maxRange = 4294967295;} var shift = getShiftFromSize(size);var fromWireType = function (value) {return value;};if (minRange === 0) {var bitshift = 32 - 8 * size;fromWireType = function (value) {retu