From 26c457f9750fc4a6f3b56c5a6dd3c2e22451603b Mon Sep 17 00:00:00 2001 From: Wesley Maa <57124298+WT-MM@users.noreply.github.com> Date: Thu, 26 Sep 2024 14:22:22 -0700 Subject: [PATCH] Fix MuJoCo WASM (#420) Co-authored-by: Winston Hsiao --- .gitignore | 4 +- frontend/index.html | 2 +- frontend/public/dist/mujoco_wasm.d.ts | 1872 + frontend/public/dist/mujoco_wasm.js | 15 + frontend/public/dist/mujoco_wasm.wasm | Bin 0 -> 1624797 bytes .../public/node_modules/three/build/three.cjs | 50850 +++++++++++++++ .../public/node_modules/three/build/three.js | 50857 ++++++++++++++++ .../node_modules/three/build/three.min.js | 7 + .../node_modules/three/build/three.module.js | 50441 +++++++++++++++ 9 files changed, 154045 insertions(+), 3 deletions(-) create mode 100644 frontend/public/dist/mujoco_wasm.d.ts create mode 100644 frontend/public/dist/mujoco_wasm.js create mode 100755 frontend/public/dist/mujoco_wasm.wasm create mode 100644 frontend/public/node_modules/three/build/three.cjs create mode 100644 frontend/public/node_modules/three/build/three.js create mode 100644 frontend/public/node_modules/three/build/three.min.js create mode 100644 frontend/public/node_modules/three/build/three.module.js diff --git a/.gitignore b/.gitignore index 04aa77f9..a9569374 100644 --- a/.gitignore +++ b/.gitignore @@ -31,5 +31,5 @@ out*/ !.elasticbeanstalk/*.global.yml # mujoco wasm setup -!/public/dist -!/public/node_modules/three/build +!frontend/public/dist +!/frontend/public/node_modules/three/build diff --git a/frontend/index.html b/frontend/index.html index 23892938..5f261aa6 100644 --- a/frontend/index.html +++ b/frontend/index.html @@ -30,7 +30,7 @@ diff --git a/frontend/public/dist/mujoco_wasm.d.ts b/frontend/public/dist/mujoco_wasm.d.ts new file mode 100644 index 00000000..c8149fc1 --- /dev/null +++ b/frontend/public/dist/mujoco_wasm.d.ts @@ -0,0 +1,1872 @@ +// Type definitions for Emscripten 1.39.16 +// Project: https://emscripten.org +// Definitions by: Kensuke Matsuzaki +// Periklis Tsirakidis +// Bumsik Kim +// Louis DeScioli +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/emscripten/index.d.ts +// TypeScript Version: 2.2 + +/** Other WebAssembly declarations, for compatibility with older versions of Typescript */ +declare namespace WebAssembly { + interface Module {} +} + +declare namespace Emscripten { + interface FileSystemType {} + type EnvironmentType = 'WEB' | 'NODE' | 'SHELL' | 'WORKER'; + + type JSType = 'number' | 'string' | 'array' | 'boolean'; + type TypeCompatibleWithC = number | string | any[] | boolean; + + type CIntType = 'i8' | 'i16' | 'i32' | 'i64'; + type CFloatType = 'float' | 'double'; + type CPointerType = 'i8*' | 'i16*' | 'i32*' | 'i64*' | 'float*' | 'double*' | '*'; + type CType = CIntType | CFloatType | CPointerType; + + type WebAssemblyImports = Array<{ + name: string; + kind: string; + }>; + + type WebAssemblyExports = Array<{ + module: string; + name: string; + kind: string; + }>; + + interface CCallOpts { + async?: boolean | undefined; + } +} + +interface EmscriptenModule { + print(str: string): void; + printErr(str: string): void; + arguments: string[]; + environment: Emscripten.EnvironmentType; + preInit: Array<{ (): void }>; + preRun: Array<{ (): void }>; + postRun: Array<{ (): void }>; + onAbort: { (what: any): void }; + onRuntimeInitialized: { (): void }; + preinitializedWebGLContext: WebGLRenderingContext; + noInitialRun: boolean; + noExitRuntime: boolean; + logReadFiles: boolean; + filePackagePrefixURL: string; + wasmBinary: ArrayBuffer; + + destroy(object: object): void; + getPreloadedPackage(remotePackageName: string, remotePackageSize: number): ArrayBuffer; + instantiateWasm( + imports: Emscripten.WebAssemblyImports, + successCallback: (module: WebAssembly.Module) => void, + ): Emscripten.WebAssemblyExports; + locateFile(url: string, scriptDirectory: string): string; + onCustomMessage(event: MessageEvent): void; + + // USE_TYPED_ARRAYS == 1 + HEAP: Int32Array; + IHEAP: Int32Array; + FHEAP: Float64Array; + + // USE_TYPED_ARRAYS == 2 + HEAP8: Int8Array; + HEAP16: Int16Array; + HEAP32: Int32Array; + HEAPU8: Uint8Array; + HEAPU16: Uint16Array; + HEAPU32: Uint32Array; + HEAPF32: Float32Array; + HEAPF64: Float64Array; + + TOTAL_STACK: number; + TOTAL_MEMORY: number; + FAST_MEMORY: number; + + addOnPreRun(cb: () => any): void; + addOnInit(cb: () => any): void; + addOnPreMain(cb: () => any): void; + addOnExit(cb: () => any): void; + addOnPostRun(cb: () => any): void; + + preloadedImages: any; + preloadedAudios: any; + + _malloc(size: number): number; + _free(ptr: number): void; +} + +/** +* A factory function is generated when setting the `MODULARIZE` build option +* to `1` in your Emscripten build. It return a Promise that resolves to an +* initialized, ready-to-call `EmscriptenModule` instance. +* +* By default, the factory function will be named `Module`. It's recommended to +* use the `EXPORT_ES6` option, in which the factory function will be the +* default export. If used without `EXPORT_ES6`, the factory function will be a +* global variable. You can rename the variable using the `EXPORT_NAME` build +* option. It's left to you to declare any global variables as needed in your +* application's types. +* @param moduleOverrides Default properties for the initialized module. +*/ +type EmscriptenModuleFactory = ( + moduleOverrides?: Partial, +) => Promise; + +declare namespace FS { + interface Lookup { + path: string; + node: FSNode; + } + + interface FSStream {} + interface FSNode {} + interface ErrnoError {} + + let ignorePermissions: boolean; + let trackingDelegate: any; + let tracking: any; + let genericErrors: any; + + // + // paths + // + function lookupPath(path: string, opts: any): Lookup; + function getPath(node: FSNode): string; + + // + // nodes + // + function isFile(mode: number): boolean; + function isDir(mode: number): boolean; + function isLink(mode: number): boolean; + function isChrdev(mode: number): boolean; + function isBlkdev(mode: number): boolean; + function isFIFO(mode: number): boolean; + function isSocket(mode: number): boolean; + + // + // devices + // + function major(dev: number): number; + function minor(dev: number): number; + function makedev(ma: number, mi: number): number; + function registerDevice(dev: number, ops: any): void; + + // + // core + // + function syncfs(populate: boolean, callback: (e: any) => any): void; + function syncfs(callback: (e: any) => any, populate?: boolean): void; + function mount(type: Emscripten.FileSystemType, opts: any, mountpoint: string): any; + function unmount(mountpoint: string): void; + + function mkdir(path: string, mode?: number): any; + function mkdev(path: string, mode?: number, dev?: number): any; + function symlink(oldpath: string, newpath: string): any; + function rename(old_path: string, new_path: string): void; + function rmdir(path: string): void; + function readdir(path: string): any; + function unlink(path: string): void; + function readlink(path: string): string; + function stat(path: string, dontFollow?: boolean): any; + function lstat(path: string): any; + function chmod(path: string, mode: number, dontFollow?: boolean): void; + function lchmod(path: string, mode: number): void; + function fchmod(fd: number, mode: number): void; + function chown(path: string, uid: number, gid: number, dontFollow?: boolean): void; + function lchown(path: string, uid: number, gid: number): void; + function fchown(fd: number, uid: number, gid: number): void; + function truncate(path: string, len: number): void; + function ftruncate(fd: number, len: number): void; + function utime(path: string, atime: number, mtime: number): void; + function open(path: string, flags: string, mode?: number, fd_start?: number, fd_end?: number): FSStream; + function close(stream: FSStream): void; + function llseek(stream: FSStream, offset: number, whence: number): any; + function read(stream: FSStream, buffer: ArrayBufferView, offset: number, length: number, position?: number): number; + function write( + stream: FSStream, + buffer: ArrayBufferView, + offset: number, + length: number, + position?: number, + canOwn?: boolean, + ): number; + function allocate(stream: FSStream, offset: number, length: number): void; + function mmap( + stream: FSStream, + buffer: ArrayBufferView, + offset: number, + length: number, + position: number, + prot: number, + flags: number, + ): any; + function ioctl(stream: FSStream, cmd: any, arg: any): any; + function readFile(path: string, opts: { encoding: 'binary'; flags?: string | undefined }): Uint8Array; + function readFile(path: string, opts: { encoding: 'utf8'; flags?: string | undefined }): string; + function readFile(path: string, opts?: { flags?: string | undefined }): Uint8Array; + function writeFile(path: string, data: string | ArrayBufferView, opts?: { flags?: string | undefined }): void; + + // + // module-level FS code + // + function cwd(): string; + function chdir(path: string): void; + function init( + input: null | (() => number | null), + output: null | ((c: number) => any), + error: null | ((c: number) => any), + ): void; + + function createLazyFile( + parent: string | FSNode, + name: string, + url: string, + canRead: boolean, + canWrite: boolean, + ): FSNode; + function createPreloadedFile( + parent: string | FSNode, + name: string, + url: string, + canRead: boolean, + canWrite: boolean, + onload?: () => void, + onerror?: () => void, + dontCreateFile?: boolean, + canOwn?: boolean, + ): void; + function createDataFile( + parent: string | FSNode, + name: string, + data: ArrayBufferView, + canRead: boolean, + canWrite: boolean, + canOwn: boolean, + ): FSNode; +} + +declare var MEMFS: Emscripten.FileSystemType; +declare var NODEFS: Emscripten.FileSystemType; +declare var IDBFS: Emscripten.FileSystemType; + +// https://emscripten.org/docs/porting/connecting_cpp_and_javascript/Interacting-with-code.html +type StringToType = R extends Emscripten.JSType +? { + number: number; + string: string; + array: number[] | string[] | boolean[] | Uint8Array | Int8Array; + boolean: boolean; + null: null; + }[R] +: never; + +type ArgsToType> = Extract< +{ + [P in keyof T]: StringToType; +}, +any[] +>; + +type ReturnToType = R extends null +? null +: StringToType>; + +// ENUMS +/** disable default feature bitflags */ +export enum mjtDisableBit { + /** entire constraint solver */ + mjDSBL_CONSTRAINT , + /** equality constraints */ + mjDSBL_EQUALITY , + /** joint and tendon frictionloss constraints */ + mjDSBL_FRICTIONLOSS , + /** joint and tendon limit constraints */ + mjDSBL_LIMIT , + /** contact constraints */ + mjDSBL_CONTACT , + /** passive forces */ + mjDSBL_PASSIVE , + /** gravitational forces */ + mjDSBL_GRAVITY , + /** clamp control to specified range */ + mjDSBL_CLAMPCTRL , + /** warmstart constraint solver */ + mjDSBL_WARMSTART , + /** remove collisions with parent body */ + mjDSBL_FILTERPARENT , + /** apply actuation forces */ + mjDSBL_ACTUATION , + /** integrator safety: make ref[0]>=2*timestep */ + mjDSBL_REFSAFE , + /** sensors */ + mjDSBL_SENSOR , + /** number of disable flags */ + mjNDISABLE , +} +/** enable optional feature bitflags */ +export enum mjtEnableBit { + /** override contact parameters */ + mjENBL_OVERRIDE , + /** energy computation */ + mjENBL_ENERGY , + /** record solver statistics */ + mjENBL_FWDINV , + /** add noise to sensor data */ + mjENBL_SENSORNOISE , + /** multi-point convex collision detection */ + mjENBL_MULTICCD , + /** number of enable flags */ + mjNENABLE , +} +/** type of degree of freedom */ +export enum mjtJoint { + /** global position and orientation (quat) (7) */ + mjJNT_FREE , + /** orientation (quat) relative to parent (4) */ + mjJNT_BALL , + /** sliding distance along body-fixed axis (1) */ + mjJNT_SLIDE , + /** rotation angle (rad) around body-fixed axis (1) */ + mjJNT_HINGE , +} +/** type of geometric shape */ +export enum mjtGeom { + /** plane */ + mjGEOM_PLANE , + /** height field */ + mjGEOM_HFIELD , + /** sphere */ + mjGEOM_SPHERE , + /** capsule */ + mjGEOM_CAPSULE , + /** ellipsoid */ + mjGEOM_ELLIPSOID , + /** cylinder */ + mjGEOM_CYLINDER , + /** box */ + mjGEOM_BOX , + /** mesh */ + mjGEOM_MESH , + /** number of regular geom types */ + mjNGEOMTYPES , + /** arrow */ + mjGEOM_ARROW , + /** arrow without wedges */ + mjGEOM_ARROW1 , + /** arrow in both directions */ + mjGEOM_ARROW2 , + /** line */ + mjGEOM_LINE , + /** skin */ + mjGEOM_SKIN , + /** text label */ + mjGEOM_LABEL , + /** missing geom type */ + mjGEOM_NONE , +} +/** tracking mode for camera and light */ +export enum mjtCamLight { + /** pos and rot fixed in body */ + mjCAMLIGHT_FIXED , + /** pos tracks body, rot fixed in global */ + mjCAMLIGHT_TRACK , + /** pos tracks subtree com, rot fixed in body */ + mjCAMLIGHT_TRACKCOM , + /** pos fixed in body, rot tracks target body */ + mjCAMLIGHT_TARGETBODY , + /** pos fixed in body, rot tracks target subtree com */ + mjCAMLIGHT_TARGETBODYCOM , +} +/** type of texture */ +export enum mjtTexture { + /** 2d texture, suitable for planes and hfields */ + mjTEXTURE_2D , + /** cube texture, suitable for all other geom types */ + mjTEXTURE_CUBE , + /** cube texture used as skybox */ + mjTEXTURE_SKYBOX , +} +/** integrator mode */ +export enum mjtIntegrator { + /** semi-implicit Euler */ + mjINT_EULER , + /** 4th-order Runge Kutta */ + mjINT_RK4 , + /** implicit in velocity */ + mjINT_IMPLICIT , +} +/** collision mode for selecting geom pairs */ +export enum mjtCollision { + /** test precomputed and dynamic pairs */ + mjCOL_ALL , + /** test predefined pairs only */ + mjCOL_PAIR , + /** test dynamic pairs only */ + mjCOL_DYNAMIC , +} +/** type of friction cone */ +export enum mjtCone { + /** pyramidal */ + mjCONE_PYRAMIDAL , + /** elliptic */ + mjCONE_ELLIPTIC , +} +/** type of constraint Jacobian */ +export enum mjtJacobian { + /** dense */ + mjJAC_DENSE , + /** sparse */ + mjJAC_SPARSE , + /** dense if nv<60, sparse otherwise */ + mjJAC_AUTO , +} +/** constraint solver algorithm */ +export enum mjtSolver { + /** PGS (dual) */ + mjSOL_PGS , + /** CG (primal) */ + mjSOL_CG , + /** Newton (primal) */ + mjSOL_NEWTON , +} +/** type of equality constraint */ +export enum mjtEq { + /** connect two bodies at a point (ball joint) */ + mjEQ_CONNECT , + /** fix relative position and orientation of two bodies */ + mjEQ_WELD , + /** couple the values of two scalar joints with cubic */ + mjEQ_JOINT , + /** couple the lengths of two tendons with cubic */ + mjEQ_TENDON , + /** unsupported, will cause an error if used */ + mjEQ_DISTANCE , +} +/** type of tendon wrap object */ +export enum mjtWrap { + /** null object */ + mjWRAP_NONE , + /** constant moment arm */ + mjWRAP_JOINT , + /** pulley used to split tendon */ + mjWRAP_PULLEY , + /** pass through site */ + mjWRAP_SITE , + /** wrap around sphere */ + mjWRAP_SPHERE , + /** wrap around (infinite) cylinder */ + mjWRAP_CYLINDER , +} +/** type of actuator transmission */ +export enum mjtTrn { + /** force on joint */ + mjTRN_JOINT , + /** force on joint, expressed in parent frame */ + mjTRN_JOINTINPARENT , + /** force via slider-crank linkage */ + mjTRN_SLIDERCRANK , + /** force on tendon */ + mjTRN_TENDON , + /** force on site */ + mjTRN_SITE , + /** adhesion force on a body's geoms */ + mjTRN_BODY , + /** undefined transmission type */ + mjTRN_UNDEFINED , +} +/** type of actuator dynamics */ +export enum mjtDyn { + /** no internal dynamics; ctrl specifies force */ + mjDYN_NONE , + /** integrator: da/dt = u */ + mjDYN_INTEGRATOR , + /** linear filter: da/dt = (u-a) / tau */ + mjDYN_FILTER , + /** piece-wise linear filter with two time constants */ + mjDYN_MUSCLE , + /** user-defined dynamics type */ + mjDYN_USER , +} +/** type of actuator gain */ +export enum mjtGain { + /** fixed gain */ + mjGAIN_FIXED , + /** const + kp*length + kv*velocity */ + mjGAIN_AFFINE , + /** muscle FLV curve computed by mju_muscleGain() */ + mjGAIN_MUSCLE , + /** user-defined gain type */ + mjGAIN_USER , +} +/** type of actuator bias */ +export enum mjtBias { + /** no bias */ + mjBIAS_NONE , + /** const + kp*length + kv*velocity */ + mjBIAS_AFFINE , + /** muscle passive force computed by mju_muscleBias() */ + mjBIAS_MUSCLE , + /** user-defined bias type */ + mjBIAS_USER , +} +/** type of MujoCo object */ +export enum mjtObj { + /** unknown object type */ + mjOBJ_UNKNOWN , + /** body */ + mjOBJ_BODY , + /** body, used to access regular frame instead of i-frame */ + mjOBJ_XBODY , + /** joint */ + mjOBJ_JOINT , + /** dof */ + mjOBJ_DOF , + /** geom */ + mjOBJ_GEOM , + /** site */ + mjOBJ_SITE , + /** camera */ + mjOBJ_CAMERA , + /** light */ + mjOBJ_LIGHT , + /** mesh */ + mjOBJ_MESH , + /** skin */ + mjOBJ_SKIN , + /** heightfield */ + mjOBJ_HFIELD , + /** texture */ + mjOBJ_TEXTURE , + /** material for rendering */ + mjOBJ_MATERIAL , + /** geom pair to include */ + mjOBJ_PAIR , + /** body pair to exclude */ + mjOBJ_EXCLUDE , + /** equality constraint */ + mjOBJ_EQUALITY , + /** tendon */ + mjOBJ_TENDON , + /** actuator */ + mjOBJ_ACTUATOR , + /** sensor */ + mjOBJ_SENSOR , + /** numeric */ + mjOBJ_NUMERIC , + /** text */ + mjOBJ_TEXT , + /** tuple */ + mjOBJ_TUPLE , + /** keyframe */ + mjOBJ_KEY , + /** plugin instance */ + mjOBJ_PLUGIN , +} +/** type of constraint */ +export enum mjtConstraint { + /** equality constraint */ + mjCNSTR_EQUALITY , + /** dof friction */ + mjCNSTR_FRICTION_DOF , + /** tendon friction */ + mjCNSTR_FRICTION_TENDON , + /** joint limit */ + mjCNSTR_LIMIT_JOINT , + /** tendon limit */ + mjCNSTR_LIMIT_TENDON , + /** frictionless contact */ + mjCNSTR_CONTACT_FRICTIONLESS, + /** frictional contact, pyramidal friction cone */ + mjCNSTR_CONTACT_PYRAMIDAL, + /** frictional contact, elliptic friction cone */ + mjCNSTR_CONTACT_ELLIPTIC , +} +/** constraint state */ +export enum mjtConstraintState { + /** constraint satisfied, zero cost (limit, contact) */ + mjCNSTRSTATE_SATISFIED , + /** quadratic cost (equality, friction, limit, contact) */ + mjCNSTRSTATE_QUADRATIC , + /** linear cost, negative side (friction) */ + mjCNSTRSTATE_LINEARNEG , + /** linear cost, positive side (friction) */ + mjCNSTRSTATE_LINEARPOS , + /** squared distance to cone cost (elliptic contact) */ + mjCNSTRSTATE_CONE , +} +/** type of sensor */ +export enum mjtSensor { + /** scalar contact normal forces summed over sensor zone */ + mjSENS_TOUCH , + /** 3D linear acceleration, in local frame */ + mjSENS_ACCELEROMETER , + /** 3D linear velocity, in local frame */ + mjSENS_VELOCIMETER , + /** 3D angular velocity, in local frame */ + mjSENS_GYRO , + /** 3D force between site's body and its parent body */ + mjSENS_FORCE , + /** 3D torque between site's body and its parent body */ + mjSENS_TORQUE , + /** 3D magnetometer */ + mjSENS_MAGNETOMETER , + /** scalar distance to nearest geom or site along z-axis */ + mjSENS_RANGEFINDER , + /** scalar joint position (hinge and slide only) */ + mjSENS_JOINTPOS , + /** scalar joint velocity (hinge and slide only) */ + mjSENS_JOINTVEL , + /** scalar tendon position */ + mjSENS_TENDONPOS , + /** scalar tendon velocity */ + mjSENS_TENDONVEL , + /** scalar actuator position */ + mjSENS_ACTUATORPOS , + /** scalar actuator velocity */ + mjSENS_ACTUATORVEL , + /** scalar actuator force */ + mjSENS_ACTUATORFRC , + /** 4D ball joint quaternion */ + mjSENS_BALLQUAT , + /** 3D ball joint angular velocity */ + mjSENS_BALLANGVEL , + /** joint limit distance-margin */ + mjSENS_JOINTLIMITPOS , + /** joint limit velocity */ + mjSENS_JOINTLIMITVEL , + /** joint limit force */ + mjSENS_JOINTLIMITFRC , + /** tendon limit distance-margin */ + mjSENS_TENDONLIMITPOS , + /** tendon limit velocity */ + mjSENS_TENDONLIMITVEL , + /** tendon limit force */ + mjSENS_TENDONLIMITFRC , + /** 3D position */ + mjSENS_FRAMEPOS , + /** 4D unit quaternion orientation */ + mjSENS_FRAMEQUAT , + /** 3D unit vector: x-axis of object's frame */ + mjSENS_FRAMEXAXIS , + /** 3D unit vector: y-axis of object's frame */ + mjSENS_FRAMEYAXIS , + /** 3D unit vector: z-axis of object's frame */ + mjSENS_FRAMEZAXIS , + /** 3D linear velocity */ + mjSENS_FRAMELINVEL , + /** 3D angular velocity */ + mjSENS_FRAMEANGVEL , + /** 3D linear acceleration */ + mjSENS_FRAMELINACC , + /** 3D angular acceleration */ + mjSENS_FRAMEANGACC , + /** 3D center of mass of subtree */ + mjSENS_SUBTREECOM , + /** 3D linear velocity of subtree */ + mjSENS_SUBTREELINVEL , + /** 3D angular momentum of subtree */ + mjSENS_SUBTREEANGMOM , + /** simulation time */ + mjSENS_CLOCK , + /** plugin-controlled */ + mjSENS_PLUGIN , + /** sensor data provided by mjcb_sensor callback */ + mjSENS_USER , +} +/** computation stage */ +export enum mjtStage { + /** no computations */ + mjSTAGE_NONE , + /** position-dependent computations */ + mjSTAGE_POS , + /** velocity-dependent computations */ + mjSTAGE_VEL , + /** acceleration/force-dependent computations */ + mjSTAGE_ACC , +} +/** data type for sensors */ +export enum mjtDataType { + /** real values, no constraints */ + mjDATATYPE_REAL , + /** positive values; 0 or negative: inactive */ + mjDATATYPE_POSITIVE , + /** 3D unit vector */ + mjDATATYPE_AXIS , + /** unit quaternion */ + mjDATATYPE_QUATERNION , +} +/** mode for actuator length range computation */ +export enum mjtLRMode { + /** do not process any actuators */ + mjLRMODE_NONE , + /** process muscle actuators */ + mjLRMODE_MUSCLE , + /** process muscle and user actuators */ + mjLRMODE_MUSCLEUSER , + /** process all actuators */ + mjLRMODE_ALL , +} + +export interface Model { + new (filename : string) : Model; + load_from_xml(str: string): Model; + /** Free the memory associated with the model */ + free(): void; + /** Retrive various parameters of the current simulation */ + getOptions(): any; + // MODEL_INTERFACE + /** number of generalized coordinates = dim(qpos)*/ + nq : number; + /** number of degrees of freedom = dim(qvel)*/ + nv : number; + /** number of actuators/controls = dim(ctrl)*/ + nu : number; + /** number of activation states = dim(act)*/ + na : number; + /** number of bodies*/ + nbody : number; + /** number of joints*/ + njnt : number; + /** number of geoms*/ + ngeom : number; + /** number of sites*/ + nsite : number; + /** number of cameras*/ + ncam : number; + /** number of lights*/ + nlight : number; + /** number of meshes*/ + nmesh : number; + /** number of vertices in all meshes*/ + nmeshvert : number; + /** number of vertices with texcoords in all meshes*/ + nmeshtexvert : number; + /** number of triangular faces in all meshes*/ + nmeshface : number; + /** number of ints in mesh auxiliary data*/ + nmeshgraph : number; + /** number of skins*/ + nskin : number; + /** number of vertices in all skins*/ + nskinvert : number; + /** number of vertiex with texcoords in all skins*/ + nskintexvert : number; + /** number of triangular faces in all skins*/ + nskinface : number; + /** number of bones in all skins*/ + nskinbone : number; + /** number of vertices in all skin bones*/ + nskinbonevert : number; + /** number of heightfields*/ + nhfield : number; + /** number of data points in all heightfields*/ + nhfielddata : number; + /** number of textures*/ + ntex : number; + /** number of bytes in texture rgb data*/ + ntexdata : number; + /** number of materials*/ + nmat : number; + /** number of predefined geom pairs*/ + npair : number; + /** number of excluded geom pairs*/ + nexclude : number; + /** number of equality constraints*/ + neq : number; + /** number of tendons*/ + ntendon : number; + /** number of wrap objects in all tendon paths*/ + nwrap : number; + /** number of sensors*/ + nsensor : number; + /** number of numeric custom fields*/ + nnumeric : number; + /** number of mjtNums in all numeric fields*/ + nnumericdata : number; + /** number of text custom fields*/ + ntext : number; + /** number of mjtBytes in all text fields*/ + ntextdata : number; + /** number of tuple custom fields*/ + ntuple : number; + /** number of objects in all tuple fields*/ + ntupledata : number; + /** number of keyframes*/ + nkey : number; + /** number of mocap bodies*/ + nmocap : number; + /** number of plugin instances*/ + nplugin : number; + /** number of chars in all plugin config attributes*/ + npluginattr : number; + /** number of mjtNums in body_user*/ + nuser_body : number; + /** number of mjtNums in jnt_user*/ + nuser_jnt : number; + /** number of mjtNums in geom_user*/ + nuser_geom : number; + /** number of mjtNums in site_user*/ + nuser_site : number; + /** number of mjtNums in cam_user*/ + nuser_cam : number; + /** number of mjtNums in tendon_user*/ + nuser_tendon : number; + /** number of mjtNums in actuator_user*/ + nuser_actuator : number; + /** number of mjtNums in sensor_user*/ + nuser_sensor : number; + /** number of chars in all names*/ + nnames : number; + /** number of non-zeros in sparse inertia matrix*/ + nM : number; + /** number of non-zeros in sparse derivative matrix*/ + nD : number; + /** number of potential equality-constraint rows*/ + nemax : number; + /** number of available rows in constraint Jacobian*/ + njmax : number; + /** number of potential contacts in contact list*/ + nconmax : number; + /** number of fields in mjData stack*/ + nstack : number; + /** number of extra fields in mjData*/ + nuserdata : number; + /** number of fields in sensor data vector*/ + nsensordata : number; + /** number of fields in the plugin state vector*/ + npluginstate : number; + /** number of bytes in buffer*/ + nbuffer : number; + /** qpos values at default pose (nq x 1)*/ + qpos0 : Float64Array; + /** reference pose for springs (nq x 1)*/ + qpos_spring : Float64Array; + /** id of body's parent (nbody x 1)*/ + body_parentid : Int32Array; + /** id of root above body (nbody x 1)*/ + body_rootid : Int32Array; + /** id of body that this body is welded to (nbody x 1)*/ + body_weldid : Int32Array; + /** id of mocap data; -1: none (nbody x 1)*/ + body_mocapid : Int32Array; + /** number of joints for this body (nbody x 1)*/ + body_jntnum : Int32Array; + /** start addr of joints; -1: no joints (nbody x 1)*/ + body_jntadr : Int32Array; + /** number of motion degrees of freedom (nbody x 1)*/ + body_dofnum : Int32Array; + /** start addr of dofs; -1: no dofs (nbody x 1)*/ + body_dofadr : Int32Array; + /** number of geoms (nbody x 1)*/ + body_geomnum : Int32Array; + /** start addr of geoms; -1: no geoms (nbody x 1)*/ + body_geomadr : Int32Array; + /** body is simple (has diagonal M) (nbody x 1)*/ + body_simple : Uint8Array; + /** inertial frame is same as body frame (nbody x 1)*/ + body_sameframe : Uint8Array; + /** position offset rel. to parent body (nbody x 3)*/ + body_pos : Float64Array; + /** orientation offset rel. to parent body (nbody x 4)*/ + body_quat : Float64Array; + /** local position of center of mass (nbody x 3)*/ + body_ipos : Float64Array; + /** local orientation of inertia ellipsoid (nbody x 4)*/ + body_iquat : Float64Array; + /** mass (nbody x 1)*/ + body_mass : Float64Array; + /** mass of subtree starting at this body (nbody x 1)*/ + body_subtreemass : Float64Array; + /** diagonal inertia in ipos/iquat frame (nbody x 3)*/ + body_inertia : Float64Array; + /** mean inv inert in qpos0 (trn, rot) (nbody x 2)*/ + body_invweight0 : Float64Array; + /** antigravity force, units of body weight (nbody x 1)*/ + body_gravcomp : Float64Array; + /** user data (nbody x nuser_body)*/ + body_user : Float64Array; + /** plugin instance id (-1 if not in use) (nbody x 1)*/ + body_plugin : Int32Array; + /** type of joint (mjtJoint) (njnt x 1)*/ + jnt_type : Int32Array; + /** start addr in 'qpos' for joint's data (njnt x 1)*/ + jnt_qposadr : Int32Array; + /** start addr in 'qvel' for joint's data (njnt x 1)*/ + jnt_dofadr : Int32Array; + /** id of joint's body (njnt x 1)*/ + jnt_bodyid : Int32Array; + /** group for visibility (njnt x 1)*/ + jnt_group : Int32Array; + /** does joint have limits (njnt x 1)*/ + jnt_limited : Uint8Array; + /** constraint solver reference: limit (njnt x mjNREF)*/ + jnt_solref : Float64Array; + /** constraint solver impedance: limit (njnt x mjNIMP)*/ + jnt_solimp : Float64Array; + /** local anchor position (njnt x 3)*/ + jnt_pos : Float64Array; + /** local joint axis (njnt x 3)*/ + jnt_axis : Float64Array; + /** stiffness coefficient (njnt x 1)*/ + jnt_stiffness : Float64Array; + /** joint limits (njnt x 2)*/ + jnt_range : Float64Array; + /** min distance for limit detection (njnt x 1)*/ + jnt_margin : Float64Array; + /** user data (njnt x nuser_jnt)*/ + jnt_user : Float64Array; + /** id of dof's body (nv x 1)*/ + dof_bodyid : Int32Array; + /** id of dof's joint (nv x 1)*/ + dof_jntid : Int32Array; + /** id of dof's parent; -1: none (nv x 1)*/ + dof_parentid : Int32Array; + /** dof address in M-diagonal (nv x 1)*/ + dof_Madr : Int32Array; + /** number of consecutive simple dofs (nv x 1)*/ + dof_simplenum : Int32Array; + /** constraint solver reference:frictionloss (nv x mjNREF)*/ + dof_solref : Float64Array; + /** constraint solver impedance:frictionloss (nv x mjNIMP)*/ + dof_solimp : Float64Array; + /** dof friction loss (nv x 1)*/ + dof_frictionloss : Float64Array; + /** dof armature inertia/mass (nv x 1)*/ + dof_armature : Float64Array; + /** damping coefficient (nv x 1)*/ + dof_damping : Float64Array; + /** diag. inverse inertia in qpos0 (nv x 1)*/ + dof_invweight0 : Float64Array; + /** diag. inertia in qpos0 (nv x 1)*/ + dof_M0 : Float64Array; + /** geometric type (mjtGeom) (ngeom x 1)*/ + geom_type : Int32Array; + /** geom contact type (ngeom x 1)*/ + geom_contype : Int32Array; + /** geom contact affinity (ngeom x 1)*/ + geom_conaffinity : Int32Array; + /** contact dimensionality (1, 3, 4, 6) (ngeom x 1)*/ + geom_condim : Int32Array; + /** id of geom's body (ngeom x 1)*/ + geom_bodyid : Int32Array; + /** id of geom's mesh/hfield (-1: none) (ngeom x 1)*/ + geom_dataid : Int32Array; + /** material id for rendering (ngeom x 1)*/ + geom_matid : Int32Array; + /** group for visibility (ngeom x 1)*/ + geom_group : Int32Array; + /** geom contact priority (ngeom x 1)*/ + geom_priority : Int32Array; + /** same as body frame (1) or iframe (2) (ngeom x 1)*/ + geom_sameframe : Uint8Array; + /** mixing coef for solref/imp in geom pair (ngeom x 1)*/ + geom_solmix : Float64Array; + /** constraint solver reference: contact (ngeom x mjNREF)*/ + geom_solref : Float64Array; + /** constraint solver impedance: contact (ngeom x mjNIMP)*/ + geom_solimp : Float64Array; + /** geom-specific size parameters (ngeom x 3)*/ + geom_size : Float64Array; + /** radius of bounding sphere (ngeom x 1)*/ + geom_rbound : Float64Array; + /** local position offset rel. to body (ngeom x 3)*/ + geom_pos : Float64Array; + /** local orientation offset rel. to body (ngeom x 4)*/ + geom_quat : Float64Array; + /** friction for (slide, spin, roll) (ngeom x 3)*/ + geom_friction : Float64Array; + /** detect contact if distmocap when selected body is mocap, and in d->qpos otherwise + * d->qpos written only if flg_paused and subtree root for selected body has free joint */ + applyPose(bodyID: number, + refPosX : number, refPosY : number, refPosZ : number, + refQuat1: number, refQuat2: number, refQuat3: number, refQuat4: number, + flg_paused: number): void; + // DATA_INTERFACE + /** position (nq x 1)*/ + qpos : Float64Array; + /** velocity (nv x 1)*/ + qvel : Float64Array; + /** actuator activation (na x 1)*/ + act : Float64Array; + /** acceleration used for warmstart (nv x 1)*/ + qacc_warmstart : Float64Array; + /** plugin state (npluginstate x 1)*/ + plugin_state : Float64Array; + /** control (nu x 1)*/ + ctrl : Float64Array; + /** applied generalized force (nv x 1)*/ + qfrc_applied : Float64Array; + /** applied Cartesian force/torque (nbody x 6)*/ + xfrc_applied : Float64Array; + /** positions of mocap bodies (nmocap x 3)*/ + mocap_pos : Float64Array; + /** orientations of mocap bodies (nmocap x 4)*/ + mocap_quat : Float64Array; + /** acceleration (nv x 1)*/ + qacc : Float64Array; + /** time-derivative of actuator activation (na x 1)*/ + act_dot : Float64Array; + /** user data, not touched by engine (nuserdata x 1)*/ + userdata : Float64Array; + /** sensor data array (nsensordata x 1)*/ + sensordata : Float64Array; + /** copy of m->plugin, required for deletion (nplugin x 1)*/ + plugin : Int32Array; + /** pointer to plugin-managed data structure (nplugin x 1)*/ + plugin_data : BigUint64Array; + /** Cartesian position of body frame (nbody x 3)*/ + xpos : Float64Array; + /** Cartesian orientation of body frame (nbody x 4)*/ + xquat : Float64Array; + /** Cartesian orientation of body frame (nbody x 9)*/ + xmat : Float64Array; + /** Cartesian position of body com (nbody x 3)*/ + xipos : Float64Array; + /** Cartesian orientation of body inertia (nbody x 9)*/ + ximat : Float64Array; + /** Cartesian position of joint anchor (njnt x 3)*/ + xanchor : Float64Array; + /** Cartesian joint axis (njnt x 3)*/ + xaxis : Float64Array; + /** Cartesian geom position (ngeom x 3)*/ + geom_xpos : Float64Array; + /** Cartesian geom orientation (ngeom x 9)*/ + geom_xmat : Float64Array; + /** Cartesian site position (nsite x 3)*/ + site_xpos : Float64Array; + /** Cartesian site orientation (nsite x 9)*/ + site_xmat : Float64Array; + /** Cartesian camera position (ncam x 3)*/ + cam_xpos : Float64Array; + /** Cartesian camera orientation (ncam x 9)*/ + cam_xmat : Float64Array; + /** Cartesian light position (nlight x 3)*/ + light_xpos : Float64Array; + /** Cartesian light direction (nlight x 3)*/ + light_xdir : Float64Array; + /** center of mass of each subtree (nbody x 3)*/ + subtree_com : Float64Array; + /** com-based motion axis of each dof (nv x 6)*/ + cdof : Float64Array; + /** com-based body inertia and mass (nbody x 10)*/ + cinert : Float64Array; + /** start address of tendon's path (ntendon x 1)*/ + ten_wrapadr : Int32Array; + /** number of wrap points in path (ntendon x 1)*/ + ten_wrapnum : Int32Array; + /** number of non-zeros in Jacobian row (ntendon x 1)*/ + ten_J_rownnz : Int32Array; + /** row start address in colind array (ntendon x 1)*/ + ten_J_rowadr : Int32Array; + /** column indices in sparse Jacobian (ntendon x nv)*/ + ten_J_colind : Int32Array; + /** tendon lengths (ntendon x 1)*/ + ten_length : Float64Array; + /** tendon Jacobian (ntendon x nv)*/ + ten_J : Float64Array; + /** geom id; -1: site; -2: pulley (nwrap*2 x 1)*/ + wrap_obj : Int32Array; + /** Cartesian 3D points in all path (nwrap*2 x 3)*/ + wrap_xpos : Float64Array; + /** actuator lengths (nu x 1)*/ + actuator_length : Float64Array; + /** actuator moments (nu x nv)*/ + actuator_moment : Float64Array; + /** com-based composite inertia and mass (nbody x 10)*/ + crb : Float64Array; + /** total inertia (sparse) (nM x 1)*/ + qM : Float64Array; + /** L'*D*L factorization of M (sparse) (nM x 1)*/ + qLD : Float64Array; + /** 1/diag(D) (nv x 1)*/ + qLDiagInv : Float64Array; + /** 1/sqrt(diag(D)) (nv x 1)*/ + qLDiagSqrtInv : Float64Array; + /** tendon velocities (ntendon x 1)*/ + ten_velocity : Float64Array; + /** actuator velocities (nu x 1)*/ + actuator_velocity : Float64Array; + /** com-based velocity [3D rot; 3D tran] (nbody x 6)*/ + cvel : Float64Array; + /** time-derivative of cdof (nv x 6)*/ + cdof_dot : Float64Array; + /** C(qpos,qvel) (nv x 1)*/ + qfrc_bias : Float64Array; + /** passive force (nv x 1)*/ + qfrc_passive : Float64Array; + /** linear velocity of subtree com (nbody x 3)*/ + subtree_linvel : Float64Array; + /** angular momentum about subtree com (nbody x 3)*/ + subtree_angmom : Float64Array; + /** L'*D*L factorization of modified M (nM x 1)*/ + qH : Float64Array; + /** 1/diag(D) of modified M (nv x 1)*/ + qHDiagInv : Float64Array; + /** non-zeros in each row (nv x 1)*/ + D_rownnz : Int32Array; + /** address of each row in D_colind (nv x 1)*/ + D_rowadr : Int32Array; + /** column indices of non-zeros (nD x 1)*/ + D_colind : Int32Array; + /** d (passive + actuator - bias) / d qvel (nD x 1)*/ + qDeriv : Float64Array; + /** sparse LU of (qM - dt*qDeriv) (nD x 1)*/ + qLU : Float64Array; + /** actuator force in actuation space (nu x 1)*/ + actuator_force : Float64Array; + /** actuator force (nv x 1)*/ + qfrc_actuator : Float64Array; + /** net unconstrained force (nv x 1)*/ + qfrc_smooth : Float64Array; + /** unconstrained acceleration (nv x 1)*/ + qacc_smooth : Float64Array; + /** constraint force (nv x 1)*/ + qfrc_constraint : Float64Array; + /** net external force; should equal: (nv x 1)*/ + qfrc_inverse : Float64Array; + /** com-based acceleration (nbody x 6)*/ + cacc : Float64Array; + /** com-based interaction force with parent (nbody x 6)*/ + cfrc_int : Float64Array; + /** com-based external force on body (nbody x 6)*/ + cfrc_ext : Float64Array; + /** Free last XML model if loaded. Called internally at each load.*/ + freeLastXML (): void; + /** Advance simulation, use control callback to obtain external force and control.*/ + step (): void; + /** Advance simulation in two steps: before external force and control is set by user.*/ + step1 (): void; + /** Advance simulation in two steps: after external force and control is set by user.*/ + step2 (): void; + /** Forward dynamics: same as mj_step but do not integrate in time.*/ + forward (): void; + /** Inverse dynamics: qacc must be set before calling.*/ + inverse (): void; + /** Forward dynamics with skip; skipstage is mjtStage.*/ + forwardSkip (skipstage : number, skipsensor : number): void; + /** Inverse dynamics with skip; skipstage is mjtStage.*/ + inverseSkip (skipstage : number, skipsensor : number): void; + /** Set solver parameters to default values. [Only works with MuJoCo Allocated Arrays!]*/ + defaultSolRefImp (solref : Float64Array, solimp : Float64Array): void; + /** Return size of buffer needed to hold model.*/ + sizeModel (): number; + /** Reset data to defaults.*/ + resetData (): void; + /** Reset data to defaults, fill everything else with debug_value.*/ + resetDataDebug (debug_value : string): void; + /** Reset data, set fields from specified keyframe.*/ + resetDataKeyframe (key : number): void; + /** Free memory allocation in mjData.*/ + deleteData (): void; + /** Reset all callbacks to NULL pointers (NULL is the default).*/ + resetCallbacks (): void; + /** Print mjModel to text file, specifying format. float_format must be a valid printf-style format string for a single float value.*/ + printFormattedModel (filename : string, float_format : string): void; + /** Print model to text file.*/ + printModel (filename : string): void; + /** Print mjData to text file, specifying format. float_format must be a valid printf-style format string for a single float value*/ + printFormattedData (filename : string, float_format : string): void; + /** Print data to text file.*/ + printData (filename : string): void; + /** Print matrix to screen. [Only works with MuJoCo Allocated Arrays!]*/ + _printMat (mat : Float64Array, nr : number, nc : number): void; + /** Run position-dependent computations.*/ + fwdPosition (): void; + /** Run velocity-dependent computations.*/ + fwdVelocity (): void; + /** Compute actuator force qfrc_actuator.*/ + fwdActuation (): void; + /** Add up all non-constraint forces, compute qacc_smooth.*/ + fwdAcceleration (): void; + /** Run selected constraint solver.*/ + fwdConstraint (): void; + /** Euler integrator, semi-implicit in velocity.*/ + Euler (): void; + /** Runge-Kutta explicit order-N integrator.*/ + RungeKutta (N : number): void; + /** Run position-dependent computations in inverse dynamics.*/ + invPosition (): void; + /** Run velocity-dependent computations in inverse dynamics.*/ + invVelocity (): void; + /** Apply the analytical formula for inverse constraint dynamics.*/ + invConstraint (): void; + /** Compare forward and inverse dynamics, save results in fwdinv.*/ + compareFwdInv (): void; + /** Evaluate position-dependent sensors.*/ + sensorPos (): void; + /** Evaluate velocity-dependent sensors.*/ + sensorVel (): void; + /** Evaluate acceleration and force-dependent sensors.*/ + sensorAcc (): void; + /** Evaluate position-dependent energy (potential).*/ + energyPos (): void; + /** Evaluate velocity-dependent energy (kinetic).*/ + energyVel (): void; + /** Check qpos, reset if any element is too big or nan.*/ + checkPos (): void; + /** Check qvel, reset if any element is too big or nan.*/ + checkVel (): void; + /** Check qacc, reset if any element is too big or nan.*/ + checkAcc (): void; + /** Run forward kinematics.*/ + kinematics (): void; + /** Map inertias and motion dofs to global frame centered at CoM.*/ + comPos (): void; + /** Compute camera and light positions and orientations.*/ + camlight (): void; + /** Compute tendon lengths, velocities and moment arms.*/ + tendon (): void; + /** Compute actuator transmission lengths and moments.*/ + transmission (): void; + /** Run composite rigid body inertia algorithm (CRB).*/ + crbCalculate (): void; + /** Compute sparse L'*D*L factorizaton of inertia matrix.*/ + factorM (): void; + /** Solve linear system M * x = y using factorization: x = inv(L'*D*L)*y [Only works with MuJoCo Allocated Arrays!]*/ + solveM (x : Float64Array, y : Float64Array, n : number): void; + /** Half of linear solve: x = sqrt(inv(D))*inv(L')*y [Only works with MuJoCo Allocated Arrays!]*/ + solveM2 (x : Float64Array, y : Float64Array, n : number): void; + /** Compute cvel, cdof_dot.*/ + comVel (): void; + /** Compute qfrc_passive from spring-dampers, viscosity and density.*/ + passive (): void; + /** subtree linear velocity and angular momentum*/ + subtreeVel (): void; + /** RNE: compute M(qpos)*qacc + C(qpos,qvel); flg_acc=0 removes inertial term. [Only works with MuJoCo Allocated Arrays!]*/ + rne (flg_acc : number, result : Float64Array): void; + /** RNE with complete data: compute cacc, cfrc_ext, cfrc_int.*/ + rnePostConstraint (): void; + /** Run collision detection.*/ + collision (): void; + /** Construct constraints.*/ + makeConstraint (): void; + /** Compute inverse constraint inertia efc_AR.*/ + projectConstraint (): void; + /** Compute efc_vel, efc_aref.*/ + referenceConstraint (): void; + /** Determine type of friction cone.*/ + isPyramidal (): number; + /** Determine type of constraint Jacobian.*/ + isSparse (): number; + /** Determine type of solver (PGS is dual, CG and Newton are primal).*/ + isDual (): number; + /** Multiply dense or sparse constraint Jacobian by vector. [Only works with MuJoCo Allocated Arrays!]*/ + mulJacVec (res : Float64Array, vec : Float64Array): void; + /** Multiply dense or sparse constraint Jacobian transpose by vector. [Only works with MuJoCo Allocated Arrays!]*/ + mulJacTVec (res : Float64Array, vec : Float64Array): void; + /** Compute subtree center-of-mass end-effector Jacobian. [Only works with MuJoCo Allocated Arrays!]*/ + jacSubtreeCom (jacp : Float64Array, body : number): void; + /** Get id of object with the specified mjtObj type and name, returns -1 if id not found.*/ + name2id (type : number, name : string): number; + /** Get name of object with the specified mjtObj type and id, returns NULL if name not found.*/ + id2name (type : number, id : number): string; + /** Convert sparse inertia matrix M into full (i.e. dense) matrix. [Only works with MuJoCo Allocated Arrays!]*/ + fullM (dst : Float64Array, M : Float64Array): void; + /** Compute velocity by finite-differencing two positions. [Only works with MuJoCo Allocated Arrays!]*/ + differentiatePos (qvel : Float64Array, dt : number, qpos1 : Float64Array, qpos2 : Float64Array): void; + /** Integrate position with given velocity. [Only works with MuJoCo Allocated Arrays!]*/ + integratePos (qpos : Float64Array, qvel : Float64Array, dt : number): void; + /** Normalize all quaternions in qpos-type vector. [Only works with MuJoCo Allocated Arrays!]*/ + normalizeQuat (qpos : Float64Array): void; + /** Sum all body masses.*/ + getTotalmass (): number; + /** Return a config attribute value of a plugin instance; NULL: invalid plugin instance ID or attribute name*/ + getPluginConfig (plugin_id : number, attrib : string): string; + /** Load a dynamic library. The dynamic library is assumed to register one or more plugins.*/ + loadPluginLibrary (path : string): void; + /** Return version number: 1.0.2 is encoded as 102.*/ + version (): number; + /** Return the current version of MuJoCo as a null-terminated string.*/ + versionString (): string; + /** Draw rectangle.*/ + _rectangle (viewport : mjrRect, r : number, g : number, b : number, a : number): void; + /** Call glFinish.*/ + _finish (): void; + /** Call glGetError and return result.*/ + _getError (): number; + /** Get builtin UI theme spacing (ind: 0-1).*/ + i_themeSpacing (ind : number): mjuiThemeSpacing; + /** Get builtin UI theme color (ind: 0-3).*/ + i_themeColor (ind : number): mjuiThemeColor; + /** Main error function; does not return to caller.*/ + _error (msg : string): void; + /** Deprecated: use mju_error.*/ + _error_i (msg : string, i : number): void; + /** Deprecated: use mju_error.*/ + _error_s (msg : string, text : string): void; + /** Main warning function; returns to caller.*/ + _warning (msg : string): void; + /** Deprecated: use mju_warning.*/ + _warning_i (msg : string, i : number): void; + /** Deprecated: use mju_warning.*/ + _warning_s (msg : string, text : string): void; + /** Clear user error and memory handlers.*/ + _clearHandlers (): void; + /** High-level warning function: count warnings in mjData, print only the first.*/ + warning (warning : number, info : number): void; + /** Write [datetime, type: message] to MUJOCO_LOG.TXT.*/ + _writeLog (type : string, msg : string): void; + /** Return 1 (for backward compatibility).*/ + activate (filename : string): number; + /** Do nothing (for backward compatibility).*/ + deactivate (): void; + /** Set res = 0. [Only works with MuJoCo Allocated Arrays!]*/ + _zero (res : Float64Array, n : number): void; + /** Set res = val. [Only works with MuJoCo Allocated Arrays!]*/ + _fill (res : Float64Array, val : number, n : number): void; + /** Set res = vec. [Only works with MuJoCo Allocated Arrays!]*/ + _copy (res : Float64Array, data : Float64Array, n : number): void; + /** Return sum(vec). [Only works with MuJoCo Allocated Arrays!]*/ + _sum (vec : Float64Array, n : number): number; + /** Return L1 norm: sum(abs(vec)). [Only works with MuJoCo Allocated Arrays!]*/ + _L1 (vec : Float64Array, n : number): number; + /** Set res = vec*scl. [Only works with MuJoCo Allocated Arrays!]*/ + _scl (res : Float64Array, vec : Float64Array, scl : number, n : number): void; + /** Set res = vec1 + vec2. [Only works with MuJoCo Allocated Arrays!]*/ + _add (res : Float64Array, vec1 : Float64Array, vec2 : Float64Array, n : number): void; + /** Set res = vec1 - vec2. [Only works with MuJoCo Allocated Arrays!]*/ + _sub (res : Float64Array, vec1 : Float64Array, vec2 : Float64Array, n : number): void; + /** Set res = res + vec. [Only works with MuJoCo Allocated Arrays!]*/ + _addTo (res : Float64Array, vec : Float64Array, n : number): void; + /** Set res = res - vec. [Only works with MuJoCo Allocated Arrays!]*/ + _subFrom (res : Float64Array, vec : Float64Array, n : number): void; + /** Set res = res + vec*scl. [Only works with MuJoCo Allocated Arrays!]*/ + _addToScl (res : Float64Array, vec : Float64Array, scl : number, n : number): void; + /** Set res = vec1 + vec2*scl. [Only works with MuJoCo Allocated Arrays!]*/ + _addScl (res : Float64Array, vec1 : Float64Array, vec2 : Float64Array, scl : number, n : number): void; + /** Normalize vector, return length before normalization. [Only works with MuJoCo Allocated Arrays!]*/ + _normalize (res : Float64Array, n : number): number; + /** Return vector length (without normalizing vector). [Only works with MuJoCo Allocated Arrays!]*/ + _norm (res : Float64Array, n : number): number; + /** Return dot-product of vec1 and vec2. [Only works with MuJoCo Allocated Arrays!]*/ + _dot (vec1 : Float64Array, vec2 : Float64Array, n : number): number; + /** Multiply matrix and vector: res = mat * vec. [Only works with MuJoCo Allocated Arrays!]*/ + _mulMatVec (res : Float64Array, mat : Float64Array, vec : Float64Array, nr : number, nc : number): void; + /** Multiply transposed matrix and vector: res = mat' * vec. [Only works with MuJoCo Allocated Arrays!]*/ + _mulMatTVec (res : Float64Array, mat : Float64Array, vec : Float64Array, nr : number, nc : number): void; + /** Multiply square matrix with vectors on both sides: returns vec1' * mat * vec2. [Only works with MuJoCo Allocated Arrays!]*/ + _mulVecMatVec (vec1 : Float64Array, mat : Float64Array, vec2 : Float64Array, n : number): number; + /** Transpose matrix: res = mat'. [Only works with MuJoCo Allocated Arrays!]*/ + _transpose (res : Float64Array, mat : Float64Array, nr : number, nc : number): void; + /** Symmetrize square matrix res = (mat + mat')/2. [Only works with MuJoCo Allocated Arrays!]*/ + _symmetrize (res : Float64Array, mat : Float64Array, n : number): void; + /** Set mat to the identity matrix. [Only works with MuJoCo Allocated Arrays!]*/ + _eye (mat : Float64Array, n : number): void; + /** Multiply matrices: res = mat1 * mat2. [Only works with MuJoCo Allocated Arrays!]*/ + _mulMatMat (res : Float64Array, mat1 : Float64Array, mat2 : Float64Array, r1 : number, c1 : number, c2 : number): void; + /** Multiply matrices, second argument transposed: res = mat1 * mat2'. [Only works with MuJoCo Allocated Arrays!]*/ + _mulMatMatT (res : Float64Array, mat1 : Float64Array, mat2 : Float64Array, r1 : number, c1 : number, r2 : number): void; + /** Multiply matrices, first argument transposed: res = mat1' * mat2. [Only works with MuJoCo Allocated Arrays!]*/ + _mulMatTMat (res : Float64Array, mat1 : Float64Array, mat2 : Float64Array, r1 : number, c1 : number, c2 : number): void; + /** Set res = mat' * diag * mat if diag is not NULL, and res = mat' * mat otherwise. [Only works with MuJoCo Allocated Arrays!]*/ + _sqrMatTD (res : Float64Array, mat : Float64Array, diag : Float64Array, nr : number, nc : number): void; + /** Cholesky decomposition: mat = L*L'; return rank, decomposition performed in-place into mat. [Only works with MuJoCo Allocated Arrays!]*/ + _cholFactor (mat : Float64Array, n : number, mindiag : number): number; + /** Solve mat * res = vec, where mat is Cholesky-factorized [Only works with MuJoCo Allocated Arrays!]*/ + _cholSolve (res : Float64Array, mat : Float64Array, vec : Float64Array, n : number): void; + /** Cholesky rank-one update: L*L' +/- x*x'; return rank. [Only works with MuJoCo Allocated Arrays!]*/ + _cholUpdate (mat : Float64Array, x : Float64Array, n : number, flg_plus : number): number; + /** Convert contact force to pyramid representation. [Only works with MuJoCo Allocated Arrays!]*/ + _encodePyramid (pyramid : Float64Array, force : Float64Array, mu : Float64Array, dim : number): void; + /** Convert pyramid representation to contact force. [Only works with MuJoCo Allocated Arrays!]*/ + _decodePyramid (force : Float64Array, pyramid : Float64Array, mu : Float64Array, dim : number): void; + /** Integrate spring-damper analytically, return pos(dt).*/ + _springDamper (pos0 : number, vel0 : number, Kp : number, Kv : number, dt : number): number; + /** Return min(a,b) with single evaluation of a and b.*/ + _min (a : number, b : number): number; + /** Return max(a,b) with single evaluation of a and b.*/ + _max (a : number, b : number): number; + /** Clip x to the range [min, max].*/ + _clip (x : number, min : number, max : number): number; + /** Return sign of x: +1, -1 or 0.*/ + _sign (x : number): number; + /** Round x to nearest integer.*/ + _round (x : number): number; + /** Convert type id (mjtObj) to type name.*/ + _type2Str (type : number): string; + /** Convert type name to type id (mjtObj).*/ + _str2Type (str : string): number; + /** Return human readable number of bytes using standard letter suffix.*/ + _writeNumBytes (nbytes : number): string; + /** Construct a warning message given the warning type and info.*/ + _warningText (warning : number, info : number): string; + /** Return 1 if nan or abs(x)>mjMAXVAL, 0 otherwise. Used by check functions.*/ + _isBad (x : number): number; + /** Return 1 if all elements are 0. [Only works with MuJoCo Allocated Arrays!]*/ + _isZero (vec : Float64Array, n : number): number; + /** Standard normal random number generator (optional second number). [Only works with MuJoCo Allocated Arrays!]*/ + _standardNormal (num2 : Float64Array): number; + /** Insertion sort, resulting list is in increasing order. [Only works with MuJoCo Allocated Arrays!]*/ + _insertionSort (list : Float64Array, n : number): void; + /** Generate Halton sequence.*/ + _Halton (index : number, base : number): number; + /** Sigmoid function over 0<=x<=1 constructed from half-quadratics.*/ + _sigmoid (x : number): number; + /** Finite differenced transition matrices (control theory notation) d(x_next) = A*dx + B*du d(sensor) = C*dx + D*du required output matrix dimensions: A: (2*nv+na x 2*nv+na) B: (2*nv+na x nu) D: (nsensordata x 2*nv+na) C: (nsensordata x nu) [Only works with MuJoCo Allocated Arrays!]*/ + _transitionFD (eps : number, centered : mjtByte, A : Float64Array, B : Float64Array, C : Float64Array, D : Float64Array): void; + /** Return the number of globally registered plugins.*/ + _pluginCount (): number; +} + +export interface mujoco extends EmscriptenModule { + FS : typeof FS; + MEMFS : typeof MEMFS; + Model : Model; + State : State; + Simulation : Simulation; +} +declare var load_mujoco: EmscriptenModuleFactory; +export default load_mujoco; diff --git a/frontend/public/dist/mujoco_wasm.js b/frontend/public/dist/mujoco_wasm.js new file mode 100644 index 00000000..0ef4842f --- /dev/null +++ b/frontend/public/dist/mujoco_wasm.js @@ -0,0 +1,15 @@ + +var load_mujoco = (() => { + var _scriptDir = import.meta.url; + + return ( +async function(moduleArg = {}) { + +var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});["getExceptionMessage","$incrementExceptionRefcount","$decrementExceptionRefcount","_memory","___indirect_function_table","_main","onRuntimeInitialized"].forEach(prop=>{if(!Object.getOwnPropertyDescriptor(Module["ready"],prop)){Object.defineProperty(Module["ready"],prop,{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"),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")})}});var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(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 ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;if(Module["ENVIRONMENT"]){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)")}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary;if(ENVIRONMENT_IS_NODE){if(typeof process=="undefined"||!process.release||process.release.name!=="node")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?)");var nodeVersion=process.versions.node;var numericVersion=nodeVersion.split(".").slice(0,3);numericVersion=numericVersion[0]*1e4+numericVersion[1]*100+numericVersion[2].split("-")[0]*1;if(numericVersion<16e4){throw new Error("This emscripten-generated code requires node v16.0.0 (detected v"+nodeVersion+")")}const{createRequire:createRequire}=await import("module");var require=createRequire(import.meta.url);var fs=require("fs");var nodePath=require("path");if(ENVIRONMENT_IS_WORKER){scriptDirectory=nodePath.dirname(scriptDirectory)+"/"}else{scriptDirectory=require("url").fileURLToPath(new URL("./",import.meta.url))}read_=(filename,binary)=>{filename=isFileURI(filename)?new URL(filename):nodePath.normalize(filename);return fs.readFileSync(filename,binary?undefined:"utf8")};readBinary=filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}assert(ret.buffer);return ret};readAsync=(filename,onload,onerror,binary=true)=>{filename=isFileURI(filename)?new URL(filename):nodePath.normalize(filename);fs.readFile(filename,binary?undefined:"utf8",(err,data)=>{if(err)onerror(err);else onload(binary?data.buffer:data)})};if(!Module["thisProgram"]&&process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_SHELL){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?)");if(typeof read!="undefined"){read_=read}readBinary=f=>{if(typeof readbuffer=="function"){return new Uint8Array(readbuffer(f))}let data=read(f,"binary");assert(typeof data=="object");return data};readAsync=(f,onload,onerror)=>{setTimeout(()=>onload(readBinary(f)))};if(typeof clearTimeout=="undefined"){globalThis.clearTimeout=id=>{}}if(typeof setTimeout=="undefined"){globalThis.setTimeout=f=>typeof f=="function"?f():abort()}if(typeof scriptArgs!="undefined"){arguments_=scriptArgs}else if(typeof arguments!="undefined"){arguments_=arguments}if(typeof quit=="function"){quit_=(status,toThrow)=>{setTimeout(()=>{if(!(toThrow instanceof ExitStatus)){let toLog=toThrow;if(toThrow&&typeof toThrow=="object"&&toThrow.stack){toLog=[toThrow,toThrow.stack]}err(`exiting due to exception: ${toLog}`)}quit(status)});throw toThrow}}if(typeof print!="undefined"){if(typeof console=="undefined")console={};console.log=print;console.warn=console.error=typeof printErr!="undefined"?printErr:print}}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.startsWith("blob:")){scriptDirectory=""}else{scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}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?)");{read_=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}}else{throw new Error("environment detection error")}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;checkIncomingModuleAPI();if(Module["arguments"])arguments_=Module["arguments"];legacyModuleProp("arguments","arguments_");if(Module["thisProgram"])thisProgram=Module["thisProgram"];legacyModuleProp("thisProgram","thisProgram");if(Module["quit"])quit_=Module["quit"];legacyModuleProp("quit","quit_");assert(typeof Module["memoryInitializerPrefixURL"]=="undefined","Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["pthreadMainPrefixURL"]=="undefined","Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["cdInitializerPrefixURL"]=="undefined","Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["filePackagePrefixURL"]=="undefined","Module.filePackagePrefixURL option was removed, use Module.locateFile instead");assert(typeof Module["read"]=="undefined","Module.read option was removed (modify read_ in JS)");assert(typeof Module["readAsync"]=="undefined","Module.readAsync option was removed (modify readAsync in JS)");assert(typeof Module["readBinary"]=="undefined","Module.readBinary option was removed (modify readBinary in JS)");assert(typeof Module["setWindowTitle"]=="undefined","Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");assert(typeof Module["TOTAL_MEMORY"]=="undefined","Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");legacyModuleProp("asm","wasmExports");legacyModuleProp("read","read_");legacyModuleProp("readAsync","readAsync");legacyModuleProp("readBinary","readBinary");legacyModuleProp("setWindowTitle","setWindowTitle");assert(!ENVIRONMENT_IS_SHELL,"shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.");var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];legacyModuleProp("wasmBinary","wasmBinary");if(typeof WebAssembly!="object"){err("no native wasm support detected")}function intArrayFromBase64(s){if(typeof ENVIRONMENT_IS_NODE!="undefined"&&ENVIRONMENT_IS_NODE){var buf=Buffer.from(s,"base64");return new Uint8Array(buf.buffer,buf.byteOffset,buf.length)}var decoded=atob(s);var bytes=new Uint8Array(decoded.length);for(var i=0;i>2]=34821223;HEAPU32[max+4>>2]=2310721022;HEAPU32[0>>2]=1668509029}function checkStackCookie(){if(ABORT)return;var max=_emscripten_stack_get_end();if(max==0){max+=4}var cookie1=HEAPU32[max>>2];var cookie2=HEAPU32[max+4>>2];if(cookie1!=34821223||cookie2!=2310721022){abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`)}if(HEAPU32[0>>2]!=1668509029){abort("Runtime error: The application has corrupted its heap memory area (address zero)!")}}(function(){var h16=new Int16Array(1);var h8=new Int8Array(h16.buffer);h16[0]=25459;if(h8[0]!==115||h8[1]!==99)throw"Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)"})();var __ATPRERUN__=[];var __ATINIT__=[];var __ATMAIN__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;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(){assert(!runtimeInitialized);runtimeInitialized=true;checkStackCookie();if(!Module["noFSInit"]&&!FS.init.initialized)FS.init();FS.ignorePermissions=false;TTY.init();callRuntimeCallbacks(__ATINIT__)}function preMain(){checkStackCookie();callRuntimeCallbacks(__ATMAIN__)}function postRun(){checkStackCookie();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)}assert(Math.imul,"This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");assert(Math.fround,"This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");assert(Math.clz32,"This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");assert(Math.trunc,"This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;var runDependencyTracking={};function getUniqueRunDependency(id){var orig=id;while(1){if(!runDependencyTracking[id])return id;id=orig+Math.random()}}function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies);if(id){assert(!runDependencyTracking[id]);runDependencyTracking[id]=1;if(runDependencyWatcher===null&&typeof setInterval!="undefined"){runDependencyWatcher=setInterval(()=>{if(ABORT){clearInterval(runDependencyWatcher);runDependencyWatcher=null;return}var shown=false;for(var dep in runDependencyTracking){if(!shown){shown=true;err("still waiting on run dependencies:")}err(`dependency: ${dep}`)}if(shown){err("(end of list)")}},1e4)}}else{err("warning: run dependency added without ID")}}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(id){assert(runDependencyTracking[id]);delete runDependencyTracking[id]}else{err("warning: run dependency removed without ID")}if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";var isDataURI=filename=>filename.startsWith(dataURIPrefix);var isFileURI=filename=>filename.startsWith("file://");function createExportWrapper(name){return(...args)=>{assert(runtimeInitialized,`native function \`${name}\` called before runtime initialization`);var f=wasmExports[name];assert(f,`exported native function \`${name}\` not found`);return f(...args)}}class EmscriptenEH extends Error{}class EmscriptenSjLj extends EmscriptenEH{}class CppException extends EmscriptenEH{constructor(excPtr){super(excPtr);this.excPtr=excPtr;const excInfo=getExceptionMessage(excPtr);this.name=excInfo[0];this.message=excInfo[1]}}var wasmBinaryFile;if(Module["locateFile"]){wasmBinaryFile="mujoco_wasm.wasm";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}}else{wasmBinaryFile=new URL("mujoco_wasm.wasm",import.meta.url).href}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}function getBinaryPromise(binaryFile){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"&&!isFileURI(binaryFile)){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{if(!response["ok"]){throw`failed to load wasm binary file at '${binaryFile}'`}return response["arrayBuffer"]()}).catch(()=>getBinarySync(binaryFile))}else if(readAsync){return new Promise((resolve,reject)=>{readAsync(binaryFile,response=>resolve(new Uint8Array(response)),reject)})}}return Promise.resolve().then(()=>getBinarySync(binaryFile))}function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then(receiver,reason=>{err(`failed to asynchronously prepare wasm: ${reason}`);if(isFileURI(wasmBinaryFile)){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`)}abort(reason)})}function instantiateAsync(binary,binaryFile,imports,callback){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{var result=WebAssembly.instantiateStreaming(response,imports);return result.then(callback,function(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(binaryFile,imports,callback)})})}return instantiateArrayBuffer(binaryFile,imports,callback)}function createWasm(){var info={"env":wasmImports,"wasi_snapshot_preview1":wasmImports};function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["memory"];assert(wasmMemory,"memory not found in wasm exports");updateMemoryViews();wasmTable=wasmExports["__indirect_function_table"];assert(wasmTable,"table not found in wasm exports");addOnInit(wasmExports["__wasm_call_ctors"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");var trueModule=Module;function receiveInstantiationResult(result){assert(Module===trueModule,"the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");trueModule=null;receiveInstance(result["instance"])}if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);readyPromiseReject(e)}}instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch(readyPromiseReject);return{}}var tempDouble;var tempI64;function legacyModuleProp(prop,newName,incoming=true){if(!Object.getOwnPropertyDescriptor(Module,prop)){Object.defineProperty(Module,prop,{configurable:true,get(){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)":"";abort(`\`Module.${prop}\` has been replaced by \`${newName}\``+extra)}})}}function ignoredModuleProp(prop){if(Object.getOwnPropertyDescriptor(Module,prop)){abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`)}}function isExportedByForceFilesystem(name){return name==="FS_createPath"||name==="FS_createDataFile"||name==="FS_createPreloadedFile"||name==="FS_unlink"||name==="addRunDependency"||name==="FS_createLazyFile"||name==="FS_createDevice"||name==="removeRunDependency"}function missingGlobal(sym,msg){if(typeof globalThis!=="undefined"){Object.defineProperty(globalThis,sym,{configurable:true,get(){warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);return undefined}})}}missingGlobal("buffer","Please use HEAP8.buffer or wasmMemory.buffer");missingGlobal("asm","Please use wasmExports instead");function missingLibrarySymbol(sym){if(typeof globalThis!=="undefined"&&!Object.getOwnPropertyDescriptor(globalThis,sym)){Object.defineProperty(globalThis,sym,{configurable:true,get(){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`;var librarySymbol=sym;if(!librarySymbol.startsWith("_")){librarySymbol="$"+sym}msg+=` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;if(isExportedByForceFilesystem(sym)){msg+=". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"}warnOnce(msg);return undefined}})}unexportedRuntimeSymbol(sym)}function unexportedRuntimeSymbol(sym){if(!Object.getOwnPropertyDescriptor(Module,sym)){Object.defineProperty(Module,sym,{configurable:true,get(){var msg=`'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;if(isExportedByForceFilesystem(sym)){msg+=". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"}abort(msg)}})}}function ExitStatus(status){this.name="ExitStatus";this.message=`Program terminated with exit(${status})`;this.status=status}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var withStackSave=f=>{var stack=stackSave();var ret=f();stackRestore(stack);return ret};var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;var UTF8ArrayToString=(heapOrArray,idx,maxBytesToRead)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>{assert(typeof ptr=="number",`UTF8ToString expects a number (got ${typeof ptr})`);return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""};var getExceptionMessageCommon=ptr=>withStackSave(()=>{var type_addr_addr=stackAlloc(4);var message_addr_addr=stackAlloc(4);___get_exception_message(ptr,type_addr_addr,message_addr_addr);var type_addr=HEAPU32[type_addr_addr>>2];var message_addr=HEAPU32[message_addr_addr>>2];var type=UTF8ToString(type_addr);_free(type_addr);var message;if(message_addr){message=UTF8ToString(message_addr);_free(message_addr)}return[type,message]});var getExceptionMessage=ptr=>getExceptionMessageCommon(ptr);Module["getExceptionMessage"]=getExceptionMessage;var noExitRuntime=Module["noExitRuntime"]||true;var ptrToString=ptr=>{assert(typeof ptr==="number");ptr>>>=0;return"0x"+ptr.toString(16).padStart(8,"0")};var warnOnce=text=>{warnOnce.shown||={};if(!warnOnce.shown[text]){warnOnce.shown[text]=1;if(ENVIRONMENT_IS_NODE)text="warning: "+text;err(text)}};var ___assert_fail=(condition,filename,line,func)=>{abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])};var exceptionCaught=[];var uncaughtExceptionCount=0;var ___cxa_begin_catch=ptr=>{var info=new ExceptionInfo(ptr);if(!info.get_caught()){info.set_caught(true);uncaughtExceptionCount--}info.set_rethrown(false);exceptionCaught.push(info);___cxa_increment_exception_refcount(info.excPtr);return info.get_exception_ptr()};var exceptionLast=0;var ___cxa_end_catch=()=>{_setThrew(0,0);assert(exceptionCaught.length>0);var info=exceptionCaught.pop();___cxa_decrement_exception_refcount(info.excPtr);exceptionLast=0};class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}var ___resumeException=ptr=>{if(!exceptionLast){exceptionLast=new CppException(ptr)}throw exceptionLast};var findMatchingCatch=args=>{var thrown=exceptionLast?.excPtr;if(!thrown){setTempRet0(0);return 0}var info=new ExceptionInfo(thrown);info.set_adjusted_ptr(thrown);var thrownType=info.get_type();if(!thrownType){setTempRet0(0);return thrown}for(var arg in args){var caughtType=args[arg];if(caughtType===0||caughtType===thrownType){break}var adjusted_ptr_addr=info.ptr+16;if(___cxa_can_catch(caughtType,thrownType,adjusted_ptr_addr)){setTempRet0(caughtType);return thrown}}setTempRet0(thrownType);return thrown};var ___cxa_find_matching_catch_2=()=>findMatchingCatch([]);var ___cxa_find_matching_catch_3=arg0=>findMatchingCatch([arg0]);var ___cxa_rethrow=()=>{var info=exceptionCaught.pop();if(!info){abort("no exception to throw")}var ptr=info.excPtr;if(!info.get_rethrown()){exceptionCaught.push(info);info.set_rethrown(true);info.set_caught(false);uncaughtExceptionCount++}exceptionLast=new CppException(ptr);throw exceptionLast};var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);exceptionLast=new CppException(ptr);uncaughtExceptionCount++;throw exceptionLast};var ___cxa_uncaught_exceptions=()=>uncaughtExceptionCount;var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:path=>{if(path==="/")return"/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>{if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){return view=>crypto.getRandomValues(view)}else if(ENVIRONMENT_IS_NODE){try{var crypto_module=require("crypto");var randomFillSync=crypto_module["randomFillSync"];if(randomFillSync){return view=>crypto_module["randomFillSync"](view)}var randomBytes=crypto_module["randomBytes"];return view=>(view.set(randomBytes(view.byteLength)),view)}catch(e){}}abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: (array) => { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };")};var randomFill=view=>(randomFill=initRandomFill())(view);var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{assert(typeof str==="string",`stringToUTF8Array expects a string (got ${typeof str})`);if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;if(u>1114111)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).");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 intArrayFromString(stringy,dontAddNull,length){var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array}var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(ENVIRONMENT_IS_NODE){var BUFSIZE=256;var buf=Buffer.alloc(BUFSIZE);var bytesRead=0;var fd=process.stdin.fd;try{bytesRead=fs.readSync(fd,buf)}catch(e){if(e.toString().includes("EOF"))bytesRead=0;else throw e}if(bytesRead>0){result=buf.slice(0,bytesRead).toString("utf-8")}else{result=null}}else if(typeof window!="undefined"&&typeof window.prompt=="function"){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else if(typeof readline=="function"){result=readline();if(result!==null){result+="\n"}}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops:ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i0){out(UTF8ArrayToString(tty.output,0));tty.output=[]}},ioctl_tcgets(tty){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output,0));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output&&tty.output.length>0){err(UTF8ArrayToString(tty.output,0));tty.output=[]}}}};var mmapAlloc=size=>{abort("internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported")};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16384|511,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,allocate:MEMFS.stream_ops.allocate,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.timestamp=Date.now();if(parent){parent.contents[name]=node;parent.timestamp=node.timestamp}return node},getFileDataAsTypedArray(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize}},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.timestamp);attr.mtime=new Date(node.timestamp);attr.ctime=new Date(node.timestamp);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){if(attr.mode!==undefined){node.mode=attr.mode}if(attr.timestamp!==undefined){node.timestamp=attr.timestamp}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){throw FS.genericErrors[44]},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){if(FS.isDir(old_node.mode)){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}}delete old_node.parent.contents[old_node.name];old_node.parent.timestamp=Date.now();old_node.name=new_name;new_dir.contents[new_name]=old_node;new_dir.timestamp=old_node.parent.timestamp;old_node.parent=new_dir},unlink(parent,name){delete parent.contents[name];parent.timestamp=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.timestamp=Date.now()},readdir(node){var entries=[".",".."];for(var key of Object.keys(node.contents)){entries.push(key)}return entries},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);assert(size>=0);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length{var dep=!noRunDep?getUniqueRunDependency(`al ${url}`):"";readAsync(url,arrayBuffer=>{assert(arrayBuffer,`Loading data file "${url}" failed (no arrayBuffer).`);onload(new Uint8Array(arrayBuffer));if(dep)removeRunDependency(dep)},event=>{if(onerror){onerror()}else{throw`Loading data file "${url}" failed.`}});if(dep)addRunDependency(dep)};var FS_createDataFile=(parent,name,fileData,canRead,canWrite,canOwn)=>{FS.createDataFile(parent,name,fileData,canRead,canWrite,canOwn)};var preloadPlugins=Module["preloadPlugins"]||[];var FS_handledByPreloadPlugin=(byteArray,fullname,finish,onerror)=>{if(typeof Browser!="undefined")Browser.init();var handled=false;preloadPlugins.forEach(plugin=>{if(handled)return;if(plugin["canHandle"](fullname)){plugin["handle"](byteArray,fullname,finish,onerror);handled=true}});return handled};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);function processData(byteArray){function finish(byteArray){preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}onload?.();removeRunDependency(dep)}if(FS_handledByPreloadPlugin(byteArray,fullname,finish,()=>{onerror?.();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url,processData,onerror)}else{processData(url)}};var FS_modeStringToFlags=str=>{var flagModes={"r":0,"r+":2,"w":512|64|1,"w+":512|64|2,"a":1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var ERRNO_MESSAGES={0:"Success",1:"Arg list too long",2:"Permission denied",3:"Address already in use",4:"Address not available",5:"Address family not supported by protocol family",6:"No more processes",7:"Socket already connected",8:"Bad file number",9:"Trying to read unreadable message",10:"Mount device busy",11:"Operation canceled",12:"No children",13:"Connection aborted",14:"Connection refused",15:"Connection reset by peer",16:"File locking deadlock error",17:"Destination address required",18:"Math arg out of domain of func",19:"Quota exceeded",20:"File exists",21:"Bad address",22:"File too large",23:"Host is unreachable",24:"Identifier removed",25:"Illegal byte sequence",26:"Connection already in progress",27:"Interrupted system call",28:"Invalid argument",29:"I/O error",30:"Socket is already connected",31:"Is a directory",32:"Too many symbolic links",33:"Too many open files",34:"Too many links",35:"Message too long",36:"Multihop attempted",37:"File or path name too long",38:"Network interface is not configured",39:"Connection reset by network",40:"Network is unreachable",41:"Too many open files in system",42:"No buffer space available",43:"No such device",44:"No such file or directory",45:"Exec format error",46:"No record locks available",47:"The link has been severed",48:"Not enough core",49:"No message of desired type",50:"Protocol not available",51:"No space left on device",52:"Function not implemented",53:"Socket is not connected",54:"Not a directory",55:"Directory not empty",56:"State not recoverable",57:"Socket operation on non-socket",59:"Not a typewriter",60:"No such device or address",61:"Value too large for defined data type",62:"Previous owner died",63:"Not super-user",64:"Broken pipe",65:"Protocol error",66:"Unknown protocol",67:"Protocol wrong type for socket",68:"Math result not representable",69:"Read only file system",70:"Illegal seek",71:"No such process",72:"Stale file handle",73:"Connection timed out",74:"Text file busy",75:"Cross-device link",100:"Device not a stream",101:"Bad font file fmt",102:"Invalid slot",103:"Invalid request code",104:"No anode",105:"Block device required",106:"Channel number out of range",107:"Level 3 halted",108:"Level 3 reset",109:"Link number out of range",110:"Protocol driver not attached",111:"No CSI structure available",112:"Level 2 halted",113:"Invalid exchange",114:"Invalid request descriptor",115:"Exchange full",116:"No data (for no delay io)",117:"Timer expired",118:"Out of streams resources",119:"Machine is not on the network",120:"Package not installed",121:"The object is remote",122:"Advertise error",123:"Srmount error",124:"Communication error on send",125:"Cross mount point (not really error)",126:"Given log. name not unique",127:"f.d. invalid for this operation",128:"Remote address changed",129:"Can access a needed shared lib",130:"Accessing a corrupted shared lib",131:".lib section in a.out corrupted",132:"Attempting to link in too many libs",133:"Attempting to exec a shared library",135:"Streams pipe error",136:"Too many users",137:"Socket type not supported",138:"Not supported",139:"Protocol family not supported",140:"Can't send after socket shutdown",141:"Too many references",142:"Host is down",148:"No medium (in tape drive)",156:"Level 2 not synchronized"};var ERRNO_CODES={"EPERM":63,"ENOENT":44,"ESRCH":71,"EINTR":27,"EIO":29,"ENXIO":60,"E2BIG":1,"ENOEXEC":45,"EBADF":8,"ECHILD":12,"EAGAIN":6,"EWOULDBLOCK":6,"ENOMEM":48,"EACCES":2,"EFAULT":21,"ENOTBLK":105,"EBUSY":10,"EEXIST":20,"EXDEV":75,"ENODEV":43,"ENOTDIR":54,"EISDIR":31,"EINVAL":28,"ENFILE":41,"EMFILE":33,"ENOTTY":59,"ETXTBSY":74,"EFBIG":22,"ENOSPC":51,"ESPIPE":70,"EROFS":69,"EMLINK":34,"EPIPE":64,"EDOM":18,"ERANGE":68,"ENOMSG":49,"EIDRM":24,"ECHRNG":106,"EL2NSYNC":156,"EL3HLT":107,"EL3RST":108,"ELNRNG":109,"EUNATCH":110,"ENOCSI":111,"EL2HLT":112,"EDEADLK":16,"ENOLCK":46,"EBADE":113,"EBADR":114,"EXFULL":115,"ENOANO":104,"EBADRQC":103,"EBADSLT":102,"EDEADLOCK":16,"EBFONT":101,"ENOSTR":100,"ENODATA":116,"ETIME":117,"ENOSR":118,"ENONET":119,"ENOPKG":120,"EREMOTE":121,"ENOLINK":47,"EADV":122,"ESRMNT":123,"ECOMM":124,"EPROTO":65,"EMULTIHOP":36,"EDOTDOT":125,"EBADMSG":9,"ENOTUNIQ":126,"EBADFD":127,"EREMCHG":128,"ELIBACC":129,"ELIBBAD":130,"ELIBSCN":131,"ELIBMAX":132,"ELIBEXEC":133,"ENOSYS":52,"ENOTEMPTY":55,"ENAMETOOLONG":37,"ELOOP":32,"EOPNOTSUPP":138,"EPFNOSUPPORT":139,"ECONNRESET":15,"ENOBUFS":42,"EAFNOSUPPORT":5,"EPROTOTYPE":67,"ENOTSOCK":57,"ENOPROTOOPT":50,"ESHUTDOWN":140,"ECONNREFUSED":14,"EADDRINUSE":3,"ECONNABORTED":13,"ENETUNREACH":40,"ENETDOWN":38,"ETIMEDOUT":73,"EHOSTDOWN":142,"EHOSTUNREACH":23,"EINPROGRESS":26,"EALREADY":7,"EDESTADDRREQ":17,"EMSGSIZE":35,"EPROTONOSUPPORT":66,"ESOCKTNOSUPPORT":137,"EADDRNOTAVAIL":4,"ENETRESET":39,"EISCONN":30,"ENOTCONN":53,"ETOOMANYREFS":141,"EUSERS":136,"EDQUOT":19,"ESTALE":72,"ENOTSUP":138,"ENOMEDIUM":148,"EILSEQ":25,"EOVERFLOW":61,"ECANCELED":11,"ENOTRECOVERABLE":56,"EOWNERDEAD":62,"ESTRPIPE":135};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:class extends Error{constructor(errno){super(ERRNO_MESSAGES[errno]);this.name="ErrnoError";this.errno=errno;for(var key in ERRNO_CODES){if(ERRNO_CODES[key]===errno){this.code=key;break}}}},genericErrors:{},filesystems:null,syncFSRequests:0,FSStream:class{constructor(){this.shared={}}get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.mounted=null;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.node_ops={};this.stream_ops={};this.rdev=rdev;this.readMode=292|73;this.writeMode=146}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){path=PATH_FS.resolve(path);if(!path)return{path:"",node:null};var defaults={follow_mount:true,recurse_count:0};opts=Object.assign(defaults,opts);if(opts.recurse_count>8){throw new FS.ErrnoError(32)}var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i40){throw new FS.ErrnoError(32)}}}}return{path:current_path,node:current}},getPath(node){var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?`${mount}/${path}`:mount+path}path=path?`${node.name}/${path}`:node.name;node=node.parent}},hashName(parentid,name){var hash=0;for(var i=0;i>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){assert(typeof parent=="object");var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){assert(FS.syncFSRequests>0);FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount(type,opts,mountpoint){if(typeof type=="string"){throw type}var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type:type,opts:opts,mountpoint:mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);Object.keys(FS.nameTable).forEach(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);assert(idx!==-1);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},create(path,mode){mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode){mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var i=0;i=0);if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write(stream,buffer,offset,length,position,canOwn){assert(offset>=0);if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},allocate(stream,offset,length){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(offset<0||length<=0){throw new FS.ErrnoError(28)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(!FS.isFile(stream.node.mode)&&!FS.isDir(stream.node.mode)){throw new FS.ErrnoError(43)}if(!stream.stream_ops.allocate){throw new FS.ErrnoError(138)}stream.stream_ops.allocate(stream,offset,length)},mmap(stream,length,position,prot,flags){if((prot&2)!==0&&(flags&2)===0&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync(stream,buffer,offset,length,mmapFlags){assert(offset>=0);if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},ioctl(stream,cmd,arg){if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile(path,opts={}){opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){throw new Error(`Invalid encoding type "${opts.encoding}"`)}var ret;var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){ret=UTF8ArrayToString(buf,0)}else if(opts.encoding==="binary"){ret=buf}FS.close(stream);return ret},writeFile(path,data,opts={}){opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){var buf=new Uint8Array(lengthBytesUTF8(data)+1);var actualNumBytes=stringToUTF8Array(data,buf,0,buf.length);FS.write(stream,buf,0,actualNumBytes,undefined,opts.canOwn)}else if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{throw new Error("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomLeft=randomFill(randomBuffer).byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16384|511,73);node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd")},createStandardStreams(){if(Module["stdin"]){FS.createDevice("/dev","stdin",Module["stdin"])}else{FS.symlink("/dev/tty","/dev/stdin")}if(Module["stdout"]){FS.createDevice("/dev","stdout",null,Module["stdout"])}else{FS.symlink("/dev/tty","/dev/stdout")}if(Module["stderr"]){FS.createDevice("/dev","stderr",null,Module["stderr"])}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1);assert(stdin.fd===0,`invalid handle for stdin (${stdin.fd})`);assert(stdout.fd===1,`invalid handle for stdout (${stdout.fd})`);assert(stderr.fd===2,`invalid handle for stderr (${stderr.fd})`)},staticInit(){[44].forEach(code=>{FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack=""});FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={"MEMFS":MEMFS}},init(input,output,error){assert(!FS.init.initialized,"FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");FS.init.initialized=true;Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams()},quit(){FS.init.initialized=false;_fflush(0);for(var i=0;ithis.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)throw new Error("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)throw new Error("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")throw new Error("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(typeof XMLHttpRequest!="undefined"){if(!ENVIRONMENT_IS_WORKER)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url:url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};var keys=Object.keys(node.stream_ops);keys.forEach(key=>{var fn=node.stream_ops[key];stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}});function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);assert(size>=0);if(contents.slice){for(var i=0;i{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr:ptr,allocated:true}};node.stream_ops=stream_ops;return node},absolutePath(){abort("FS.absolutePath has been removed; use PATH_FS.resolve instead")},createFolder(){abort("FS.createFolder has been removed; use FS.mkdir instead")},createLink(){abort("FS.createLink has been removed; use FS.symlink instead")},joinPath(){abort("FS.joinPath has been removed; use PATH.join instead")},mmapAlloc(){abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc")},standardizePath(){abort("FS.standardizePath has been removed; use PATH.normalize instead")}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return PATH.join2(dir,path)},doStat(func,path,buf){var stat=func(path);HEAP32[buf>>2]=stat.dev;HEAP32[buf+4>>2]=stat.mode;HEAPU32[buf+8>>2]=stat.nlink;HEAP32[buf+12>>2]=stat.uid;HEAP32[buf+16>>2]=stat.gid;HEAP32[buf+20>>2]=stat.rdev;tempI64=[stat.size>>>0,(tempDouble=stat.size,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+24>>2]=tempI64[0],HEAP32[buf+28>>2]=tempI64[1];HEAP32[buf+32>>2]=4096;HEAP32[buf+36>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();tempI64=[Math.floor(atime/1e3)>>>0,(tempDouble=Math.floor(atime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+40>>2]=tempI64[0],HEAP32[buf+44>>2]=tempI64[1];HEAPU32[buf+48>>2]=atime%1e3*1e3;tempI64=[Math.floor(mtime/1e3)>>>0,(tempDouble=Math.floor(mtime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+56>>2]=tempI64[0],HEAP32[buf+60>>2]=tempI64[1];HEAPU32[buf+64>>2]=mtime%1e3*1e3;tempI64=[Math.floor(ctime/1e3)>>>0,(tempDouble=Math.floor(ctime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+72>>2]=tempI64[0],HEAP32[buf+76>>2]=tempI64[1];HEAPU32[buf+80>>2]=ctime%1e3*1e3;tempI64=[stat.ino>>>0,(tempDouble=stat.ino,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+88>>2]=tempI64[0],HEAP32[buf+92>>2]=tempI64[1];return 0},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},varargs:undefined,get(){assert(SYSCALLS.varargs!=undefined);var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret},getp(){return SYSCALLS.get()},getStr(ptr){var ret=UTF8ToString(ptr);return ret},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream}};function ___syscall_dup3(fd,newfd,flags){try{var old=SYSCALLS.getStreamFromFD(fd);assert(!flags);if(old.fd===newfd)return-28;var existing=FS.getStream(newfd);if(existing)FS.close(existing);return FS.dupStream(old,newfd).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=SYSCALLS.get();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=SYSCALLS.get();stream.flags|=arg;return 0}case 12:{var arg=SYSCALLS.getp();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 13:case 14:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:{if(!stream.tty)return-59;return 0}case 21505:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcgets){var termios=stream.tty.ops.ioctl_tcgets(stream);var argp=SYSCALLS.getp();HEAP32[argp>>2]=termios.c_iflag||0;HEAP32[argp+4>>2]=termios.c_oflag||0;HEAP32[argp+8>>2]=termios.c_cflag||0;HEAP32[argp+12>>2]=termios.c_lflag||0;for(var i=0;i<32;i++){HEAP8[argp+i+17]=termios.c_cc[i]||0}return 0}return 0}case 21510:case 21511:case 21512:{if(!stream.tty)return-59;return 0}case 21506:case 21507:case 21508:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcsets){var argp=SYSCALLS.getp();var c_iflag=HEAP32[argp>>2];var c_oflag=HEAP32[argp+4>>2];var c_cflag=HEAP32[argp+8>>2];var c_lflag=HEAP32[argp+12>>2];var c_cc=[];for(var i=0;i<32;i++){c_cc.push(HEAP8[argp+i+17])}return stream.tty.ops.ioctl_tcsets(stream.tty,op,{c_iflag:c_iflag,c_oflag:c_oflag,c_cflag:c_cflag,c_lflag:c_lflag,c_cc:c_cc})}return 0}case 21519:{if(!stream.tty)return-59;var argp=SYSCALLS.getp();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21531:{var argp=SYSCALLS.getp();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tiocgwinsz){var winsize=stream.tty.ops.ioctl_tiocgwinsz(stream.tty);var argp=SYSCALLS.getp();HEAP16[argp>>1]=winsize[0];HEAP16[argp+2>>1]=winsize[1]}return 0}case 21524:{if(!stream.tty)return-59;return 0}case 21515:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?SYSCALLS.get():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var structRegistrations={};var runDestructors=destructors=>{while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}};function readPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var InternalError;var throwInternalError=message=>{throw new InternalError(message)};var whenDependentTypesAreResolved=(myTypes,dependentTypes,getTypeConverters)=>{myTypes.forEach(function(type){typeDependencies[type]=dependentTypes});function onComplete(typeConverters){var myTypeConverters=getTypeConverters(typeConverters);if(myTypeConverters.length!==myTypes.length){throwInternalError("Mismatched type converter count")}for(var i=0;i{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}};var __embind_finalize_value_object=structType=>{var reg=structRegistrations[structType];delete structRegistrations[structType];var rawConstructor=reg.rawConstructor;var rawDestructor=reg.rawDestructor;var fieldRecords=reg.fields;var fieldTypes=fieldRecords.map(field=>field.getterReturnType).concat(fieldRecords.map(field=>field.setterArgumentType));whenDependentTypesAreResolved([structType],fieldTypes,fieldTypes=>{var fields={};fieldRecords.forEach((field,i)=>{var fieldName=field.fieldName;var getterReturnType=fieldTypes[i];var getter=field.getter;var getterContext=field.getterContext;var setterArgumentType=fieldTypes[i+fieldRecords.length];var setter=field.setter;var setterContext=field.setterContext;fields[fieldName]={read:ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr)),write:(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}}});return[{name:reg.name,"fromWireType":ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv},"toWireType":(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr},"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":readPointer,destructorFunction:rawDestructor}]})};var __embind_register_bigint=(primitiveType,name,size,minRange,maxRange)=>{};var 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;var readLatin1String=ptr=>{var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]]}return ret};var BindingError;var throwBindingError=message=>{throw new BindingError(message)};function sharedRegisterType(rawType,registeredInstance,options={}){var name=registeredInstance.name;if(!rawType){throwBindingError(`type "${name}" must have a positive integer typeid pointer`)}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else{throwBindingError(`Cannot register type '${name}' twice`)}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb())}}function registerType(rawType,registeredInstance,options={}){if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}return sharedRegisterType(rawType,registeredInstance,options)}var GenericWireTypeSize=8;var __embind_register_bool=(rawType,name,trueValue,falseValue)=>{name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return!!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":function(pointer){return this["fromWireType"](HEAPU8[pointer])},destructorFunction:null})};var shallowCopyInternalPointer=o=>({count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType});var throwInstanceAlreadyDeleted=obj=>{function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted")};var finalizationRegistry=false;var detachFinalizer=handle=>{};var runDestructor=$$=>{if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr)}else{$$.ptrType.registeredClass.rawDestructor($$.ptr)}};var releaseClassHandle=$$=>{$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$)}};var downcastPointer=(ptr,ptrClass,desiredClass)=>{if(ptrClass===desiredClass){return ptr}if(undefined===desiredClass.baseClass){return null}var rv=downcastPointer(ptr,ptrClass,desiredClass.baseClass);if(rv===null){return null}return desiredClass.downcast(rv)};var registeredPointers={};var getInheritedInstanceCount=()=>Object.keys(registeredInstances).length;var getLiveInheritedInstances=()=>{var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k])}}return rv};var deletionQueue=[];var flushPendingDeletes=()=>{while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}};var delayFunction;var setDelayFunction=fn=>{delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes)}};var init_embind=()=>{Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction};var registeredInstances={};var getBasestPointer=(class_,ptr)=>{if(ptr===undefined){throwBindingError("ptr should not be undefined")}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass}return ptr};var getInheritedInstance=(class_,ptr)=>{ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]};var 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,writable:true}}))};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})}}var attachFinalizer=handle=>{if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{console.warn(info.leakWarning.stack.replace(/^Error: /,""));releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$:$$};var cls=$$.ptrType.registeredClass;info.leakWarning=new Error(`Embind found a leaked C++ instance ${cls.name} <${ptrToString($$.ptr)}>.\n`+"We'll free it automatically in this case, but this functionality is not reliable across various environments.\n"+"Make sure to invoke .delete() manually once you're done with the instance instead.\n"+"Originally allocated");if("captureStackTrace"in Error){Error.captureStackTrace(info.leakWarning,RegisteredPointer_fromWireType)}finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.unregister(handle);return attachFinalizer(handle)};var init_ClassHandle=()=>{Object.assign(ClassHandle.prototype,{"isAliasOf"(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;other.$$=other.$$;var rightClass=other.$$.ptrType.registeredClass;var right=other.$$.ptr;while(leftClass.baseClass){left=leftClass.upcast(left);leftClass=leftClass.baseClass}while(rightClass.baseClass){right=rightClass.upcast(right);rightClass=rightClass.baseClass}return leftClass===rightClass&&left===right},"clone"(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.preservePointerOnDelete){this.$$.count.value+=1;return this}else{var clone=attachFinalizer(Object.create(Object.getPrototypeOf(this),{$$:{value:shallowCopyInternalPointer(this.$$)}}));clone.$$.count.value+=1;clone.$$.deleteScheduled=false;return clone}},"delete"(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}detachFinalizer(this);releaseClassHandle(this.$$);if(!this.$$.preservePointerOnDelete){this.$$.smartPtr=undefined;this.$$.ptr=undefined}},"isDeleted"(){return!this.$$.ptr},"deleteLater"(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}deletionQueue.push(this);if(deletionQueue.length===1&&delayFunction){delayFunction(flushPendingDeletes)}this.$$.deleteScheduled=true;return this}})};function ClassHandle(){}var createNamedFunction=(name,body)=>Object.defineProperty(body,"name",{value:name});var ensureOverloadTable=(proto,methodName,humanName)=>{if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(...args){if(!proto[methodName].overloadTable.hasOwnProperty(args.length)){throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`)}return proto[methodName].overloadTable[args.length].apply(this,args)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc}};var 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}}};var char_0=48;var char_9=57;var makeLegalFunctionName=name=>{if(undefined===name){return"_unknown"}name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return`_${name}`}return name};function 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=[]}var 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 "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr)}return ptr}else{return 0}}if(!handle||!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(!this.isConst&&handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);if(this.isSmartPointer){if(undefined===handle.$$.smartPtr){throwBindingError("Passing raw pointer to smart pointer is illegal")}switch(this.sharingPolicy){case 0:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}break;case 1:ptr=handle.$$.smartPtr;break;case 2:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{var clonedHandle=handle["clone"]();ptr=this.rawShare(ptr,Emval.toHandle(()=>clonedHandle["delete"]()));if(destructors!==null){destructors.push(this.rawDestructor,ptr)}}break;default:throwBindingError("Unsupporting sharing policy")}}return ptr}function nonConstNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}return 0}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}var init_RegisteredPointer=()=>{Object.assign(RegisteredPointer.prototype,{getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr)}return ptr},destructor(ptr){this.rawDestructor?.(ptr)},"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":readPointer,"fromWireType":RegisteredPointer_fromWireType})};function RegisteredPointer(name,registeredClass,isReference,isConst,isSmartPointer,pointeeType,sharingPolicy,rawGetPointee,rawConstructor,rawShare,rawDestructor){this.name=name;this.registeredClass=registeredClass;this.isReference=isReference;this.isConst=isConst;this.isSmartPointer=isSmartPointer;this.pointeeType=pointeeType;this.sharingPolicy=sharingPolicy;this.rawGetPointee=rawGetPointee;this.rawConstructor=rawConstructor;this.rawShare=rawShare;this.rawDestructor=rawDestructor;if(!isSmartPointer&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null}else{this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null}}else{this["toWireType"]=genericPointerToWireType}}var replacePublicSymbol=(name,value,numArguments)=>{if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistent public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}};var dynCallLegacy=(sig,ptr,args)=>{assert("dynCall_"+sig in Module,`bad function pointer type - dynCall function not found for sig '${sig}'`);if(args?.length){assert(args.length===sig.substring(1).replace(/j/g,"--").length)}else{assert(sig.length==1)}var f=Module["dynCall_"+sig];return f(ptr,...args)};var wasmTableMirror=[];var wasmTable;var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}assert(wasmTable.get(funcPtr)==func,"JavaScript-side Wasm function table mirror is out of date!");return func};var dynCall=(sig,ptr,args=[])=>{if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}assert(getWasmTableEntry(ptr),`missing table entry in dynCall: ${ptr}`);var rtn=getWasmTableEntry(ptr)(...args);return rtn};var getDynCaller=(sig,ptr)=>{assert(sig.includes("j")||sig.includes("p"),"getDynCaller should only be called with i64 sigs");return(...args)=>dynCall(sig,ptr,args)};var embind__requireFunction=(signature,rawFunction)=>{signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();if(typeof fp!="function"){throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`)}return fp};var 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 UnboundTypeError;var getTypeName=type=>{var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv};var 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([", "]))};var __embind_register_class=(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor)=>{name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);upcast&&=embind__requireFunction(upcastSignature,upcast);downcast&&=embind__requireFunction(downcastSignature,downcast);rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);var legalFunctionName=makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName,function(){throwUnboundTypeError(`Cannot construct ${name} due to unbound types`,[baseClassRawType])});whenDependentTypesAreResolved([rawType,rawPointerType,rawConstPointerType],baseClassRawType?[baseClassRawType]:[],base=>{base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype}else{basePrototype=ClassHandle.prototype}var constructor=createNamedFunction(name,function(...args){if(Object.getPrototypeOf(this)!==instancePrototype){throw new BindingError("Use 'new' to construct "+name)}if(undefined===registeredClass.constructor_body){throw new BindingError(name+" has no accessible constructor")}var body=registeredClass.constructor_body[args.length];if(undefined===body){throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`)}return body.apply(this,args)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);if(registeredClass.baseClass){registeredClass.baseClass.__derivedClasses??=[];registeredClass.baseClass.__derivedClasses.push(registeredClass)}var referenceConverter=new RegisteredPointer(name,registeredClass,true,false,false);var pointerConverter=new RegisteredPointer(name+"*",registeredClass,false,false,false);var constPointerConverter=new RegisteredPointer(name+" const*",registeredClass,false,true,false);registeredPointers[rawType]={pointerType:pointerConverter,constPointerType:constPointerConverter};replacePublicSymbol(legalFunctionName,constructor);return[referenceConverter,pointerConverter,constPointerConverter]})};function usesDestructorStack(argTypes){for(var i=1;i0?", ":"")+argsListWired}invokerFnBody+=(returns||isAsync?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n"}else{for(var i=isClassMethodFunc?1:2;i{var array=[];for(var i=0;i>2])}return array};var getFunctionName=signature=>{signature=signature.trim();const argsIndex=signature.indexOf("(");if(argsIndex!==-1){assert(signature[signature.length-1]==")","Parentheses for argument names should match.");return signature.substr(0,argsIndex)}else{return signature}};var __embind_register_class_class_function=(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,fn,isAsync)=>{var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);methodName=getFunctionName(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],classType=>{classType=classType[0];var humanName=`${classType.name}.${methodName}`;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,argTypes=>{var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));var func=craftInvokerFunction(humanName,invokerArgsArray,null,rawInvoker,fn,isAsync);if(undefined===proto[methodName].overloadTable){func.argCount=argCount-1;proto[methodName]=func}else{proto[methodName].overloadTable[argCount-1]=func}if(classType.registeredClass.__derivedClasses){for(const derivedClass of classType.registeredClass.__derivedClasses){if(!derivedClass.constructor.hasOwnProperty(methodName)){derivedClass.constructor[methodName]=func}}}return[]});return[]})};var __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],classType=>{classType=classType[0];var humanName=`constructor ${classType.name}`;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount-1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`)}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`,rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,argTypes=>{argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})};var __embind_register_class_function=(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,context,isPureVirtual,isAsync)=>{var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);methodName=getFunctionName(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],classType=>{classType=classType[0];var humanName=`${classType.name}.${methodName}`;if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}if(isPureVirtual){classType.registeredClass.pureVirtualFunctions.push(methodName)}function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}var proto=classType.registeredClass.instancePrototype;var method=proto[methodName];if(undefined===method||undefined===method.overloadTable&&method.className!==classType.name&&method.argCount===argCount-2){unboundTypesHandler.argCount=argCount-2;unboundTypesHandler.className=classType.name;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-2]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,argTypes=>{var memberFunction=craftInvokerFunction(humanName,argTypes,classType,rawInvoker,context,isAsync);if(undefined===proto[methodName].overloadTable){memberFunction.argCount=argCount-2;proto[methodName]=memberFunction}else{proto[methodName].overloadTable[argCount-2]=memberFunction}return[]});return[]})};var validateThis=(this_,classType,humanName)=>{if(!(this_ instanceof Object)){throwBindingError(`${humanName} with invalid "this": ${this_}`)}if(!(this_ instanceof classType.registeredClass.constructor)){throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`)}if(!this_.$$.ptr){throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`)}return upcastPointer(this_.$$.ptr,this_.$$.ptrType.registeredClass,classType.registeredClass)};var __embind_register_class_property=(classType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext)=>{fieldName=readLatin1String(fieldName);getter=embind__requireFunction(getterSignature,getter);whenDependentTypesAreResolved([],[classType],classType=>{classType=classType[0];var humanName=`${classType.name}.${fieldName}`;var desc={get(){throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])},enumerable:true,configurable:true};if(setter){desc.set=()=>throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])}else{desc.set=v=>throwBindingError(humanName+" is a read-only property")}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);whenDependentTypesAreResolved([],setter?[getterReturnType,setterArgumentType]:[getterReturnType],types=>{var getterReturnType=types[0];var desc={get(){var ptr=validateThis(this,classType,humanName+" getter");return getterReturnType["fromWireType"](getter(getterContext,ptr))},enumerable:true};if(setter){setter=embind__requireFunction(setterSignature,setter);var setterArgumentType=types[1];desc.set=function(v){var ptr=validateThis(this,classType,humanName+" setter");var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,v));runDestructors(destructors)}}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);return[]});return[]})};var emval_freelist=[];var emval_handles=[];var __emval_decref=handle=>{if(handle>9&&0===--emval_handles[handle+1]){assert(emval_handles[handle]!==undefined,`Decref for unallocated handle.`);emval_handles[handle]=undefined;emval_freelist.push(handle)}};var count_emval_handles=()=>emval_handles.length/2-5-emval_freelist.length;var init_emval=()=>{emval_handles.push(0,1,undefined,1,null,1,true,1,false,1);assert(emval_handles.length===5*2);Module["count_emval_handles"]=count_emval_handles};var Emval={toValue:handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}assert(handle===2||emval_handles[handle]!==undefined&&handle%2===0,`invalid handle: ${handle}`);return emval_handles[handle]},toHandle:value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}};var EmValType={name:"emscripten::val","fromWireType":handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv},"toWireType":(destructors,value)=>Emval.toHandle(value),"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":readPointer,destructorFunction:null};var __embind_register_emval=rawType=>registerType(rawType,EmValType);var enumReadValueFromPointer=(name,width,signed)=>{switch(width){case 1:return signed?function(pointer){return this["fromWireType"](HEAP8[pointer])}:function(pointer){return this["fromWireType"](HEAPU8[pointer])};case 2:return signed?function(pointer){return this["fromWireType"](HEAP16[pointer>>1])}:function(pointer){return this["fromWireType"](HEAPU16[pointer>>1])};case 4:return signed?function(pointer){return this["fromWireType"](HEAP32[pointer>>2])}:function(pointer){return this["fromWireType"](HEAPU32[pointer>>2])};default:throw new TypeError(`invalid integer width (${width}): ${name}`)}};var __embind_register_enum=(rawType,name,size,isSigned)=>{name=readLatin1String(name);function ctor(){}ctor.values={};registerType(rawType,{name:name,constructor:ctor,"fromWireType":function(c){return this.constructor.values[c]},"toWireType":(destructors,c)=>c.value,"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":enumReadValueFromPointer(name,size,isSigned),destructorFunction:null});exposePublicSymbol(name,ctor)};var requireRegisteredType=(rawType,humanName)=>{var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`)}return impl};var __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};var embindRepr=v=>{if(v===null){return"null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else{return""+v}};var floatReadValueFromPointer=(name,width)=>{switch(width){case 4:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 8:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError(`invalid float width (${width}): ${name}`)}};var __embind_register_float=(rawType,name,size)=>{name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":value=>value,"toWireType":(destructors,value)=>{if(typeof value!="number"&&typeof value!="boolean"){throw new TypeError(`Cannot convert ${embindRepr(value)} to ${this.name}`)}return value},"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":floatReadValueFromPointer(name,size),destructorFunction:null})};var integerReadValueFromPointer=(name,width,signed)=>{switch(width){case 1:return signed?pointer=>HEAP8[pointer]:pointer=>HEAPU8[pointer];case 2:return signed?pointer=>HEAP16[pointer>>1]:pointer=>HEAPU16[pointer>>1];case 4:return signed?pointer=>HEAP32[pointer>>2]:pointer=>HEAPU32[pointer>>2];default:throw new TypeError(`invalid integer width (${width}): ${name}`)}};var __embind_register_integer=(primitiveType,name,size,minRange,maxRange)=>{name=readLatin1String(name);if(maxRange===-1){maxRange=4294967295}var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{if(typeof value!="number"&&typeof value!="boolean"){throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${toTypeName}`)}if(valuemaxRange){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}]!`)}};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":integerReadValueFromPointer(name,size,minRange!==0),destructorFunction:null})};var __embind_register_memory_view=(rawType,dataTypeIndex,name)=>{var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){var size=HEAPU32[handle>>2];var data=HEAPU32[handle+4>>2];return new TA(HEAP8.buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true})};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>{assert(typeof maxBytesToWrite=="number","stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)};var __embind_register_std_string=(rawType,name)=>{name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType"(value){var length=HEAPU32[value>>2];var payload=value+4;var str;if(stdStringIsUTF8){var decodeStartPtr=payload;for(var i=0;i<=length;++i){var currentBytePtr=payload+i;if(i==length||HEAPU8[currentBytePtr]==0){var maxRead=currentBytePtr-decodeStartPtr;var stringSegment=UTF8ToString(decodeStartPtr,maxRead);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}}else{var a=new Array(length);for(var i=0;i>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr,length+1)}else{if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+i]=charCode}}else{for(var i=0;i{assert(ptr%2==0,"Pointer passed to UTF16ToString must be aligned to two bytes!");var endPtr=ptr;var idx=endPtr>>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder)return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr));var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit)}return str};var stringToUTF16=(str,outPtr,maxBytesToWrite)=>{assert(outPtr%2==0,"Pointer passed to stringToUTF16 must be aligned to two bytes!");assert(typeof maxBytesToWrite=="number","stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");maxBytesToWrite??=2147483647;if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2}HEAP16[outPtr>>1]=0;return outPtr-startPtr};var lengthBytesUTF16=str=>str.length*2;var UTF32ToString=(ptr,maxBytesToRead)=>{assert(ptr%4==0,"Pointer passed to UTF32ToString must be aligned to four bytes!");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};var stringToUTF32=(str,outPtr,maxBytesToWrite)=>{assert(outPtr%4==0,"Pointer passed to stringToUTF32 must be aligned to four bytes!");assert(typeof maxBytesToWrite=="number","stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");maxBytesToWrite??=2147483647;if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr};var lengthBytesUTF32=str=>{var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4}return len};var __embind_register_std_wstring=(rawType,charSize,name)=>{name=readLatin1String(name);var decodeString,encodeString,readCharAt,lengthBytesUTF;if(charSize===2){decodeString=UTF16ToString;encodeString=stringToUTF16;lengthBytesUTF=lengthBytesUTF16;readCharAt=pointer=>HEAPU16[pointer>>1]}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;readCharAt=pointer=>HEAPU32[pointer>>2]}registerType(rawType,{name:name,"fromWireType":value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str},"toWireType":(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr},"argPackAdvance":GenericWireTypeSize,"readValueFromPointer":readPointer,destructorFunction(ptr){_free(ptr)}})};var __embind_register_value_object=(rawType,name,constructorSignature,rawConstructor,destructorSignature,rawDestructor)=>{structRegistrations[rawType]={name:readLatin1String(name),rawConstructor:embind__requireFunction(constructorSignature,rawConstructor),rawDestructor:embind__requireFunction(destructorSignature,rawDestructor),fields:[]}};var __embind_register_value_object_field=(structType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext)=>{structRegistrations[structType].fields.push({fieldName:readLatin1String(fieldName),getterReturnType:getterReturnType,getter:embind__requireFunction(getterSignature,getter),getterContext:getterContext,setterArgumentType:setterArgumentType,setter:embind__requireFunction(setterSignature,setter),setterContext:setterContext})};var __embind_register_void=(rawType,name)=>{name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":()=>undefined,"toWireType":(destructors,o)=>undefined})};var __emscripten_throw_longjmp=()=>{throw new EmscriptenSjLj};var emval_returnValue=(returnType,destructorsRef,handle)=>{var destructors=[];var result=returnType["toWireType"](destructors,handle);if(destructors.length){HEAPU32[destructorsRef>>2]=Emval.toHandle(destructors)}return result};var __emval_as=(handle,returnType,destructorsRef)=>{handle=Emval.toValue(handle);returnType=requireRegisteredType(returnType,"emval::as");return emval_returnValue(returnType,destructorsRef,handle)};var __emval_get_property=(handle,key)=>{handle=Emval.toValue(handle);key=Emval.toValue(key);return Emval.toHandle(handle[key])};var emval_symbols={};var getStringOrSymbol=address=>{var symbol=emval_symbols[address];if(symbol===undefined){return readLatin1String(address)}return symbol};var __emval_new_cstring=v=>Emval.toHandle(getStringOrSymbol(v));var __emval_run_destructors=handle=>{var destructors=Emval.toValue(handle);runDestructors(destructors);__emval_decref(handle)};var __emval_take_value=(type,arg)=>{type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](arg);return Emval.toHandle(v)};var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};var convertI32PairToI53Checked=(lo,hi)=>{assert(lo==lo>>>0||lo==(lo|0));assert(hi===(hi|0));return hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN};function __localtime_js(time_low,time_high,tmPtr){var time=convertI32PairToI53Checked(time_low,time_high);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst}var __tzset_js=(timezone,daylight,std_name,dst_name)=>{var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);function extractZone(date){var match=date.toTimeString().match(/\(([A-Za-z ]+)\)$/);return match?match[1]:"GMT"}var winterName=extractZone(winter);var summerName=extractZone(summer);if(summerOffset{abort("native code called abort()")};var _emscripten_date_now=()=>Date.now();var getHeapMax=()=>2147483648;var _emscripten_get_heap_max=()=>getHeapMax();var _emscripten_memcpy_js=(dest,src,num)=>HEAPU8.copyWithin(dest,src,src+num);var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`)}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;assert(requestedSize>oldSize);var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);return false}var alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);return false};var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8";var env={"USER":"web_user","LOGNAME":"web_user","PATH":"/","PWD":"/","HOME":"/home/web_user","LANG":lang,"_":getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};var stringToAscii=(str,buffer)=>{for(var i=0;i{var bufSize=0;getEnvStrings().forEach((string,i)=>{var ptr=environ_buf+bufSize;HEAPU32[__environ+i*4>>2]=ptr;stringToAscii(string,ptr);bufSize+=string.length+1});return 0};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(string=>bufSize+=string.length+1);HEAPU32[penviron_buf_size>>2]=bufSize;return 0};var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;checkUnflushedContent();if(keepRuntimeAlive()&&!implicit){var msg=`program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`;readyPromiseReject(msg);err(msg)}_proc_exit(status)};var _exit=exitJS;function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){var offset=convertI32PairToI53Checked(offset_low,offset_high);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[newOffset>>2]=tempI64[0],HEAP32[newOffset+4>>2]=tempI64[1];if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(typeof offset!=="undefined"){offset+=curr}}return ret};function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var arraySum=(array,index)=>{var sum=0;for(var i=0;i<=index;sum+=array[i++]){}return sum};var MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];var MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];var addDays=(date,days)=>{var newDate=new Date(date.getTime());while(days>0){var leap=isLeapYear(newDate.getFullYear());var currentMonth=newDate.getMonth();var daysInCurrentMonth=(leap?MONTH_DAYS_LEAP:MONTH_DAYS_REGULAR)[currentMonth];if(days>daysInCurrentMonth-newDate.getDate()){days-=daysInCurrentMonth-newDate.getDate()+1;newDate.setDate(1);if(currentMonth<11){newDate.setMonth(currentMonth+1)}else{newDate.setMonth(0);newDate.setFullYear(newDate.getFullYear()+1)}}else{newDate.setDate(newDate.getDate()+days);return newDate}}return newDate};var writeArrayToMemory=(array,buffer)=>{assert(array.length>=0,"writeArrayToMemory array must have a length (should be an array or typed array)");HEAP8.set(array,buffer)};var _strftime=(s,maxsize,format,tm)=>{var tm_zone=HEAPU32[tm+40>>2];var date={tm_sec:HEAP32[tm>>2],tm_min:HEAP32[tm+4>>2],tm_hour:HEAP32[tm+8>>2],tm_mday:HEAP32[tm+12>>2],tm_mon:HEAP32[tm+16>>2],tm_year:HEAP32[tm+20>>2],tm_wday:HEAP32[tm+24>>2],tm_yday:HEAP32[tm+28>>2],tm_isdst:HEAP32[tm+32>>2],tm_gmtoff:HEAP32[tm+36>>2],tm_zone:tm_zone?UTF8ToString(tm_zone):""};var pattern=UTF8ToString(format);var EXPANSION_RULES_1={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y","%X":"%H:%M:%S","%Ec":"%c","%EC":"%C","%Ex":"%m/%d/%y","%EX":"%H:%M:%S","%Ey":"%y","%EY":"%Y","%Od":"%d","%Oe":"%e","%OH":"%H","%OI":"%I","%Om":"%m","%OM":"%M","%OS":"%S","%Ou":"%u","%OU":"%U","%OV":"%V","%Ow":"%w","%OW":"%W","%Oy":"%y"};for(var rule in EXPANSION_RULES_1){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_1[rule])}var WEEKDAYS=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];var MONTHS=["January","February","March","April","May","June","July","August","September","October","November","December"];function leadingSomething(value,digits,character){var str=typeof value=="number"?value.toString():value||"";while(str.length0?1:0}var compare;if((compare=sgn(date1.getFullYear()-date2.getFullYear()))===0){if((compare=sgn(date1.getMonth()-date2.getMonth()))===0){compare=sgn(date1.getDate()-date2.getDate())}}return compare}function getFirstWeekStartDate(janFourth){switch(janFourth.getDay()){case 0:return new Date(janFourth.getFullYear()-1,11,29);case 1:return janFourth;case 2:return new Date(janFourth.getFullYear(),0,3);case 3:return new Date(janFourth.getFullYear(),0,2);case 4:return new Date(janFourth.getFullYear(),0,1);case 5:return new Date(janFourth.getFullYear()-1,11,31);case 6:return new Date(janFourth.getFullYear()-1,11,30)}}function getWeekBasedYear(date){var thisDate=addDays(new Date(date.tm_year+1900,0,1),date.tm_yday);var janFourthThisYear=new Date(thisDate.getFullYear(),0,4);var janFourthNextYear=new Date(thisDate.getFullYear()+1,0,4);var firstWeekStartThisYear=getFirstWeekStartDate(janFourthThisYear);var firstWeekStartNextYear=getFirstWeekStartDate(janFourthNextYear);if(compareByDay(firstWeekStartThisYear,thisDate)<=0){if(compareByDay(firstWeekStartNextYear,thisDate)<=0){return thisDate.getFullYear()+1}return thisDate.getFullYear()}return thisDate.getFullYear()-1}var EXPANSION_RULES_2={"%a":date=>WEEKDAYS[date.tm_wday].substring(0,3),"%A":date=>WEEKDAYS[date.tm_wday],"%b":date=>MONTHS[date.tm_mon].substring(0,3),"%B":date=>MONTHS[date.tm_mon],"%C":date=>{var year=date.tm_year+1900;return leadingNulls(year/100|0,2)},"%d":date=>leadingNulls(date.tm_mday,2),"%e":date=>leadingSomething(date.tm_mday,2," "),"%g":date=>getWeekBasedYear(date).toString().substring(2),"%G":getWeekBasedYear,"%H":date=>leadingNulls(date.tm_hour,2),"%I":date=>{var twelveHour=date.tm_hour;if(twelveHour==0)twelveHour=12;else if(twelveHour>12)twelveHour-=12;return leadingNulls(twelveHour,2)},"%j":date=>leadingNulls(date.tm_mday+arraySum(isLeapYear(date.tm_year+1900)?MONTH_DAYS_LEAP:MONTH_DAYS_REGULAR,date.tm_mon-1),3),"%m":date=>leadingNulls(date.tm_mon+1,2),"%M":date=>leadingNulls(date.tm_min,2),"%n":()=>"\n","%p":date=>{if(date.tm_hour>=0&&date.tm_hour<12){return"AM"}return"PM"},"%S":date=>leadingNulls(date.tm_sec,2),"%t":()=>"\t","%u":date=>date.tm_wday||7,"%U":date=>{var days=date.tm_yday+7-date.tm_wday;return leadingNulls(Math.floor(days/7),2)},"%V":date=>{var val=Math.floor((date.tm_yday+7-(date.tm_wday+6)%7)/7);if((date.tm_wday+371-date.tm_yday-2)%7<=2){val++}if(!val){val=52;var dec31=(date.tm_wday+7-date.tm_yday-1)%7;if(dec31==4||dec31==5&&isLeapYear(date.tm_year%400-1)){val++}}else if(val==53){var jan1=(date.tm_wday+371-date.tm_yday)%7;if(jan1!=4&&(jan1!=3||!isLeapYear(date.tm_year)))val=1}return leadingNulls(val,2)},"%w":date=>date.tm_wday,"%W":date=>{var days=date.tm_yday+7-(date.tm_wday+6)%7;return leadingNulls(Math.floor(days/7),2)},"%y":date=>(date.tm_year+1900).toString().substring(2),"%Y":date=>date.tm_year+1900,"%z":date=>{var off=date.tm_gmtoff;var ahead=off>=0;off=Math.abs(off)/60;off=off/60*100+off%60;return(ahead?"+":"-")+String("0000"+off).slice(-4)},"%Z":date=>date.tm_zone,"%%":()=>"%"};pattern=pattern.replace(/%%/g,"\0\0");for(var rule in EXPANSION_RULES_2){if(pattern.includes(rule)){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_2[rule](date))}}pattern=pattern.replace(/\0\0/g,"%");var bytes=intArrayFromString(pattern,false);if(bytes.length>maxsize){return 0}writeArrayToMemory(bytes,s);return bytes.length-1};var _strftime_l=(s,maxsize,format,tm,loc)=>_strftime(s,maxsize,format,tm);var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}checkStackCookie();if(e instanceof WebAssembly.RuntimeError){if(_emscripten_stack_get_current()<=0){err("Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 65536)")}}quit_(1,e)};var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};FS.createPreloadedFile=FS_createPreloadedFile;FS.staticInit();Module["FS_createPath"]=FS.createPath;Module["FS_createDataFile"]=FS.createDataFile;Module["FS_createPreloadedFile"]=FS.createPreloadedFile;Module["FS_unlink"]=FS.unlink;Module["FS_createLazyFile"]=FS.createLazyFile;Module["FS_createDevice"]=FS.createDevice;InternalError=Module["InternalError"]=class InternalError extends Error{constructor(message){super(message);this.name="InternalError"}};embind_init_charCodes();BindingError=Module["BindingError"]=class BindingError extends Error{constructor(message){super(message);this.name="BindingError"}};init_ClassHandle();init_embind();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();function checkIncomingModuleAPI(){ignoredModuleProp("fetchSettings")}var wasmImports={__assert_fail:___assert_fail,__cxa_begin_catch:___cxa_begin_catch,__cxa_end_catch:___cxa_end_catch,__cxa_find_matching_catch_2:___cxa_find_matching_catch_2,__cxa_find_matching_catch_3:___cxa_find_matching_catch_3,__cxa_rethrow:___cxa_rethrow,__cxa_throw:___cxa_throw,__cxa_uncaught_exceptions:___cxa_uncaught_exceptions,__resumeException:___resumeException,__syscall_dup3:___syscall_dup3,__syscall_fcntl64:___syscall_fcntl64,__syscall_ioctl:___syscall_ioctl,__syscall_openat:___syscall_openat,_embind_finalize_value_object:__embind_finalize_value_object,_embind_register_bigint:__embind_register_bigint,_embind_register_bool:__embind_register_bool,_embind_register_class:__embind_register_class,_embind_register_class_class_function:__embind_register_class_class_function,_embind_register_class_constructor:__embind_register_class_constructor,_embind_register_class_function:__embind_register_class_function,_embind_register_class_property:__embind_register_class_property,_embind_register_emval:__embind_register_emval,_embind_register_enum:__embind_register_enum,_embind_register_enum_value:__embind_register_enum_value,_embind_register_float:__embind_register_float,_embind_register_integer:__embind_register_integer,_embind_register_memory_view:__embind_register_memory_view,_embind_register_std_string:__embind_register_std_string,_embind_register_std_wstring:__embind_register_std_wstring,_embind_register_value_object:__embind_register_value_object,_embind_register_value_object_field:__embind_register_value_object_field,_embind_register_void:__embind_register_void,_emscripten_throw_longjmp:__emscripten_throw_longjmp,_emval_as:__emval_as,_emval_decref:__emval_decref,_emval_get_property:__emval_get_property,_emval_new_cstring:__emval_new_cstring,_emval_run_destructors:__emval_run_destructors,_emval_take_value:__emval_take_value,_localtime_js:__localtime_js,_tzset_js:__tzset_js,abort:_abort,emscripten_date_now:_emscripten_date_now,emscripten_get_heap_max:_emscripten_get_heap_max,emscripten_memcpy_js:_emscripten_memcpy_js,emscripten_resize_heap:_emscripten_resize_heap,environ_get:_environ_get,environ_sizes_get:_environ_sizes_get,exit:_exit,fd_close:_fd_close,fd_read:_fd_read,fd_seek:_fd_seek,fd_write:_fd_write,invoke_diii:invoke_diii,invoke_fiii:invoke_fiii,invoke_i:invoke_i,invoke_ii:invoke_ii,invoke_iii:invoke_iii,invoke_iiii:invoke_iiii,invoke_iiiii:invoke_iiiii,invoke_iiiiii:invoke_iiiiii,invoke_iiiiiii:invoke_iiiiiii,invoke_iiiiiiii:invoke_iiiiiiii,invoke_iiiiiiiiiii:invoke_iiiiiiiiiii,invoke_iiiiiiiiiiii:invoke_iiiiiiiiiiii,invoke_iiiiiiiiiiiii:invoke_iiiiiiiiiiiii,invoke_jiiii:invoke_jiiii,invoke_v:invoke_v,invoke_vi:invoke_vi,invoke_vii:invoke_vii,invoke_viii:invoke_viii,invoke_viiii:invoke_viiii,invoke_viiiii:invoke_viiiii,invoke_viiiiii:invoke_viiiiii,invoke_viiiiiii:invoke_viiiiiii,invoke_viiiiiiiiii:invoke_viiiiiiiiii,invoke_viiiiiiiiiiiiiii:invoke_viiiiiiiiiiiiiii,strftime_l:_strftime_l};var wasmExports=createWasm();var ___wasm_call_ctors=createExportWrapper("__wasm_call_ctors");var _main=Module["_main"]=createExportWrapper("__main_argc_argv");var _malloc=createExportWrapper("malloc");var _free=createExportWrapper("free");var setTempRet0=createExportWrapper("setTempRet0");var _fflush=createExportWrapper("fflush");var ___getTypeName=createExportWrapper("__getTypeName");var _setThrew=createExportWrapper("setThrew");var _emscripten_stack_init=()=>(_emscripten_stack_init=wasmExports["emscripten_stack_init"])();var _emscripten_stack_get_free=()=>(_emscripten_stack_get_free=wasmExports["emscripten_stack_get_free"])();var _emscripten_stack_get_base=()=>(_emscripten_stack_get_base=wasmExports["emscripten_stack_get_base"])();var _emscripten_stack_get_end=()=>(_emscripten_stack_get_end=wasmExports["emscripten_stack_get_end"])();var stackSave=createExportWrapper("stackSave");var stackRestore=createExportWrapper("stackRestore");var stackAlloc=createExportWrapper("stackAlloc");var _emscripten_stack_get_current=()=>(_emscripten_stack_get_current=wasmExports["emscripten_stack_get_current"])();var ___cxa_free_exception=createExportWrapper("__cxa_free_exception");var ___cxa_decrement_exception_refcount=createExportWrapper("__cxa_decrement_exception_refcount");var ___cxa_increment_exception_refcount=createExportWrapper("__cxa_increment_exception_refcount");var ___get_exception_message=createExportWrapper("__get_exception_message");var ___cxa_can_catch=createExportWrapper("__cxa_can_catch");var ___cxa_is_pointer_type=createExportWrapper("__cxa_is_pointer_type");var dynCall_jiji=Module["dynCall_jiji"]=createExportWrapper("dynCall_jiji");var dynCall_viijii=Module["dynCall_viijii"]=createExportWrapper("dynCall_viijii");var dynCall_jiiii=Module["dynCall_jiiii"]=createExportWrapper("dynCall_jiiii");var dynCall_iiiiij=Module["dynCall_iiiiij"]=createExportWrapper("dynCall_iiiiij");var dynCall_iiiiijj=Module["dynCall_iiiiijj"]=createExportWrapper("dynCall_iiiiijj");var dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=createExportWrapper("dynCall_iiiiiijj");function invoke_ii(index,a1){var sp=stackSave();try{return getWasmTableEntry(index)(a1)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_vii(index,a1,a2){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiiiii(index,a1,a2,a3,a4,a5,a6){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiiiiii(index,a1,a2,a3,a4,a5,a6){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiiii(index,a1,a2,a3,a4,a5){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_vi(index,a1){var sp=stackSave();try{getWasmTableEntry(index)(a1)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viii(index,a1,a2,a3){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iii(index,a1,a2){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_i(index){var sp=stackSave();try{return getWasmTableEntry(index)()}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiii(index,a1,a2,a3,a4){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiii(index,a1,a2,a3){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiiiii(index,a1,a2,a3,a4,a5){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_v(index){var sp=stackSave();try{getWasmTableEntry(index)()}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiiiiiii(index,a1,a2,a3,a4,a5,a6,a7){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiiii(index,a1,a2,a3,a4){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_fiii(index,a1,a2,a3){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_diii(index,a1,a2,a3){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_viiiiiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_jiiii(index,a1,a2,a3,a4){var sp=stackSave();try{return dynCall_jiiii(index,a1,a2,a3,a4)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}Module["addRunDependency"]=addRunDependency;Module["removeRunDependency"]=removeRunDependency;Module["FS_createPath"]=FS.createPath;Module["FS_createLazyFile"]=FS.createLazyFile;Module["FS_createDevice"]=FS.createDevice;Module["FS_createPreloadedFile"]=FS.createPreloadedFile;Module["FS"]=FS;Module["FS_createDataFile"]=FS.createDataFile;Module["FS_unlink"]=FS.unlink;Module["MEMFS"]=MEMFS;var missingLibrarySymbols=["writeI53ToI64","writeI53ToI64Clamped","writeI53ToI64Signaling","writeI53ToU64Clamped","writeI53ToU64Signaling","readI53FromI64","readI53FromU64","convertI32PairToI53","convertU32PairToI53","inetPton4","inetNtop4","inetPton6","inetNtop6","readSockaddr","writeSockaddr","getCallstack","emscriptenLog","convertPCtoSourceLocation","readEmAsmArgs","jstoi_q","listenOnce","autoResumeAudioContext","runtimeKeepalivePush","runtimeKeepalivePop","callUserCallback","maybeExit","asmjsMangle","HandleAllocator","getNativeTypeSize","STACK_SIZE","STACK_ALIGN","POINTER_SIZE","ASSERTIONS","getCFunc","ccall","cwrap","uleb128Encode","sigToWasmTypes","generateFuncType","convertJsFunctionToWasm","getEmptyTableSlot","updateTableMap","getFunctionAddress","addFunction","removeFunction","reallyNegative","unSign","strLen","reSign","formatString","intArrayToString","AsciiToString","stringToNewUTF8","registerKeyEventCallback","maybeCStringToJsString","findEventTarget","getBoundingClientRect","fillMouseEventData","registerMouseEventCallback","registerWheelEventCallback","registerUiEventCallback","registerFocusEventCallback","fillDeviceOrientationEventData","registerDeviceOrientationEventCallback","fillDeviceMotionEventData","registerDeviceMotionEventCallback","screenOrientation","fillOrientationChangeEventData","registerOrientationChangeEventCallback","fillFullscreenChangeEventData","registerFullscreenChangeEventCallback","JSEvents_requestFullscreen","JSEvents_resizeCanvasForFullscreen","registerRestoreOldStyle","hideEverythingExceptGivenElement","restoreHiddenElements","setLetterbox","softFullscreenResizeWebGLRenderTarget","doRequestFullscreen","fillPointerlockChangeEventData","registerPointerlockChangeEventCallback","registerPointerlockErrorEventCallback","requestPointerLock","fillVisibilityChangeEventData","registerVisibilityChangeEventCallback","registerTouchEventCallback","fillGamepadEventData","registerGamepadEventCallback","registerBeforeUnloadEventCallback","fillBatteryEventData","battery","registerBatteryEventCallback","setCanvasElementSize","getCanvasElementSize","jsStackTrace","stackTrace","checkWasiClock","wasiRightsToMuslOFlags","wasiOFlagsToMuslOFlags","createDyncallWrapper","safeSetTimeout","setImmediateWrapped","clearImmediateWrapped","polyfillSetImmediate","getPromise","makePromise","idsToPromises","makePromiseCallback","Browser_asyncPrepareDataCounter","setMainLoop","getSocketFromFD","getSocketAddress","FS_mkdirTree","_setNetworkCallback","heapObjectForWebGLType","toTypedArrayIndex","webgl_enable_ANGLE_instanced_arrays","webgl_enable_OES_vertex_array_object","webgl_enable_WEBGL_draw_buffers","webgl_enable_WEBGL_multi_draw","emscriptenWebGLGet","computeUnpackAlignedImageSize","colorChannelsInGlTextureFormat","emscriptenWebGLGetTexPixelData","emscriptenWebGLGetUniform","webglGetUniformLocation","webglPrepareUniformLocationsBeforeFirstUse","webglGetLeftBracePos","emscriptenWebGLGetVertexAttrib","__glGetActiveAttribOrUniform","writeGLArray","registerWebGlEventCallback","runAndAbortIfError","ALLOC_NORMAL","ALLOC_STACK","allocate","writeStringToMemory","writeAsciiToMemory","setErrNo","demangle","getFunctionArgsName","createJsInvokerSignature","registerInheritedInstance","unregisterInheritedInstance","emval_get_global","emval_lookupTypes","emval_addMethodCaller"];missingLibrarySymbols.forEach(missingLibrarySymbol);var unexportedSymbols=["run","addOnPreRun","addOnInit","addOnPreMain","addOnExit","addOnPostRun","FS_createFolder","FS_createLink","FS_readFile","out","err","callMain","abort","wasmMemory","wasmExports","stackAlloc","stackSave","stackRestore","getTempRet0","setTempRet0","writeStackCookie","checkStackCookie","convertI32PairToI53Checked","ptrToString","zeroMemory","exitJS","getHeapMax","growMemory","ENV","MONTH_DAYS_REGULAR","MONTH_DAYS_LEAP","MONTH_DAYS_REGULAR_CUMULATIVE","MONTH_DAYS_LEAP_CUMULATIVE","isLeapYear","ydayFromDate","arraySum","addDays","ERRNO_CODES","ERRNO_MESSAGES","DNS","Protocols","Sockets","initRandomFill","randomFill","timers","warnOnce","UNWIND_CACHE","readEmAsmArgsArray","jstoi_s","getExecutableName","dynCallLegacy","getDynCaller","dynCall","handleException","keepRuntimeAlive","asyncLoad","alignMemory","mmapAlloc","wasmTable","noExitRuntime","freeTableIndexes","functionsInTableMap","setValue","getValue","PATH","PATH_FS","UTF8Decoder","UTF8ArrayToString","UTF8ToString","stringToUTF8Array","stringToUTF8","lengthBytesUTF8","intArrayFromString","stringToAscii","UTF16Decoder","UTF16ToString","stringToUTF16","lengthBytesUTF16","UTF32ToString","stringToUTF32","lengthBytesUTF32","stringToUTF8OnStack","writeArrayToMemory","JSEvents","specialHTMLTargets","findCanvasEventTarget","currentFullscreenStrategy","restoreOldWindowedStyle","ExitStatus","getEnvStrings","doReadv","doWritev","promiseMap","uncaughtExceptionCount","exceptionLast","exceptionCaught","ExceptionInfo","findMatchingCatch","getExceptionMessageCommon","incrementExceptionRefcount","decrementExceptionRefcount","getExceptionMessage","Browser","getPreloadedImageData__data","wget","SYSCALLS","preloadPlugins","FS_modeStringToFlags","FS_getMode","FS_stdin_getChar_buffer","FS_stdin_getChar","TTY","PIPEFS","SOCKFS","tempFixedLengthArray","miniTempWebGLFloatBuffers","miniTempWebGLIntBuffers","GL","AL","GLUT","EGL","GLEW","IDBStore","SDL","SDL_gfx","allocateUTF8","allocateUTF8OnStack","InternalError","BindingError","throwInternalError","throwBindingError","registeredTypes","awaitingDependencies","typeDependencies","tupleRegistrations","structRegistrations","sharedRegisterType","whenDependentTypesAreResolved","embind_charCodes","embind_init_charCodes","readLatin1String","getTypeName","getFunctionName","heap32VectorToArray","requireRegisteredType","usesDestructorStack","createJsInvoker","UnboundTypeError","PureVirtualError","GenericWireTypeSize","EmValType","init_embind","throwUnboundTypeError","ensureOverloadTable","exposePublicSymbol","replacePublicSymbol","extendError","createNamedFunction","embindRepr","registeredInstances","getBasestPointer","getInheritedInstance","getInheritedInstanceCount","getLiveInheritedInstances","registeredPointers","registerType","integerReadValueFromPointer","enumReadValueFromPointer","floatReadValueFromPointer","readPointer","runDestructors","newFunc","craftInvokerFunction","embind__requireFunction","genericPointerToWireType","constNoSmartPtrRawPointerToWireType","nonConstNoSmartPtrRawPointerToWireType","init_RegisteredPointer","RegisteredPointer","RegisteredPointer_fromWireType","runDestructor","releaseClassHandle","finalizationRegistry","detachFinalizer_deps","detachFinalizer","attachFinalizer","makeClassHandle","init_ClassHandle","ClassHandle","throwInstanceAlreadyDeleted","deletionQueue","flushPendingDeletes","delayFunction","setDelayFunction","RegisteredClass","shallowCopyInternalPointer","downcastPointer","upcastPointer","validateThis","char_0","char_9","makeLegalFunctionName","emval_freelist","emval_handles","emval_symbols","init_emval","count_emval_handles","getStringOrSymbol","Emval","emval_returnValue","emval_methodCallers","reflectConstruct"];unexportedSymbols.forEach(unexportedRuntimeSymbol);var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function callMain(args=[]){assert(runDependencies==0,'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');assert(__ATPRERUN__.length==0,"cannot call main when preRun functions remain to be called");var entryFunction=_main;args.unshift(thisProgram);var argc=args.length;var argv=stackAlloc((argc+1)*4);var argv_ptr=argv;args.forEach(arg=>{HEAPU32[argv_ptr>>2]=stringToUTF8OnStack(arg);argv_ptr+=4});HEAPU32[argv_ptr>>2]=0;try{var ret=entryFunction(argc,argv);exitJS(ret,true);return ret}catch(e){return handleException(e)}}function stackCheckInit(){_emscripten_stack_init();writeStackCookie()}function run(args=arguments_){if(runDependencies>0){return}stackCheckInit();preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();if(shouldRunNow)callMain(args);postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}checkStackCookie()}function checkUnflushedContent(){var oldOut=out;var oldErr=err;var has=false;out=err=x=>{has=true};try{_fflush(0);["stdout","stderr"].forEach(function(name){var info=FS.analyzePath("/dev/"+name);if(!info)return;var stream=info.object;var rdev=stream.rdev;var tty=TTY.ttys[rdev];if(tty?.output?.length){has=true}})}catch(e){}out=oldOut;err=oldErr;if(has){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.")}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}var shouldRunNow=true;if(Module["noInitialRun"])shouldRunNow=false;run(); + + + return moduleArg.ready +} +); +})(); +export default load_mujoco; \ No newline at end of file diff --git a/frontend/public/dist/mujoco_wasm.wasm b/frontend/public/dist/mujoco_wasm.wasm new file mode 100755 index 0000000000000000000000000000000000000000..5b3f7cae8d78a6be0985846e88a72cf2d309408e GIT binary patch literal 1624797 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