{"version":3,"sources":["webpack://fengari/webpack/universalModuleDefinition","webpack://fengari/webpack/bootstrap","webpack://fengari/../fengari/src/defs.js","webpack://fengari/../fengari/src/lua.js","webpack://fengari/../fengari/src/llimits.js","webpack://fengari/../fengari/src/luaconf.js","webpack://fengari/../fengari/src/lauxlib.js","webpack://fengari/../fengari/src/lobject.js","webpack://fengari/../fengari/src/fengaricore.js","webpack://fengari/../fengari/src/ldo.js","webpack://fengari/../fengari/src/lstring.js","webpack://fengari/../fengari/src/ltable.js","webpack://fengari/../fengari/src/lstate.js","webpack://fengari/../fengari/src/ldebug.js","webpack://fengari/../fengari/src/lualib.js","webpack://fengari/../fengari/src/lopcodes.js","webpack://fengari/../fengari/src/lvm.js","webpack://fengari/../fengari/src/ltm.js","webpack://fengari/../fengari/src/lfunc.js","webpack://fengari/../fengari/src/lzio.js","webpack://fengari/../fengari/src/lapi.js","webpack://fengari/../fengari/src/llex.js","webpack://fengari/../fengari/src/fengari.js","webpack://fengari/../fengari/src/fengarilib.js","webpack://fengari/../fengari/src/loadlib.js","webpack://fengari/../fengari/src/ldblib.js","webpack://fengari/../fengari/src/lmathlib.js","webpack://fengari/../fengari/src/lutf8lib.js","webpack://fengari/../fengari/src/lstrlib.js","webpack://fengari/../fengari/src/loslib.js","webpack://fengari/../fengari/src/ltablib.js","webpack://fengari/../fengari/src/lcorolib.js","webpack://fengari/../fengari/src/lparser.js","webpack://fengari/../fengari/src/ljstype.js","webpack://fengari/../fengari-interop/src/js.js","webpack://fengari/../fengari/src/lbaselib.js","webpack://fengari/../fengari/src/linit.js","webpack://fengari/../node_modules/sprintf-js/src/sprintf.js","webpack://fengari/../fengari/src/ldump.js","webpack://fengari/../fengari/src/lundump.js","webpack://fengari/../fengari/src/lcode.js","webpack://fengari/./src/fengari-web.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","r","value","n","__esModule","object","property","prototype","hasOwnProperty","p","s","luastring_from","Uint8Array","from","bind","a","len","length","luastring_indexOf","indexOf","v","array_indexOf","Error","luastring_of","of","arguments","is_luastring","unicode_error_message","uri_allowed","split","reduce","charCodeAt","to_luastring_cache","to_luastring","str","cache","TypeError","cached","outU8Array","Array","outIdx","u","luastring_eq","b","to_jsstring","to","replacement_char","Math","min","u0","String","fromCharCode","RangeError","u1","u2","s1","s2","u3","to_uristring","toString","from_userstring","LUA_SIGNATURE","LUA_VERSION_MAJOR","LUA_VERSION_MINOR","LUA_VERSION_NUM","LUA_VERSION_RELEASE","LUA_VERSION","LUA_RELEASE","LUA_COPYRIGHT","LUA_AUTHORS","constant_types","LUA_TNONE","LUA_TNIL","LUA_TBOOLEAN","LUA_TLIGHTUSERDATA","LUA_TNUMBER","LUA_TSTRING","LUA_TTABLE","LUA_TFUNCTION","LUA_TUSERDATA","LUA_TTHREAD","LUA_NUMTAGS","LUA_TSHRSTR","LUA_TLNGSTR","LUA_TNUMFLT","LUA_TNUMINT","LUA_TLCL","LUA_TLCF","LUA_TCCL","LUA_REGISTRYINDEX","LUAI_MAXSTACK","LUA_HOOKCALL","LUA_HOOKCOUNT","LUA_HOOKLINE","LUA_HOOKRET","LUA_HOOKTAILCALL","LUA_MASKCALL","LUA_MASKCOUNT","LUA_MASKLINE","LUA_MASKRET","LUA_MINSTACK","LUA_MULTRET","LUA_OPADD","LUA_OPBAND","LUA_OPBNOT","LUA_OPBOR","LUA_OPBXOR","LUA_OPDIV","LUA_OPEQ","LUA_OPIDIV","LUA_OPLE","LUA_OPLT","LUA_OPMOD","LUA_OPMUL","LUA_OPPOW","LUA_OPSHL","LUA_OPSHR","LUA_OPSUB","LUA_OPUNM","LUA_RIDX_GLOBALS","LUA_RIDX_LAST","LUA_RIDX_MAINTHREAD","lua_Debug","_classCallCheck","this","event","NaN","namewhat","what","source","currentline","linedefined","lastlinedefined","nups","nparams","isvararg","istailcall","short_src","i_ci","lua_upvalueindex","thread_status","LUA_OK","LUA_YIELD","LUA_ERRRUN","LUA_ERRSYNTAX","LUA_ERRMEM","LUA_ERRGCMM","LUA_ERRERR","defs","lapi","ldebug","ldo","lstate","lua_absindex","lua_arith","lua_atpanic","lua_atnativeerror","lua_call","lua_callk","lua_checkstack","lua_close","lua_compare","lua_concat","lua_copy","lua_createtable","lua_dump","lua_error","lua_gc","lua_getallocf","lua_getextraspace","lua_getfield","lua_getglobal","lua_gethook","lua_gethookcount","lua_gethookmask","lua_geti","lua_getinfo","lua_getlocal","lua_getmetatable","lua_getstack","lua_gettable","lua_gettop","lua_getupvalue","lua_getuservalue","lua_insert","lua_isboolean","lua_iscfunction","lua_isfunction","lua_isinteger","lua_islightuserdata","lua_isnil","lua_isnone","lua_isnoneornil","lua_isnumber","lua_isproxy","lua_isstring","lua_istable","lua_isthread","lua_isuserdata","lua_isyieldable","lua_len","lua_load","lua_newstate","lua_newtable","lua_newthread","lua_newuserdata","lua_next","lua_pcall","lua_pcallk","lua_pop","lua_pushboolean","lua_pushcclosure","lua_pushcfunction","lua_pushfstring","lua_pushglobaltable","lua_pushinteger","lua_pushjsclosure","lua_pushjsfunction","lua_pushlightuserdata","lua_pushliteral","lua_pushlstring","lua_pushnil","lua_pushnumber","lua_pushstring","lua_pushthread","lua_pushvalue","lua_pushvfstring","lua_rawequal","lua_rawget","lua_rawgeti","lua_rawgetp","lua_rawlen","lua_rawset","lua_rawseti","lua_rawsetp","lua_register","lua_remove","lua_replace","lua_resume","lua_rotate","lua_setallof","lua_setfield","lua_setglobal","lua_sethook","lua_seti","lua_setlocal","lua_setmetatable","lua_settable","lua_settop","lua_setupvalue","lua_setuservalue","lua_status","lua_stringtonumber","lua_toboolean","lua_todataview","lua_tointeger","lua_tointegerx","lua_tojsstring","lua_tolstring","lua_tonumber","lua_tonumberx","lua_topointer","lua_toproxy","lua_tostring","lua_tothread","lua_touserdata","lua_type","lua_typename","lua_upvalueid","lua_upvaluejoin","lua_version","lua_xmove","lua_yield","lua_yieldk","lua_tocfunction","luai_apicheck","lua_assert","e","api_check","msg","LUAI_MAXCCALLS","LUA_MINBUFFER","luai_nummod","L","MAX_INT","MIN_INT","conf","LUA_PATH_SEP","LUA_PATH_MARK","LUA_EXEC_DIR","LUA_VDIR","LUA_DIRSEP","LUA_LDIR","LUA_JSDIR","LUA_PATH_DEFAULT","LUA_JSPATH_DEFAULT","LUA_COMPAT_FLOATSTRING","LUA_IDSIZE","LUAL_BUFFERSIZE","ldexp","mantissa","exponent","steps","ceil","abs","result","pow","floor","LUA_INTEGER_FMT","LUA_INTEGER_FRMLEN","LUA_MAXINTEGER","LUA_MININTEGER","LUA_NUMBER_FMT","LUA_NUMBER_FRMLEN","frexp","data","DataView","ArrayBuffer","setFloat64","bits","getUint32","lua_getlocaledecpoint","toLocaleString","lua_integer2str","lua_number2str","Number","toPrecision","lua_numbertointeger","LUA_ERRFILE","LUA_LOADED_TABLE","LUA_PRELOAD_TABLE","LUA_FILEHANDLE","__name","__tostring","empty","luaL_Buffer","pushglobalfuncname","ar","top","findfield","objidx","level","subarray","pushfuncname","panic","luaL_argerror","arg","extramsg","luaL_error","typeerror","tname","typearg","luaL_getmetafield","luaL_typename","luaL_where","fmt","_len","argp","_key","luaL_fileresult","stat","fname","message","errno","luaL_getmetatable","luaL_testudata","ud","tag_error","tag","luaL_checklstring","undefined","luaL_checkstring","luaL_optlstring","def","luaL_optstring","luaL_checknumber","luaL_checkinteger","interror","luaL_prepbuffsize","B","sz","newend","newsize","max","newbuff","set","luaL_buffinit","luaL_addlstring","luaL_addsize","luaL_addstring","luaL_pushresult","luaL_opt","f","getS","string","luaL_loadbufferx","buff","size","mode","luaL_loadbuffer","luaL_loadstring","obj","tt","luaL_callmeta","p_I","p_f","find_subarray","arr","subarr","from_index","sl","loop","j","luaL_getsubtable","idx","luaL_setfuncs","nup","lib","luaL_checkstack","space","errfile","fnameindex","error","serr","filename","getc","utf8_bom","skipcomment","lf","skipBOM","skipped","luaL_loadfilex","getF","bytes","pos","LoadF","err","path","xhr","XMLHttpRequest","open","responseType","send","status","statusText","response","com","readstatus","luaL_loadfile","luaL_checkversion_","ver","LUA_NOREF","LUA_REFNIL","luaL_addchar","luaL_addvalue","luaL_argcheck","cond","luaL_buffinitsize","luaL_checkany","luaL_checkoption","lst","luaL_checktype","t","luaL_checkudata","luaL_checkversion","luaL_dofile","luaL_dostring","luaL_execresult","signal","luaL_gsub","wild","luaL_len","luaL_newlib","luaL_newlibtable","luaL_newmetatable","luaL_newstate","luaL_optinteger","luaL_optnumber","luaL_prepbuffer","luaL_pushresultsize","luaL_ref","ref","luaL_requiref","modname","openf","glb","luaL_setmetatable","luaL_tolstring","kind","luaL_traceback","L1","last","li","le","lastlevel","n1","LEVELS1","luaL_unref","lua_writestringerror","exec","console","lisdigit","lisprint","lisspace","lisxdigit","luaS_bless","luaS_new","ltable","lvm","ltm","LUA_TPROTO","LUA_TDEADKEY","TValue","type","ttnov","checktype","checktag","ttisnil","ttisboolean","x","tv","ttisstring","tsvalue","getstr","tsslen","svalue","setsvalue2s","newidx","ts","stack","setsvalue","luaO_nilobject","freeze","LClosure","id","l_G","id_counter","nupvalues","upvals","CClosure","upvalue","Udata","metatable","uservalue","create","RETS","PRE","POS","luaO_hexavalue","luaO_utf8esc","UTF8BUFFSZ","mfb","l_str2dloc","neg","dot","sigdig","nosigdig","hasdot","neg1","exp1","lua_strx2number","flt","parseFloat","isNaN","lua_str2number","SIGILS","modes","_defineProperty","_modes","MAXBY10","MAXLASTD","luaO_tostring","ttisinteger","test","pushstr","luaD_inctop","luaO_pushvfstring","luaO_pushfstring","setivalue","setfltvalue","lua_State","Table","_typeof","JSON","stringify","ids","luaG_runerror","luaD_checkstack","luaV_concat","intarith","op","v1","v2","luaV_imul","luaV_mod","luaV_div","luaV_shiftl","numarith","LocVar","varname","startpc","endpc","luaO_arith","p1","p2","p3","res","i1","i2","tointeger","n2","tonumber","luaT_trybinTM","TMS","TM_ADD","luaO_chunkid","bufflen","out","nli","out_i","luaO_int2fb","luaO_str2num","s2i","l_str2int","pmode","l_str2d","pushobj2s","pushsvalue2s","setobjs2s","oldidx","setfrom","setobj2s","oldtv","FENGARI_COPYRIGHT","FENGARI_RELEASE","FENGARI_AUTHORS","FENGARI_VERSION","FENGARI_VERSION_MAJOR","FENGARI_VERSION_MINOR","FENGARI_VERSION_NUM","FENGARI_VERSION_RELEASE","lfunc","lobject","lopcodes","lparser","luaS_newliteral","lundump","MBuffer","adjust_top","newtop","seterrorobj","errcode","oldtop","current_top","ERRORSTACKSIZE","luaD_reallocstack","stack_last","EXTRA_STACK","luaD_growstack","luaD_throw","needed","luaD_shrinkstack","inuse","lim","ci","previous","stackinuse","goodsize","luaE_freeCI","luaD_precall","off","nresults","func","luaE_extendCI","funcOff","callstatus","hookmask","luaD_hook","api_checknelems","luaD_poscall","base","fsize","maxstacksize","is_vararg","adjust_varargs","numparams","l_base","l_code","code","l_savedpc","CIST_LUA","callhook","tryfuncTM","firstResult","nres","wanted","oldpc","next","moveresults","setnilvalue","line","hook","allowhook","ci_top","CIST_HOOKED","opcode","OpCodesI","OP_TAILCALL","CIST_TAIL","actual","nfixargs","fixed","tm","luaT_gettmbyobj","TM_CALL","ttisfunction","luaG_typeerror","luaD_call","nResults","nCcalls","stackerror","luaV_execute","errorJmp","g","mainthread","luaD_rawrunprotected","oldnCcalls","lj","atnativeerror","luaD_callnoyield","errfunc","e2","finishCcall","c_k","nny","CIST_YPCALL","c_old_errfunc","c_ctx","unroll","base_ci","luaV_finishOp","recover","findpcall","extra","luaF_close","CIST_OAH","resume_error","narg","resume","firstArg","ctx","k","luaD_pcall","old_top","ef","old_ci","old_allowhooks","old_nny","old_errfunc","SParser","z","dyd","Dyndata","checkmode","f_parser","cl","zgetc","luaU_undump","luaY_parser","upvalues","luaF_initupvals","luaD_protectedparser","nargs","oldnny","TString","hash","realstring","luaS_hash","luaS_eqlngstr","luaS_hashlongstr","lightuserdata_hashes","WeakMap","get_lightuserdata_hash","table_hash","key","strong","Map","dead_strong","dead_weak","flags","add","clear","prev","entry","mark_dead","setdeadvalue","delete","getgeneric","luaH_getint","invalidateTMcache","luaH_delete","luaH_get","ttisfloat","luaH_getn","luaH_getstr","luaH_set","kv","setgeneric","luaH_setint","luaH_new","luaH_next","table","keyI","keyO","ttisdeadkey","BASIC_STACK_SIZE","CallInfo","basehookcount","hookcount","stack_init","freestack","f_luaopen","registry","l_registry","sethvalue","init_registry","luaT_init","version","CIST_FRESH","CIST_HOOKYIELD","CIST_LEQ","CIST_FIN","close_state","global_State","tmname","TM_N","mt","api_incr_top","luaE_freethread","llex","currentpc","lineinfo","swapextra","temp","upvalname","uv","findlocal","findvararg","luaF_getlocalname","funcinfo","getfuncname","funcname","funcnamefromcode","kname","pc","ISK","kvalue","INDEXK","getobjname","filterpc","jmptarget","lastpc","reg","setreg","OCi","A","OP_LOADNIL","OP_TFORCALL","OP_CALL","OP_JMP","dest","sBx","testAMode","findsetreg","OP_MOVE","OP_GETTABUP","OP_GETTABLE","C","vn","LUA_ENV","OP_GETUPVAL","OP_LOADK","OP_LOADKX","Bx","Ax","OP_SELF","TM_INDEX","OP_SETTABUP","OP_SETTABLE","TM_NEWINDEX","OP_ADD","OP_SUB","TM_SUB","OP_MUL","TM_MUL","OP_MOD","TM_MOD","OP_POW","TM_POW","OP_DIV","TM_DIV","OP_IDIV","TM_IDIV","OP_BAND","TM_BAND","OP_BOR","TM_BOR","OP_BXOR","TM_BXOR","OP_SHL","TM_SHL","OP_SHR","TM_SHR","OP_UNM","TM_UNM","OP_BNOT","TM_BNOT","OP_LEN","TM_LEN","OP_CONCAT","TM_CONCAT","OP_EQ","TM_EQ","OP_LT","TM_LT","OP_LE","TM_LE","varinfo","getupvalname","stkid","isinstack","luaT_objtypename","luaG_addinfo","src","luaG_errormsg","luaG_concaterror","cvt2str","luaG_opinterror","luaG_ordererror","t1","t2","luaG_tointerror","luaG_traceexec","mask","counthook","npc","newline","auxgetinfo","ttisclosure","collectvalidlines","ttisLclosure","local","count","LUA_VERSUFFIX","LUA_COLIBNAME","luaopen_coroutine","LUA_TABLIBNAME","luaopen_table","LUA_OSLIBNAME","luaopen_os","LUA_STRLIBNAME","luaopen_string","LUA_UTF8LIBNAME","luaopen_utf8","LUA_BITLIBNAME","LUA_MATHLIBNAME","luaopen_math","LUA_DBLIBNAME","luaopen_debug","LUA_LOADLIBNAME","luaopen_package","LUA_FENGARILIBNAME","luaopen_fengari","linit","luaL_openlibs","luaP_opmodes","MASK1","MASK0","setarg","fullins","SETARG_Bx","POS_A","SIZE_C","ins","POS_OP","POS_C","MAXARG_Bx","BITRK","CREATE_ABC","CREATE_ABx","bc","CREATE_Ax","GET_OPCODE","GETARG_A","GETARG_B","GETARG_C","GETARG_Bx","GETARG_Ax","GETARG_sBx","LFIELDS_PER_FLUSH","MAXARG_A","MAXARG_Ax","MAXARG_B","MAXARG_C","MAXARG_sBx","MAXINDEXRK","NO_REG","OpArgK","OpArgN","OpArgR","OpArgU","OpCodes","OP_LOADBOOL","OP_SETUPVAL","OP_NEWTABLE","OP_NOT","OP_TEST","OP_TESTSET","OP_RETURN","OP_FORLOOP","OP_FORPREP","OP_TFORLOOP","OP_SETLIST","OP_CLOSURE","OP_VARARG","OP_EXTRAARG","POS_Ax","POS_B","POS_Bx","RKASK","SETARG_A","SETARG_Ax","SETARG_B","SETARG_C","SETARG_sBx","SET_OPCODE","SIZE_A","SIZE_Ax","SIZE_B","SIZE_Bx","SIZE_OP","getBMode","getCMode","getOpMode","iABC","iABx","iAsBx","iAx","testTMode","RA","RB","RKB","RKC","dojump","donextjump","luaV_lessthan","ttisnumber","LTnum","l_strcmp","luaT_callorderTM","luaV_lessequal","LEnum","luaV_equalobj","ttype","fasttm","luaT_callTM","l_isfalse","forlimit","step","stopnow","ilimit","luaV_tointeger","cvt2num","vslen","ls","rs","luaV_objlen","ra","rb","h","imul","aLo","bLo","y","getcached","encup","instack","pushclosure","ncl","setclLvalue","luaF_findupval","tostring","isemptystr","copy2buff","tl","total","luaV_gettable","ttistable","slot","settable","val","newframe","konst","setbvalue","upval","rc","op1","op2","numberop1","numberop2","numberop","rbIdx","nci","oci","nfunc","nfuncOff","ofuncOff","aux","limit","chgivalue","chgfltvalue","init","plimit","pstep","forlim","initv","nlimit","nstep","ninit","cb","inst","luaV_rawequalobj","luaT_typenames_","map","ttypename","TM_GC","TM_MODE","hasres","luaT_callbinTM","luaT_gettm","events","ename","et","ttisfulluserdata","MAXUPVAL","Proto","locvars","old","local_number","luaF_newLclosure","ZIO","reader","buffer","luaZ_fill","EOZ","luaZ_buffer","luaZ_buffremove","luaZ_read","b_offset","luaZ_resetbuffer","luaZ_resizebuffer","luaU_dump","fengari_argcheck","fengari_argcheckinteger","isvalid","index2addr","ttislcf","index2addr_","reverse","fromtv","pIdx","fromidx","toidx","fn","setclCvalue","auxsetstr","auxgetstr","narray","nrec","aux_upvalue","fi","seen","f_call","default_chunkname","checkresults","na","nr","getupvalref","fidx","panicf","errorf","index1","index2","o1","o2","writer","strip","warn","objindex","funcindex","up","ttisCclosure","G","ttislightuserdata","chunkname","gt","luaS_newudata","lua_setallocf","u8","byteOffset","byteLength","jsstring","proxy","ttisthread","fidx1","fidx2","ref1","ref2","up2","lislalnum","lislalpha","RESERVED","TK_AND","TK_BREAK","FIRST_RESERVED","TK_DO","TK_ELSE","TK_ELSEIF","TK_END","TK_FALSE","TK_FOR","TK_FUNCTION","TK_GOTO","TK_IF","TK_IN","TK_LOCAL","TK_NIL","TK_NOT","TK_OR","TK_REPEAT","TK_RETURN","TK_THEN","TK_TRUE","TK_UNTIL","TK_WHILE","TK_IDIV","TK_CONCAT","TK_DOTS","TK_EQ","TK_GE","TK_LE","TK_NE","TK_SHL","TK_SHR","TK_DBCOLON","TK_EOS","TK_FLT","TK_INT","TK_NAME","TK_STRING","luaX_tokens","SemInfo","Token","token","seminfo","save","lexerror","luaX_token2str","currIsNewline","current","save_and_next","luaX_newstring","tpair","inclinenumber","linenumber","check_next1","check_next2","read_numeral","expo","first","txtToken","skip_sep","read_long_string","sep","skip","esccheck","gethexa","readhexaesc","utf8esc","readutf8desc","readdecesc","read_string","del","will","token_to_index","forEach","kidx","LexState","lastline","lookahead","fs","envn","isreserved","w","luaX_lookahead","luaX_next","luaX_setinput","firstchar","luaX_syntaxerror","core","luaconf","lua","lauxlib","lualib","fengari","global_env","WorkerGlobalScope","self","eval","JSLIBS","LUA_CSUBSEP","LUA_LSUBSEP","LUA_POF","LUA_OFSEP","AUXMARK","lsys_load","seeglb","Function","readable","lookforfunc","sym","checkjslib","addtojslib","lsys_sym","env","setpath","fieldname","envname","dft","nver","noenv","plib","pushnexttemplate","searchpath","dirsep","findfile","pname","checkload","searcher_Lua","loadfunc","openfunc","mark","searcher_C","searcher_Croot","searcher_preload","findloader_cont","ll_require_cont","ll_require_cont2","pk_funcs","loadlib","ll_funcs","require","findloader","createjslibstable","searchers","createsearcherstable","checkstack","getthread","thread","settabss","settabsi","settabsb","treatstackoption","auxupvalue","checkupval","argf","argnup","HOOKKEY","hooknames","hookf","dblib","gethook","smask","unmakemask","getinfo","options","getlocal","nvar","getmetatable","getregistry","getupvalue","getuservalue","sethook","makemask","hooktable","setlocal","setmetatable","setupvalue","setuservalue","traceback","upvalueid","upvaluejoin","getinput","input","prompt","debug","rand_state","l_rand","pushnumint","mathlib","acos","asin","atan","atan2","cos","deg","PI","exp","fmod","log","log2","log10","imax","imin","modf","ip","rad","random","low","randomseed","sin","sqrt","tan","ult","Infinity","iscont","u_posrelat","limits","utf8_decode","cc","p_U","pushutfchar","iter_aux","dec","funcs","char","codepoint","posi","pose","MAX_SAFE_INTEGER","codes","posj","offset","UTF8PATT","sprintf","L_ESC","strlen","posrelat","SIZELENMOD","lua_number2strx","is","zero","fe","num2straux","FLAGS","isalpha","isdigit","iscntrl","isgraph","islower","isupper","isalnum","ispunct","isspace","isxdigit","addliteral","repeat","addquoted","point","ppoint","checkdp","scanformat","strfrmt","form","addlenmod","lenmod","lm","spec","Header","islittle","maxalign","digit","getnum","df","getnumlimit","getoption","opt","getdetails","totalsize","ntoalign","align","packint","unpackint","issigned","unpacknum","dv","setUint8","getFloat32","getFloat64","SPECIALS","MatchState","src_init","src_end","p_end","matchdepth","capture","classend","ms","match_class","matchbracketclass","ec","sig","singlematch","ep","matchbalance","cont","max_expand","match","min_expand","start_capture","end_capture","capture_to_close","match_capture","check_capture","ai","bi","array_cmp","gotodefault","gotoinit","push_onecapture","push_captures","nlevels","prepstate","lp","reprepstate","str_find_aux","find","nospecials","anchor","gmatch_aux","gm","lastmatch","add_value","tr","news","add_s","strlib","byte","dump","format","apply","gmatch","GMatchState","gsub","srcl","max_s","lower","pack","details","setFloat32","packsize","rep","lsep","totallen","pi","sub","start","end","unpack","ld","upper","createmetatable","LUA_STRFTIMEOPTIONS","setfield","setallfields","time","utc","getUTCSeconds","getSeconds","getUTCMinutes","getMinutes","getUTCHours","getHours","getUTCDate","getDate","getUTCMonth","getMonth","getUTCFullYear","getFullYear","getUTCDay","getDay","Date","L_MAXDATEFIELD","getfield","delta","locale","days","shortDays","months","shortMonths","AM","PM","am","pm","formats","D","F","R","T","X","week_number","date","start_of_week","weekday","yday","push_pad_2","pad","checkoption","conv","option","oplen","l_checktime","syslib","stm","strftime","tzString","day","getTimezoneOffset","difftime","clock","performance","now","checkfield","checktab","aux_getn","addfield","set2","sort_comp","partition","lo","choosePivot","rnd","r4","tab_funcs","concat","insert","TAB_R","move","remove","sort","auxsort","getco","co","auxresume","luaB_auxwrap","luaB_cocreate","NL","co_funcs","isyieldable","running","wrap","yield","BinOpr","OPR_ADD","OPR_AND","OPR_BAND","OPR_BOR","OPR_BXOR","OPR_CONCAT","OPR_DIV","OPR_EQ","OPR_GE","OPR_GT","OPR_IDIV","OPR_LE","OPR_LT","OPR_MOD","OPR_MUL","OPR_NE","OPR_NOBINOPR","OPR_OR","OPR_POW","OPR_SHL","OPR_SHR","OPR_SUB","UnOpr","OPR_BNOT","OPR_LEN","OPR_MINUS","OPR_NOT","OPR_NOUNOPR","NO_JUMP","getinstruction","luaK_checkstack","luaK_codeABC","luaK_codeABx","luaK_codeAsBx","luaK_codek","luaK_concat","luaK_dischargevars","luaK_exp2RK","luaK_exp2anyreg","luaK_exp2anyregup","luaK_exp2nextreg","luaK_exp2val","luaK_fixline","luaK_getlabel","luaK_goiffalse","luaK_goiftrue","luaK_indexed","luaK_infix","luaK_intK","luaK_jump","luaK_jumpto","luaK_nil","luaK_patchclose","luaK_patchlist","luaK_patchtohere","luaK_posfix","luaK_prefix","luaK_reserveregs","luaK_ret","luaK_self","luaK_setlist","luaK_setmultret","luaK_setoneret","luaK_setreturns","luaK_storevar","luaK_stringK","hasmultret","expkind","VCALL","VVARARG","eqstr","BlockCnt","firstlabel","firstgoto","nactvar","isloop","VVOID","VNIL","VTRUE","VFALSE","VK","VKFLT","VKINT","VNONRELOC","VLOCAL","VUPVAL","VINDEXED","VJMP","VRELOCABLE","expdesc","ival","nval","info","ind","vt","FuncState","bl","lasttarget","jpc","nk","np","firstlocal","nlocvars","freereg","Labellist","semerror","error_expected","checklimit","where","errorlimit","testnext","check","checknext","check_condition","check_match","who","str_checkname","init_exp","codestring","checkname","new_localvar","registerlocalvar","actvar","Vardesc","new_localvarliteral","getlocvar","adjustlocalvars","nvars","newupvalue","singlevaraux","vr","searchvar","markupval","searchupvalue","singlevar","adjust_assign","nexps","enterlevel","leavelevel","closegoto","label","gl","vname","findlabel","lb","newlabelentry","Labeldesc","findgotos","enterblock","open_func","leaveblock","breaklabel","tolevel","removevars","movegotosout","undefgoto","close_func","block_follow","withuntil","statlist","statement","fieldsel","yindex","expr","recfield","nh","rkkey","closelistfield","tostore","listfield","field","constructor","ConsControl","lastlistfield","body","ismethod","new_fs","clp","addprototype","parlist","codeclosure","explist","funcargs","args","suffixedexp","primaryexp","priority","left","right","subexpr","uop","getunopr","simpleexp","getbinopr","nextop","block","LHS_assign","assignment","lh","nv","conflict","check_conflict","gotostat","labelstat","ll","checkrepeated","skipnoopstat","forbody","isnum","endfor","prep","forstat","fornum","indexname","forlist","test_then_block","escapelist","jf","funcstat","ifstat","whileinit","condexit","whilestat","repeat_init","bl1","bl2","repeatstat","localfunc","localstat","nret","retstat","exprstat","lexstate","funcstate","vkisinreg","luai_ctype_","luaopen_base","construct","Reflect_deleteProperty","Reflect","deleteProperty","fApply","target","thisArgument","argumentsList","push","isobject","js_tname","testjs","checkjs","pushjs","getmainthread","mainL","states","objects_seen","tojs","jscall","invoke","thisarg","n_results","gettable","prop","has","iter_next","iter","state","done","js_proxy","Symbol","toStringTag","iterator","jsiterator","toPrimitive","hint","jslib","new","instanceof","typeof","getiter","get_iterator","Proxy","L_symbol","p_symbol","proxy_handlers","arg_length","desc","getOwnPropertyDescriptor","getPrototypeOf","ownKeys","setPrototypeOf","make_arrow_function","createproxy","raw_arrow_function","valid_types","valid_types_as_luastring","fengariProxy","jsmt","__index","__newindex","__call","__pairs","for","index","keys","isArray","__len","FENGARI_INTEROP_VERSION","FENGARI_INTEROP_VERSION_MAJOR","FENGARI_INTEROP_VERSION_NUM","FENGARI_INTEROP_RELEASE","luaopen_js","lua_writestring","lua_writeline","TextDecoder","decoder","decode","stream","copy","opts","luaB_next","ipairsaux","luaB_error","finishpcall","load_aux","envidx","generic_reader","dofilecont","d1","d2","base_funcs","assert","collectgarbage","dofile","ipairs","load","loadfile","pairs","method","iszero","pairsmeta","pcall","print","rawequal","rawget","rawlen","rawset","select","parseInt","b_str2int","xpcall","loadedlibs","re","not_string","not_bool","not_type","not_primitive","number","numeric_arg","json","not_json","text","modulo","placeholder","key_access","index_access","sign","parse_tree","argv","pad_character","pad_length","is_positive","cursor","tree_length","output","toExponential","toFixed","substring","slice","toLowerCase","valueOf","toUpperCase","replace","charAt","sprintf_format","sprintf_cache","_fmt","arg_names","SyntaxError","field_list","replacement_field","field_match","sprintf_parse","vsprintf","__WEBPACK_AMD_DEFINE_RESULT__","LUAC_DATA","LUAC_VERSION","DumpState","write","DumpBlock","DumpByte","DumpInt","ab","setInt32","DumpInteger","DumpNumber","DumpString","DumpProtos","DumpFunction","psource","DumpCode","DumpConstants","DumpUpvalues","DumpDebug","DumpHeader","BytecodeParser","Z","intSize","size_tSize","instructionSize","integerSize","numberSize","arraybuffer","getInt32","readInteger","readByte","readSize_t","read","readInt","readInstruction","readNumber","readString","readFunction","readCode","readConstants","readUpvalues","readProtos","readDebug","checkliteral","checksize","why","S","checkHeader","hasjumps","tonumeral","make_tvalue","ek","pfrom","pl","getjump","fixjump","jmp","l1","l2","list","condjump","getjumpcontroloffset","getjumpcontrol","patchtestreg","node","removevalues","patchlistaux","vtarget","dtarget","luaK_code","dischargejpc","codeextraarg","newstack","freeexp","freeexps","e1","r1","r2","addk","luaK_numberK","boolK","code_loadbool","jump","discharge2reg","discharge2anyreg","need_value","exp2reg","final","p_t","fj","vk","nilK","negatecondition","jumponcond","ie","constfolding","validop","codebinexpval","rk2","rk1","opr","codecomp","codeunexpval","codenot","ereg","nelems","ex","_fengari","ok","interop","document","HTMLDocument","msghandler","ErrorEvent","bubbles","cancelable","lineno","run_lua_script","location","syntaxerror","currentScript","dispatchEvent","process_xhr_response","Event","contentTypeRegexp","luaVersionRegex","try_tag","tagName","contentTypeMatch","mimetype","hasAttribute","getAttribute","readyState","async","fetch","credentials","crossorigin","crossorigin_to_credentials","redirect","integrity","then","resp","arrayBuffer","catch","reason","onreadystatechange","innerHTML","run_lua_script_tag","MutationObserver","records","observer","record","addedNodes","observe","childList","subtree","querySelectorAll"],"mappings":"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","file":"fengari-web.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"fengari\"] = factory();\n\telse\n\t\troot[\"fengari\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 39);\n","\"use strict\";\n\n/*\n * Fengari specific string conversion functions\n */\n\nlet luastring_from;\nif (typeof Uint8Array.from === \"function\") {\n    luastring_from = Uint8Array.from.bind(Uint8Array);\n} else {\n    luastring_from = function(a) {\n        let i = 0;\n        let len = a.length;\n        let r = new Uint8Array(len);\n        while (len > i) r[i] = a[i++];\n        return r;\n    };\n}\n\nlet luastring_indexOf;\nif (typeof (new Uint8Array().indexOf) === \"function\") {\n    luastring_indexOf = function(s, v, i) {\n        return s.indexOf(v, i);\n    };\n} else {\n    /* Browsers that don't support Uint8Array.indexOf seem to allow using Array.indexOf on Uint8Array objects e.g. IE11 */\n    let array_indexOf = [].indexOf;\n    if (array_indexOf.call(new Uint8Array(1), 0) !== 0) throw Error(\"missing .indexOf\");\n    luastring_indexOf = function(s, v, i) {\n        return array_indexOf.call(s, v, i);\n    };\n}\n\nlet luastring_of;\nif (typeof Uint8Array.of === \"function\") {\n    luastring_of = Uint8Array.of.bind(Uint8Array);\n} else {\n    luastring_of = function() {\n        return luastring_from(arguments);\n    };\n}\n\nconst is_luastring = function(s) {\n    return s instanceof Uint8Array;\n};\n\n/* test two lua strings for equality */\nconst luastring_eq = function(a, b) {\n    if (a !== b) {\n        let len = a.length;\n        if (len !== b.length) return false;\n        /* XXX: Should this be a constant time algorithm? */\n        for (let i=0; i<len; i++)\n            if (a[i] !== b[i]) return false;\n    }\n    return true;\n};\n\nconst unicode_error_message = \"cannot convert invalid utf8 to javascript string\";\nconst to_jsstring = function(value, from, to, replacement_char) {\n    if (!is_luastring(value)) throw new TypeError(\"to_jsstring expects a Uint8Array\");\n\n    if (to === void 0) {\n        to = value.length;\n    } else {\n        to = Math.min(value.length, to);\n    }\n\n    let str = \"\";\n    for (let i = (from!==void 0?from:0); i < to;) {\n        let u0 = value[i++];\n        if (u0 < 0x80) {\n            /* single byte sequence */\n            str += String.fromCharCode(u0);\n        } else if (u0 < 0xC2 || u0 > 0xF4) {\n            if (!replacement_char) throw RangeError(unicode_error_message);\n            str += \"�\";\n        } else if (u0 <= 0xDF) {\n            /* two byte sequence */\n            if (i >= to) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            let u1 = value[i++];\n            if ((u1&0xC0) !== 0x80) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            str += String.fromCharCode(((u0 & 0x1F) << 6) + (u1 & 0x3F));\n        } else if (u0 <= 0xEF) {\n            /* three byte sequence */\n            if (i+1 >= to) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            let u1 = value[i++];\n            if ((u1&0xC0) !== 0x80) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            let u2 = value[i++];\n            if ((u2&0xC0) !== 0x80) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            let u = ((u0 & 0x0F) << 12) + ((u1 & 0x3F) << 6) + (u2 & 0x3F);\n            if (u <= 0xFFFF) { /* BMP codepoint */\n                str += String.fromCharCode(u);\n            } else { /* Astral codepoint */\n                u -= 0x10000;\n                let s1 = (u >> 10) + 0xD800;\n                let s2 = (u % 0x400) + 0xDC00;\n                str += String.fromCharCode(s1, s2);\n            }\n        } else {\n            /* four byte sequence */\n            if (i+2 >= to) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            let u1 = value[i++];\n            if ((u1&0xC0) !== 0x80) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            let u2 = value[i++];\n            if ((u2&0xC0) !== 0x80) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            let u3 = value[i++];\n            if ((u3&0xC0) !== 0x80) {\n                if (!replacement_char) throw RangeError(unicode_error_message);\n                str += \"�\";\n                continue;\n            }\n            /* Has to be astral codepoint */\n            let u = ((u0 & 0x07) << 18) + ((u1 & 0x3F) << 12) + ((u2 & 0x3F) << 6) + (u3 & 0x3F);\n            u -= 0x10000;\n            let s1 = (u >> 10) + 0xD800;\n            let s2 = (u % 0x400) + 0xDC00;\n            str += String.fromCharCode(s1, s2);\n        }\n    }\n    return str;\n};\n\n/* bytes allowed unescaped in a uri */\nconst uri_allowed = (\";,/?:@&=+$abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,-_.!~*'()#\").split('').reduce(function(uri_allowed, c) {\n    uri_allowed[c.charCodeAt(0)] = true;\n    return uri_allowed;\n}, {});\n\n/* utility function to convert a lua string to a js string with uri escaping */\nconst to_uristring = function(a) {\n    if (!is_luastring(a)) throw new TypeError(\"to_uristring expects a Uint8Array\");\n    let s = \"\";\n    for (let i=0; i<a.length; i++) {\n        let v = a[i];\n        if (uri_allowed[v]) {\n            s += String.fromCharCode(v);\n        } else {\n            s += \"%\" + (v<0x10?\"0\":\"\") + v.toString(16);\n        }\n    }\n    return s;\n};\n\nconst to_luastring_cache = {};\n\nconst to_luastring = function(str, cache) {\n    if (typeof str !== \"string\") throw new TypeError(\"to_luastring expects a javascript string\");\n\n    if (cache) {\n        let cached = to_luastring_cache[str];\n        if (is_luastring(cached)) return cached;\n    }\n\n    let len = str.length;\n    let outU8Array = Array(len); /* array is at *least* going to be length of string */\n    let outIdx = 0;\n    for (let i = 0; i < len; ++i) {\n        let u = str.charCodeAt(i);\n        if (u <= 0x7F) {\n            outU8Array[outIdx++] = u;\n        } else if (u <= 0x7FF) {\n            outU8Array[outIdx++] = 0xC0 | (u >> 6);\n            outU8Array[outIdx++] = 0x80 | (u & 63);\n        } else {\n            /* This part is to work around possible lack of String.codePointAt */\n            if (u >= 0xD800 && u <= 0xDBFF && (i+1) < len) {\n                /* is first half of surrogate pair */\n                let v = str.charCodeAt(i+1);\n                if (v >= 0xDC00 && v <= 0xDFFF) {\n                    /* is valid low surrogate */\n                    i++;\n                    u = (u - 0xD800) * 0x400 + v + 0x2400;\n                }\n            }\n            if (u <= 0xFFFF) {\n                outU8Array[outIdx++] = 0xE0 | (u >> 12);\n                outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);\n                outU8Array[outIdx++] = 0x80 | (u & 63);\n            } else {\n                outU8Array[outIdx++] = 0xF0 | (u >> 18);\n                outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);\n                outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);\n                outU8Array[outIdx++] = 0x80 | (u & 63);\n            }\n        }\n    }\n    outU8Array = luastring_from(outU8Array);\n\n    if (cache) to_luastring_cache[str] = outU8Array;\n\n    return outU8Array;\n};\n\nconst from_userstring = function(str) {\n    if (!is_luastring(str)) {\n        if (typeof str === \"string\") {\n            str = to_luastring(str);\n        } else {\n            throw new TypeError(\"expects an array of bytes or javascript string\");\n        }\n    }\n    return str;\n};\n\nmodule.exports.luastring_from    = luastring_from;\nmodule.exports.luastring_indexOf = luastring_indexOf;\nmodule.exports.luastring_of      = luastring_of;\nmodule.exports.is_luastring      = is_luastring;\nmodule.exports.luastring_eq      = luastring_eq;\nmodule.exports.to_jsstring       = to_jsstring;\nmodule.exports.to_uristring      = to_uristring;\nmodule.exports.to_luastring      = to_luastring;\nmodule.exports.from_userstring   = from_userstring;\n\n\n/* mark for precompiled code ('<esc>Lua') */\nconst LUA_SIGNATURE = to_luastring(\"\\x1bLua\");\n\nconst LUA_VERSION_MAJOR   = \"5\";\nconst LUA_VERSION_MINOR   = \"3\";\nconst LUA_VERSION_NUM     = 503;\nconst LUA_VERSION_RELEASE = \"4\";\n\nconst LUA_VERSION         = \"Lua \" + LUA_VERSION_MAJOR + \".\" + LUA_VERSION_MINOR;\nconst LUA_RELEASE         = LUA_VERSION + \".\" + LUA_VERSION_RELEASE;\nconst LUA_COPYRIGHT       = LUA_RELEASE + \"  Copyright (C) 1994-2017 Lua.org, PUC-Rio\";\nconst LUA_AUTHORS         = \"R. Ierusalimschy, L. H. de Figueiredo, W. Celes\";\n\nmodule.exports.LUA_SIGNATURE       = LUA_SIGNATURE;\nmodule.exports.LUA_VERSION_MAJOR   = LUA_VERSION_MAJOR;\nmodule.exports.LUA_VERSION_MINOR   = LUA_VERSION_MINOR;\nmodule.exports.LUA_VERSION_NUM     = LUA_VERSION_NUM;\nmodule.exports.LUA_VERSION_RELEASE = LUA_VERSION_RELEASE;\nmodule.exports.LUA_VERSION         = LUA_VERSION;\nmodule.exports.LUA_RELEASE         = LUA_RELEASE;\nmodule.exports.LUA_COPYRIGHT       = LUA_COPYRIGHT;\nmodule.exports.LUA_AUTHORS         = LUA_AUTHORS;\n\n\nconst thread_status = {\n    LUA_OK:        0,\n    LUA_YIELD:     1,\n    LUA_ERRRUN:    2,\n    LUA_ERRSYNTAX: 3,\n    LUA_ERRMEM:    4,\n    LUA_ERRGCMM:   5,\n    LUA_ERRERR:    6\n};\n\nconst constant_types = {\n    LUA_TNONE:          -1,\n    LUA_TNIL:           0,\n    LUA_TBOOLEAN:       1,\n    LUA_TLIGHTUSERDATA: 2,\n    LUA_TNUMBER:        3,\n    LUA_TSTRING:        4,\n    LUA_TTABLE:         5,\n    LUA_TFUNCTION:      6,\n    LUA_TUSERDATA:      7,\n    LUA_TTHREAD:        8,\n    LUA_NUMTAGS:        9\n};\n\nconstant_types.LUA_TSHRSTR = constant_types.LUA_TSTRING | (0 << 4);  /* short strings */\nconstant_types.LUA_TLNGSTR = constant_types.LUA_TSTRING | (1 << 4);  /* long strings */\n\nconstant_types.LUA_TNUMFLT = constant_types.LUA_TNUMBER | (0 << 4);  /* float numbers */\nconstant_types.LUA_TNUMINT = constant_types.LUA_TNUMBER | (1 << 4);  /* integer numbers */\n\nconstant_types.LUA_TLCL = constant_types.LUA_TFUNCTION | (0 << 4);  /* Lua closure */\nconstant_types.LUA_TLCF = constant_types.LUA_TFUNCTION | (1 << 4);  /* light C function */\nconstant_types.LUA_TCCL = constant_types.LUA_TFUNCTION | (2 << 4);  /* C closure */\n\n/*\n** Comparison and arithmetic functions\n*/\n\nconst LUA_OPADD  = 0;   /* ORDER TM, ORDER OP */\nconst LUA_OPSUB  = 1;\nconst LUA_OPMUL  = 2;\nconst LUA_OPMOD  = 3;\nconst LUA_OPPOW  = 4;\nconst LUA_OPDIV  = 5;\nconst LUA_OPIDIV = 6;\nconst LUA_OPBAND = 7;\nconst LUA_OPBOR  = 8;\nconst LUA_OPBXOR = 9;\nconst LUA_OPSHL  = 10;\nconst LUA_OPSHR  = 11;\nconst LUA_OPUNM  = 12;\nconst LUA_OPBNOT = 13;\n\nconst LUA_OPEQ = 0;\nconst LUA_OPLT = 1;\nconst LUA_OPLE = 2;\n\nconst LUA_MINSTACK = 20;\n\nconst { LUAI_MAXSTACK } = require('./luaconf.js');\nconst LUA_REGISTRYINDEX = -LUAI_MAXSTACK - 1000;\n\nconst lua_upvalueindex = function(i) {\n    return LUA_REGISTRYINDEX - i;\n};\n\n/* predefined values in the registry */\nconst LUA_RIDX_MAINTHREAD = 1;\nconst LUA_RIDX_GLOBALS    = 2;\nconst LUA_RIDX_LAST       = LUA_RIDX_GLOBALS;\n\nclass lua_Debug {\n    constructor() {\n        this.event = NaN;\n        this.name = null;           /* (n) */\n        this.namewhat = null;       /* (n) 'global', 'local', 'field', 'method' */\n        this.what = null;           /* (S) 'Lua', 'C', 'main', 'tail' */\n        this.source = null;         /* (S) */\n        this.currentline = NaN;     /* (l) */\n        this.linedefined = NaN;     /* (S) */\n        this.lastlinedefined = NaN; /* (S) */\n        this.nups = NaN;            /* (u) number of upvalues */\n        this.nparams = NaN;         /* (u) number of parameters */\n        this.isvararg = NaN;        /* (u) */\n        this.istailcall = NaN;      /* (t) */\n        this.short_src = null;      /* (S) */\n        /* private part */\n        this.i_ci = null;           /* active function */\n    }\n}\n\n/*\n** Event codes\n*/\nconst LUA_HOOKCALL     = 0;\nconst LUA_HOOKRET      = 1;\nconst LUA_HOOKLINE     = 2;\nconst LUA_HOOKCOUNT    = 3;\nconst LUA_HOOKTAILCALL = 4;\n\n\n/*\n** Event masks\n*/\nconst LUA_MASKCALL  = (1 << LUA_HOOKCALL);\nconst LUA_MASKRET   = (1 << LUA_HOOKRET);\nconst LUA_MASKLINE  = (1 << LUA_HOOKLINE);\nconst LUA_MASKCOUNT = (1 << LUA_HOOKCOUNT);\n\nmodule.exports.LUA_HOOKCALL            = LUA_HOOKCALL;\nmodule.exports.LUA_HOOKCOUNT           = LUA_HOOKCOUNT;\nmodule.exports.LUA_HOOKLINE            = LUA_HOOKLINE;\nmodule.exports.LUA_HOOKRET             = LUA_HOOKRET;\nmodule.exports.LUA_HOOKTAILCALL        = LUA_HOOKTAILCALL;\nmodule.exports.LUA_MASKCALL            = LUA_MASKCALL;\nmodule.exports.LUA_MASKCOUNT           = LUA_MASKCOUNT;\nmodule.exports.LUA_MASKLINE            = LUA_MASKLINE;\nmodule.exports.LUA_MASKRET             = LUA_MASKRET;\nmodule.exports.LUA_MINSTACK            = LUA_MINSTACK;\nmodule.exports.LUA_MULTRET             = -1;\nmodule.exports.LUA_OPADD               = LUA_OPADD;\nmodule.exports.LUA_OPBAND              = LUA_OPBAND;\nmodule.exports.LUA_OPBNOT              = LUA_OPBNOT;\nmodule.exports.LUA_OPBOR               = LUA_OPBOR;\nmodule.exports.LUA_OPBXOR              = LUA_OPBXOR;\nmodule.exports.LUA_OPDIV               = LUA_OPDIV;\nmodule.exports.LUA_OPEQ                = LUA_OPEQ;\nmodule.exports.LUA_OPIDIV              = LUA_OPIDIV;\nmodule.exports.LUA_OPLE                = LUA_OPLE;\nmodule.exports.LUA_OPLT                = LUA_OPLT;\nmodule.exports.LUA_OPMOD               = LUA_OPMOD;\nmodule.exports.LUA_OPMUL               = LUA_OPMUL;\nmodule.exports.LUA_OPPOW               = LUA_OPPOW;\nmodule.exports.LUA_OPSHL               = LUA_OPSHL;\nmodule.exports.LUA_OPSHR               = LUA_OPSHR;\nmodule.exports.LUA_OPSUB               = LUA_OPSUB;\nmodule.exports.LUA_OPUNM               = LUA_OPUNM;\nmodule.exports.LUA_REGISTRYINDEX       = LUA_REGISTRYINDEX;\nmodule.exports.LUA_RIDX_GLOBALS        = LUA_RIDX_GLOBALS;\nmodule.exports.LUA_RIDX_LAST           = LUA_RIDX_LAST;\nmodule.exports.LUA_RIDX_MAINTHREAD     = LUA_RIDX_MAINTHREAD;\nmodule.exports.constant_types          = constant_types;\nmodule.exports.lua_Debug               = lua_Debug;\nmodule.exports.lua_upvalueindex        = lua_upvalueindex;\nmodule.exports.thread_status           = thread_status;\n","\"use strict\";\n\nconst defs   = require(\"./defs.js\");\nconst lapi   = require(\"./lapi.js\");\nconst ldebug = require(\"./ldebug.js\");\nconst ldo    = require(\"./ldo.js\");\nconst lstate = require(\"./lstate.js\");\n\nmodule.exports.LUA_AUTHORS             = defs.LUA_AUTHORS;\nmodule.exports.LUA_COPYRIGHT           = defs.LUA_COPYRIGHT;\nmodule.exports.LUA_ERRERR              = defs.thread_status.LUA_ERRERR;\nmodule.exports.LUA_ERRGCMM             = defs.thread_status.LUA_ERRGCMM;\nmodule.exports.LUA_ERRMEM              = defs.thread_status.LUA_ERRMEM;\nmodule.exports.LUA_ERRRUN              = defs.thread_status.LUA_ERRRUN;\nmodule.exports.LUA_ERRSYNTAX           = defs.thread_status.LUA_ERRSYNTAX;\nmodule.exports.LUA_HOOKCALL            = defs.LUA_HOOKCALL;\nmodule.exports.LUA_HOOKCOUNT           = defs.LUA_HOOKCOUNT;\nmodule.exports.LUA_HOOKLINE            = defs.LUA_HOOKLINE;\nmodule.exports.LUA_HOOKRET             = defs.LUA_HOOKRET;\nmodule.exports.LUA_HOOKTAILCALL        = defs.LUA_HOOKTAILCALL;\nmodule.exports.LUA_MASKCALL            = defs.LUA_MASKCALL;\nmodule.exports.LUA_MASKCOUNT           = defs.LUA_MASKCOUNT;\nmodule.exports.LUA_MASKLINE            = defs.LUA_MASKLINE;\nmodule.exports.LUA_MASKRET             = defs.LUA_MASKRET;\nmodule.exports.LUA_MINSTACK            = defs.LUA_MINSTACK;\nmodule.exports.LUA_MULTRET             = defs.LUA_MULTRET;\nmodule.exports.LUA_NUMTAGS             = defs.constant_types.LUA_NUMTAGS;\nmodule.exports.LUA_OK                  = defs.thread_status.LUA_OK;\nmodule.exports.LUA_OPADD               = defs.LUA_OPADD;\nmodule.exports.LUA_OPBAND              = defs.LUA_OPBAND;\nmodule.exports.LUA_OPBNOT              = defs.LUA_OPBNOT;\nmodule.exports.LUA_OPBOR               = defs.LUA_OPBOR;\nmodule.exports.LUA_OPBXOR              = defs.LUA_OPBXOR;\nmodule.exports.LUA_OPDIV               = defs.LUA_OPDIV;\nmodule.exports.LUA_OPEQ                = defs.LUA_OPEQ;\nmodule.exports.LUA_OPIDIV              = defs.LUA_OPIDIV;\nmodule.exports.LUA_OPLE                = defs.LUA_OPLE;\nmodule.exports.LUA_OPLT                = defs.LUA_OPLT;\nmodule.exports.LUA_OPMOD               = defs.LUA_OPMOD;\nmodule.exports.LUA_OPMUL               = defs.LUA_OPMUL;\nmodule.exports.LUA_OPPOW               = defs.LUA_OPPOW;\nmodule.exports.LUA_OPSHL               = defs.LUA_OPSHL;\nmodule.exports.LUA_OPSHR               = defs.LUA_OPSHR;\nmodule.exports.LUA_OPSUB               = defs.LUA_OPSUB;\nmodule.exports.LUA_OPUNM               = defs.LUA_OPUNM;\nmodule.exports.LUA_REGISTRYINDEX       = defs.LUA_REGISTRYINDEX;\nmodule.exports.LUA_RELEASE             = defs.LUA_RELEASE;\nmodule.exports.LUA_RIDX_GLOBALS        = defs.LUA_RIDX_GLOBALS;\nmodule.exports.LUA_RIDX_LAST           = defs.LUA_RIDX_LAST;\nmodule.exports.LUA_RIDX_MAINTHREAD     = defs.LUA_RIDX_MAINTHREAD;\nmodule.exports.LUA_SIGNATURE           = defs.LUA_SIGNATURE;\nmodule.exports.LUA_TNONE               = defs.constant_types.LUA_TNONE;\nmodule.exports.LUA_TNIL                = defs.constant_types.LUA_TNIL;\nmodule.exports.LUA_TBOOLEAN            = defs.constant_types.LUA_TBOOLEAN;\nmodule.exports.LUA_TLIGHTUSERDATA      = defs.constant_types.LUA_TLIGHTUSERDATA;\nmodule.exports.LUA_TNUMBER             = defs.constant_types.LUA_TNUMBER;\nmodule.exports.LUA_TSTRING             = defs.constant_types.LUA_TSTRING;\nmodule.exports.LUA_TTABLE              = defs.constant_types.LUA_TTABLE;\nmodule.exports.LUA_TFUNCTION           = defs.constant_types.LUA_TFUNCTION;\nmodule.exports.LUA_TUSERDATA           = defs.constant_types.LUA_TUSERDATA;\nmodule.exports.LUA_TTHREAD             = defs.constant_types.LUA_TTHREAD;\nmodule.exports.LUA_VERSION             = defs.LUA_VERSION;\nmodule.exports.LUA_VERSION_MAJOR       = defs.LUA_VERSION_MAJOR;\nmodule.exports.LUA_VERSION_MINOR       = defs.LUA_VERSION_MINOR;\nmodule.exports.LUA_VERSION_NUM         = defs.LUA_VERSION_NUM;\nmodule.exports.LUA_VERSION_RELEASE     = defs.LUA_VERSION_RELEASE;\nmodule.exports.LUA_YIELD               = defs.thread_status.LUA_YIELD;\nmodule.exports.lua_Debug               = defs.lua_Debug;\nmodule.exports.lua_upvalueindex        = defs.lua_upvalueindex;\nmodule.exports.lua_absindex            = lapi.lua_absindex;\nmodule.exports.lua_arith               = lapi.lua_arith;\nmodule.exports.lua_atpanic             = lapi.lua_atpanic;\nmodule.exports.lua_atnativeerror       = lapi.lua_atnativeerror;\nmodule.exports.lua_call                = lapi.lua_call;\nmodule.exports.lua_callk               = lapi.lua_callk;\nmodule.exports.lua_checkstack          = lapi.lua_checkstack;\nmodule.exports.lua_close               = lstate.lua_close;\nmodule.exports.lua_compare             = lapi.lua_compare;\nmodule.exports.lua_concat              = lapi.lua_concat;\nmodule.exports.lua_copy                = lapi.lua_copy;\nmodule.exports.lua_createtable         = lapi.lua_createtable;\nmodule.exports.lua_dump                = lapi.lua_dump;\nmodule.exports.lua_error               = lapi.lua_error;\nmodule.exports.lua_gc                  = lapi.lua_gc;\nmodule.exports.lua_getallocf           = lapi.lua_getallocf;\nmodule.exports.lua_getextraspace       = lapi.lua_getextraspace;\nmodule.exports.lua_getfield            = lapi.lua_getfield;\nmodule.exports.lua_getglobal           = lapi.lua_getglobal;\nmodule.exports.lua_gethook             = ldebug.lua_gethook;\nmodule.exports.lua_gethookcount        = ldebug.lua_gethookcount;\nmodule.exports.lua_gethookmask         = ldebug.lua_gethookmask;\nmodule.exports.lua_geti                = lapi.lua_geti;\nmodule.exports.lua_getinfo             = ldebug.lua_getinfo;\nmodule.exports.lua_getlocal            = ldebug.lua_getlocal;\nmodule.exports.lua_getmetatable        = lapi.lua_getmetatable;\nmodule.exports.lua_getstack            = ldebug.lua_getstack;\nmodule.exports.lua_gettable            = lapi.lua_gettable;\nmodule.exports.lua_gettop              = lapi.lua_gettop;\nmodule.exports.lua_getupvalue          = lapi.lua_getupvalue;\nmodule.exports.lua_getuservalue        = lapi.lua_getuservalue;\nmodule.exports.lua_insert              = lapi.lua_insert;\nmodule.exports.lua_isboolean           = lapi.lua_isboolean;\nmodule.exports.lua_iscfunction         = lapi.lua_iscfunction;\nmodule.exports.lua_isfunction          = lapi.lua_isfunction;\nmodule.exports.lua_isinteger           = lapi.lua_isinteger;\nmodule.exports.lua_islightuserdata     = lapi.lua_islightuserdata;\nmodule.exports.lua_isnil               = lapi.lua_isnil;\nmodule.exports.lua_isnone              = lapi.lua_isnone;\nmodule.exports.lua_isnoneornil         = lapi.lua_isnoneornil;\nmodule.exports.lua_isnumber            = lapi.lua_isnumber;\nmodule.exports.lua_isproxy             = lapi.lua_isproxy;\nmodule.exports.lua_isstring            = lapi.lua_isstring;\nmodule.exports.lua_istable             = lapi.lua_istable;\nmodule.exports.lua_isthread            = lapi.lua_isthread;\nmodule.exports.lua_isuserdata          = lapi.lua_isuserdata;\nmodule.exports.lua_isyieldable         = ldo.lua_isyieldable;\nmodule.exports.lua_len                 = lapi.lua_len;\nmodule.exports.lua_load                = lapi.lua_load;\nmodule.exports.lua_newstate            = lstate.lua_newstate;\nmodule.exports.lua_newtable            = lapi.lua_newtable;\nmodule.exports.lua_newthread           = lstate.lua_newthread;\nmodule.exports.lua_newuserdata         = lapi.lua_newuserdata;\nmodule.exports.lua_next                = lapi.lua_next;\nmodule.exports.lua_pcall               = lapi.lua_pcall;\nmodule.exports.lua_pcallk              = lapi.lua_pcallk;\nmodule.exports.lua_pop                 = lapi.lua_pop;\nmodule.exports.lua_pushboolean         = lapi.lua_pushboolean;\nmodule.exports.lua_pushcclosure        = lapi.lua_pushcclosure;\nmodule.exports.lua_pushcfunction       = lapi.lua_pushcfunction;\nmodule.exports.lua_pushfstring         = lapi.lua_pushfstring;\nmodule.exports.lua_pushglobaltable     = lapi.lua_pushglobaltable;\nmodule.exports.lua_pushinteger         = lapi.lua_pushinteger;\nmodule.exports.lua_pushjsclosure       = lapi.lua_pushjsclosure;\nmodule.exports.lua_pushjsfunction      = lapi.lua_pushjsfunction;\nmodule.exports.lua_pushlightuserdata   = lapi.lua_pushlightuserdata;\nmodule.exports.lua_pushliteral         = lapi.lua_pushliteral;\nmodule.exports.lua_pushlstring         = lapi.lua_pushlstring;\nmodule.exports.lua_pushnil             = lapi.lua_pushnil;\nmodule.exports.lua_pushnumber          = lapi.lua_pushnumber;\nmodule.exports.lua_pushstring          = lapi.lua_pushstring;\nmodule.exports.lua_pushthread          = lapi.lua_pushthread;\nmodule.exports.lua_pushvalue           = lapi.lua_pushvalue;\nmodule.exports.lua_pushvfstring        = lapi.lua_pushvfstring;\nmodule.exports.lua_rawequal            = lapi.lua_rawequal;\nmodule.exports.lua_rawget              = lapi.lua_rawget;\nmodule.exports.lua_rawgeti             = lapi.lua_rawgeti;\nmodule.exports.lua_rawgetp             = lapi.lua_rawgetp;\nmodule.exports.lua_rawlen              = lapi.lua_rawlen;\nmodule.exports.lua_rawset              = lapi.lua_rawset;\nmodule.exports.lua_rawseti             = lapi.lua_rawseti;\nmodule.exports.lua_rawsetp             = lapi.lua_rawsetp;\nmodule.exports.lua_register            = lapi.lua_register;\nmodule.exports.lua_remove              = lapi.lua_remove;\nmodule.exports.lua_replace             = lapi.lua_replace;\nmodule.exports.lua_resume              = ldo.lua_resume;\nmodule.exports.lua_rotate              = lapi.lua_rotate;\nmodule.exports.lua_setallof            = ldo.lua_setallof;\nmodule.exports.lua_setfield            = lapi.lua_setfield;\nmodule.exports.lua_setglobal           = lapi.lua_setglobal;\nmodule.exports.lua_sethook             = ldebug.lua_sethook;\nmodule.exports.lua_seti                = lapi.lua_seti;\nmodule.exports.lua_setlocal            = ldebug.lua_setlocal;\nmodule.exports.lua_setmetatable        = lapi.lua_setmetatable;\nmodule.exports.lua_settable            = lapi.lua_settable;\nmodule.exports.lua_settop              = lapi.lua_settop;\nmodule.exports.lua_setupvalue          = lapi.lua_setupvalue;\nmodule.exports.lua_setuservalue        = lapi.lua_setuservalue;\nmodule.exports.lua_status              = lapi.lua_status;\nmodule.exports.lua_stringtonumber      = lapi.lua_stringtonumber;\nmodule.exports.lua_toboolean           = lapi.lua_toboolean;\nmodule.exports.lua_todataview          = lapi.lua_todataview;\nmodule.exports.lua_tointeger           = lapi.lua_tointeger;\nmodule.exports.lua_tointegerx          = lapi.lua_tointegerx;\nmodule.exports.lua_tojsstring          = lapi.lua_tojsstring;\nmodule.exports.lua_tolstring           = lapi.lua_tolstring;\nmodule.exports.lua_tonumber            = lapi.lua_tonumber;\nmodule.exports.lua_tonumberx           = lapi.lua_tonumberx;\nmodule.exports.lua_topointer           = lapi.lua_topointer;\nmodule.exports.lua_toproxy             = lapi.lua_toproxy;\nmodule.exports.lua_tostring            = lapi.lua_tostring;\nmodule.exports.lua_tothread            = lapi.lua_tothread;\nmodule.exports.lua_touserdata          = lapi.lua_touserdata;\nmodule.exports.lua_type                = lapi.lua_type;\nmodule.exports.lua_typename            = lapi.lua_typename;\nmodule.exports.lua_upvalueid           = lapi.lua_upvalueid;\nmodule.exports.lua_upvaluejoin         = lapi.lua_upvaluejoin;\nmodule.exports.lua_version             = lapi.lua_version;\nmodule.exports.lua_xmove               = lapi.lua_xmove;\nmodule.exports.lua_yield               = ldo.lua_yield;\nmodule.exports.lua_yieldk              = ldo.lua_yieldk;\nmodule.exports.lua_tocfunction         = lapi.lua_tocfunction;\n","\"use strict\";\n\nconst { luai_apicheck } = require(\"./luaconf.js\");\n\nconst lua_assert = function(c) {\n    if (!c) throw Error(\"assertion failed\");\n};\nmodule.exports.lua_assert = lua_assert;\n\nmodule.exports.luai_apicheck = luai_apicheck || function(l, e) { return lua_assert(e); };\n\nconst api_check = function(l, e, msg) {\n    return luai_apicheck(l, e && msg);\n};\nmodule.exports.api_check = api_check;\n\nconst LUAI_MAXCCALLS = 200;\nmodule.exports.LUAI_MAXCCALLS = LUAI_MAXCCALLS;\n\n/* minimum size for string buffer */\nconst LUA_MINBUFFER = 32;\nmodule.exports.LUA_MINBUFFER = LUA_MINBUFFER;\n\nconst luai_nummod = function(L, a, b) {\n    let m = a % b;\n    if ((m*b) < 0)\n        m += b;\n    return m;\n};\nmodule.exports.luai_nummod = luai_nummod;\n\n// If later integers are more than 32bit, LUA_MAXINTEGER will then be != MAX_INT\nconst MAX_INT = 2147483647;\nmodule.exports.MAX_INT = MAX_INT;\nconst MIN_INT = -2147483648;\nmodule.exports.MIN_INT = MIN_INT;\n","\"use strict\";\n\nconst conf = (process.env.FENGARICONF ? JSON.parse(process.env.FENGARICONF) : {});\n\nconst {\n    LUA_VERSION_MAJOR,\n    LUA_VERSION_MINOR,\n    to_luastring\n} = require('./defs.js');\n\n/*\n** LUA_PATH_SEP is the character that separates templates in a path.\n** LUA_PATH_MARK is the string that marks the substitution points in a\n** template.\n** LUA_EXEC_DIR in a Windows path is replaced by the executable's\n** directory.\n*/\nconst LUA_PATH_SEP  = \";\";\nmodule.exports.LUA_PATH_SEP = LUA_PATH_SEP;\n\nconst LUA_PATH_MARK = \"?\";\nmodule.exports.LUA_PATH_MARK = LUA_PATH_MARK;\n\nconst LUA_EXEC_DIR  = \"!\";\nmodule.exports.LUA_EXEC_DIR = LUA_EXEC_DIR;\n\n/*\n@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for\n** Lua libraries.\n@@ LUA_JSPATH_DEFAULT is the default path that Lua uses to look for\n** JS libraries.\n** CHANGE them if your machine has a non-conventional directory\n** hierarchy or if you want to install your libraries in\n** non-conventional directories.\n*/\nconst LUA_VDIR = LUA_VERSION_MAJOR + \".\" + LUA_VERSION_MINOR;\nmodule.exports.LUA_VDIR = LUA_VDIR;\n\nif (typeof process === \"undefined\") {\n    const LUA_DIRSEP = \"/\";\n    module.exports.LUA_DIRSEP = LUA_DIRSEP;\n\n    const LUA_LDIR = \"./lua/\" + LUA_VDIR + \"/\";\n    module.exports.LUA_LDIR = LUA_LDIR;\n\n    const LUA_JSDIR = LUA_LDIR;\n    module.exports.LUA_JSDIR = LUA_JSDIR;\n\n    const LUA_PATH_DEFAULT = to_luastring(\n        LUA_LDIR + \"?.lua;\" + LUA_LDIR + \"?/init.lua;\" +\n        /* LUA_JSDIR excluded as it is equal to LUA_LDIR */\n        \"./?.lua;./?/init.lua\"\n    );\n    module.exports.LUA_PATH_DEFAULT = LUA_PATH_DEFAULT;\n\n    const LUA_JSPATH_DEFAULT = to_luastring(\n        LUA_JSDIR + \"?.js;\" + LUA_JSDIR + \"loadall.js;./?.js\"\n    );\n    module.exports.LUA_JSPATH_DEFAULT = LUA_JSPATH_DEFAULT;\n} else if (require('os').platform() === 'win32') {\n    const LUA_DIRSEP = \"\\\\\";\n    module.exports.LUA_DIRSEP = LUA_DIRSEP;\n\n    /*\n    ** In Windows, any exclamation mark ('!') in the path is replaced by the\n    ** path of the directory of the executable file of the current process.\n    */\n    const LUA_LDIR = \"!\\\\lua\\\\\";\n    module.exports.LUA_LDIR = LUA_LDIR;\n\n    const LUA_JSDIR = \"!\\\\\";\n    module.exports.LUA_JSDIR = LUA_JSDIR;\n\n    const LUA_SHRDIR = \"!\\\\..\\\\share\\\\lua\\\\\" + LUA_VDIR + \"\\\\\";\n    module.exports.LUA_SHRDIR = LUA_SHRDIR;\n\n    const LUA_PATH_DEFAULT = to_luastring(\n        LUA_LDIR + \"?.lua;\" + LUA_LDIR + \"?\\\\init.lua;\" +\n        LUA_JSDIR + \"?.lua;\" + LUA_JSDIR + \"?\\\\init.lua;\" +\n        LUA_SHRDIR + \"?.lua;\" + LUA_SHRDIR + \"?\\\\init.lua;\" +\n        \".\\\\?.lua;.\\\\?\\\\init.lua\"\n    );\n    module.exports.LUA_PATH_DEFAULT = LUA_PATH_DEFAULT;\n\n    const LUA_JSPATH_DEFAULT = to_luastring(\n        LUA_JSDIR + \"?.js;\" +\n        LUA_JSDIR + \"..\\\\share\\\\lua\\\\\" + LUA_VDIR + \"\\\\?.js;\" +\n        LUA_JSDIR + \"loadall.js;.\\\\?.js\"\n    );\n    module.exports.LUA_JSPATH_DEFAULT = LUA_JSPATH_DEFAULT;\n} else {\n    const LUA_DIRSEP = \"/\";\n    module.exports.LUA_DIRSEP = LUA_DIRSEP;\n\n    const LUA_ROOT = \"/usr/local/\";\n    module.exports.LUA_ROOT = LUA_ROOT;\n    const LUA_ROOT2 = \"/usr/\";\n\n    const LUA_LDIR = LUA_ROOT + \"share/lua/\" + LUA_VDIR + \"/\";\n    const LUA_LDIR2 = LUA_ROOT2 + \"share/lua/\" + LUA_VDIR + \"/\";\n    module.exports.LUA_LDIR = LUA_LDIR;\n\n    const LUA_JSDIR = LUA_LDIR;\n    module.exports.LUA_JSDIR = LUA_JSDIR;\n    const LUA_JSDIR2 = LUA_LDIR2;\n\n    const LUA_PATH_DEFAULT = to_luastring(\n        LUA_LDIR + \"?.lua;\" + LUA_LDIR + \"?/init.lua;\" +\n        LUA_LDIR2 + \"?.lua;\" + LUA_LDIR2 + \"?/init.lua;\" +\n        /* LUA_JSDIR(2) excluded as it is equal to LUA_LDIR(2) */\n        \"./?.lua;./?/init.lua\"\n    );\n    module.exports.LUA_PATH_DEFAULT = LUA_PATH_DEFAULT;\n\n    const LUA_JSPATH_DEFAULT = to_luastring(\n        LUA_JSDIR + \"?.js;\" + LUA_JSDIR + \"loadall.js;\" +\n        LUA_JSDIR2 + \"?.js;\" + LUA_JSDIR2 + \"loadall.js;\" +\n        \"./?.js\"\n    );\n    module.exports.LUA_JSPATH_DEFAULT = LUA_JSPATH_DEFAULT;\n}\n\n/*\n@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a\n@@ a float mark ('.0').\n** This macro is not on by default even in compatibility mode,\n** because this is not really an incompatibility.\n*/\nconst LUA_COMPAT_FLOATSTRING = conf.LUA_COMPAT_FLOATSTRING || false;\n\nconst LUA_MAXINTEGER = 2147483647;\nconst LUA_MININTEGER = -2147483648;\n\n/*\n@@ LUAI_MAXSTACK limits the size of the Lua stack.\n** CHANGE it if you need a different limit. This limit is arbitrary;\n** its only purpose is to stop Lua from consuming unlimited stack\n** space (and to reserve some numbers for pseudo-indices).\n*/\nconst LUAI_MAXSTACK = conf.LUAI_MAXSTACK || 1000000;\n\n/*\n@@ LUA_IDSIZE gives the maximum size for the description of the source\n@@ of a function in debug information.\n** CHANGE it if you want a different size.\n*/\nconst LUA_IDSIZE = conf.LUA_IDSIZE || (60-1); /* fengari uses 1 less than lua as we don't embed the null byte */\n\nconst lua_integer2str = function(n) {\n    return String(n); /* should match behaviour of LUA_INTEGER_FMT */\n};\n\nconst lua_number2str = function(n) {\n    return String(Number(n.toPrecision(14))); /* should match behaviour of LUA_NUMBER_FMT */\n};\n\nconst lua_numbertointeger = function(n) {\n    return n >= LUA_MININTEGER && n < -LUA_MININTEGER ? n : false;\n};\n\nconst LUA_INTEGER_FRMLEN = \"\";\nconst LUA_NUMBER_FRMLEN = \"\";\n\nconst LUA_INTEGER_FMT = `%${LUA_INTEGER_FRMLEN}d`;\nconst LUA_NUMBER_FMT  = \"%.14g\";\n\nconst lua_getlocaledecpoint = function() {\n    return (1.1).toLocaleString().charCodeAt(1);\n};\n\nconst luai_apicheck = function(l, e) {\n    if (!e) throw Error(e);\n};\n\n/*\n@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.\n*/\nconst LUAL_BUFFERSIZE = conf.LUAL_BUFFERSIZE || 8192;\n\n// See: http://croquetweak.blogspot.fr/2014/08/deconstructing-floats-frexp-and-ldexp.html\nconst frexp = function(value) {\n    if (value === 0) return [value, 0];\n    var data = new DataView(new ArrayBuffer(8));\n    data.setFloat64(0, value);\n    var bits = (data.getUint32(0) >>> 20) & 0x7FF;\n    if (bits === 0) { // denormal\n        data.setFloat64(0, value * Math.pow(2, 64));  // exp + 64\n        bits = ((data.getUint32(0) >>> 20) & 0x7FF) - 64;\n    }\n    var exponent = bits - 1022;\n    var mantissa = ldexp(value, -exponent);\n    return [mantissa, exponent];\n};\n\nconst ldexp = function(mantissa, exponent) {\n    var steps = Math.min(3, Math.ceil(Math.abs(exponent) / 1023));\n    var result = mantissa;\n    for (var i = 0; i < steps; i++)\n        result *= Math.pow(2, Math.floor((exponent + i) / steps));\n    return result;\n};\n\nmodule.exports.LUAI_MAXSTACK          = LUAI_MAXSTACK;\nmodule.exports.LUA_COMPAT_FLOATSTRING = LUA_COMPAT_FLOATSTRING;\nmodule.exports.LUA_IDSIZE             = LUA_IDSIZE;\nmodule.exports.LUA_INTEGER_FMT        = LUA_INTEGER_FMT;\nmodule.exports.LUA_INTEGER_FRMLEN     = LUA_INTEGER_FRMLEN;\nmodule.exports.LUA_MAXINTEGER         = LUA_MAXINTEGER;\nmodule.exports.LUA_MININTEGER         = LUA_MININTEGER;\nmodule.exports.LUA_NUMBER_FMT         = LUA_NUMBER_FMT;\nmodule.exports.LUA_NUMBER_FRMLEN      = LUA_NUMBER_FRMLEN;\nmodule.exports.LUAL_BUFFERSIZE        = LUAL_BUFFERSIZE;\nmodule.exports.frexp                  = frexp;\nmodule.exports.ldexp                  = ldexp;\nmodule.exports.lua_getlocaledecpoint  = lua_getlocaledecpoint;\nmodule.exports.lua_integer2str        = lua_integer2str;\nmodule.exports.lua_number2str         = lua_number2str;\nmodule.exports.lua_numbertointeger    = lua_numbertointeger;\nmodule.exports.luai_apicheck          = luai_apicheck;\n","\"use strict\";\n\nconst {\n    LUAL_BUFFERSIZE\n} = require('./luaconf.js');\nconst {\n    LUA_ERRERR,\n    LUA_MULTRET,\n    LUA_REGISTRYINDEX,\n    LUA_SIGNATURE,\n    LUA_TBOOLEAN,\n    LUA_TLIGHTUSERDATA,\n    LUA_TNIL,\n    LUA_TNONE,\n    LUA_TNUMBER,\n    LUA_TSTRING,\n    LUA_TTABLE,\n    LUA_VERSION_NUM,\n    lua_Debug,\n    lua_absindex,\n    lua_atpanic,\n    lua_call,\n    lua_checkstack,\n    lua_concat,\n    lua_copy,\n    lua_createtable,\n    lua_error,\n    lua_getfield,\n    lua_getinfo,\n    lua_getmetatable,\n    lua_getstack,\n    lua_gettop,\n    lua_insert,\n    lua_isinteger,\n    lua_isnil,\n    lua_isnumber,\n    lua_isstring,\n    lua_istable,\n    lua_len,\n    lua_load,\n    lua_newstate,\n    lua_newtable,\n    lua_next,\n    lua_pcall,\n    lua_pop,\n    lua_pushboolean,\n    lua_pushcclosure,\n    lua_pushcfunction,\n    lua_pushfstring,\n    lua_pushinteger,\n    lua_pushliteral,\n    lua_pushlstring,\n    lua_pushnil,\n    lua_pushstring,\n    lua_pushvalue,\n    lua_pushvfstring,\n    lua_rawequal,\n    lua_rawget,\n    lua_rawgeti,\n    lua_rawlen,\n    lua_rawseti,\n    lua_remove,\n    lua_setfield,\n    lua_setglobal,\n    lua_setmetatable,\n    lua_settop,\n    lua_toboolean,\n    lua_tointeger,\n    lua_tointegerx,\n    lua_tojsstring,\n    lua_tolstring,\n    lua_tonumber,\n    lua_tonumberx,\n    lua_topointer,\n    lua_tostring,\n    lua_touserdata,\n    lua_type,\n    lua_typename,\n    lua_version\n} = require('./lua.js');\nconst {\n    from_userstring,\n    luastring_eq,\n    to_luastring,\n    to_uristring\n} = require(\"./fengaricore.js\");\n\n/* extra error code for 'luaL_loadfilex' */\nconst LUA_ERRFILE = LUA_ERRERR+1;\n\n/* key, in the registry, for table of loaded modules */\nconst LUA_LOADED_TABLE = to_luastring(\"_LOADED\");\n\n/* key, in the registry, for table of preloaded loaders */\nconst LUA_PRELOAD_TABLE = to_luastring(\"_PRELOAD\");\n\nconst LUA_FILEHANDLE = to_luastring(\"FILE*\");\n\nconst LUAL_NUMSIZES  = 4*16 + 8;\n\nconst __name = to_luastring(\"__name\");\nconst __tostring = to_luastring(\"__tostring\");\n\nconst empty = new Uint8Array(0);\n\nclass luaL_Buffer {\n    constructor() {\n        this.L = null;\n        this.b = empty;\n        this.n = 0;\n    }\n}\n\nconst LEVELS1 = 10;  /* size of the first part of the stack */\nconst LEVELS2 = 11;  /* size of the second part of the stack */\n\n/*\n** search for 'objidx' in table at index -1.\n** return 1 + string at top if find a good name.\n*/\nconst findfield = function(L, objidx, level) {\n    if (level === 0 || !lua_istable(L, -1))\n        return 0;  /* not found */\n\n    lua_pushnil(L);  /* start 'next' loop */\n\n    while (lua_next(L, -2)) {  /* for each pair in table */\n        if (lua_type(L, -2) === LUA_TSTRING) {  /* ignore non-string keys */\n            if (lua_rawequal(L, objidx, -1)) {  /* found object? */\n                lua_pop(L, 1);  /* remove value (but keep name) */\n                return 1;\n            } else if (findfield(L, objidx, level - 1)) {  /* try recursively */\n                lua_remove(L, -2);  /* remove table (but keep name) */\n                lua_pushliteral(L, \".\");\n                lua_insert(L, -2);  /* place '.' between the two names */\n                lua_concat(L, 3);\n                return 1;\n            }\n        }\n        lua_pop(L, 1);  /* remove value */\n    }\n\n    return 0;  /* not found */\n};\n\n/*\n** Search for a name for a function in all loaded modules\n*/\nconst pushglobalfuncname = function(L, ar) {\n    let top = lua_gettop(L);\n    lua_getinfo(L, to_luastring(\"f\"), ar);  /* push function */\n    lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);\n    if (findfield(L, top + 1, 2)) {\n        let name = lua_tostring(L, -1);\n        if (name[0] === 95 /* '_'.charCodeAt(0) */ &&\n            name[1] === 71 /* 'G'.charCodeAt(0) */ &&\n            name[2] === 46 /* '.'.charCodeAt(0) */\n        ) {  /* name start with '_G.'? */\n            lua_pushstring(L, name.subarray(3));  /* push name without prefix */\n            lua_remove(L, -2);  /* remove original name */\n        }\n        lua_copy(L, -1, top + 1);  /* move name to proper place */\n        lua_pop(L, 2);  /* remove pushed values */\n        return 1;\n    } else {\n        lua_settop(L, top);  /* remove function and global table */\n        return 0;\n    }\n};\n\nconst pushfuncname = function(L, ar) {\n    if (pushglobalfuncname(L, ar)) {  /* try first a global name */\n        lua_pushfstring(L, to_luastring(\"function '%s'\"), lua_tostring(L, -1));\n        lua_remove(L, -2);  /* remove name */\n    }\n    else if (ar.namewhat.length !== 0)  /* is there a name from code? */\n        lua_pushfstring(L, to_luastring(\"%s '%s'\"), ar.namewhat, ar.name);  /* use it */\n    else if (ar.what && ar.what[0] === 109 /* 'm'.charCodeAt(0) */)  /* main? */\n        lua_pushliteral(L, \"main chunk\");\n    else if (ar.what && ar.what[0] === 76 /* 'L'.charCodeAt(0) */)  /* for Lua functions, use <file:line> */\n        lua_pushfstring(L, to_luastring(\"function <%s:%d>\"), ar.short_src, ar.linedefined);\n    else  /* nothing left... */\n        lua_pushliteral(L, \"?\");\n};\n\nconst lastlevel = function(L) {\n    let ar = new lua_Debug();\n    let li = 1;\n    let le = 1;\n    /* find an upper bound */\n    while (lua_getstack(L, le, ar)) { li = le; le *= 2; }\n    /* do a binary search */\n    while (li < le) {\n        let m = Math.floor((li + le)/2);\n        if (lua_getstack(L, m, ar)) li = m + 1;\n        else le = m;\n    }\n    return le - 1;\n};\n\nconst luaL_traceback = function(L, L1, msg, level) {\n    let ar = new lua_Debug();\n    let top = lua_gettop(L);\n    let last = lastlevel(L1);\n    let n1 = last - level > LEVELS1 + LEVELS2 ? LEVELS1 : -1;\n    if (msg)\n        lua_pushfstring(L, to_luastring(\"%s\\n\"), msg);\n    luaL_checkstack(L, 10, null);\n    lua_pushliteral(L, \"stack traceback:\");\n    while (lua_getstack(L1, level++, ar)) {\n        if (n1-- === 0) {  /* too many levels? */\n            lua_pushliteral(L, \"\\n\\t...\");  /* add a '...' */\n            level = last - LEVELS2 + 1;  /* and skip to last ones */\n        } else {\n            lua_getinfo(L1, to_luastring(\"Slnt\", true), ar);\n            lua_pushfstring(L, to_luastring(\"\\n\\t%s:\"), ar.short_src);\n            if (ar.currentline > 0)\n                lua_pushliteral(L, `${ar.currentline}:`);\n            lua_pushliteral(L, \" in \");\n            pushfuncname(L, ar);\n            if (ar.istailcall)\n                lua_pushliteral(L, \"\\n\\t(...tail calls..)\");\n            lua_concat(L, lua_gettop(L) - top);\n        }\n    }\n    lua_concat(L, lua_gettop(L) - top);\n};\n\nconst panic = function(L) {\n    let msg = \"PANIC: unprotected error in call to Lua API (\" + lua_tojsstring(L, -1) + \")\";\n    throw new Error(msg);\n};\n\nconst luaL_argerror = function(L, arg, extramsg) {\n    let ar = new lua_Debug();\n\n    if (!lua_getstack(L, 0, ar))  /* no stack frame? */\n        return luaL_error(L, to_luastring(\"bad argument #%d (%s)\"), arg, extramsg);\n\n    lua_getinfo(L, to_luastring(\"n\"), ar);\n\n    if (luastring_eq(ar.namewhat, to_luastring(\"method\"))) {\n        arg--;  /* do not count 'self' */\n        if (arg === 0)  /* error is in the self argument itself? */\n            return luaL_error(L, to_luastring(\"calling '%s' on bad self (%s)\"), ar.name, extramsg);\n    }\n\n    if (ar.name === null)\n        ar.name = pushglobalfuncname(L, ar) ? lua_tostring(L, -1) : to_luastring(\"?\");\n\n    return luaL_error(L, to_luastring(\"bad argument #%d to '%s' (%s)\"), arg, ar.name, extramsg);\n};\n\nconst typeerror = function(L, arg, tname) {\n    let typearg;\n    if (luaL_getmetafield(L, arg, __name) === LUA_TSTRING)\n        typearg = lua_tostring(L, -1);\n    else if (lua_type(L, arg) === LUA_TLIGHTUSERDATA)\n        typearg = to_luastring(\"light userdata\", true);\n    else\n        typearg = luaL_typename(L, arg);\n\n    let msg = lua_pushfstring(L, to_luastring(\"%s expected, got %s\"), tname, typearg);\n    return luaL_argerror(L, arg, msg);\n};\n\nconst luaL_where = function(L, level) {\n    let ar = new lua_Debug();\n    if (lua_getstack(L, level, ar)) {\n        lua_getinfo(L, to_luastring(\"Sl\", true), ar);\n        if (ar.currentline > 0) {\n            lua_pushfstring(L, to_luastring(\"%s:%d: \"), ar.short_src, ar.currentline);\n            return;\n        }\n    }\n    lua_pushstring(L, to_luastring(\"\"));\n};\n\nconst luaL_error = function(L, fmt, ...argp) {\n    luaL_where(L, 1);\n    lua_pushvfstring(L, fmt, argp);\n    lua_concat(L, 2);\n    return lua_error(L);\n};\n\n/* Unlike normal lua, we pass in an error object */\nconst luaL_fileresult = function(L, stat, fname, e) {\n    if (stat) {\n        lua_pushboolean(L, 1);\n        return 1;\n    } else {\n        lua_pushnil(L);\n        let message, errno;\n        if (e) {\n            message = e.message;\n            errno = -e.errno;\n        } else {\n            message = \"Success\"; /* what strerror(0) returns */\n            errno = 0;\n        }\n        if (fname)\n            lua_pushfstring(L, to_luastring(\"%s: %s\"), fname, to_luastring(message));\n        else\n            lua_pushstring(L, to_luastring(message));\n        lua_pushinteger(L, errno);\n        return 3;\n    }\n};\n\n/* Unlike normal lua, we pass in an error object */\nconst luaL_execresult = function(L, e) {\n    let what, stat;\n    if (e === null) {\n        lua_pushboolean(L, 1);\n        lua_pushliteral(L, \"exit\");\n        lua_pushinteger(L, 0);\n        return 3;\n    } else if (e.status) {\n        what = \"exit\";\n        stat = e.status;\n    } else if (e.signal) {\n        what = \"signal\";\n        stat = e.signal;\n    } else {\n        /* XXX: node seems to have e.errno as a string instead of a number */\n        return luaL_fileresult(L, 0, null, e);\n    }\n    lua_pushnil(L);\n    lua_pushliteral(L, what);\n    lua_pushinteger(L, stat);\n    return 3;\n};\n\nconst luaL_getmetatable = function(L, n) {\n    return lua_getfield(L, LUA_REGISTRYINDEX, n);\n};\n\nconst luaL_newmetatable = function(L, tname) {\n    if (luaL_getmetatable(L, tname) !== LUA_TNIL)  /* name already in use? */\n        return 0;  /* leave previous value on top, but return 0 */\n    lua_pop(L, 1);\n    lua_createtable(L, 0, 2);  /* create metatable */\n    lua_pushstring(L, tname);\n    lua_setfield(L, -2, __name);  /* metatable.__name = tname */\n    lua_pushvalue(L, -1);\n    lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */\n    return 1;\n\n};\n\nconst luaL_setmetatable = function(L, tname) {\n    luaL_getmetatable(L, tname);\n    lua_setmetatable(L, -2);\n};\n\nconst luaL_testudata = function(L, ud, tname) {\n    let p = lua_touserdata(L, ud);\n    if (p !== null) {  /* value is a userdata? */\n        if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */\n            luaL_getmetatable(L, tname);  /* get correct metatable */\n            if (!lua_rawequal(L, -1, -2))  /* not the same? */\n                p = null;  /* value is a userdata with wrong metatable */\n            lua_pop(L, 2);  /* remove both metatables */\n            return p;\n        }\n    }\n    return null;  /* value is not a userdata with a metatable */\n};\n\nconst luaL_checkudata = function(L, ud, tname) {\n    let p = luaL_testudata(L, ud, tname);\n    if (p === null) typeerror(L, ud, tname);\n    return p;\n};\n\nconst luaL_checkoption = function(L, arg, def, lst) {\n    let name = def !== null ? luaL_optstring(L, arg, def) : luaL_checkstring(L, arg);\n    for (let i = 0; lst[i]; i++)\n        if (luastring_eq(lst[i], name))\n            return i;\n    return luaL_argerror(L, arg, lua_pushfstring(L, to_luastring(\"invalid option '%s'\"), name));\n};\n\nconst tag_error = function(L, arg, tag) {\n    typeerror(L, arg, lua_typename(L, tag));\n};\n\nconst luaL_newstate = function() {\n    let L = lua_newstate();\n    if (L) lua_atpanic(L, panic);\n    return L;\n};\n\n\nconst luaL_typename = function(L, i) {\n    return lua_typename(L, lua_type(L, i));\n};\n\nconst luaL_argcheck = function(L, cond, arg, extramsg) {\n    if (!cond) luaL_argerror(L, arg, extramsg);\n};\n\nconst luaL_checkany = function(L, arg) {\n    if (lua_type(L, arg) === LUA_TNONE)\n        luaL_argerror(L, arg, to_luastring(\"value expected\", true));\n};\n\nconst luaL_checktype = function(L, arg, t) {\n    if (lua_type(L, arg) !== t)\n        tag_error(L, arg, t);\n};\n\nconst luaL_checklstring = function(L, arg) {\n    let s = lua_tolstring(L, arg);\n    if (s === null || s === undefined) tag_error(L, arg, LUA_TSTRING);\n    return s;\n};\n\nconst luaL_checkstring = luaL_checklstring;\n\nconst luaL_optlstring = function(L, arg, def) {\n    if (lua_type(L, arg) <= 0) {\n        return def === null ? null : from_userstring(def);\n    } else return luaL_checklstring(L, arg);\n};\n\nconst luaL_optstring = luaL_optlstring;\n\nconst interror = function(L, arg) {\n    if (lua_isnumber(L, arg))\n        luaL_argerror(L, arg, to_luastring(\"number has no integer representation\", true));\n    else\n        tag_error(L, arg, LUA_TNUMBER);\n};\n\nconst luaL_checknumber = function(L, arg) {\n    let d = lua_tonumberx(L, arg);\n    if (d === false)\n        tag_error(L, arg, LUA_TNUMBER);\n    return d;\n};\n\nconst luaL_optnumber = function(L, arg, def) {\n    return luaL_opt(L, luaL_checknumber, arg, def);\n};\n\nconst luaL_checkinteger = function(L, arg) {\n    let d = lua_tointegerx(L, arg);\n    if (d === false)\n        interror(L, arg);\n    return d;\n};\n\nconst luaL_optinteger = function(L, arg, def) {\n    return luaL_opt(L, luaL_checkinteger, arg, def);\n};\n\nconst luaL_prepbuffsize = function(B, sz) {\n    let newend = B.n + sz;\n    if (B.b.length < newend) {\n        let newsize = Math.max(B.b.length * 2, newend);  /* double buffer size */\n        let newbuff = new Uint8Array(newsize);  /* create larger buffer */\n        newbuff.set(B.b);  /* copy original content */\n        B.b = newbuff;\n    }\n    return B.b.subarray(B.n, newend);\n};\n\nconst luaL_buffinit = function(L, B) {\n    B.L = L;\n    B.b = empty;\n};\n\nconst luaL_buffinitsize = function(L, B, sz) {\n    luaL_buffinit(L, B);\n    return luaL_prepbuffsize(B, sz);\n};\n\nconst luaL_prepbuffer = function(B) {\n    return luaL_prepbuffsize(B, LUAL_BUFFERSIZE);\n};\n\nconst luaL_addlstring = function(B, s, l) {\n    if (l > 0) {\n        s = from_userstring(s);\n        let b = luaL_prepbuffsize(B, l);\n        b.set(s.subarray(0, l));\n        luaL_addsize(B, l);\n    }\n};\n\nconst luaL_addstring = function(B, s) {\n    s = from_userstring(s);\n    luaL_addlstring(B, s, s.length);\n};\n\nconst luaL_pushresult = function(B) {\n    lua_pushlstring(B.L, B.b, B.n);\n    /* delete old buffer */\n    B.n = 0;\n    B.b = empty;\n};\n\nconst luaL_addchar = function(B, c) {\n    luaL_prepbuffsize(B, 1);\n    B.b[B.n++] = c;\n};\n\nconst luaL_addsize = function(B, s) {\n    B.n += s;\n};\n\nconst luaL_pushresultsize = function(B, sz) {\n    luaL_addsize(B, sz);\n    luaL_pushresult(B);\n};\n\nconst luaL_addvalue = function(B) {\n    let L = B.L;\n    let s = lua_tostring(L, -1);\n    luaL_addlstring(B, s, s.length);\n    lua_pop(L, 1);  /* remove value */\n};\n\nconst luaL_opt = function(L, f, n, d) {\n    return lua_type(L, n) <= 0 ? d : f(L, n);\n};\n\nconst getS = function(L, ud) {\n    let s = ud.string;\n    ud.string = null;\n    return s;\n};\n\nconst luaL_loadbufferx = function(L, buff, size, name, mode) {\n    return lua_load(L, getS, {string: buff}, name, mode);\n};\n\nconst luaL_loadbuffer = function(L, s, sz, n) {\n    return luaL_loadbufferx(L, s, sz, n, null);\n};\n\nconst luaL_loadstring = function(L, s) {\n    return luaL_loadbuffer(L, s, s.length, s);\n};\n\nconst luaL_dostring = function(L, s) {\n    return (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0));\n};\n\nconst luaL_getmetafield = function(L, obj, event) {\n    if (!lua_getmetatable(L, obj))  /* no metatable? */\n        return LUA_TNIL;\n    else {\n        lua_pushstring(L, event);\n        let tt = lua_rawget(L, -2);\n        if (tt === LUA_TNIL)  /* is metafield nil? */\n            lua_pop(L, 2);  /* remove metatable and metafield */\n        else\n            lua_remove(L, -2);  /* remove only metatable */\n        return tt;  /* return metafield type */\n    }\n};\n\nconst luaL_callmeta = function(L, obj, event) {\n    obj = lua_absindex(L, obj);\n    if (luaL_getmetafield(L, obj, event) === LUA_TNIL)\n        return false;\n\n    lua_pushvalue(L, obj);\n    lua_call(L, 1, 1);\n\n    return true;\n};\n\nconst luaL_len = function(L, idx) {\n    lua_len(L, idx);\n    let l = lua_tointegerx(L, -1);\n    if (l === false)\n        luaL_error(L, to_luastring(\"object length is not an integer\", true));\n    lua_pop(L, 1);  /* remove object */\n    return l;\n};\n\nconst p_I = to_luastring(\"%I\");\nconst p_f = to_luastring(\"%f\");\nconst luaL_tolstring = function(L, idx) {\n    if (luaL_callmeta(L, idx, __tostring)) {\n        if (!lua_isstring(L, -1))\n            luaL_error(L, to_luastring(\"'__tostring' must return a string\"));\n    } else {\n        let t = lua_type(L, idx);\n        switch(t) {\n            case LUA_TNUMBER: {\n                if (lua_isinteger(L, idx))\n                    lua_pushfstring(L, p_I, lua_tointeger(L, idx));\n                else\n                    lua_pushfstring(L, p_f, lua_tonumber(L, idx));\n                break;\n            }\n            case LUA_TSTRING:\n                lua_pushvalue(L, idx);\n                break;\n            case LUA_TBOOLEAN:\n                lua_pushliteral(L, (lua_toboolean(L, idx) ? \"true\" : \"false\"));\n                break;\n            case LUA_TNIL:\n                lua_pushliteral(L, \"nil\");\n                break;\n            default: {\n                let tt = luaL_getmetafield(L, idx, __name);\n                let kind = tt === LUA_TSTRING ? lua_tostring(L, -1) : luaL_typename(L, idx);\n                lua_pushfstring(L, to_luastring(\"%s: %p\"), kind, lua_topointer(L, idx));\n                if (tt !== LUA_TNIL)\n                    lua_remove(L, -2);\n                break;\n            }\n        }\n    }\n\n    return lua_tolstring(L, -1);\n};\n\n/*\n** Stripped-down 'require': After checking \"loaded\" table, calls 'openf'\n** to open a module, registers the result in 'package.loaded' table and,\n** if 'glb' is true, also registers the result in the global table.\n** Leaves resulting module on the top.\n*/\nconst luaL_requiref = function(L, modname, openf, glb) {\n    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);\n    lua_getfield(L, -1, modname); /* LOADED[modname] */\n    if (!lua_toboolean(L, -1)) {  /* package not already loaded? */\n        lua_pop(L, 1);  /* remove field */\n        lua_pushcfunction(L, openf);\n        lua_pushstring(L, modname);  /* argument to open function */\n        lua_call(L, 1, 1);  /* call 'openf' to open module */\n        lua_pushvalue(L, -1);  /* make copy of module (call result) */\n        lua_setfield(L, -3, modname);  /* LOADED[modname] = module */\n    }\n    lua_remove(L, -2);  /* remove LOADED table */\n    if (glb) {\n        lua_pushvalue(L, -1);  /* copy of module */\n        lua_setglobal(L, modname);  /* _G[modname] = module */\n    }\n};\n\nconst find_subarray = function(arr, subarr, from_index) {\n    var i = from_index >>> 0,\n        sl = subarr.length,\n        l = arr.length + 1 - sl;\n\n    loop: for (; i < l; i++) {\n        for (let j = 0; j < sl; j++)\n            if (arr[i+j] !== subarr[j])\n                continue loop;\n        return i;\n    }\n    return -1;\n};\n\nconst luaL_gsub = function(L, s, p, r) {\n    let wild;\n    let b = new luaL_Buffer();\n    luaL_buffinit(L, b);\n    while ((wild = find_subarray(s, p)) >= 0) {\n        luaL_addlstring(b, s, wild);  /* push prefix */\n        luaL_addstring(b, r);  /* push replacement in place of pattern */\n        s = s.subarray(wild + p.length);  /* continue after 'p' */\n    }\n    luaL_addstring(b, s);  /* push last suffix */\n    luaL_pushresult(b);\n    return lua_tostring(L, -1);\n};\n\n/*\n** ensure that stack[idx][fname] has a table and push that table\n** into the stack\n*/\nconst luaL_getsubtable = function(L, idx, fname) {\n    if (lua_getfield(L, idx, fname) === LUA_TTABLE)\n        return true;  /* table already there */\n    else {\n        lua_pop(L, 1);  /* remove previous result */\n        idx = lua_absindex(L, idx);\n        lua_newtable(L);\n        lua_pushvalue(L, -1);  /* copy to be left at top */\n        lua_setfield(L, idx, fname);  /* assign new table to field */\n        return false;  /* false, because did not find table there */\n    }\n};\n\n/*\n** set functions from list 'l' into table at top - 'nup'; each\n** function gets the 'nup' elements at the top as upvalues.\n** Returns with only the table at the stack.\n*/\nconst luaL_setfuncs = function(L, l, nup) {\n    luaL_checkstack(L, nup, to_luastring(\"too many upvalues\", true));\n    for (let lib in l) {  /* fill the table with given functions */\n        for (let i = 0; i < nup; i++)  /* copy upvalues to the top */\n            lua_pushvalue(L, -nup);\n        lua_pushcclosure(L, l[lib], nup);  /* closure with those upvalues */\n        lua_setfield(L, -(nup + 2), to_luastring(lib));\n    }\n    lua_pop(L, nup);  /* remove upvalues */\n};\n\n/*\n** Ensures the stack has at least 'space' extra slots, raising an error\n** if it cannot fulfill the request. (The error handling needs a few\n** extra slots to format the error message. In case of an error without\n** this extra space, Lua will generate the same 'stack overflow' error,\n** but without 'msg'.)\n*/\nconst luaL_checkstack = function(L, space, msg) {\n    if (!lua_checkstack(L, space)) {\n        if (msg)\n            luaL_error(L, to_luastring(\"stack overflow (%s)\"), msg);\n        else\n            luaL_error(L, to_luastring('stack overflow', true));\n    }\n};\n\nconst luaL_newlibtable = function(L) {\n    lua_createtable(L);\n};\n\nconst luaL_newlib = function(L, l) {\n    lua_createtable(L);\n    luaL_setfuncs(L, l, 0);\n};\n\n/* predefined references */\nconst LUA_NOREF  = -2;\nconst LUA_REFNIL = -1;\n\nconst luaL_ref = function(L, t) {\n    let ref;\n    if (lua_isnil(L, -1)) {\n        lua_pop(L, 1);  /* remove from stack */\n        return LUA_REFNIL;  /* 'nil' has a unique fixed reference */\n    }\n    t = lua_absindex(L, t);\n    lua_rawgeti(L, t, 0);  /* get first free element */\n    ref = lua_tointeger(L, -1);  /* ref = t[freelist] */\n    lua_pop(L, 1);  /* remove it from stack */\n    if (ref !== 0) {  /* any free element? */\n        lua_rawgeti(L, t, ref);  /* remove it from list */\n        lua_rawseti(L, t, 0);  /* (t[freelist] = t[ref]) */\n    }\n    else  /* no free elements */\n        ref = lua_rawlen(L, t) + 1;  /* get a new reference */\n    lua_rawseti(L, t, ref);\n    return ref;\n};\n\n\nconst luaL_unref = function(L, t, ref) {\n    if (ref >= 0) {\n        t = lua_absindex(L, t);\n        lua_rawgeti(L, t, 0);\n        lua_rawseti(L, t, ref);  /* t[ref] = t[freelist] */\n        lua_pushinteger(L, ref);\n        lua_rawseti(L, t, 0);  /* t[freelist] = ref */\n    }\n};\n\n\nconst errfile = function(L, what, fnameindex, error) {\n    let serr = error.message;\n    let filename = lua_tostring(L, fnameindex).subarray(1);\n    lua_pushfstring(L, to_luastring(\"cannot %s %s: %s\"), to_luastring(what), filename, to_luastring(serr));\n    lua_remove(L, fnameindex);\n    return LUA_ERRFILE;\n};\n\nlet getc;\n\nconst utf8_bom = [0XEF, 0XBB, 0XBF];  /* UTF-8 BOM mark */\nconst skipBOM = function(lf) {\n    lf.n = 0;\n    let c;\n    let p = 0;\n    do {\n        c = getc(lf);\n        if (c === null || c !== utf8_bom[p]) return c;\n        p++;\n        lf.buff[lf.n++] = c;  /* to be read by the parser */\n    } while (p < utf8_bom.length);\n    lf.n = 0;  /* prefix matched; discard it */\n    return getc(lf);  /* return next character */\n};\n\n/*\n** reads the first character of file 'f' and skips an optional BOM mark\n** in its beginning plus its first line if it starts with '#'. Returns\n** true if it skipped the first line.  In any case, '*cp' has the\n** first \"valid\" character of the file (after the optional BOM and\n** a first-line comment).\n*/\nconst skipcomment = function(lf) {\n    let c = skipBOM(lf);\n    if (c === 35 /* '#'.charCodeAt(0) */) {  /* first line is a comment (Unix exec. file)? */\n        do {  /* skip first line */\n            c = getc(lf);\n        } while (c && c !== 10 /* '\\n'.charCodeAt(0) */);\n\n        return {\n            skipped: true,\n            c: getc(lf)  /* skip end-of-line, if present */\n        };\n    } else {\n        return {\n            skipped: false,\n            c: c\n        };\n    }\n};\n\nlet luaL_loadfilex;\n\nif (typeof process === \"undefined\") {\n    class LoadF {\n        constructor() {\n            this.n = NaN;  /* number of pre-read characters */\n            this.f = null;  /* file being read */\n            this.buff = new Uint8Array(1024);  /* area for reading file */\n            this.pos = 0;  /* current position in file */\n            this.err = void 0;\n        }\n    }\n\n    const getF = function(L, ud) {\n        let lf = ud;\n\n        if (lf.f !== null && lf.n > 0) {  /* are there pre-read characters to be read? */\n            let bytes = lf.n; /* return them (chars already in buffer) */\n            lf.n = 0;  /* no more pre-read characters */\n            lf.f = lf.f.subarray(lf.pos);  /* we won't use lf.buff anymore */\n            return lf.buff.subarray(0, bytes);\n        }\n\n        let f = lf.f;\n        lf.f = null;\n        return f;\n    };\n\n    getc = function(lf) {\n        return lf.pos < lf.f.length ? lf.f[lf.pos++] : null;\n    };\n\n    luaL_loadfilex = function(L, filename, mode) {\n        let lf = new LoadF();\n        let fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */\n        if (filename === null) {\n            throw new Error(\"Can't read stdin in the browser\");\n        } else {\n            lua_pushfstring(L, to_luastring(\"@%s\"), filename);\n            let path = to_uristring(filename);\n            let xhr = new XMLHttpRequest();\n            xhr.open(\"GET\", path, false);\n            /*\n            Synchronous xhr in main thread always returns a js string.\n            Some browsers make console noise if you even attempt to set responseType\n            */\n            if (typeof window === \"undefined\") {\n                xhr.responseType = \"arraybuffer\";\n            }\n            xhr.send();\n            if (xhr.status >= 200 && xhr.status <= 299) {\n                if (typeof xhr.response === \"string\") {\n                    lf.f = to_luastring(xhr.response);\n                } else {\n                    lf.f = new Uint8Array(xhr.response);\n                }\n            } else {\n                lf.err = xhr.status;\n                return errfile(L, \"open\", fnameindex, { message: `${xhr.status}: ${xhr.statusText}` });\n            }\n        }\n        let com = skipcomment(lf);\n        /* check for signature first, as we don't want to add line number corrections in binary case */\n        if (com.c === LUA_SIGNATURE[0] && filename) {  /* binary file? */\n            /* no need to re-open */\n        } else if (com.skipped) { /* read initial portion */\n            lf.buff[lf.n++] = 10 /* '\\n'.charCodeAt(0) */;  /* add line to correct line numbers */\n        }\n        if (com.c !== null)\n            lf.buff[lf.n++] = com.c; /* 'c' is the first character of the stream */\n        let status = lua_load(L, getF, lf, lua_tostring(L, -1), mode);\n        let readstatus = lf.err;\n        if (readstatus) {\n            lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */\n            return errfile(L, \"read\", fnameindex, readstatus);\n        }\n        lua_remove(L, fnameindex);\n        return status;\n    };\n} else {\n    const fs = require('fs');\n\n    class LoadF {\n        constructor() {\n            this.n = NaN;  /* number of pre-read characters */\n            this.f = null;  /* file being read */\n            this.buff = Buffer.alloc(1024);  /* area for reading file */\n            this.pos = 0;  /* current position in file */\n            this.err = void 0;\n        }\n    }\n\n    const getF = function(L, ud) {\n        let lf = ud;\n        let bytes = 0;\n        if (lf.n > 0) {  /* are there pre-read characters to be read? */\n            bytes = lf.n; /* return them (chars already in buffer) */\n            lf.n = 0;  /* no more pre-read characters */\n        } else {  /* read a block from file */\n            try {\n                bytes = fs.readSync(lf.f, lf.buff, 0, lf.buff.length, lf.pos); /* read block */\n            } catch(e) {\n                lf.err = e;\n                bytes = 0;\n            }\n            lf.pos += bytes;\n        }\n        if (bytes > 0)\n            return lf.buff.subarray(0, bytes);\n        else return null;\n    };\n\n    getc = function(lf) {\n        let b = Buffer.alloc(1);\n        let bytes;\n        try {\n            bytes = fs.readSync(lf.f, b, 0, 1, lf.pos);\n        } catch(e) {\n            lf.err = e;\n            return null;\n        }\n        lf.pos += bytes;\n        return bytes > 0 ? b.readUInt8() : null;\n    };\n\n    luaL_loadfilex = function(L, filename, mode) {\n        let lf = new LoadF();\n        let fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */\n        if (filename === null) {\n            lua_pushliteral(L, \"=stdin\");\n            lf.f = process.stdin.fd;\n        } else {\n            lua_pushfstring(L, to_luastring(\"@%s\"), filename);\n            try {\n                lf.f = fs.openSync(filename, \"r\");\n            } catch (e) {\n                return errfile(L, \"open\", fnameindex, e);\n            }\n        }\n        let com = skipcomment(lf);\n        /* check for signature first, as we don't want to add line number corrections in binary case */\n        if (com.c === LUA_SIGNATURE[0] && filename) {  /* binary file? */\n            /* no need to re-open */\n        } else if (com.skipped) { /* read initial portion */\n            lf.buff[lf.n++] = 10 /* '\\n'.charCodeAt(0) */;  /* add line to correct line numbers */\n        }\n        if (com.c !== null)\n            lf.buff[lf.n++] = com.c; /* 'c' is the first character of the stream */\n        let status = lua_load(L, getF, lf, lua_tostring(L, -1), mode);\n        let readstatus = lf.err;\n        if (filename) try { fs.closeSync(lf.f); } catch(e) {}  /* close file (even in case of errors) */\n        if (readstatus) {\n            lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */\n            return errfile(L, \"read\", fnameindex, readstatus);\n        }\n        lua_remove(L, fnameindex);\n        return status;\n    };\n}\n\nconst luaL_loadfile = function(L, filename) {\n    return luaL_loadfilex(L, filename, null);\n};\n\nconst luaL_dofile = function(L, filename) {\n    return (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0));\n};\n\nconst lua_writestringerror = function() {\n    for (let i=0; i<arguments.length; i++) {\n        let a = arguments[i];\n        if (typeof process === \"undefined\") {\n            /* split along new lines for separate console.error invocations */\n            do {\n                /* regexp uses [\\d\\D] to work around matching new lines\n                   the 's' flag is non-standard */\n                let r = /([^\\n]*)\\n?([\\d\\D]*)/.exec(a);\n                console.error(r[1]);\n                a = r[2];\n            } while (a !== \"\");\n        } else {\n            process.stderr.write(a);\n        }\n    }\n};\n\nconst luaL_checkversion_ = function(L, ver, sz) {\n    let v = lua_version(L);\n    if (sz != LUAL_NUMSIZES)  /* check numeric types */\n        luaL_error(L, to_luastring(\"core and library have incompatible numeric types\"));\n    if (v != lua_version(null))\n        luaL_error(L, to_luastring(\"multiple Lua VMs detected\"));\n    else if (v !== ver)\n        luaL_error(L, to_luastring(\"version mismatch: app. needs %f, Lua core provides %f\"), ver, v);\n};\n\n/* There is no point in providing this function... */\nconst luaL_checkversion = function(L) {\n    luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES);\n};\n\nmodule.exports.LUA_ERRFILE          = LUA_ERRFILE;\nmodule.exports.LUA_FILEHANDLE       = LUA_FILEHANDLE;\nmodule.exports.LUA_LOADED_TABLE     = LUA_LOADED_TABLE;\nmodule.exports.LUA_NOREF            = LUA_NOREF;\nmodule.exports.LUA_PRELOAD_TABLE    = LUA_PRELOAD_TABLE;\nmodule.exports.LUA_REFNIL           = LUA_REFNIL;\nmodule.exports.luaL_Buffer          = luaL_Buffer;\nmodule.exports.luaL_addchar         = luaL_addchar;\nmodule.exports.luaL_addlstring      = luaL_addlstring;\nmodule.exports.luaL_addsize         = luaL_addsize;\nmodule.exports.luaL_addstring       = luaL_addstring;\nmodule.exports.luaL_addvalue        = luaL_addvalue;\nmodule.exports.luaL_argcheck        = luaL_argcheck;\nmodule.exports.luaL_argerror        = luaL_argerror;\nmodule.exports.luaL_buffinit        = luaL_buffinit;\nmodule.exports.luaL_buffinitsize    = luaL_buffinitsize;\nmodule.exports.luaL_callmeta        = luaL_callmeta;\nmodule.exports.luaL_checkany        = luaL_checkany;\nmodule.exports.luaL_checkinteger    = luaL_checkinteger;\nmodule.exports.luaL_checklstring    = luaL_checklstring;\nmodule.exports.luaL_checknumber     = luaL_checknumber;\nmodule.exports.luaL_checkoption     = luaL_checkoption;\nmodule.exports.luaL_checkstack      = luaL_checkstack;\nmodule.exports.luaL_checkstring     = luaL_checkstring;\nmodule.exports.luaL_checktype       = luaL_checktype;\nmodule.exports.luaL_checkudata      = luaL_checkudata;\nmodule.exports.luaL_checkversion    = luaL_checkversion;\nmodule.exports.luaL_checkversion_   = luaL_checkversion_;\nmodule.exports.luaL_dofile          = luaL_dofile;\nmodule.exports.luaL_dostring        = luaL_dostring;\nmodule.exports.luaL_error           = luaL_error;\nmodule.exports.luaL_execresult      = luaL_execresult;\nmodule.exports.luaL_fileresult      = luaL_fileresult;\nmodule.exports.luaL_getmetafield    = luaL_getmetafield;\nmodule.exports.luaL_getmetatable    = luaL_getmetatable;\nmodule.exports.luaL_getsubtable     = luaL_getsubtable;\nmodule.exports.luaL_gsub            = luaL_gsub;\nmodule.exports.luaL_len             = luaL_len;\nmodule.exports.luaL_loadbuffer      = luaL_loadbuffer;\nmodule.exports.luaL_loadbufferx     = luaL_loadbufferx;\nmodule.exports.luaL_loadfile        = luaL_loadfile;\nmodule.exports.luaL_loadfilex       = luaL_loadfilex;\nmodule.exports.luaL_loadstring      = luaL_loadstring;\nmodule.exports.luaL_newlib          = luaL_newlib;\nmodule.exports.luaL_newlibtable     = luaL_newlibtable;\nmodule.exports.luaL_newmetatable    = luaL_newmetatable;\nmodule.exports.luaL_newstate        = luaL_newstate;\nmodule.exports.luaL_opt             = luaL_opt;\nmodule.exports.luaL_optinteger      = luaL_optinteger;\nmodule.exports.luaL_optlstring      = luaL_optlstring;\nmodule.exports.luaL_optnumber       = luaL_optnumber;\nmodule.exports.luaL_optstring       = luaL_optstring;\nmodule.exports.luaL_prepbuffer      = luaL_prepbuffer;\nmodule.exports.luaL_prepbuffsize    = luaL_prepbuffsize;\nmodule.exports.luaL_pushresult      = luaL_pushresult;\nmodule.exports.luaL_pushresultsize  = luaL_pushresultsize;\nmodule.exports.luaL_ref             = luaL_ref;\nmodule.exports.luaL_requiref        = luaL_requiref;\nmodule.exports.luaL_setfuncs        = luaL_setfuncs;\nmodule.exports.luaL_setmetatable    = luaL_setmetatable;\nmodule.exports.luaL_testudata       = luaL_testudata;\nmodule.exports.luaL_tolstring       = luaL_tolstring;\nmodule.exports.luaL_traceback       = luaL_traceback;\nmodule.exports.luaL_typename        = luaL_typename;\nmodule.exports.luaL_unref           = luaL_unref;\nmodule.exports.luaL_where           = luaL_where;\nmodule.exports.lua_writestringerror = lua_writestringerror;\n","\"use strict\";\n\nconst {\n    LUA_OPADD,\n    LUA_OPBAND,\n    LUA_OPBNOT,\n    LUA_OPBOR,\n    LUA_OPBXOR,\n    LUA_OPDIV,\n    LUA_OPIDIV,\n    LUA_OPMOD,\n    LUA_OPMUL,\n    LUA_OPPOW,\n    LUA_OPSHL,\n    LUA_OPSHR,\n    LUA_OPSUB,\n    LUA_OPUNM,\n    constant_types: {\n        LUA_NUMTAGS,\n        LUA_TBOOLEAN,\n        LUA_TCCL,\n        LUA_TFUNCTION,\n        LUA_TLCF,\n        LUA_TLCL,\n        LUA_TLIGHTUSERDATA,\n        LUA_TLNGSTR,\n        LUA_TNIL,\n        LUA_TNUMBER,\n        LUA_TNUMFLT,\n        LUA_TNUMINT,\n        LUA_TSHRSTR,\n        LUA_TSTRING,\n        LUA_TTABLE,\n        LUA_TTHREAD,\n        LUA_TUSERDATA\n    },\n    from_userstring,\n    luastring_indexOf,\n    luastring_of,\n    to_jsstring,\n    to_luastring\n} = require('./defs.js');\nconst {\n    lisdigit,\n    lisprint,\n    lisspace,\n    lisxdigit\n} = require('./ljstype.js');\nconst ldebug  = require('./ldebug.js');\nconst ldo     = require('./ldo.js');\nconst lstate  = require('./lstate.js');\nconst {\n    luaS_bless,\n    luaS_new\n} = require('./lstring.js');\nconst ltable  = require('./ltable.js');\nconst {\n    LUA_COMPAT_FLOATSTRING,\n    ldexp,\n    lua_getlocaledecpoint,\n    lua_integer2str,\n    lua_number2str\n} = require('./luaconf.js');\nconst lvm     = require('./lvm.js');\nconst {\n    MAX_INT,\n    luai_nummod,\n    lua_assert\n} = require(\"./llimits.js\");\nconst ltm     = require('./ltm.js');\n\nconst LUA_TPROTO = LUA_NUMTAGS;\nconst LUA_TDEADKEY = LUA_NUMTAGS+1;\n\nclass TValue {\n\n    constructor(type, value) {\n        this.type = type;\n        this.value = value;\n    }\n\n    /* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */\n    ttype() {\n        return this.type & 0x3F;\n    }\n\n    /* type tag of a TValue with no variants (bits 0-3) */\n    ttnov() {\n        return this.type & 0x0F;\n    }\n\n    checktag(t) {\n        return this.type === t;\n    }\n\n    checktype(t) {\n        return this.ttnov() === t;\n    }\n\n    ttisnumber() {\n        return this.checktype(LUA_TNUMBER);\n    }\n\n    ttisfloat() {\n        return this.checktag(LUA_TNUMFLT);\n    }\n\n    ttisinteger() {\n        return this.checktag(LUA_TNUMINT);\n    }\n\n    ttisnil() {\n        return this.checktag(LUA_TNIL);\n    }\n\n    ttisboolean() {\n        return this.checktag(LUA_TBOOLEAN);\n    }\n\n    ttislightuserdata() {\n        return this.checktag(LUA_TLIGHTUSERDATA);\n    }\n\n    ttisstring() {\n        return this.checktype(LUA_TSTRING);\n    }\n\n    ttisshrstring() {\n        return this.checktag(LUA_TSHRSTR);\n    }\n\n    ttislngstring() {\n        return this.checktag(LUA_TLNGSTR);\n    }\n\n    ttistable() {\n        return this.checktag(LUA_TTABLE);\n    }\n\n    ttisfunction() {\n        return this.checktype(LUA_TFUNCTION);\n    }\n\n    ttisclosure() {\n        return (this.type & 0x1F) === LUA_TFUNCTION;\n    }\n\n    ttisCclosure() {\n        return this.checktag(LUA_TCCL);\n    }\n\n    ttisLclosure() {\n        return this.checktag(LUA_TLCL);\n    }\n\n    ttislcf() {\n        return this.checktag(LUA_TLCF);\n    }\n\n    ttisfulluserdata() {\n        return this.checktag(LUA_TUSERDATA);\n    }\n\n    ttisthread() {\n        return this.checktag(LUA_TTHREAD);\n    }\n\n    ttisdeadkey() {\n        return this.checktag(LUA_TDEADKEY);\n    }\n\n    l_isfalse() {\n        return this.ttisnil() || (this.ttisboolean() && this.value === false);\n    }\n\n    setfltvalue(x) {\n        this.type = LUA_TNUMFLT;\n        this.value = x;\n    }\n\n    chgfltvalue(x) {\n        lua_assert(this.type == LUA_TNUMFLT);\n        this.value = x;\n    }\n\n    setivalue(x) {\n        this.type = LUA_TNUMINT;\n        this.value = x;\n    }\n\n    chgivalue(x) {\n        lua_assert(this.type == LUA_TNUMINT);\n        this.value = x;\n    }\n\n    setnilvalue() {\n        this.type = LUA_TNIL;\n        this.value = null;\n    }\n\n    setfvalue(x) {\n        this.type = LUA_TLCF;\n        this.value = x;\n    }\n\n    setpvalue(x) {\n        this.type = LUA_TLIGHTUSERDATA;\n        this.value = x;\n    }\n\n    setbvalue(x) {\n        this.type = LUA_TBOOLEAN;\n        this.value = x;\n    }\n\n    setsvalue(x) {\n        this.type = LUA_TLNGSTR; /* LUA_TSHRSTR? */\n        this.value = x;\n    }\n\n    setuvalue(x) {\n        this.type = LUA_TUSERDATA;\n        this.value = x;\n    }\n\n    setthvalue(x) {\n        this.type = LUA_TTHREAD;\n        this.value = x;\n    }\n\n    setclLvalue(x) {\n        this.type = LUA_TLCL;\n        this.value = x;\n    }\n\n    setclCvalue(x) {\n        this.type = LUA_TCCL;\n        this.value = x;\n    }\n\n    sethvalue(x) {\n        this.type = LUA_TTABLE;\n        this.value = x;\n    }\n\n    setdeadvalue() {\n        this.type = LUA_TDEADKEY;\n        this.value = null;\n    }\n\n    setfrom(tv) { /* in lua C source setobj2t is often used for this */\n        this.type = tv.type;\n        this.value = tv.value;\n    }\n\n    tsvalue() {\n        lua_assert(this.ttisstring());\n        return this.value;\n    }\n\n    svalue() {\n        return this.tsvalue().getstr();\n    }\n\n    vslen() {\n        return this.tsvalue().tsslen();\n    }\n\n    jsstring(from, to) {\n        return to_jsstring(this.svalue(), from, to, true);\n    }\n}\n\nconst pushobj2s = function(L, tv) {\n    L.stack[L.top++] = new TValue(tv.type, tv.value);\n};\nconst pushsvalue2s = function(L, ts) {\n    L.stack[L.top++] = new TValue(LUA_TLNGSTR, ts);\n};\n/* from stack to (same) stack */\nconst setobjs2s = function(L, newidx, oldidx) {\n    L.stack[newidx].setfrom(L.stack[oldidx]);\n};\n/* to stack (not from same stack) */\nconst setobj2s = function(L, newidx, oldtv) {\n    L.stack[newidx].setfrom(oldtv);\n};\nconst setsvalue2s = function(L, newidx, ts) {\n    L.stack[newidx].setsvalue(ts);\n};\n\nconst luaO_nilobject = new TValue(LUA_TNIL, null);\nObject.freeze(luaO_nilobject);\nmodule.exports.luaO_nilobject = luaO_nilobject;\n\nclass LClosure {\n\n    constructor(L, n) {\n        this.id = L.l_G.id_counter++;\n\n        this.p = null;\n        this.nupvalues = n;\n        this.upvals = new Array(n); /* list of upvalues. initialised in luaF_initupvals */\n    }\n\n}\n\nclass CClosure {\n\n    constructor(L, f, n) {\n        this.id = L.l_G.id_counter++;\n\n        this.f = f;\n        this.nupvalues = n;\n        this.upvalue = new Array(n); /* list of upvalues as TValues */\n        while (n--) {\n            this.upvalue[n] = new TValue(LUA_TNIL, null);\n        }\n    }\n\n}\n\nclass Udata {\n\n    constructor(L, size) {\n        this.id = L.l_G.id_counter++;\n\n        this.metatable = null;\n        this.uservalue = new TValue(LUA_TNIL, null);\n        this.len = size;\n        this.data = Object.create(null); // ignores size argument\n    }\n\n}\n\n/*\n** Description of a local variable for function prototypes\n** (used for debug information)\n*/\nclass LocVar {\n    constructor() {\n        this.varname = null;\n        this.startpc = NaN;  /* first point where variable is active */\n        this.endpc = NaN;    /* first point where variable is dead */\n    }\n}\n\nconst RETS = to_luastring(\"...\");\nconst PRE  = to_luastring(\"[string \\\"\");\nconst POS  = to_luastring(\"\\\"]\");\n\nconst luaO_chunkid = function(source, bufflen) {\n    let l = source.length;\n    let out;\n    if (source[0] === 61 /* ('=').charCodeAt(0) */) {  /* 'literal' source */\n        if (l < bufflen) {  /* small enough? */\n            out = new Uint8Array(l-1);\n            out.set(source.subarray(1));\n        } else {  /* truncate it */\n            out = new Uint8Array(bufflen);\n            out.set(source.subarray(1, bufflen+1));\n        }\n    } else if (source[0] === 64 /* ('@').charCodeAt(0) */) {  /* file name */\n        if (l <= bufflen) {  /* small enough? */\n            out = new Uint8Array(l-1);\n            out.set(source.subarray(1));\n        } else {  /* add '...' before rest of name */\n            out = new Uint8Array(bufflen);\n            out.set(RETS);\n            bufflen -= RETS.length;\n            out.set(source.subarray(l - bufflen), RETS.length);\n        }\n    } else {  /* string; format as [string \"source\"] */\n        out = new Uint8Array(bufflen);\n        let nli = luastring_indexOf(source, 10 /* ('\\n').charCodeAt(0) */);  /* find first new line (if any) */\n        out.set(PRE);  /* add prefix */\n        let out_i = PRE.length;\n        bufflen -= PRE.length + RETS.length + POS.length;  /* save space for prefix+suffix */\n        if (l < bufflen && nli === -1) {  /* small one-line source? */\n            out.set(source, out_i);  /* keep it */\n            out_i += source.length;\n        } else {\n            if (nli !== -1) l = nli;  /* stop at first newline */\n            if (l > bufflen) l = bufflen;\n            out.set(source.subarray(0, l), out_i);\n            out_i += l;\n            out.set(RETS, out_i);\n            out_i += RETS.length;\n        }\n        out.set(POS, out_i);\n        out_i += POS.length;\n        out = out.subarray(0, out_i);\n    }\n    return out;\n};\n\nconst luaO_hexavalue = function(c) {\n    if (lisdigit(c)) return c - 48;\n    else return (c & 0xdf) - 55;\n};\n\nconst UTF8BUFFSZ = 8;\n\nconst luaO_utf8esc = function(buff, x) {\n    let n = 1;  /* number of bytes put in buffer (backwards) */\n    lua_assert(x <= 0x10FFFF);\n    if (x < 0x80)  /* ascii? */\n        buff[UTF8BUFFSZ - 1] = x;\n    else {  /* need continuation bytes */\n        let mfb = 0x3f;  /* maximum that fits in first byte */\n        do {\n            buff[UTF8BUFFSZ - (n++)] = 0x80 | (x & 0x3f);\n            x >>= 6;  /* remove added bits */\n            mfb >>= 1;  /* now there is one less bit available in first byte */\n        } while (x > mfb);  /* still needs continuation byte? */\n        buff[UTF8BUFFSZ - n] = (~mfb << 1) | x;  /* add first byte */\n    }\n    return n;\n};\n\n/* maximum number of significant digits to read (to avoid overflows\n   even with single floats) */\nconst MAXSIGDIG = 30;\n\n/*\n** convert an hexadecimal numeric string to a number, following\n** C99 specification for 'strtod'\n*/\nconst lua_strx2number = function(s) {\n    let i = 0;\n    let dot = lua_getlocaledecpoint();\n    let r = 0.0;  /* result (accumulator) */\n    let sigdig = 0;  /* number of significant digits */\n    let nosigdig = 0;  /* number of non-significant digits */\n    let e = 0;  /* exponent correction */\n    let neg;  /* 1 if number is negative */\n    let hasdot = false;  /* true after seen a dot */\n    while (lisspace(s[i])) i++;  /* skip initial spaces */\n    if ((neg = (s[i] === 45 /* ('-').charCodeAt(0) */))) i++;  /* check signal */\n    else if (s[i] === 43 /* ('+').charCodeAt(0) */) i++;\n    if (!(s[i] === 48 /* ('0').charCodeAt(0) */ && (s[i+1] === 120 /* ('x').charCodeAt(0) */ || s[i+1] === 88 /* ('X').charCodeAt(0) */)))  /* check '0x' */\n        return null;  /* invalid format (no '0x') */\n    for (i += 2; ; i++) {  /* skip '0x' and read numeral */\n        if (s[i] === dot) {\n            if (hasdot) break;  /* second dot? stop loop */\n            else hasdot = true;\n        } else if (lisxdigit(s[i])) {\n            if (sigdig === 0 && s[i] === 48 /* ('0').charCodeAt(0) */)  /* non-significant digit (zero)? */\n                nosigdig++;\n            else if (++sigdig <= MAXSIGDIG)  /* can read it without overflow? */\n                r = (r * 16) + luaO_hexavalue(s[i]);\n            else e++; /* too many digits; ignore, but still count for exponent */\n            if (hasdot) e--;  /* decimal digit? correct exponent */\n        } else break;  /* neither a dot nor a digit */\n    }\n\n    if (nosigdig + sigdig === 0)  /* no digits? */\n        return null;  /* invalid format */\n    e *= 4;  /* each digit multiplies/divides value by 2^4 */\n    if (s[i] === 112 /* ('p').charCodeAt(0) */ || s[i] === 80 /* ('P').charCodeAt(0) */) {  /* exponent part? */\n        let exp1 = 0;  /* exponent value */\n        let neg1;  /* exponent signal */\n        i++;  /* skip 'p' */\n        if ((neg1 = (s[i] === 45 /* ('-').charCodeAt(0) */))) i++;  /* signal */\n        else if (s[i] === 43 /* ('+').charCodeAt(0) */) i++;\n        if (!lisdigit(s[i]))\n            return null;  /* invalid; must have at least one digit */\n        while (lisdigit(s[i]))  /* read exponent */\n            exp1 = exp1 * 10 + s[i++] - 48 /* ('0').charCodeAt(0) */;\n        if (neg1) exp1 = -exp1;\n        e += exp1;\n    }\n    if (neg) r = -r;\n    return {\n        n: ldexp(r, e),\n        i: i\n    };\n};\n\nconst lua_str2number = function(s) {\n    try {\n        s = to_jsstring(s);\n    } catch (e) {\n        return null;\n    }\n    /* use a regex to validate number and also to get length\n       parseFloat ignores trailing junk */\n    let r = /^[\\t\\v\\f \\n\\r]*[+-]?(?:[0-9]+\\.?[0-9]*|\\.[0-9]*)(?:[eE][+-]?[0-9]+)?/.exec(s);\n    if (!r)\n        return null;\n    let flt = parseFloat(r[0]);\n    return !isNaN(flt) ? { n: flt, i: r[0].length } : null;\n};\n\nconst l_str2dloc = function(s, mode) {\n    let result = mode === 'x' ? lua_strx2number(s) : lua_str2number(s); /* try to convert */\n    if (result === null) return null;\n    while (lisspace(s[result.i])) result.i++;  /* skip trailing spaces */\n    return (result.i === s.length || s[result.i] === 0) ? result : null;  /* OK if no trailing characters */\n};\n\nconst SIGILS = [\n    46  /* (\".\").charCodeAt(0) */,\n    120 /* (\"x\").charCodeAt(0) */,\n    88  /* (\"X\").charCodeAt(0) */,\n    110 /* (\"n\").charCodeAt(0) */,\n    78  /* (\"N\").charCodeAt(0) */\n];\nconst modes = {\n    [ 46]: \".\",\n    [120]: \"x\",\n    [ 88]: \"x\",\n    [110]: \"n\",\n    [ 78]: \"n\"\n};\nconst l_str2d = function(s) {\n    let l = s.length;\n    let pmode = 0;\n    for (let i=0; i<l; i++) {\n        let v = s[i];\n        if (SIGILS.indexOf(v) !== -1) {\n            pmode = v;\n            break;\n        }\n    }\n    let mode = modes[pmode];\n    if (mode === 'n')  /* reject 'inf' and 'nan' */\n        return null;\n    let end = l_str2dloc(s, mode);  /* try to convert */\n    // if (end === null) {   /* failed? may be a different locale */\n    //     throw new Error(\"Locale not available to handle number\"); // TODO\n    // }\n    return end;\n};\n\nconst MAXBY10  = Math.floor(MAX_INT / 10);\nconst MAXLASTD = MAX_INT % 10;\n\nconst l_str2int = function(s) {\n    let i = 0;\n    let a = 0;\n    let empty = true;\n    let neg;\n\n    while (lisspace(s[i])) i++;  /* skip initial spaces */\n    if ((neg = (s[i] === 45 /* ('-').charCodeAt(0) */))) i++;\n    else if (s[i] === 43 /* ('+').charCodeAt(0) */) i++;\n    if (s[i] === 48 /* ('0').charCodeAt(0) */ && (s[i+1] === 120 /* ('x').charCodeAt(0) */ || s[i+1] === 88 /* ('X').charCodeAt(0) */)) {  /* hex? */\n        i += 2;  /* skip '0x' */\n        for (; i < s.length && lisxdigit(s[i]); i++) {\n            a = (a * 16 + luaO_hexavalue(s[i]))|0;\n            empty = false;\n        }\n    } else {  /* decimal */\n        for (; i < s.length && lisdigit(s[i]); i++) {\n            let d = s[i] - 48 /* ('0').charCodeAt(0) */;\n            if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg))  /* overflow? */\n                return null;  /* do not accept it (as integer) */\n            a = (a * 10 + d)|0;\n            empty = false;\n        }\n    }\n    while (i < s.length && lisspace(s[i])) i++;  /* skip trailing spaces */\n    if (empty || (i !== s.length && s[i] !== 0)) return null;  /* something wrong in the numeral */\n    else {\n        return {\n            n: (neg ? -a : a)|0,\n            i: i\n        };\n    }\n};\n\nconst luaO_str2num = function(s, o) {\n    let s2i = l_str2int(s);\n    if (s2i !== null) {   /* try as an integer */\n        o.setivalue(s2i.n);\n        return s2i.i+1;\n    } else {   /* else try as a float */\n        s2i = l_str2d(s);\n        if (s2i !== null) {\n            o.setfltvalue(s2i.n);\n            return s2i.i+1;\n        } else\n            return 0;  /* conversion failed */\n    }\n};\n\nconst luaO_tostring = function(L, obj) {\n    let buff;\n    if (obj.ttisinteger())\n        buff = to_luastring(lua_integer2str(obj.value));\n    else {\n        let str = lua_number2str(obj.value);\n        if (!LUA_COMPAT_FLOATSTRING && /^[-0123456789]+$/.test(str)) {  /* looks like an int? */\n            str += String.fromCharCode(lua_getlocaledecpoint()) + '0'; /* adds '.0' to result */\n        }\n        buff = to_luastring(str);\n    }\n    obj.setsvalue(luaS_bless(L, buff));\n};\n\nconst pushstr = function(L, str) {\n    ldo.luaD_inctop(L);\n    setsvalue2s(L, L.top-1, luaS_new(L, str));\n};\n\nconst luaO_pushvfstring = function(L, fmt, argp) {\n    let n = 0;\n    let i = 0;\n    let a = 0;\n    let e;\n    for (;;) {\n        e = luastring_indexOf(fmt, 37 /* ('%').charCodeAt(0) */, i);\n        if (e == -1) break;\n        pushstr(L, fmt.subarray(i, e));\n        switch(fmt[e+1]) {\n            case 115 /* ('s').charCodeAt(0) */: {\n                let s = argp[a++];\n                if (s === null) s = to_luastring(\"(null)\", true);\n                else {\n                    s = from_userstring(s);\n                    /* respect null terminator */\n                    let i = luastring_indexOf(s, 0);\n                    if (i !== -1)\n                        s = s.subarray(0, i);\n                }\n                pushstr(L, s);\n                break;\n            }\n            case 99 /* ('c').charCodeAt(0) */: {\n                let buff = argp[a++];\n                if (lisprint(buff))\n                    pushstr(L, luastring_of(buff));\n                else\n                    luaO_pushfstring(L, to_luastring(\"<\\\\%d>\", true), buff);\n                break;\n            }\n            case 100 /* ('d').charCodeAt(0) */:\n            case 73 /* ('I').charCodeAt(0) */:\n                ldo.luaD_inctop(L);\n                L.stack[L.top-1].setivalue(argp[a++]);\n                luaO_tostring(L, L.stack[L.top-1]);\n                break;\n            case 102 /* ('f').charCodeAt(0) */:\n                ldo.luaD_inctop(L);\n                L.stack[L.top-1].setfltvalue(argp[a++]);\n                luaO_tostring(L, L.stack[L.top-1]);\n                break;\n            case 112 /* ('p').charCodeAt(0) */: {\n                let v = argp[a++];\n                if (v instanceof lstate.lua_State ||\n                    v instanceof ltable.Table ||\n                    v instanceof Udata ||\n                    v instanceof LClosure ||\n                    v instanceof CClosure) {\n                    pushstr(L, to_luastring(\"0x\"+v.id.toString(16)));\n                } else {\n                    switch(typeof v) {\n                        case \"undefined\":\n                            pushstr(L, to_luastring(\"undefined\"));\n                            break;\n                        case \"number\":  /* before check object as null is an object */\n                            pushstr(L, to_luastring(\"Number(\"+v+\")\"));\n                            break;\n                        case \"string\":  /* before check object as null is an object */\n                            pushstr(L, to_luastring(\"String(\"+JSON.stringify(v)+\")\"));\n                            break;\n                        case \"boolean\":  /* before check object as null is an object */\n                            pushstr(L, to_luastring(v?\"Boolean(true)\":\"Boolean(false)\"));\n                            break;\n                        case \"object\":\n                            if (v === null) { /* null is special */\n                                pushstr(L, to_luastring(\"null\"));\n                                break;\n                            }\n                            /* fall through */\n                        case \"function\": {\n                            let id = L.l_G.ids.get(v);\n                            if (!id) {\n                                id = L.l_G.id_counter++;\n                                L.l_G.ids.set(v, id);\n                            }\n                            pushstr(L, to_luastring(\"0x\"+id.toString(16)));\n                            break;\n                        }\n                        default:\n                            /* user provided object. no id available */\n                            pushstr(L, to_luastring(\"<id NYI>\"));\n                    }\n                }\n                break;\n            }\n            case 85 /* ('U').charCodeAt(0) */: {\n                let buff = new Uint8Array(UTF8BUFFSZ);\n                let l = luaO_utf8esc(buff, argp[a++]);\n                pushstr(L, buff.subarray(UTF8BUFFSZ - l));\n                break;\n            }\n            case 37 /* ('%').charCodeAt(0) */:\n                pushstr(L, to_luastring(\"%\", true));\n                break;\n            default:\n                ldebug.luaG_runerror(L, to_luastring(\"invalid option '%%%c' to 'lua_pushfstring'\"), fmt[e + 1]);\n        }\n        n += 2;\n        i = e + 2;\n    }\n    ldo.luaD_checkstack(L, 1);\n    pushstr(L, fmt.subarray(i));\n    if (n > 0) lvm.luaV_concat(L, n+1);\n    return L.stack[L.top-1].svalue();\n};\n\nconst luaO_pushfstring = function(L, fmt, ...argp) {\n    return luaO_pushvfstring(L, fmt, argp);\n};\n\n\n/*\n** converts an integer to a \"floating point byte\", represented as\n** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if\n** eeeee !== 0 and (xxx) otherwise.\n*/\nconst luaO_int2fb = function(x) {\n    let e = 0;  /* exponent */\n    if (x < 8) return x;\n    while (x >= (8 << 4)) {  /* coarse steps */\n        x = (x + 0xf) >> 4;  /* x = ceil(x / 16) */\n        e += 4;\n    }\n    while (x >= (8 << 1)) {  /* fine steps */\n        x = (x + 1) >> 1;  /* x = ceil(x / 2) */\n        e++;\n    }\n    return ((e+1) << 3) | (x - 8);\n};\n\nconst intarith = function(L, op, v1, v2) {\n    switch (op) {\n        case LUA_OPADD:  return (v1 + v2)|0;\n        case LUA_OPSUB:  return (v1 - v2)|0;\n        case LUA_OPMUL:  return lvm.luaV_imul(v1, v2);\n        case LUA_OPMOD:  return lvm.luaV_mod(L, v1, v2);\n        case LUA_OPIDIV: return lvm.luaV_div(L, v1, v2);\n        case LUA_OPBAND: return (v1 & v2);\n        case LUA_OPBOR:  return (v1 | v2);\n        case LUA_OPBXOR: return (v1 ^ v2);\n        case LUA_OPSHL:  return lvm.luaV_shiftl(v1, v2);\n        case LUA_OPSHR:  return lvm.luaV_shiftl(v1, -v2);\n        case LUA_OPUNM:  return (0 - v1)|0;\n        case LUA_OPBNOT: return (~0 ^ v1);\n        default: lua_assert(0);\n    }\n};\n\n\nconst numarith = function(L, op, v1, v2) {\n    switch (op) {\n        case LUA_OPADD:  return v1 + v2;\n        case LUA_OPSUB:  return v1 - v2;\n        case LUA_OPMUL:  return v1 * v2;\n        case LUA_OPDIV:  return v1 / v2;\n        case LUA_OPPOW:  return Math.pow(v1, v2);\n        case LUA_OPIDIV: return Math.floor(v1 / v2);\n        case LUA_OPUNM:  return -v1;\n        case LUA_OPMOD:  return luai_nummod(L, v1, v2);\n        default: lua_assert(0);\n    }\n};\n\nconst luaO_arith = function(L, op, p1, p2, p3) {\n    let res = (typeof p3 === \"number\") ? L.stack[p3] : p3;  /* FIXME */\n\n    switch (op) {\n        case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:\n        case LUA_OPSHL: case LUA_OPSHR:\n        case LUA_OPBNOT: {  /* operate only on integers */\n            let i1, i2;\n            if ((i1 = lvm.tointeger(p1)) !== false && (i2 = lvm.tointeger(p2)) !== false) {\n                res.setivalue(intarith(L, op, i1, i2));\n                return;\n            }\n            else break;  /* go to the end */\n        }\n        case LUA_OPDIV: case LUA_OPPOW: {  /* operate only on floats */\n            let n1, n2;\n            if ((n1 = lvm.tonumber(p1)) !== false && (n2 = lvm.tonumber(p2)) !== false) {\n                res.setfltvalue(numarith(L, op, n1, n2));\n                return;\n            }\n            else break;  /* go to the end */\n        }\n        default: {  /* other operations */\n            let n1, n2;\n            if (p1.ttisinteger() && p2.ttisinteger()) {\n                res.setivalue(intarith(L, op, p1.value, p2.value));\n                return;\n            }\n            else if ((n1 = lvm.tonumber(p1)) !== false && (n2 = lvm.tonumber(p2)) !== false) {\n                res.setfltvalue(numarith(L, op, n1, n2));\n                return;\n            }\n            else break;  /* go to the end */\n        }\n    }\n    /* could not perform raw operation; try metamethod */\n    lua_assert(L !== null);  /* should not fail when folding (compile time) */\n    ltm.luaT_trybinTM(L, p1, p2, p3, (op - LUA_OPADD) + ltm.TMS.TM_ADD);\n};\n\n\nmodule.exports.CClosure          = CClosure;\nmodule.exports.LClosure          = LClosure;\nmodule.exports.LUA_TDEADKEY      = LUA_TDEADKEY;\nmodule.exports.LUA_TPROTO        = LUA_TPROTO;\nmodule.exports.LocVar            = LocVar;\nmodule.exports.TValue            = TValue;\nmodule.exports.Udata             = Udata;\nmodule.exports.UTF8BUFFSZ        = UTF8BUFFSZ;\nmodule.exports.luaO_arith        = luaO_arith;\nmodule.exports.luaO_chunkid      = luaO_chunkid;\nmodule.exports.luaO_hexavalue    = luaO_hexavalue;\nmodule.exports.luaO_int2fb       = luaO_int2fb;\nmodule.exports.luaO_pushfstring  = luaO_pushfstring;\nmodule.exports.luaO_pushvfstring = luaO_pushvfstring;\nmodule.exports.luaO_str2num      = luaO_str2num;\nmodule.exports.luaO_tostring     = luaO_tostring;\nmodule.exports.luaO_utf8esc      = luaO_utf8esc;\nmodule.exports.numarith          = numarith;\nmodule.exports.pushobj2s         = pushobj2s;\nmodule.exports.pushsvalue2s      = pushsvalue2s;\nmodule.exports.setobjs2s         = setobjs2s;\nmodule.exports.setobj2s          = setobj2s;\nmodule.exports.setsvalue2s       = setsvalue2s;\n","/* Fengari specific functions\n *\n * This file includes fengari-specific data or and functionality for users to\n * manipulate fengari's string type.\n * The fields are exposed to the user on the 'fengari' entry point; however to\n * avoid a dependency on defs.js from lauxlib.js they are defined in this file.\n */\n\nconst defs = require(\"./defs.js\");\n\nconst FENGARI_VERSION_MAJOR   = \"0\";\nconst FENGARI_VERSION_MINOR   = \"1\";\nconst FENGARI_VERSION_NUM     = 1;\nconst FENGARI_VERSION_RELEASE = \"2\";\nconst FENGARI_VERSION         = \"Fengari \" + FENGARI_VERSION_MAJOR + \".\" + FENGARI_VERSION_MINOR;\nconst FENGARI_RELEASE         = FENGARI_VERSION + \".\" + FENGARI_VERSION_RELEASE;\nconst FENGARI_AUTHORS         = \"B. Giannangeli, Daurnimator\";\nconst FENGARI_COPYRIGHT       = FENGARI_RELEASE + \"  Copyright (C) 2017-2018 \" + FENGARI_AUTHORS + \"\\nBased on: \" + defs.LUA_COPYRIGHT;\n\nmodule.exports.FENGARI_AUTHORS         = FENGARI_AUTHORS;\nmodule.exports.FENGARI_COPYRIGHT       = FENGARI_COPYRIGHT;\nmodule.exports.FENGARI_RELEASE         = FENGARI_RELEASE;\nmodule.exports.FENGARI_VERSION         = FENGARI_VERSION;\nmodule.exports.FENGARI_VERSION_MAJOR   = FENGARI_VERSION_MAJOR;\nmodule.exports.FENGARI_VERSION_MINOR   = FENGARI_VERSION_MINOR;\nmodule.exports.FENGARI_VERSION_NUM     = FENGARI_VERSION_NUM;\nmodule.exports.FENGARI_VERSION_RELEASE = FENGARI_VERSION_RELEASE;\nmodule.exports.is_luastring            = defs.is_luastring;\nmodule.exports.luastring_eq            = defs.luastring_eq;\nmodule.exports.luastring_from          = defs.luastring_from;\nmodule.exports.luastring_indexOf       = defs.luastring_indexOf;\nmodule.exports.luastring_of            = defs.luastring_of;\nmodule.exports.to_jsstring             = defs.to_jsstring;\nmodule.exports.to_luastring            = defs.to_luastring;\nmodule.exports.to_uristring            = defs.to_uristring;\nmodule.exports.from_userstring         = defs.from_userstring;\n","\"use strict\";\n\nconst {\n    LUA_HOOKCALL,\n    LUA_HOOKRET,\n    LUA_HOOKTAILCALL,\n    LUA_MASKCALL,\n    LUA_MASKLINE,\n    LUA_MASKRET,\n    LUA_MINSTACK,\n    LUA_MULTRET,\n    LUA_SIGNATURE,\n    constant_types: {\n        LUA_TCCL,\n        LUA_TLCF,\n        LUA_TLCL,\n        LUA_TNIL\n    },\n    thread_status: {\n        LUA_ERRMEM,\n        LUA_ERRERR,\n        LUA_ERRRUN,\n        LUA_ERRSYNTAX,\n        LUA_OK,\n        LUA_YIELD\n    },\n    lua_Debug,\n    luastring_indexOf,\n    to_luastring\n} = require('./defs.js');\nconst lapi     = require('./lapi.js');\nconst ldebug   = require('./ldebug.js');\nconst lfunc    = require('./lfunc.js');\nconst {\n    api_check,\n    lua_assert,\n    LUAI_MAXCCALLS\n} = require('./llimits.js');\nconst lobject  = require('./lobject.js');\nconst lopcodes = require('./lopcodes.js');\nconst lparser  = require('./lparser.js');\nconst lstate   = require('./lstate.js');\nconst { luaS_newliteral } = require('./lstring.js');\nconst ltm      = require('./ltm.js');\nconst { LUAI_MAXSTACK } = require('./luaconf.js');\nconst lundump  = require('./lundump.js');\nconst lvm      = require('./lvm.js');\nconst { MBuffer } = require('./lzio.js');\n\nconst adjust_top = function(L, newtop) {\n    if (L.top < newtop) {\n        while (L.top < newtop)\n            L.stack[L.top++] = new lobject.TValue(LUA_TNIL, null);\n    } else {\n        while (L.top > newtop)\n            delete L.stack[--L.top];\n    }\n};\n\nconst seterrorobj = function(L, errcode, oldtop) {\n    let current_top = L.top;\n\n    /* extend stack so that L.stack[oldtop] is sure to exist */\n    while (L.top < oldtop + 1)\n        L.stack[L.top++] = new lobject.TValue(LUA_TNIL, null);\n\n    switch (errcode) {\n        case LUA_ERRMEM: {\n            lobject.setsvalue2s(L, oldtop, luaS_newliteral(L, \"not enough memory\"));\n            break;\n        }\n        case LUA_ERRERR: {\n            lobject.setsvalue2s(L, oldtop, luaS_newliteral(L, \"error in error handling\"));\n            break;\n        }\n        default: {\n            lobject.setobjs2s(L, oldtop, current_top - 1);\n        }\n    }\n\n    while (L.top > oldtop + 1)\n        delete L.stack[--L.top];\n};\n\nconst ERRORSTACKSIZE = LUAI_MAXSTACK + 200;\n\nconst luaD_reallocstack = function(L, newsize) {\n    lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);\n    lua_assert(L.stack_last == L.stack.length - lstate.EXTRA_STACK);\n    L.stack.length = newsize;\n    L.stack_last = newsize - lstate.EXTRA_STACK;\n};\n\nconst luaD_growstack = function(L, n) {\n    let size = L.stack.length;\n    if (size > LUAI_MAXSTACK)\n        luaD_throw(L, LUA_ERRERR);\n    else {\n        let needed = L.top + n + lstate.EXTRA_STACK;\n        let newsize = 2 * size;\n        if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK;\n        if (newsize < needed) newsize = needed;\n        if (newsize > LUAI_MAXSTACK) {  /* stack overflow? */\n            luaD_reallocstack(L, ERRORSTACKSIZE);\n            ldebug.luaG_runerror(L, to_luastring(\"stack overflow\", true));\n        }\n        else\n            luaD_reallocstack(L, newsize);\n    }\n};\n\nconst luaD_checkstack = function(L, n) {\n    if (L.stack_last - L.top <= n)\n        luaD_growstack(L, n);\n};\n\nconst stackinuse = function(L) {\n    let lim = L.top;\n    for (let ci = L.ci; ci !== null; ci = ci.previous) {\n        if (lim < ci.top) lim = ci.top;\n    }\n    lua_assert(lim <= L.stack_last);\n    return lim + 1; /* part of stack in use */\n};\n\nconst luaD_shrinkstack = function(L) {\n    let inuse = stackinuse(L);\n    let goodsize = inuse + Math.floor(inuse / 8) + 2*lstate.EXTRA_STACK;\n    if (goodsize > LUAI_MAXSTACK)\n        goodsize = LUAI_MAXSTACK;  /* respect stack limit */\n    if (L.stack.length > LUAI_MAXSTACK)  /* had been handling stack overflow? */\n        lstate.luaE_freeCI(L);  /* free all CIs (list grew because of an error) */\n    /* if thread is currently not handling a stack overflow and its\n     good size is smaller than current size, shrink its stack */\n    if (inuse <= (LUAI_MAXSTACK - lstate.EXTRA_STACK) && goodsize < L.stack.length)\n        luaD_reallocstack(L, goodsize);\n};\n\nconst luaD_inctop = function(L) {\n    luaD_checkstack(L, 1);\n    L.stack[L.top++] = new lobject.TValue(LUA_TNIL, null);\n};\n\n/*\n** Prepares a function call: checks the stack, creates a new CallInfo\n** entry, fills in the relevant information, calls hook if needed.\n** If function is a JS function, does the call, too. (Otherwise, leave\n** the execution ('luaV_execute') to the caller, to allow stackless\n** calls.) Returns true iff function has been executed (JS function).\n*/\nconst luaD_precall = function(L, off, nresults) {\n    let func = L.stack[off];\n\n    switch(func.type) {\n        case LUA_TCCL:\n        case LUA_TLCF: {\n            let f = func.type === LUA_TCCL ? func.value.f : func.value;\n\n            luaD_checkstack(L, LUA_MINSTACK);\n            let ci = lstate.luaE_extendCI(L);\n            ci.funcOff = off;\n            ci.nresults = nresults;\n            ci.func = func;\n            ci.top = L.top + LUA_MINSTACK;\n            lua_assert(ci.top <= L.stack_last);\n            ci.callstatus = 0;\n            if (L.hookmask & LUA_MASKCALL)\n                luaD_hook(L, LUA_HOOKCALL, -1);\n            let n = f(L); /* do the actual call */\n            if (typeof n !== \"number\" || n < 0 || (n|0) !== n)\n                throw Error(\"invalid return value from JS function (expected integer)\");\n            lapi.api_checknelems(L, n);\n\n            luaD_poscall(L, ci, L.top - n, n);\n\n            return true;\n        }\n        case LUA_TLCL: {\n            let base;\n            let p = func.value.p;\n            let n = L.top - off - 1;\n            let fsize = p.maxstacksize;\n            luaD_checkstack(L, fsize);\n            if (p.is_vararg) {\n                base = adjust_varargs(L, p, n);\n            } else {\n                for (; n < p.numparams; n++)\n                    L.stack[L.top++] = new lobject.TValue(LUA_TNIL, null); // complete missing arguments\n                base = off + 1;\n            }\n\n            let ci = lstate.luaE_extendCI(L);\n            ci.funcOff = off;\n            ci.nresults = nresults;\n            ci.func = func;\n            ci.l_base = base;\n            ci.top = base + fsize;\n            adjust_top(L, ci.top);\n            ci.l_code = p.code;\n            ci.l_savedpc = 0;\n            ci.callstatus = lstate.CIST_LUA;\n            if (L.hookmask & LUA_MASKCALL)\n                callhook(L, ci);\n            return false;\n        }\n        default:\n            luaD_checkstack(L, 1);\n            tryfuncTM(L, off, func);\n            return luaD_precall(L, off, nresults);\n    }\n};\n\nconst luaD_poscall = function(L, ci, firstResult, nres) {\n    let wanted = ci.nresults;\n\n    if (L.hookmask & (LUA_MASKRET | LUA_MASKLINE)) {\n        if (L.hookmask & LUA_MASKRET)\n            luaD_hook(L, LUA_HOOKRET, -1);\n        L.oldpc = ci.previous.l_savedpc;  /* 'oldpc' for caller function */\n    }\n\n    let res = ci.funcOff;\n    L.ci = ci.previous;\n    L.ci.next = null;\n    return moveresults(L, firstResult, res, nres, wanted);\n};\n\nconst moveresults = function(L, firstResult, res, nres, wanted) {\n    switch (wanted) {\n        case 0:\n            break;\n        case 1: {\n            if (nres === 0)\n                L.stack[res].setnilvalue();\n            else {\n                lobject.setobjs2s(L, res, firstResult); /* move it to proper place */\n            }\n            break;\n        }\n        case LUA_MULTRET: {\n            for (let i = 0; i < nres; i++)\n                lobject.setobjs2s(L, res + i, firstResult + i);\n            for (let i=L.top; i>=(res + nres); i--)\n                delete L.stack[i];\n            L.top = res + nres;\n            return false;\n        }\n        default: {\n            let i;\n            if (wanted <= nres) {\n                for (i = 0; i < wanted; i++)\n                    lobject.setobjs2s(L, res + i, firstResult + i);\n            } else {\n                for (i = 0; i < nres; i++)\n                    lobject.setobjs2s(L, res + i, firstResult + i);\n                for (; i < wanted; i++) {\n                    if (res+i >= L.top)\n                        L.stack[res + i] = new lobject.TValue(LUA_TNIL, null);\n                    else\n                        L.stack[res + i].setnilvalue();\n                }\n            }\n            break;\n        }\n    }\n    let newtop = res + wanted; /* top points after the last result */\n    for (let i=L.top; i>=newtop; i--)\n        delete L.stack[i];\n    L.top = newtop;\n    return true;\n};\n\n/*\n** Call a hook for the given event. Make sure there is a hook to be\n** called. (Both 'L->hook' and 'L->hookmask', which triggers this\n** function, can be changed asynchronously by signals.)\n*/\nconst luaD_hook = function(L, event, line) {\n    let hook = L.hook;\n    if (hook && L.allowhook) {  /* make sure there is a hook */\n        let ci = L.ci;\n        let top = L.top;\n        let ci_top = ci.top;\n        let ar = new lua_Debug();\n        ar.event = event;\n        ar.currentline = line;\n        ar.i_ci = ci;\n        luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */\n        ci.top = L.top + LUA_MINSTACK;\n        lua_assert(ci.top <= L.stack_last);\n        L.allowhook = 0;  /* cannot call hooks inside a hook */\n        ci.callstatus |= lstate.CIST_HOOKED;\n        hook(L, ar);\n        lua_assert(!L.allowhook);\n        L.allowhook = 1;\n        ci.top = ci_top;\n        adjust_top(L, top);\n        ci.callstatus &= ~lstate.CIST_HOOKED;\n    }\n};\n\nconst callhook = function(L, ci) {\n    let hook = LUA_HOOKCALL;\n    ci.l_savedpc++;  /* hooks assume 'pc' is already incremented */\n    if ((ci.previous.callstatus & lstate.CIST_LUA) &&\n      ci.previous.l_code[ci.previous.l_savedpc - 1].opcode == lopcodes.OpCodesI.OP_TAILCALL) {\n        ci.callstatus |= lstate.CIST_TAIL;\n        hook = LUA_HOOKTAILCALL;\n    }\n    luaD_hook(L, hook, -1);\n    ci.l_savedpc--;  /* correct 'pc' */\n};\n\nconst adjust_varargs = function(L, p, actual) {\n    let nfixargs = p.numparams;\n    /* move fixed parameters to final position */\n    let fixed = L.top - actual; /* first fixed argument */\n    let base = L.top; /* final position of first argument */\n\n    let i;\n    for (i = 0; i < nfixargs && i < actual; i++) {\n        lobject.pushobj2s(L, L.stack[fixed + i]);\n        L.stack[fixed + i].setnilvalue();\n    }\n\n    for (; i < nfixargs; i++)\n        L.stack[L.top++] = new lobject.TValue(LUA_TNIL, null);\n\n    return base;\n};\n\nconst tryfuncTM = function(L, off, func) {\n    let tm = ltm.luaT_gettmbyobj(L, func, ltm.TMS.TM_CALL);\n    if (!tm.ttisfunction(tm))\n        ldebug.luaG_typeerror(L, func, to_luastring(\"call\", true));\n    /* Open a hole inside the stack at 'func' */\n    lobject.pushobj2s(L, L.stack[L.top-1]); /* push top of stack again */\n    for (let p = L.top-2; p > off; p--)\n        lobject.setobjs2s(L, p, p-1); /* move other items up one */\n    lobject.setobj2s(L, off, tm); /* tag method is the new function to be called */\n};\n\n/*\n** Check appropriate error for stack overflow (\"regular\" overflow or\n** overflow while handling stack overflow). If 'nCalls' is larger than\n** LUAI_MAXCCALLS (which means it is handling a \"regular\" overflow) but\n** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to\n** allow overflow handling to work)\n*/\nconst stackerror = function(L) {\n    if (L.nCcalls === LUAI_MAXCCALLS)\n        ldebug.luaG_runerror(L, to_luastring(\"JS stack overflow\", true));\n    else if (L.nCcalls >= LUAI_MAXCCALLS + (LUAI_MAXCCALLS >> 3))\n        luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */\n};\n\n/*\n** Call a function (JS or Lua). The function to be called is at func.\n** The arguments are on the stack, right after the function.\n** When returns, all the results are on the stack, starting at the original\n** function position.\n*/\nconst luaD_call = function(L, off, nResults) {\n    if (++L.nCcalls >= LUAI_MAXCCALLS)\n        stackerror(L);\n    if (!luaD_precall(L, off, nResults))\n        lvm.luaV_execute(L);\n    L.nCcalls--;\n};\n\nconst luaD_throw = function(L, errcode) {\n    if (L.errorJmp) {  /* thread has an error handler? */\n        L.errorJmp.status = errcode;  /* set status */\n        throw L.errorJmp;\n    } else {  /* thread has no error handler */\n        let g = L.l_G;\n        L.status = errcode;  /* mark it as dead */\n        if (g.mainthread.errorJmp) {  /* main thread has a handler? */\n            g.mainthread.stack[g.mainthread.top++] = L.stack[L.top - 1];  /* copy error obj. */\n            luaD_throw(g.mainthread, errcode);  /* re-throw in main thread */\n        } else {  /* no handler at all; abort */\n            let panic = g.panic;\n            if (panic) {  /* panic function? */\n                seterrorobj(L, errcode, L.top);  /* assume EXTRA_STACK */\n                if (L.ci.top < L.top)\n                    L.ci.top = L.top;  /* pushing msg. can break this invariant */\n                panic(L);  /* call panic function (last chance to jump out) */\n            }\n            throw new Error(`Aborted ${errcode}`);\n        }\n    }\n};\n\nconst luaD_rawrunprotected = function(L, f, ud) {\n    let oldnCcalls = L.nCcalls;\n    let lj = {\n        status: LUA_OK,\n        previous: L.errorJmp /* chain new error handler */\n    };\n    L.errorJmp = lj;\n\n    try {\n        f(L, ud);\n    } catch (e) {\n        if (lj.status === LUA_OK) {\n            /* error was not thrown via luaD_throw, i.e. it is a JS error */\n            /* run user error handler (if it exists) */\n            let atnativeerror = L.l_G.atnativeerror;\n            if (atnativeerror) {\n                try {\n                    lj.status = LUA_OK;\n\n                    lapi.lua_pushcfunction(L, atnativeerror);\n                    lapi.lua_pushlightuserdata(L, e);\n                    luaD_callnoyield(L, L.top - 2, 1);\n\n                    /* Now run the message handler (if it exists) */\n                    /* copy of luaG_errormsg without the throw */\n                    if (L.errfunc !== 0) {  /* is there an error handling function? */\n                        let errfunc = L.errfunc;\n                        lobject.pushobj2s(L, L.stack[L.top - 1]); /* move argument */\n                        lobject.setobjs2s(L, L.top - 2, errfunc); /* push function */\n                        luaD_callnoyield(L, L.top - 2, 1);\n                    }\n\n                    lj.status = LUA_ERRRUN;\n                } catch(e2) {\n                    if (lj.status === LUA_OK) {\n                        /* also failed */\n                        lj.status = -1;\n                    }\n                }\n            } else {\n                lj.status = -1;\n            }\n        }\n    }\n\n    L.errorJmp = lj.previous;\n    L.nCcalls = oldnCcalls;\n\n    return lj.status;\n\n};\n\n/*\n** Completes the execution of an interrupted C function, calling its\n** continuation function.\n*/\nconst finishCcall = function(L, status) {\n    let ci = L.ci;\n\n    /* must have a continuation and must be able to call it */\n    lua_assert(ci.c_k !== null && L.nny === 0);\n    /* error status can only happen in a protected call */\n    lua_assert(ci.callstatus & lstate.CIST_YPCALL || status === LUA_YIELD);\n\n    if (ci.callstatus & lstate.CIST_YPCALL) {  /* was inside a pcall? */\n        ci.callstatus &= ~lstate.CIST_YPCALL;  /* continuation is also inside it */\n        L.errfunc = ci.c_old_errfunc;  /* with the same error function */\n    }\n\n    /* finish 'lua_callk'/'lua_pcall'; CIST_YPCALL and 'errfunc' already\n       handled */\n    if (ci.nresults === LUA_MULTRET && L.ci.top < L.top) L.ci.top = L.top;\n    let c_k = ci.c_k; /* don't want to call as method */\n    let n = c_k(L, status, ci.c_ctx);  /* call continuation function */\n    lapi.api_checknelems(L, n);\n    luaD_poscall(L, ci, L.top - n, n);  /* finish 'luaD_precall' */\n};\n\n/*\n** Executes \"full continuation\" (everything in the stack) of a\n** previously interrupted coroutine until the stack is empty (or another\n** interruption long-jumps out of the loop). If the coroutine is\n** recovering from an error, 'ud' points to the error status, which must\n** be passed to the first continuation function (otherwise the default\n** status is LUA_YIELD).\n*/\nconst unroll = function(L, ud) {\n    if (ud !== null)  /* error status? */\n        finishCcall(L, ud);  /* finish 'lua_pcallk' callee */\n\n    while (L.ci !== L.base_ci) {  /* something in the stack */\n        if (!(L.ci.callstatus & lstate.CIST_LUA))  /* C function? */\n            finishCcall(L, LUA_YIELD);  /* complete its execution */\n        else {  /* Lua function */\n            lvm.luaV_finishOp(L);  /* finish interrupted instruction */\n            lvm.luaV_execute(L);  /* execute down to higher C 'boundary' */\n        }\n    }\n};\n\n/*\n** Try to find a suspended protected call (a \"recover point\") for the\n** given thread.\n*/\nconst findpcall = function(L) {\n    for (let ci = L.ci; ci !== null; ci = ci.previous) {  /* search for a pcall */\n        if (ci.callstatus & lstate.CIST_YPCALL)\n            return ci;\n    }\n\n    return null;  /* no pending pcall */\n};\n\n/*\n** Recovers from an error in a coroutine. Finds a recover point (if\n** there is one) and completes the execution of the interrupted\n** 'luaD_pcall'. If there is no recover point, returns zero.\n*/\nconst recover = function(L, status) {\n    let ci = findpcall(L);\n    if (ci === null) return 0;  /* no recovery point */\n    /* \"finish\" luaD_pcall */\n    let oldtop = ci.extra;\n    lfunc.luaF_close(L, oldtop);\n    seterrorobj(L, status, oldtop);\n    L.ci = ci;\n    L.allowhook = ci.callstatus & lstate.CIST_OAH;  /* restore original 'allowhook' */\n    L.nny = 0;  /* should be zero to be yieldable */\n    luaD_shrinkstack(L);\n    L.errfunc = ci.c_old_errfunc;\n    return 1;  /* continue running the coroutine */\n};\n\n/*\n** Signal an error in the call to 'lua_resume', not in the execution\n** of the coroutine itself. (Such errors should not be handled by any\n** coroutine error handler and should not kill the coroutine.)\n*/\nconst resume_error = function(L, msg, narg) {\n    let ts = luaS_newliteral(L, msg);\n    if (narg === 0) {\n        lobject.pushsvalue2s(L, ts);\n        api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    } else {\n        /* remove args from the stack */\n        for (let i=1; i<narg; i++)\n            delete L.stack[--L.top];\n        lobject.setsvalue2s(L, L.top-1, ts);  /* push error message */\n    }\n    return LUA_ERRRUN;\n};\n\n/*\n** Do the work for 'lua_resume' in protected mode. Most of the work\n** depends on the status of the coroutine: initial state, suspended\n** inside a hook, or regularly suspended (optionally with a continuation\n** function), plus erroneous cases: non-suspended coroutine or dead\n** coroutine.\n*/\nconst resume = function(L, n) {\n    let firstArg = L.top - n;  /* first argument */\n    let ci = L.ci;\n    if (L.status === LUA_OK) {  /* starting a coroutine? */\n        if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */\n            lvm.luaV_execute(L);  /* call it */\n    } else {  /* resuming from previous yield */\n        lua_assert(L.status === LUA_YIELD);\n        L.status = LUA_OK;  /* mark that it is running (again) */\n        ci.funcOff = ci.extra;\n        ci.func = L.stack[ci.funcOff];\n\n        if (ci.callstatus & lstate.CIST_LUA)  /* yielded inside a hook? */\n            lvm.luaV_execute(L);  /* just continue running Lua code */\n        else {  /* 'common' yield */\n            if (ci.c_k !== null) {  /* does it have a continuation function? */\n                n = ci.c_k(L, LUA_YIELD, ci.c_ctx); /* call continuation */\n                lapi.api_checknelems(L, n);\n                firstArg = L.top - n;  /* yield results come from continuation */\n            }\n\n            luaD_poscall(L, ci, firstArg, n);  /* finish 'luaD_precall' */\n        }\n\n        unroll(L, null);  /* run continuation */\n    }\n};\n\nconst lua_resume = function(L, from, nargs) {\n    let oldnny = L.nny;  /* save \"number of non-yieldable\" calls */\n\n    if (L.status === LUA_OK) {  /* may be starting a coroutine */\n        if (L.ci !== L.base_ci)  /* not in base level? */\n            return resume_error(L, \"cannot resume non-suspended coroutine\", nargs);\n    } else if (L.status !== LUA_YIELD)\n        return resume_error(L, \"cannot resume dead coroutine\", nargs);\n\n    L.nCcalls = from ? from.nCcalls + 1 : 1;\n    if (L.nCcalls >= LUAI_MAXCCALLS)\n        return resume_error(L, \"JS stack overflow\", nargs);\n\n    L.nny = 0;  /* allow yields */\n\n    lapi.api_checknelems(L, L.status === LUA_OK ? nargs + 1: nargs);\n\n    let status = luaD_rawrunprotected(L, resume, nargs);\n    if (status === -1)  /* error calling 'lua_resume'? */\n        status = LUA_ERRRUN;\n    else {  /* continue running after recoverable errors */\n        while (status > LUA_YIELD && recover(L, status)) {\n            /* unroll continuation */\n            status = luaD_rawrunprotected(L, unroll, status);\n        }\n\n        if (status > LUA_YIELD) {  /* unrecoverable error? */\n            L.status = status;  /* mark thread as 'dead' */\n            seterrorobj(L, status, L.top);  /* push error message */\n            L.ci.top = L.top;\n        } else\n            lua_assert(status === L.status);  /* normal end or yield */\n    }\n\n    L.nny = oldnny;  /* restore 'nny' */\n    L.nCcalls--;\n    lua_assert(L.nCcalls === (from ? from.nCcalls : 0));\n    return status;\n};\n\nconst lua_isyieldable = function(L) {\n    return L.nny === 0;\n};\n\nconst lua_yieldk = function(L, nresults, ctx, k) {\n    let ci = L.ci;\n    lapi.api_checknelems(L, nresults);\n\n    if (L.nny > 0) {\n        if (L !== L.l_G.mainthread)\n            ldebug.luaG_runerror(L, to_luastring(\"attempt to yield across a JS-call boundary\", true));\n        else\n            ldebug.luaG_runerror(L, to_luastring(\"attempt to yield from outside a coroutine\", true));\n    }\n\n    L.status = LUA_YIELD;\n    ci.extra = ci.funcOff;  /* save current 'func' */\n    if (ci.callstatus & lstate.CIST_LUA)  /* inside a hook? */\n        api_check(L, k === null, \"hooks cannot continue after yielding\");\n    else {\n        ci.c_k = k;\n        if (k !== null)  /* is there a continuation? */\n            ci.c_ctx = ctx;  /* save context */\n        ci.funcOff = L.top - nresults - 1;  /* protect stack below results */\n        ci.func = L.stack[ci.funcOff];\n        luaD_throw(L, LUA_YIELD);\n    }\n\n    lua_assert(ci.callstatus & lstate.CIST_HOOKED);  /* must be inside a hook */\n    return 0;  /* return to 'luaD_hook' */\n};\n\nconst lua_yield = function(L, n) {\n    lua_yieldk(L, n, 0, null);\n};\n\nconst luaD_pcall = function(L, func, u, old_top, ef) {\n    let old_ci = L.ci;\n    let old_allowhooks = L.allowhook;\n    let old_nny = L.nny;\n    let old_errfunc = L.errfunc;\n    L.errfunc = ef;\n\n    let status = luaD_rawrunprotected(L, func, u);\n\n    if (status !== LUA_OK) {\n        lfunc.luaF_close(L, old_top);\n        seterrorobj(L, status, old_top);\n        L.ci = old_ci;\n        L.allowhook = old_allowhooks;\n        L.nny = old_nny;\n        luaD_shrinkstack(L);\n    }\n\n    L.errfunc = old_errfunc;\n\n    return status;\n};\n\n/*\n** Similar to 'luaD_call', but does not allow yields during the call\n*/\nconst luaD_callnoyield = function(L, off, nResults) {\n    L.nny++;\n    luaD_call(L, off, nResults);\n    L.nny--;\n};\n\n/*\n** Execute a protected parser.\n*/\nclass SParser {\n    constructor(z, name, mode) {  /* data to 'f_parser' */\n        this.z = z;\n        this.buff = new MBuffer();  /* dynamic structure used by the scanner */\n        this.dyd = new lparser.Dyndata();  /* dynamic structures used by the parser */\n        this.mode = mode;\n        this.name = name;\n    }\n}\n\nconst checkmode = function(L, mode, x) {\n    if (mode && luastring_indexOf(mode, x[0]) === -1) {\n        lobject.luaO_pushfstring(L,\n            to_luastring(\"attempt to load a %s chunk (mode is '%s')\"), x, mode);\n        luaD_throw(L, LUA_ERRSYNTAX);\n    }\n};\n\nconst f_parser = function(L, p) {\n    let cl;\n    let c = p.z.zgetc();  /* read first character */\n    if (c === LUA_SIGNATURE[0]) {\n        checkmode(L, p.mode, to_luastring(\"binary\", true));\n        cl = lundump.luaU_undump(L, p.z, p.name);\n    } else {\n        checkmode(L, p.mode, to_luastring(\"text\", true));\n        cl = lparser.luaY_parser(L, p.z, p.buff, p.dyd, p.name, c);\n    }\n\n    lua_assert(cl.nupvalues === cl.p.upvalues.length);\n    lfunc.luaF_initupvals(L, cl);\n};\n\nconst luaD_protectedparser = function(L, z, name, mode) {\n    let p = new SParser(z, name, mode);\n    L.nny++;  /* cannot yield during parsing */\n    let status = luaD_pcall(L, f_parser, p, L.top, L.errfunc);\n    L.nny--;\n    return status;\n};\n\nmodule.exports.adjust_top           = adjust_top;\nmodule.exports.luaD_call            = luaD_call;\nmodule.exports.luaD_callnoyield     = luaD_callnoyield;\nmodule.exports.luaD_checkstack      = luaD_checkstack;\nmodule.exports.luaD_growstack       = luaD_growstack;\nmodule.exports.luaD_hook            = luaD_hook;\nmodule.exports.luaD_inctop          = luaD_inctop;\nmodule.exports.luaD_pcall           = luaD_pcall;\nmodule.exports.luaD_poscall         = luaD_poscall;\nmodule.exports.luaD_precall         = luaD_precall;\nmodule.exports.luaD_protectedparser = luaD_protectedparser;\nmodule.exports.luaD_rawrunprotected = luaD_rawrunprotected;\nmodule.exports.luaD_reallocstack    = luaD_reallocstack;\nmodule.exports.luaD_throw           = luaD_throw;\nmodule.exports.lua_isyieldable      = lua_isyieldable;\nmodule.exports.lua_resume           = lua_resume;\nmodule.exports.lua_yield            = lua_yield;\nmodule.exports.lua_yieldk           = lua_yieldk;\n","\"use strict\";\n\nconst {\n    is_luastring,\n    luastring_eq,\n    luastring_from,\n    to_luastring\n} = require('./defs.js');\nconst { lua_assert } = require(\"./llimits.js\");\n\nclass TString {\n\n    constructor(L, str) {\n        this.hash = null;\n        this.realstring = str;\n    }\n\n    getstr() {\n        return this.realstring;\n    }\n\n    tsslen() {\n        return this.realstring.length;\n    }\n\n}\n\nconst luaS_eqlngstr = function(a, b) {\n    lua_assert(a instanceof TString);\n    lua_assert(b instanceof TString);\n    return a == b || luastring_eq(a.realstring, b.realstring);\n};\n\n/* converts strings (arrays) to a consistent map key\n   make sure this doesn't conflict with any of the anti-collision strategies in ltable */\nconst luaS_hash = function(str) {\n    lua_assert(is_luastring(str));\n    let len = str.length;\n    let s = \"|\";\n    for (let i=0; i<len; i++)\n        s += str[i].toString(16);\n    return s;\n};\n\nconst luaS_hashlongstr = function(ts) {\n    lua_assert(ts instanceof TString);\n    if(ts.hash === null) {\n        ts.hash = luaS_hash(ts.getstr());\n    }\n    return ts.hash;\n};\n\n/* variant that takes ownership of array */\nconst luaS_bless = function(L, str) {\n    lua_assert(str instanceof Uint8Array);\n    return new TString(L, str);\n};\n\n/* makes a copy */\nconst luaS_new = function(L, str) {\n    return luaS_bless(L, luastring_from(str));\n};\n\n/* takes a js string */\nconst luaS_newliteral = function(L, str) {\n    return luaS_bless(L, to_luastring(str));\n};\n\nmodule.exports.luaS_eqlngstr    = luaS_eqlngstr;\nmodule.exports.luaS_hash        = luaS_hash;\nmodule.exports.luaS_hashlongstr = luaS_hashlongstr;\nmodule.exports.luaS_bless       = luaS_bless;\nmodule.exports.luaS_new         = luaS_new;\nmodule.exports.luaS_newliteral  = luaS_newliteral;\nmodule.exports.TString          = TString;\n","\"use strict\";\n\nconst {\n    constant_types: {\n        LUA_TBOOLEAN,\n        LUA_TCCL,\n        LUA_TLCF,\n        LUA_TLCL,\n        LUA_TLIGHTUSERDATA,\n        LUA_TLNGSTR,\n        LUA_TNIL,\n        LUA_TNUMFLT,\n        LUA_TNUMINT,\n        LUA_TSHRSTR,\n        LUA_TTABLE,\n        LUA_TTHREAD,\n        LUA_TUSERDATA\n    },\n    to_luastring\n} = require('./defs.js');\nconst { lua_assert } = require('./llimits.js');\nconst ldebug  = require('./ldebug.js');\nconst lobject = require('./lobject.js');\nconst {\n    luaS_hashlongstr,\n    TString\n} = require('./lstring.js');\nconst lstate  = require('./lstate.js');\n\n/* used to prevent conflicts with lightuserdata keys */\nlet lightuserdata_hashes = new WeakMap();\nconst get_lightuserdata_hash = function(v) {\n    let hash = lightuserdata_hashes.get(v);\n    if (!hash) {\n        /* Hash should be something unique that is a valid WeakMap key\n           so that it ends up in dead_weak when removed from a table */\n        hash = {};\n        lightuserdata_hashes.set(v, hash);\n    }\n    return hash;\n};\n\nconst table_hash = function(L, key) {\n    switch(key.type) {\n        case LUA_TNIL:\n            return ldebug.luaG_runerror(L, to_luastring(\"table index is nil\", true));\n        case LUA_TNUMFLT:\n            if (isNaN(key.value))\n                return ldebug.luaG_runerror(L, to_luastring(\"table index is NaN\", true));\n            /* fall through */\n        case LUA_TNUMINT: /* takes advantage of floats and integers being same in JS */\n        case LUA_TBOOLEAN:\n        case LUA_TTABLE:\n        case LUA_TLCL:\n        case LUA_TLCF:\n        case LUA_TCCL:\n        case LUA_TUSERDATA:\n        case LUA_TTHREAD:\n            return key.value;\n        case LUA_TSHRSTR:\n        case LUA_TLNGSTR:\n            return luaS_hashlongstr(key.tsvalue());\n        case LUA_TLIGHTUSERDATA: {\n            let v = key.value;\n            switch(typeof v) {\n                case \"string\":\n                    /* possible conflict with LUA_TSTRING.\n                       prefix this string with \"*\" so they don't clash */\n                    return \"*\" + v;\n                case \"number\":\n                    /* possible conflict with LUA_TNUMBER.\n                       turn into string and prefix with \"#\" to avoid clash with other strings */\n                    return \"#\" + v;\n                case \"boolean\":\n                    /* possible conflict with LUA_TBOOLEAN. use strings ?true and ?false instead */\n                    return v?\"?true\":\"?false\";\n                case \"function\":\n                    /* possible conflict with LUA_TLCF.\n                       indirect via a weakmap */\n                    return get_lightuserdata_hash(v);\n                case \"object\":\n                    /* v could be a lua_State, CClosure, LClosure, Table or Userdata from this state as returned by lua_topointer */\n                    if ((v instanceof lstate.lua_State && v.l_G === L.l_G) ||\n                        v instanceof Table ||\n                        v instanceof lobject.Udata ||\n                        v instanceof lobject.LClosure ||\n                        v instanceof lobject.CClosure) {\n                        /* indirect via a weakmap */\n                        return get_lightuserdata_hash(v);\n                    }\n                    /* fall through */\n                default:\n                    return v;\n            }\n        }\n        default:\n            throw new Error(\"unknown key type: \" + key.type);\n    }\n};\n\nclass Table {\n    constructor(L) {\n        this.id = L.l_G.id_counter++;\n        this.strong = new Map();\n        this.dead_strong = new Map();\n        this.dead_weak = void 0; /* initialised when needed */\n        this.f = void 0; /* first entry */\n        this.l = void 0; /* last entry */\n        this.metatable = null;\n        this.flags = ~0;\n    }\n}\n\nconst invalidateTMcache = function(t) {\n    t.flags = 0;\n};\n\nconst add = function(t, hash, key, value) {\n    t.dead_strong.clear();\n    t.dead_weak = void 0;\n    let prev = null;\n    let entry = {\n        key: key,\n        value: value,\n        p: prev = t.l,\n        n: void 0\n    };\n    if (!t.f) t.f = entry;\n    if (prev) prev.n = entry;\n    t.strong.set(hash, entry);\n    t.l = entry;\n};\n\nconst is_valid_weakmap_key = function(k) {\n    return typeof k === 'object' ? k !== null : typeof k === 'function';\n};\n\n/* Move out of 'strong' part and into 'dead' part. */\nconst mark_dead = function(t, hash) {\n    let e = t.strong.get(hash);\n    if (e) {\n        e.key.setdeadvalue();\n        e.value = void 0;\n        let next = e.n;\n        let prev = e.p;\n        e.p = void 0; /* no need to know previous item any more */\n        if(prev) prev.n = next;\n        if(next) next.p = prev;\n        if(t.f === e) t.f = next;\n        if(t.l === e) t.l = prev;\n        t.strong.delete(hash);\n        if (is_valid_weakmap_key(hash)) {\n            if (!t.dead_weak) t.dead_weak = new WeakMap();\n            t.dead_weak.set(hash, e);\n        } else {\n            /* can't be used as key in weakmap */\n            t.dead_strong.set(hash, e);\n        }\n    }\n};\n\nconst luaH_new = function(L) {\n    return new Table(L);\n};\n\nconst getgeneric = function(t, hash) {\n    let v = t.strong.get(hash);\n    return v ? v.value : lobject.luaO_nilobject;\n};\n\nconst luaH_getint = function(t, key) {\n    lua_assert(typeof key == \"number\" && (key|0) === key);\n    return getgeneric(t, key);\n};\n\nconst luaH_getstr = function(t, key) {\n    lua_assert(key instanceof TString);\n    return getgeneric(t, luaS_hashlongstr(key));\n};\n\nconst luaH_get = function(L, t, key) {\n    lua_assert(key instanceof lobject.TValue);\n    if (key.ttisnil() || (key.ttisfloat() && isNaN(key.value)))\n        return lobject.luaO_nilobject;\n    return getgeneric(t, table_hash(L, key));\n};\n\nconst setgeneric = function(t, hash, key) {\n    let v = t.strong.get(hash);\n    if (v)\n        return v.value;\n\n    let kv = key.value;\n    if ((key.ttisfloat() && (kv|0) === kv)) { /* does index fit in an integer? */\n        /* insert it as an integer */\n        key = new lobject.TValue(LUA_TNUMINT, kv);\n    } else {\n        key = new lobject.TValue(key.type, kv);\n    }\n    let tv = new lobject.TValue(LUA_TNIL, null);\n    add(t, hash, key, tv);\n    return tv;\n};\n\nconst luaH_setint = function(t, key, value) {\n    lua_assert(typeof key == \"number\" && (key|0) === key && value instanceof lobject.TValue);\n    let hash = key; /* table_hash known result */\n    if (value.ttisnil()) {\n        mark_dead(t, hash);\n        return;\n    }\n    let v = t.strong.get(hash);\n    if (v) {\n        let tv = v.value;\n        tv.setfrom(value);\n    } else {\n        let k = new lobject.TValue(LUA_TNUMINT, key);\n        let v = new lobject.TValue(value.type, value.value);\n        add(t, hash, k, v);\n    }\n};\n\nconst luaH_set = function(L, t, key) {\n    lua_assert(key instanceof lobject.TValue);\n    let hash = table_hash(L, key);\n    return setgeneric(t, hash, key);\n};\n\nconst luaH_delete = function(L, t, key) {\n    lua_assert(key instanceof lobject.TValue);\n    let hash = table_hash(L, key);\n    return mark_dead(t, hash);\n};\n\n/*\n** Try to find a boundary in table 't'. A 'boundary' is an integer index\n** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).\n*/\nconst luaH_getn = function(t) {\n    let i = 0;\n    let j = t.strong.size + 1; /* use known size of Map to bound search */\n    /* now do a binary search between them */\n    while (j - i > 1) {\n        let m = Math.floor((i+j)/2);\n        if (luaH_getint(t, m).ttisnil()) j = m;\n        else i = m;\n    }\n    return i;\n};\n\nconst luaH_next = function(L, table, keyI) {\n    let keyO = L.stack[keyI];\n\n    let entry;\n    if (keyO.type === LUA_TNIL) {\n        entry = table.f;\n        if (!entry)\n            return false;\n    } else {\n        /* First find current key */\n        let hash = table_hash(L, keyO);\n        /* Look in main part of table */\n        entry = table.strong.get(hash);\n        if (entry) {\n            entry = entry.n;\n            if (!entry)\n                return false;\n        } else {\n            /* Try dead keys */\n            entry = (table.dead_weak && table.dead_weak.get(hash)) || table.dead_strong.get(hash);\n            if (!entry)\n                /* item not in table */\n                return ldebug.luaG_runerror(L, to_luastring(\"invalid key to 'next'\"));\n            /* Iterate until either out of keys, or until finding a non-dead key */\n            do {\n                entry = entry.n;\n                if (!entry)\n                    return false;\n            } while (entry.key.ttisdeadkey());\n        }\n    }\n    lobject.setobj2s(L, keyI, entry.key);\n    lobject.setobj2s(L, keyI+1, entry.value);\n    return true;\n};\n\nmodule.exports.invalidateTMcache = invalidateTMcache;\nmodule.exports.luaH_delete  = luaH_delete;\nmodule.exports.luaH_get     = luaH_get;\nmodule.exports.luaH_getint  = luaH_getint;\nmodule.exports.luaH_getn    = luaH_getn;\nmodule.exports.luaH_getstr  = luaH_getstr;\nmodule.exports.luaH_set     = luaH_set;\nmodule.exports.luaH_setint  = luaH_setint;\nmodule.exports.luaH_new     = luaH_new;\nmodule.exports.luaH_next    = luaH_next;\nmodule.exports.Table        = Table;\n","\"use strict\";\n\nconst {\n    LUA_MINSTACK,\n    LUA_RIDX_GLOBALS,\n    LUA_RIDX_MAINTHREAD,\n    constant_types: {\n        LUA_NUMTAGS,\n        LUA_TNIL,\n        LUA_TTABLE,\n        LUA_TTHREAD\n    },\n    thread_status: {\n        LUA_OK\n    }\n} = require('./defs.js');\nconst lobject              = require('./lobject.js');\nconst ldo                  = require('./ldo.js');\nconst lapi                 = require('./lapi.js');\nconst ltable               = require('./ltable.js');\nconst ltm                  = require('./ltm.js');\n\nconst EXTRA_STACK = 5;\n\nconst BASIC_STACK_SIZE = 2 * LUA_MINSTACK;\n\nclass CallInfo {\n\n    constructor() {\n        this.func = null;\n        this.funcOff = NaN;\n        this.top = NaN;\n        this.previous = null;\n        this.next = null;\n\n        /* only for Lua functions */\n        this.l_base = NaN; /* base for this function */\n        this.l_code = null; /* reference to this.func.p.code */\n        this.l_savedpc = NaN; /* offset into l_code */\n        /* only for JS functions */\n        this.c_k = null;  /* continuation in case of yields */\n        this.c_old_errfunc = null;\n        this.c_ctx = null;  /* context info. in case of yields */\n\n        this.nresults = NaN;\n        this.callstatus = NaN;\n    }\n\n}\n\nclass lua_State {\n\n    constructor(g) {\n        this.id = g.id_counter++;\n\n        this.base_ci = new CallInfo(); /* CallInfo for first level (C calling Lua) */\n        this.top = NaN; /* first free slot in the stack */\n        this.stack_last = NaN; /* last free slot in the stack */\n        this.oldpc = NaN; /* last pc traced */\n\n        /* preinit_thread */\n        this.l_G = g;\n        this.stack = null;\n        this.ci = null;\n        this.errorJmp = null;\n        this.nCcalls = 0;\n        this.hook = null;\n        this.hookmask = 0;\n        this.basehookcount = 0;\n        this.allowhook = 1;\n        this.hookcount = this.basehookcount;\n        this.nny = 1;\n        this.status = LUA_OK;\n        this.errfunc = 0;\n    }\n\n}\n\nclass global_State {\n\n    constructor() {\n        this.id_counter = 1; /* used to give objects unique ids */\n        this.ids = new WeakMap();\n\n        this.mainthread = null;\n        this.l_registry = new lobject.TValue(LUA_TNIL, null);\n        this.panic = null;\n        this.atnativeerror = null;\n        this.version = null;\n        this.tmname = new Array(ltm.TMS.TM_N);\n        this.mt = new Array(LUA_NUMTAGS);\n    }\n\n}\n\nconst luaE_extendCI = function(L) {\n    let ci = new CallInfo();\n    L.ci.next = ci;\n    ci.previous = L.ci;\n    ci.next = null;\n    L.ci = ci;\n    return ci;\n};\n\nconst luaE_freeCI = function(L) {\n    let ci = L.ci;\n    ci.next = null;\n};\n\nconst stack_init = function(L1, L) {\n    L1.stack = new Array(BASIC_STACK_SIZE);\n    L1.top = 0;\n    L1.stack_last = BASIC_STACK_SIZE - EXTRA_STACK;\n    /* initialize first ci */\n    let ci = L1.base_ci;\n    ci.next = ci.previous = null;\n    ci.callstatus = 0;\n    ci.funcOff = L1.top;\n    ci.func = L1.stack[L1.top];\n    L1.stack[L1.top++] = new lobject.TValue(LUA_TNIL, null);\n    ci.top = L1.top + LUA_MINSTACK;\n    L1.ci = ci;\n};\n\nconst freestack = function(L) {\n    L.ci = L.base_ci;\n    luaE_freeCI(L);\n    L.stack = null;\n};\n\n/*\n** Create registry table and its predefined values\n*/\nconst init_registry = function(L, g) {\n    let registry = ltable.luaH_new(L);\n    g.l_registry.sethvalue(registry);\n    ltable.luaH_setint(registry, LUA_RIDX_MAINTHREAD, new lobject.TValue(LUA_TTHREAD, L));\n    ltable.luaH_setint(registry, LUA_RIDX_GLOBALS, new lobject.TValue(LUA_TTABLE, ltable.luaH_new(L)));\n};\n\n/*\n** open parts of the state that may cause memory-allocation errors.\n** ('g->version' !== NULL flags that the state was completely build)\n*/\nconst f_luaopen = function(L) {\n    let g = L.l_G;\n    stack_init(L, L);\n    init_registry(L, g);\n    ltm.luaT_init(L);\n    g.version = lapi.lua_version(null);\n};\n\nconst lua_newthread = function(L) {\n    let g = L.l_G;\n    let L1 = new lua_State(g);\n    L.stack[L.top] = new lobject.TValue(LUA_TTHREAD, L1);\n    lapi.api_incr_top(L);\n    L1.hookmask = L.hookmask;\n    L1.basehookcount = L.basehookcount;\n    L1.hook = L.hook;\n    L1.hookcount = L1.basehookcount;\n    stack_init(L1, L);\n    return L1;\n};\n\nconst luaE_freethread = function(L, L1) {\n    freestack(L1);\n};\n\nconst lua_newstate = function() {\n    let g = new global_State();\n    let L = new lua_State(g);\n    g.mainthread = L;\n\n    if (ldo.luaD_rawrunprotected(L, f_luaopen, null) !== LUA_OK) {\n        L = null;\n    }\n\n    return L;\n};\n\nconst close_state = function(L) {\n    freestack(L);\n};\n\nconst lua_close = function(L) {\n    L = L.l_G.mainthread;  /* only the main thread can be closed */\n    close_state(L);\n};\n\nmodule.exports.lua_State       = lua_State;\nmodule.exports.CallInfo        = CallInfo;\nmodule.exports.CIST_OAH        = (1<<0);  /* original value of 'allowhook' */\nmodule.exports.CIST_LUA        = (1<<1);  /* call is running a Lua function */\nmodule.exports.CIST_HOOKED     = (1<<2);  /* call is running a debug hook */\nmodule.exports.CIST_FRESH      = (1<<3);  /* call is running on a fresh invocation of luaV_execute */\nmodule.exports.CIST_YPCALL     = (1<<4);  /* call is a yieldable protected call */\nmodule.exports.CIST_TAIL       = (1<<5);  /* call was tail called */\nmodule.exports.CIST_HOOKYIELD  = (1<<6);  /* last hook called yielded */\nmodule.exports.CIST_LEQ        = (1<<7);  /* using __lt for __le */\nmodule.exports.CIST_FIN        = (1<<8);   /* call is running a finalizer */\nmodule.exports.EXTRA_STACK     = EXTRA_STACK;\nmodule.exports.lua_close       = lua_close;\nmodule.exports.lua_newstate    = lua_newstate;\nmodule.exports.lua_newthread   = lua_newthread;\nmodule.exports.luaE_extendCI   = luaE_extendCI;\nmodule.exports.luaE_freeCI     = luaE_freeCI;\nmodule.exports.luaE_freethread = luaE_freethread;\n","\"use strict\";\n\nconst {\n    LUA_HOOKCOUNT,\n    LUA_HOOKLINE,\n    LUA_MASKCOUNT,\n    LUA_MASKLINE,\n    constant_types: {\n        LUA_TBOOLEAN,\n        LUA_TNIL,\n        LUA_TTABLE\n    },\n    thread_status: {\n        LUA_ERRRUN,\n        LUA_YIELD\n    },\n    from_userstring,\n    luastring_eq,\n    luastring_indexOf,\n    to_luastring\n} = require('./defs.js');\nconst {\n    api_check,\n    lua_assert\n} = require('./llimits.js');\nconst { LUA_IDSIZE } = require('./luaconf.js');\nconst lapi     = require('./lapi.js');\nconst ldo      = require('./ldo.js');\nconst lfunc    = require('./lfunc.js');\nconst llex     = require('./llex.js');\nconst lobject  = require('./lobject.js');\nconst lopcodes = require('./lopcodes.js');\nconst lstate   = require('./lstate.js');\nconst ltable   = require('./ltable.js');\nconst ltm      = require('./ltm.js');\nconst lvm      = require('./lvm.js');\n\nconst currentpc = function(ci) {\n    lua_assert(ci.callstatus & lstate.CIST_LUA);\n    return ci.l_savedpc - 1;\n};\n\nconst currentline = function(ci) {\n    return ci.func.value.p.lineinfo.length !== 0 ? ci.func.value.p.lineinfo[currentpc(ci)] : -1;\n};\n\n/*\n** If function yielded, its 'func' can be in the 'extra' field. The\n** next function restores 'func' to its correct value for debugging\n** purposes. (It exchanges 'func' and 'extra'; so, when called again,\n** after debugging, it also \"re-restores\" ** 'func' to its altered value.\n*/\nconst swapextra = function(L) {\n    if (L.status === LUA_YIELD) {\n        let ci = L.ci;  /* get function that yielded */\n        let temp = ci.funcOff;  /* exchange its 'func' and 'extra' values */\n        ci.func = L.stack[ci.extra];\n        ci.funcOff = ci.extra;\n        ci.extra = temp;\n    }\n};\n\nconst lua_sethook = function(L, func, mask, count) {\n    if (func === null || mask === 0) {  /* turn off hooks? */\n        mask = 0;\n        func = null;\n    }\n    if (L.ci.callstatus & lstate.CIST_LUA)\n        L.oldpc = L.ci.l_savedpc;\n    L.hook = func;\n    L.basehookcount = count;\n    L.hookcount = L.basehookcount;\n    L.hookmask = mask;\n};\n\nconst lua_gethook = function(L) {\n    return L.hook;\n};\n\n\nconst lua_gethookmask = function(L) {\n    return L.hookmask;\n};\n\n\nconst lua_gethookcount = function(L) {\n    return L.basehookcount;\n};\n\nconst lua_getstack = function(L, level, ar) {\n    let ci;\n    let status;\n    if (level < 0) return 0;  /* invalid (negative) level */\n    for (ci = L.ci; level > 0 && ci !== L.base_ci; ci = ci.previous)\n        level--;\n    if (level === 0 && ci !== L.base_ci) {  /* level found? */\n        status = 1;\n        ar.i_ci = ci;\n    } else\n        status = 0;  /* no such level */\n    return status;\n};\n\nconst upvalname = function(p, uv) {\n    lua_assert(uv < p.upvalues.length);\n    let s = p.upvalues[uv].name;\n    if (s === null) return to_luastring(\"?\", true);\n    return s.getstr();\n};\n\nconst findvararg = function(ci, n) {\n    let nparams = ci.func.value.p.numparams;\n    if (n >= ci.l_base - ci.funcOff - nparams)\n        return null;  /* no such vararg */\n    else {\n        return {\n            pos: ci.funcOff + nparams + n,\n            name: to_luastring(\"(*vararg)\", true)  /* generic name for any vararg */\n        };\n    }\n};\n\nconst findlocal = function(L, ci, n) {\n    let base, name = null;\n\n    if (ci.callstatus & lstate.CIST_LUA) {\n        if (n < 0)  /* access to vararg values? */\n            return findvararg(ci, -n);\n        else {\n            base = ci.l_base;\n            name = lfunc.luaF_getlocalname(ci.func.value.p, n, currentpc(ci));\n        }\n    } else\n        base = ci.funcOff + 1;\n\n    if (name === null) {  /* no 'standard' name? */\n        let limit = ci === L.ci ? L.top : ci.next.funcOff;\n        if (limit - base >= n && n > 0)  /* is 'n' inside 'ci' stack? */\n            name = to_luastring(\"(*temporary)\", true);  /* generic name for any valid slot */\n        else\n            return null;  /* no name */\n    }\n    return {\n        pos: base + (n - 1),\n        name: name\n    };\n};\n\nconst lua_getlocal = function(L, ar, n) {\n    let name;\n    swapextra(L);\n    if (ar === null) {  /* information about non-active function? */\n        if (!L.stack[L.top - 1].ttisLclosure())  /* not a Lua function? */\n            name = null;\n        else  /* consider live variables at function start (parameters) */\n            name = lfunc.luaF_getlocalname(L.stack[L.top - 1].value.p, n, 0);\n    } else {  /* active function; get information through 'ar' */\n        let local = findlocal(L, ar.i_ci, n);\n        if (local) {\n            name = local.name;\n            lobject.pushobj2s(L, L.stack[local.pos]);\n            api_check(L, L.top <= L.ci.top, \"stack overflow\");\n        } else {\n            name = null;\n        }\n    }\n    swapextra(L);\n    return name;\n};\n\nconst lua_setlocal = function(L, ar, n) {\n    let name;\n    swapextra(L);\n    let local = findlocal(L, ar.i_ci, n);\n    if (local) {\n        name = local.name;\n        lobject.setobjs2s(L, local.pos, L.top - 1);\n        delete L.stack[--L.top];  /* pop value */\n    } else {\n        name = null;\n    }\n    swapextra(L);\n    return name;\n};\n\nconst funcinfo = function(ar, cl) {\n    if (cl === null || cl instanceof lobject.CClosure) {\n        ar.source = to_luastring(\"=[JS]\", true);\n        ar.linedefined = -1;\n        ar.lastlinedefined = -1;\n        ar.what = to_luastring(\"J\", true);\n    } else {\n        let p = cl.p;\n        ar.source = p.source ? p.source.getstr() : to_luastring(\"=?\", true);\n        ar.linedefined = p.linedefined;\n        ar.lastlinedefined = p.lastlinedefined;\n        ar.what = ar.linedefined === 0 ? to_luastring(\"main\", true) : to_luastring(\"Lua\", true);\n    }\n\n    ar.short_src = lobject.luaO_chunkid(ar.source, LUA_IDSIZE);\n};\n\nconst collectvalidlines = function(L, f) {\n    if (f === null || f instanceof lobject.CClosure) {\n        L.stack[L.top] = new lobject.TValue(LUA_TNIL, null);\n        lapi.api_incr_top(L);\n    } else {\n        let lineinfo = f.p.lineinfo;\n        let t = ltable.luaH_new(L);\n        L.stack[L.top] = new lobject.TValue(LUA_TTABLE, t);\n        lapi.api_incr_top(L);\n        let v = new lobject.TValue(LUA_TBOOLEAN, true);\n        for (let i = 0; i < lineinfo.length; i++)\n            ltable.luaH_setint(t, lineinfo[i], v);\n    }\n};\n\nconst getfuncname = function(L, ci) {\n    let r = {\n        name: null,\n        funcname: null\n    };\n    if (ci === null)\n        return null;\n    else if (ci.callstatus & lstate.CIST_FIN) {  /* is this a finalizer? */\n        r.name = to_luastring(\"__gc\", true);\n        r.funcname = to_luastring(\"metamethod\", true);  /* report it as such */\n        return r;\n    }\n    /* calling function is a known Lua function? */\n    else if (!(ci.callstatus & lstate.CIST_TAIL) && ci.previous.callstatus & lstate.CIST_LUA)\n        return funcnamefromcode(L, ci.previous);\n    else return null;  /* no way to find a name */\n};\n\nconst auxgetinfo = function(L, what, ar, f, ci) {\n    let status = 1;\n    for (; what.length > 0; what = what.subarray(1)) {\n        switch (what[0]) {\n            case 83 /* ('S').charCodeAt(0) */: {\n                funcinfo(ar, f);\n                break;\n            }\n            case 108 /* ('l').charCodeAt(0) */: {\n                ar.currentline = ci && ci.callstatus & lstate.CIST_LUA ? currentline(ci) : -1;\n                break;\n            }\n            case 117 /* ('u').charCodeAt(0) */: {\n                ar.nups = f === null ? 0 : f.nupvalues;\n                if (f === null || f instanceof lobject.CClosure) {\n                    ar.isvararg = true;\n                    ar.nparams = 0;\n                } else {\n                    ar.isvararg = f.p.is_vararg;\n                    ar.nparams = f.p.numparams;\n                }\n                break;\n            }\n            case 116 /* ('t').charCodeAt(0) */: {\n                ar.istailcall = ci ? ci.callstatus & lstate.CIST_TAIL : 0;\n                break;\n            }\n            case 110 /* ('n').charCodeAt(0) */: {\n                let r = getfuncname(L, ci);\n                if (r === null) {\n                    ar.namewhat = to_luastring(\"\", true);\n                    ar.name = null;\n                } else {\n                    ar.namewhat = r.funcname;\n                    ar.name = r.name;\n                }\n                break;\n            }\n            case 76 /* ('L').charCodeAt(0) */:\n            case 102 /* ('f').charCodeAt(0) */:  /* handled by lua_getinfo */\n                break;\n            default: status = 0;  /* invalid option */\n        }\n    }\n\n    return status;\n};\n\nconst lua_getinfo = function(L, what, ar) {\n    what = from_userstring(what);\n    let status, cl, ci, func;\n    swapextra(L);\n    if (what[0] === 62 /* ('>').charCodeAt(0) */) {\n        ci = null;\n        func = L.stack[L.top - 1];\n        api_check(L, func.ttisfunction(), \"function expected\");\n        what = what.subarray(1);  /* skip the '>' */\n        L.top--;  /* pop function */\n    } else {\n        ci = ar.i_ci;\n        func = ci.func;\n        lua_assert(ci.func.ttisfunction());\n    }\n\n    cl = func.ttisclosure() ? func.value : null;\n    status = auxgetinfo(L, what, ar, cl, ci);\n    if (luastring_indexOf(what, 102 /* ('f').charCodeAt(0) */) >= 0) {\n        lobject.pushobj2s(L, func);\n        api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    }\n\n    swapextra(L);\n    if (luastring_indexOf(what, 76 /* ('L').charCodeAt(0) */) >= 0)\n        collectvalidlines(L, cl);\n\n    return status;\n};\n\nconst kname = function(p, pc, c) {\n    let r = {\n        name: null,\n        funcname: null\n    };\n\n    if (lopcodes.ISK(c)) {  /* is 'c' a constant? */\n        let kvalue = p.k[lopcodes.INDEXK(c)];\n        if (kvalue.ttisstring()) {  /* literal constant? */\n            r.name = kvalue.svalue();  /* it is its own name */\n            return r;\n        }\n        /* else no reasonable name found */\n    } else {  /* 'c' is a register */\n        let what = getobjname(p, pc, c); /* search for 'c' */\n        if (what && what.funcname[0] === 99 /* ('c').charCodeAt(0) */) {  /* found a constant name? */\n            return what;  /* 'name' already filled */\n        }\n        /* else no reasonable name found */\n    }\n    r.name = to_luastring(\"?\", true);\n    return r;  /* no reasonable name found */\n};\n\nconst filterpc = function(pc, jmptarget) {\n    if (pc < jmptarget)  /* is code conditional (inside a jump)? */\n        return -1;  /* cannot know who sets that register */\n    else return pc;  /* current position sets that register */\n};\n\n/*\n** try to find last instruction before 'lastpc' that modified register 'reg'\n*/\nconst findsetreg = function(p, lastpc, reg) {\n    let setreg = -1;  /* keep last instruction that changed 'reg' */\n    let jmptarget = 0;  /* any code before this address is conditional */\n    let OCi = lopcodes.OpCodesI;\n    for (let pc = 0; pc < lastpc; pc++) {\n        let i = p.code[pc];\n        let a = i.A;\n        switch (i.opcode) {\n            case OCi.OP_LOADNIL: {\n                let b = i.B;\n                if (a <= reg && reg <= a + b)  /* set registers from 'a' to 'a+b' */\n                    setreg = filterpc(pc, jmptarget);\n                break;\n            }\n            case OCi.OP_TFORCALL: {\n                if (reg >= a + 2)  /* affect all regs above its base */\n                    setreg = filterpc(pc, jmptarget);\n                break;\n            }\n            case OCi.OP_CALL:\n            case OCi.OP_TAILCALL: {\n                if (reg >= a)  /* affect all registers above base */\n                    setreg = filterpc(pc, jmptarget);\n                break;\n            }\n            case OCi.OP_JMP: {\n                let b = i.sBx;\n                let dest = pc + 1 + b;\n                /* jump is forward and do not skip 'lastpc'? */\n                if (pc < dest && dest <= lastpc) {\n                    if (dest > jmptarget)\n                        jmptarget = dest;  /* update 'jmptarget' */\n                }\n                break;\n            }\n            default:\n                if (lopcodes.testAMode(i.opcode) && reg === a)\n                    setreg = filterpc(pc, jmptarget);\n                break;\n        }\n    }\n\n    return setreg;\n};\n\n\nconst getobjname = function(p, lastpc, reg) {\n    let r = {\n        name: lfunc.luaF_getlocalname(p, reg + 1, lastpc),\n        funcname: null\n    };\n\n    if (r.name) {  /* is a local? */\n        r.funcname = to_luastring(\"local\", true);\n        return r;\n    }\n\n    /* else try symbolic execution */\n    let pc = findsetreg(p, lastpc, reg);\n    let OCi = lopcodes.OpCodesI;\n    if (pc !== -1) {  /* could find instruction? */\n        let i = p.code[pc];\n        switch (i.opcode) {\n            case OCi.OP_MOVE: {\n                let b = i.B;  /* move from 'b' to 'a' */\n                if (b < i.A)\n                    return getobjname(p, pc, b);  /* get name for 'b' */\n                break;\n            }\n            case OCi.OP_GETTABUP:\n            case OCi.OP_GETTABLE: {\n                let k = i.C;  /* key index */\n                let t = i.B;  /* table index */\n                let vn = i.opcode === OCi.OP_GETTABLE ? lfunc.luaF_getlocalname(p, t + 1, pc) : upvalname(p, t);\n                r.name = kname(p, pc, k).name;\n                r.funcname = (vn && luastring_eq(vn, llex.LUA_ENV)) ? to_luastring(\"global\", true) : to_luastring(\"field\", true);\n                return r;\n            }\n            case OCi.OP_GETUPVAL: {\n                r.name = upvalname(p, i.B);\n                r.funcname = to_luastring(\"upvalue\", true);\n                return r;\n            }\n            case OCi.OP_LOADK:\n            case OCi.OP_LOADKX: {\n                let b = i.opcode === OCi.OP_LOADK ? i.Bx : p.code[pc + 1].Ax;\n                if (p.k[b].ttisstring()) {\n                    r.name = p.k[b].svalue();\n                    r.funcname = to_luastring(\"constant\", true);\n                    return r;\n                }\n                break;\n            }\n            case OCi.OP_SELF: {\n                let k = i.C;\n                r.name = kname(p, pc, k).name;\n                r.funcname = to_luastring(\"method\", true);\n                return r;\n            }\n            default: break;\n        }\n    }\n\n    return null;\n};\n\n/*\n** Try to find a name for a function based on the code that called it.\n** (Only works when function was called by a Lua function.)\n** Returns what the name is (e.g., \"for iterator\", \"method\",\n** \"metamethod\") and sets '*name' to point to the name.\n*/\nconst funcnamefromcode = function(L, ci) {\n    let r = {\n        name: null,\n        funcname: null\n    };\n\n    let tm = 0;  /* (initial value avoids warnings) */\n    let p = ci.func.value.p;  /* calling function */\n    let pc = currentpc(ci);  /* calling instruction index */\n    let i = p.code[pc];  /* calling instruction */\n    let OCi = lopcodes.OpCodesI;\n\n    if (ci.callstatus & lstate.CIST_HOOKED) {\n        r.name = to_luastring(\"?\", true);\n        r.funcname = to_luastring(\"hook\", true);\n        return r;\n    }\n\n    switch (i.opcode) {\n        case OCi.OP_CALL:\n        case OCi.OP_TAILCALL:\n            return getobjname(p, pc, i.A);  /* get function name */\n        case OCi.OP_TFORCALL:\n            r.name = to_luastring(\"for iterator\", true);\n            r.funcname = to_luastring(\"for iterator\", true);\n            return r;\n        /* other instructions can do calls through metamethods */\n        case OCi.OP_SELF:\n        case OCi.OP_GETTABUP:\n        case OCi.OP_GETTABLE:\n            tm = ltm.TMS.TM_INDEX;\n            break;\n        case OCi.OP_SETTABUP:\n        case OCi.OP_SETTABLE:\n            tm = ltm.TMS.TM_NEWINDEX;\n            break;\n        case OCi.OP_ADD:    tm = ltm.TMS.TM_ADD;    break;\n        case OCi.OP_SUB:    tm = ltm.TMS.TM_SUB;    break;\n        case OCi.OP_MUL:    tm = ltm.TMS.TM_MUL;    break;\n        case OCi.OP_MOD:    tm = ltm.TMS.TM_MOD;    break;\n        case OCi.OP_POW:    tm = ltm.TMS.TM_POW;    break;\n        case OCi.OP_DIV:    tm = ltm.TMS.TM_DIV;    break;\n        case OCi.OP_IDIV:   tm = ltm.TMS.TM_IDIV;   break;\n        case OCi.OP_BAND:   tm = ltm.TMS.TM_BAND;   break;\n        case OCi.OP_BOR:    tm = ltm.TMS.TM_BOR;    break;\n        case OCi.OP_BXOR:   tm = ltm.TMS.TM_BXOR;   break;\n        case OCi.OP_SHL:    tm = ltm.TMS.TM_SHL;    break;\n        case OCi.OP_SHR:    tm = ltm.TMS.TM_SHR;    break;\n        case OCi.OP_UNM:    tm = ltm.TMS.TM_UNM;    break;\n        case OCi.OP_BNOT:   tm = ltm.TMS.TM_BNOT;   break;\n        case OCi.OP_LEN:    tm = ltm.TMS.TM_LEN;    break;\n        case OCi.OP_CONCAT: tm = ltm.TMS.TM_CONCAT; break;\n        case OCi.OP_EQ:     tm = ltm.TMS.TM_EQ;     break;\n        case OCi.OP_LT:     tm = ltm.TMS.TM_LT;     break;\n        case OCi.OP_LE:     tm = ltm.TMS.TM_LE;     break;\n        default:\n            return null;  /* cannot find a reasonable name */\n    }\n\n    r.name = L.l_G.tmname[tm].getstr();\n    r.funcname = to_luastring(\"metamethod\", true);\n    return r;\n};\n\nconst isinstack = function(L, ci, o) {\n    for (let i = ci.l_base; i < ci.top; i++) {\n        if (L.stack[i] === o)\n            return i;\n    }\n\n    return false;\n};\n\n/*\n** Checks whether value 'o' came from an upvalue. (That can only happen\n** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on\n** upvalues.)\n*/\nconst getupvalname = function(L, ci, o) {\n    let c = ci.func.value;\n    for (let i = 0; i < c.nupvalues; i++) {\n        if (c.upvals[i] === o) {\n            return {\n                name: upvalname(c.p, i),\n                funcname: to_luastring('upvalue', true)\n            };\n        }\n    }\n\n    return null;\n};\n\nconst varinfo = function(L, o) {\n    let ci = L.ci;\n    let kind = null;\n    if (ci.callstatus & lstate.CIST_LUA) {\n        kind = getupvalname(L, ci, o);  /* check whether 'o' is an upvalue */\n        let stkid = isinstack(L, ci, o);\n        if (!kind && stkid)  /* no? try a register */\n            kind = getobjname(ci.func.value.p, currentpc(ci), stkid - ci.l_base);\n    }\n\n    return kind ? lobject.luaO_pushfstring(L, to_luastring(\" (%s '%s')\", true), kind.funcname, kind.name) : to_luastring(\"\", true);\n};\n\nconst luaG_typeerror = function(L, o, op) {\n    let t = ltm.luaT_objtypename(L, o);\n    luaG_runerror(L, to_luastring(\"attempt to %s a %s value%s\", true), op, t, varinfo(L, o));\n};\n\nconst luaG_concaterror = function(L, p1, p2) {\n    if (p1.ttisstring() || lvm.cvt2str(p1)) p1 = p2;\n    luaG_typeerror(L, p1, to_luastring('concatenate', true));\n};\n\n/*\n** Error when both values are convertible to numbers, but not to integers\n*/\nconst luaG_opinterror = function(L, p1, p2, msg) {\n    if (lvm.tonumber(p1) === false)\n        p2 = p1;\n    luaG_typeerror(L, p2, msg);\n};\n\nconst luaG_ordererror = function(L, p1, p2) {\n    let t1 = ltm.luaT_objtypename(L, p1);\n    let t2 = ltm.luaT_objtypename(L, p2);\n    if (luastring_eq(t1, t2))\n        luaG_runerror(L, to_luastring(\"attempt to compare two %s values\", true), t1);\n    else\n        luaG_runerror(L, to_luastring(\"attempt to compare %s with %s\", true), t1, t2);\n};\n\n/* add src:line information to 'msg' */\nconst luaG_addinfo = function(L, msg, src, line) {\n    let buff;\n    if (src)\n        buff = lobject.luaO_chunkid(src.getstr(), LUA_IDSIZE);\n    else\n        buff = to_luastring(\"?\", true);\n\n    return lobject.luaO_pushfstring(L, to_luastring(\"%s:%d: %s\", true), buff, line, msg);\n};\n\nconst luaG_runerror = function(L, fmt, ...argp) {\n    let ci = L.ci;\n    let msg = lobject.luaO_pushvfstring(L, fmt, argp);\n    if (ci.callstatus & lstate.CIST_LUA)  /* if Lua function, add source:line information */\n        luaG_addinfo(L, msg, ci.func.value.p.source, currentline(ci));\n    luaG_errormsg(L);\n};\n\nconst luaG_errormsg = function(L) {\n    if (L.errfunc !== 0) {  /* is there an error handling function? */\n        let errfunc = L.errfunc;\n        lobject.pushobj2s(L, L.stack[L.top - 1]); /* move argument */\n        lobject.setobjs2s(L, L.top - 2, errfunc); /* push function */\n        ldo.luaD_callnoyield(L, L.top - 2, 1);\n    }\n\n    ldo.luaD_throw(L, LUA_ERRRUN);\n};\n\n/*\n** Error when both values are convertible to numbers, but not to integers\n*/\nconst luaG_tointerror = function(L, p1, p2) {\n    let temp = lvm.tointeger(p1);\n    if (temp === false)\n        p2 = p1;\n    luaG_runerror(L, to_luastring(\"number%s has no integer representation\", true), varinfo(L, p2));\n};\n\nconst luaG_traceexec = function(L) {\n    let ci = L.ci;\n    let mask = L.hookmask;\n    let counthook = (--L.hookcount === 0 && (mask & LUA_MASKCOUNT));\n    if (counthook)\n        L.hookcount = L.basehookcount;  /* reset count */\n    else if (!(mask & LUA_MASKLINE))\n        return;  /* no line hook and count != 0; nothing to be done */\n    if (ci.callstatus & lstate.CIST_HOOKYIELD) {  /* called hook last time? */\n        ci.callstatus &= ~lstate.CIST_HOOKYIELD;  /* erase mark */\n        return;  /* do not call hook again (VM yielded, so it did not move) */\n    }\n    if (counthook)\n        ldo.luaD_hook(L, LUA_HOOKCOUNT, -1);  /* call count hook */\n    if (mask & LUA_MASKLINE) {\n        let p = ci.func.value.p;\n        let npc = ci.l_savedpc - 1; // pcRel(ci.u.l.savedpc, p);\n        let newline = p.lineinfo.length !== 0 ? p.lineinfo[npc] : -1;\n        if (npc === 0 ||  /* call linehook when enter a new function, */\n            ci.l_savedpc <= L.oldpc ||  /* when jump back (loop), or when */\n            newline !== (p.lineinfo.length !== 0 ? p.lineinfo[L.oldpc - 1] : -1))  /* enter a new line */\n            ldo.luaD_hook(L, LUA_HOOKLINE, newline);  /* call line hook */\n    }\n    L.oldpc = ci.l_savedpc;\n    if (L.status === LUA_YIELD) {  /* did hook yield? */\n        if (counthook)\n            L.hookcount = 1;  /* undo decrement to zero */\n        ci.l_savedpc--;  /* undo increment (resume will increment it again) */\n        ci.callstatus |= lstate.CIST_HOOKYIELD;  /* mark that it yielded */\n        ci.funcOff = L.top - 1;  /* protect stack below results */\n        ci.func = L.stack[ci.funcOff];\n        ldo.luaD_throw(L, LUA_YIELD);\n    }\n};\n\nmodule.exports.luaG_addinfo     = luaG_addinfo;\nmodule.exports.luaG_concaterror = luaG_concaterror;\nmodule.exports.luaG_errormsg    = luaG_errormsg;\nmodule.exports.luaG_opinterror  = luaG_opinterror;\nmodule.exports.luaG_ordererror  = luaG_ordererror;\nmodule.exports.luaG_runerror    = luaG_runerror;\nmodule.exports.luaG_tointerror  = luaG_tointerror;\nmodule.exports.luaG_traceexec   = luaG_traceexec;\nmodule.exports.luaG_typeerror   = luaG_typeerror;\nmodule.exports.lua_gethook      = lua_gethook;\nmodule.exports.lua_gethookcount = lua_gethookcount;\nmodule.exports.lua_gethookmask  = lua_gethookmask;\nmodule.exports.lua_getinfo      = lua_getinfo;\nmodule.exports.lua_getlocal     = lua_getlocal;\nmodule.exports.lua_getstack     = lua_getstack;\nmodule.exports.lua_sethook      = lua_sethook;\nmodule.exports.lua_setlocal     = lua_setlocal;\n","\"use strict\";\n\nconst {\n    LUA_VERSION_MAJOR,\n    LUA_VERSION_MINOR\n} = require(\"./lua.js\");\n\nconst LUA_VERSUFFIX = \"_\" + LUA_VERSION_MAJOR + \"_\" + LUA_VERSION_MINOR;\nmodule.exports.LUA_VERSUFFIX = LUA_VERSUFFIX;\n\nmodule.exports.lua_assert = function(c) {};\n\nconst LUA_COLIBNAME = \"coroutine\";\nmodule.exports.LUA_COLIBNAME = LUA_COLIBNAME;\nmodule.exports.luaopen_coroutine = require(\"./lcorolib.js\").luaopen_coroutine;\n\nconst LUA_TABLIBNAME = \"table\";\nmodule.exports.LUA_TABLIBNAME = LUA_TABLIBNAME;\nmodule.exports.luaopen_table = require(\"./ltablib.js\").luaopen_table;\n\nif (typeof process !== \"undefined\") {\n    const LUA_IOLIBNAME = \"io\";\n    module.exports.LUA_IOLIBNAME = LUA_IOLIBNAME;\n    module.exports.luaopen_io = require(\"./liolib.js\").luaopen_io;\n}\n\nconst LUA_OSLIBNAME = \"os\";\nmodule.exports.LUA_OSLIBNAME = LUA_OSLIBNAME;\nmodule.exports.luaopen_os = require(\"./loslib.js\").luaopen_os;\n\nconst LUA_STRLIBNAME = \"string\";\nmodule.exports.LUA_STRLIBNAME = LUA_STRLIBNAME;\nmodule.exports.luaopen_string = require(\"./lstrlib.js\").luaopen_string;\n\nconst LUA_UTF8LIBNAME = \"utf8\";\nmodule.exports.LUA_UTF8LIBNAME = LUA_UTF8LIBNAME;\nmodule.exports.luaopen_utf8 = require(\"./lutf8lib.js\").luaopen_utf8;\n\nconst LUA_BITLIBNAME = \"bit32\";\nmodule.exports.LUA_BITLIBNAME = LUA_BITLIBNAME;\n// module.exports.luaopen_bit32 = require(\"./lbitlib.js\").luaopen_bit32;\n\nconst LUA_MATHLIBNAME = \"math\";\nmodule.exports.LUA_MATHLIBNAME = LUA_MATHLIBNAME;\nmodule.exports.luaopen_math = require(\"./lmathlib.js\").luaopen_math;\n\nconst LUA_DBLIBNAME = \"debug\";\nmodule.exports.LUA_DBLIBNAME = LUA_DBLIBNAME;\nmodule.exports.luaopen_debug = require(\"./ldblib.js\").luaopen_debug;\n\nconst LUA_LOADLIBNAME = \"package\";\nmodule.exports.LUA_LOADLIBNAME = LUA_LOADLIBNAME;\nmodule.exports.luaopen_package = require(\"./loadlib.js\").luaopen_package;\n\nconst LUA_FENGARILIBNAME = \"fengari\";\nmodule.exports.LUA_FENGARILIBNAME = LUA_FENGARILIBNAME;\nmodule.exports.luaopen_fengari = require(\"./fengarilib.js\").luaopen_fengari;\n\nconst linit = require('./linit.js');\nmodule.exports.luaL_openlibs = linit.luaL_openlibs;\n","\"use strict\";\n\nconst OpCodes = [\n    \"MOVE\",\n    \"LOADK\",\n    \"LOADKX\",\n    \"LOADBOOL\",\n    \"LOADNIL\",\n    \"GETUPVAL\",\n    \"GETTABUP\",\n    \"GETTABLE\",\n    \"SETTABUP\",\n    \"SETUPVAL\",\n    \"SETTABLE\",\n    \"NEWTABLE\",\n    \"SELF\",\n    \"ADD\",\n    \"SUB\",\n    \"MUL\",\n    \"MOD\",\n    \"POW\",\n    \"DIV\",\n    \"IDIV\",\n    \"BAND\",\n    \"BOR\",\n    \"BXOR\",\n    \"SHL\",\n    \"SHR\",\n    \"UNM\",\n    \"BNOT\",\n    \"NOT\",\n    \"LEN\",\n    \"CONCAT\",\n    \"JMP\",\n    \"EQ\",\n    \"LT\",\n    \"LE\",\n    \"TEST\",\n    \"TESTSET\",\n    \"CALL\",\n    \"TAILCALL\",\n    \"RETURN\",\n    \"FORLOOP\",\n    \"FORPREP\",\n    \"TFORCALL\",\n    \"TFORLOOP\",\n    \"SETLIST\",\n    \"CLOSURE\",\n    \"VARARG\",\n    \"EXTRAARG\"\n];\n\nconst OpCodesI = {\n    OP_MOVE:     0,\n    OP_LOADK:    1,\n    OP_LOADKX:   2,\n    OP_LOADBOOL: 3,\n    OP_LOADNIL:  4,\n    OP_GETUPVAL: 5,\n    OP_GETTABUP: 6,\n    OP_GETTABLE: 7,\n    OP_SETTABUP: 8,\n    OP_SETUPVAL: 9,\n    OP_SETTABLE: 10,\n    OP_NEWTABLE: 11,\n    OP_SELF:     12,\n    OP_ADD:      13,\n    OP_SUB:      14,\n    OP_MUL:      15,\n    OP_MOD:      16,\n    OP_POW:      17,\n    OP_DIV:      18,\n    OP_IDIV:     19,\n    OP_BAND:     20,\n    OP_BOR:      21,\n    OP_BXOR:     22,\n    OP_SHL:      23,\n    OP_SHR:      24,\n    OP_UNM:      25,\n    OP_BNOT:     26,\n    OP_NOT:      27,\n    OP_LEN:      28,\n    OP_CONCAT:   29,\n    OP_JMP:      30,\n    OP_EQ:       31,\n    OP_LT:       32,\n    OP_LE:       33,\n    OP_TEST:     34,\n    OP_TESTSET:  35,\n    OP_CALL:     36,\n    OP_TAILCALL: 37,\n    OP_RETURN:   38,\n    OP_FORLOOP:  39,\n    OP_FORPREP:  40,\n    OP_TFORCALL: 41,\n    OP_TFORLOOP: 42,\n    OP_SETLIST:  43,\n    OP_CLOSURE:  44,\n    OP_VARARG:   45,\n    OP_EXTRAARG: 46\n};\n\n/*\n** masks for instruction properties. The format is:\n** bits 0-1: op mode\n** bits 2-3: C arg mode\n** bits 4-5: B arg mode\n** bit 6: instruction set register A\n** bit 7: operator is a test (next instruction must be a jump)\n*/\nconst OpArgN = 0;  /* argument is not used */\nconst OpArgU = 1;  /* argument is used */\nconst OpArgR = 2;  /* argument is a register or a jump offset */\nconst OpArgK = 3;  /* argument is a constant or register/constant */\n\n/* basic instruction format */\nconst iABC  = 0;\nconst iABx  = 1;\nconst iAsBx = 2;\nconst iAx   = 3;\n\nconst luaP_opmodes = [\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iABC,   /* OP_MOVE */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgN << 2 | iABx,   /* OP_LOADK */\n    0 << 7 | 1 << 6 | OpArgN << 4 | OpArgN << 2 | iABx,   /* OP_LOADKX */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgU << 2 | iABC,   /* OP_LOADBOOL */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgN << 2 | iABC,   /* OP_LOADNIL */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgN << 2 | iABC,   /* OP_GETUPVAL */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgK << 2 | iABC,   /* OP_GETTABUP */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgK << 2 | iABC,   /* OP_GETTABLE */\n    0 << 7 | 0 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_SETTABUP */\n    0 << 7 | 0 << 6 | OpArgU << 4 | OpArgN << 2 | iABC,   /* OP_SETUPVAL */\n    0 << 7 | 0 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_SETTABLE */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgU << 2 | iABC,   /* OP_NEWTABLE */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgK << 2 | iABC,   /* OP_SELF */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_ADD */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_SUB */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_MUL */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_MOD */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_POW */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_DIV */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_IDIV */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_BAND */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_BOR */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_BXOR */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_SHL */\n    0 << 7 | 1 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_SHR */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iABC,   /* OP_UNM */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iABC,   /* OP_BNOT */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iABC,   /* OP_NOT */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iABC,   /* OP_LEN */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgR << 2 | iABC,   /* OP_CONCAT */\n    0 << 7 | 0 << 6 | OpArgR << 4 | OpArgN << 2 | iAsBx,  /* OP_JMP */\n    1 << 7 | 0 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_EQ */\n    1 << 7 | 0 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_LT */\n    1 << 7 | 0 << 6 | OpArgK << 4 | OpArgK << 2 | iABC,   /* OP_LE */\n    1 << 7 | 0 << 6 | OpArgN << 4 | OpArgU << 2 | iABC,   /* OP_TEST */\n    1 << 7 | 1 << 6 | OpArgR << 4 | OpArgU << 2 | iABC,   /* OP_TESTSET */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgU << 2 | iABC,   /* OP_CALL */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgU << 2 | iABC,   /* OP_TAILCALL */\n    0 << 7 | 0 << 6 | OpArgU << 4 | OpArgN << 2 | iABC,   /* OP_RETURN */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iAsBx,  /* OP_FORLOOP */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iAsBx,  /* OP_FORPREP */\n    0 << 7 | 0 << 6 | OpArgN << 4 | OpArgU << 2 | iABC,   /* OP_TFORCALL */\n    0 << 7 | 1 << 6 | OpArgR << 4 | OpArgN << 2 | iAsBx,  /* OP_TFORLOOP */\n    0 << 7 | 0 << 6 | OpArgU << 4 | OpArgU << 2 | iABC,   /* OP_SETLIST */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgN << 2 | iABx,   /* OP_CLOSURE */\n    0 << 7 | 1 << 6 | OpArgU << 4 | OpArgN << 2 | iABC,   /* OP_VARARG */\n    0 << 7 | 0 << 6 | OpArgU << 4 | OpArgU << 2 | iAx     /* OP_EXTRAARG */\n];\n\nconst getOpMode = function(m) {\n    return luaP_opmodes[m] & 3;\n};\n\nconst getBMode = function(m) {\n    return (luaP_opmodes[m] >> 4) & 3;\n};\n\nconst getCMode = function(m) {\n    return (luaP_opmodes[m] >> 2) & 3;\n};\n\nconst testAMode = function(m) {\n    return luaP_opmodes[m] & (1 << 6);\n};\n\nconst testTMode = function(m) {\n    return luaP_opmodes[m] & (1 << 7);\n};\n\nconst SIZE_C     = 9;\nconst SIZE_B     = 9;\nconst SIZE_Bx    = (SIZE_C + SIZE_B);\nconst SIZE_A     = 8;\nconst SIZE_Ax    = (SIZE_C + SIZE_B + SIZE_A);\nconst SIZE_OP    = 6;\nconst POS_OP     = 0;\nconst POS_A      = (POS_OP + SIZE_OP);\nconst POS_C      = (POS_A + SIZE_A);\nconst POS_B      = (POS_C + SIZE_C);\nconst POS_Bx     = POS_C;\nconst POS_Ax     = POS_A;\nconst MAXARG_Bx  = ((1 << SIZE_Bx) - 1);\nconst MAXARG_sBx = (MAXARG_Bx >> 1); /* 'sBx' is signed */\nconst MAXARG_Ax  = ((1<<SIZE_Ax)-1);\nconst MAXARG_A   = ((1 << SIZE_A) - 1);\nconst MAXARG_B   = ((1 << SIZE_B) - 1);\nconst MAXARG_C   = ((1 << SIZE_C) - 1);\n\n/* this bit 1 means constant (0 means register) */\nconst BITRK      = (1 << (SIZE_B - 1));\n\nconst MAXINDEXRK = (BITRK - 1);\n\n/*\n** invalid register that fits in 8 bits\n*/\nconst NO_REG     = MAXARG_A;\n\n/* test whether value is a constant */\nconst ISK = function (x) {\n    return x & BITRK;\n};\n\n/* gets the index of the constant */\nconst INDEXK = function (r) {\n    return r & ~BITRK;\n};\n\n/* code a constant index as a RK value */\nconst RKASK = function(x) {\n    return x | BITRK;\n};\n\n\n/* creates a mask with 'n' 1 bits at position 'p' */\nconst MASK1 = function(n, p) {\n    return ((~((~0)<<(n)))<<(p));\n};\n\n/* creates a mask with 'n' 0 bits at position 'p' */\nconst MASK0 = function(n, p) {\n    return (~MASK1(n, p));\n};\n\nconst GET_OPCODE = function(i) {\n    return i.opcode;\n};\n\nconst SET_OPCODE = function(i, o) {\n    i.code = (i.code & MASK0(SIZE_OP, POS_OP)) | ((o << POS_OP) & MASK1(SIZE_OP, POS_OP));\n    return fullins(i);\n};\n\nconst setarg = function(i, v, pos, size) {\n    i.code = (i.code & MASK0(size, pos)) | ((v << pos) & MASK1(size, pos));\n    return fullins(i);\n};\n\nconst GETARG_A = function(i) {\n    return i.A;\n};\n\nconst SETARG_A = function(i,v) {\n    return setarg(i, v, POS_A, SIZE_A);\n};\n\nconst GETARG_B = function(i) {\n    return i.B;\n};\n\nconst SETARG_B = function(i,v) {\n    return setarg(i, v, POS_B, SIZE_B);\n};\n\nconst GETARG_C = function(i) {\n    return i.C;\n};\n\nconst SETARG_C = function(i,v) {\n    return setarg(i, v, POS_C, SIZE_C);\n};\n\nconst GETARG_Bx = function(i) {\n    return i.Bx;\n};\n\nconst SETARG_Bx = function(i,v) {\n    return setarg(i, v, POS_Bx, SIZE_Bx);\n};\n\nconst GETARG_Ax = function(i) {\n    return i.Ax;\n};\n\nconst SETARG_Ax = function(i,v) {\n    return setarg(i, v, POS_Ax, SIZE_Ax);\n};\n\nconst GETARG_sBx = function(i) {\n    return i.sBx;\n};\n\nconst SETARG_sBx = function(i, b) {\n    return SETARG_Bx(i, b + MAXARG_sBx);\n};\n\n/*\n** Pre-calculate all possible part of the instruction\n*/\nconst fullins = function(ins) {\n    if (typeof ins === \"number\") {\n        return {\n            code:   ins,\n            opcode: (ins >> POS_OP) & MASK1(SIZE_OP, 0),\n            A:      (ins >> POS_A)  & MASK1(SIZE_A,  0),\n            B:      (ins >> POS_B)  & MASK1(SIZE_B,  0),\n            C:      (ins >> POS_C)  & MASK1(SIZE_C,  0),\n            Bx:     (ins >> POS_Bx) & MASK1(SIZE_Bx, 0),\n            Ax:     (ins >> POS_Ax) & MASK1(SIZE_Ax, 0),\n            sBx:    ((ins >> POS_Bx) & MASK1(SIZE_Bx, 0)) - MAXARG_sBx\n        };\n    } else {\n        let i = ins.code;\n        ins.opcode = (i >> POS_OP) & MASK1(SIZE_OP, 0);\n        ins.A      = (i >> POS_A)  & MASK1(SIZE_A,  0);\n        ins.B      = (i >> POS_B)  & MASK1(SIZE_B,  0);\n        ins.C      = (i >> POS_C)  & MASK1(SIZE_C,  0);\n        ins.Bx     = (i >> POS_Bx) & MASK1(SIZE_Bx, 0);\n        ins.Ax     = (i >> POS_Ax) & MASK1(SIZE_Ax, 0);\n        ins.sBx    = ((i >> POS_Bx) & MASK1(SIZE_Bx, 0)) - MAXARG_sBx;\n        return ins;\n    }\n};\n\nconst CREATE_ABC = function(o, a, b, c) {\n    return fullins(o << POS_OP | a << POS_A | b << POS_B | c << POS_C);\n};\n\nconst CREATE_ABx = function(o, a, bc) {\n    return fullins(o << POS_OP | a << POS_A | bc << POS_Bx);\n};\n\nconst CREATE_Ax = function(o, a) {\n    return fullins(o << POS_OP | a << POS_Ax);\n};\n\n/* number of list items to accumulate before a SETLIST instruction */\nconst LFIELDS_PER_FLUSH = 50;\n\nmodule.exports.BITRK               = BITRK;\nmodule.exports.CREATE_ABC          = CREATE_ABC;\nmodule.exports.CREATE_ABx          = CREATE_ABx;\nmodule.exports.CREATE_Ax           = CREATE_Ax;\nmodule.exports.GET_OPCODE          = GET_OPCODE;\nmodule.exports.GETARG_A            = GETARG_A;\nmodule.exports.GETARG_B            = GETARG_B;\nmodule.exports.GETARG_C            = GETARG_C;\nmodule.exports.GETARG_Bx           = GETARG_Bx;\nmodule.exports.GETARG_Ax           = GETARG_Ax;\nmodule.exports.GETARG_sBx          = GETARG_sBx;\nmodule.exports.INDEXK              = INDEXK;\nmodule.exports.ISK                 = ISK;\nmodule.exports.LFIELDS_PER_FLUSH   = LFIELDS_PER_FLUSH;\nmodule.exports.MAXARG_A            = MAXARG_A;\nmodule.exports.MAXARG_Ax           = MAXARG_Ax;\nmodule.exports.MAXARG_B            = MAXARG_B;\nmodule.exports.MAXARG_Bx           = MAXARG_Bx;\nmodule.exports.MAXARG_C            = MAXARG_C;\nmodule.exports.MAXARG_sBx          = MAXARG_sBx;\nmodule.exports.MAXINDEXRK          = MAXINDEXRK;\nmodule.exports.NO_REG              = NO_REG;\nmodule.exports.OpArgK              = OpArgK;\nmodule.exports.OpArgN              = OpArgN;\nmodule.exports.OpArgR              = OpArgR;\nmodule.exports.OpArgU              = OpArgU;\nmodule.exports.OpCodes             = OpCodes;\nmodule.exports.OpCodesI            = OpCodesI;\nmodule.exports.POS_A               = POS_A;\nmodule.exports.POS_Ax              = POS_Ax;\nmodule.exports.POS_B               = POS_B;\nmodule.exports.POS_Bx              = POS_Bx;\nmodule.exports.POS_C               = POS_C;\nmodule.exports.POS_OP              = POS_OP;\nmodule.exports.RKASK               = RKASK;\nmodule.exports.SETARG_A            = SETARG_A;\nmodule.exports.SETARG_Ax           = SETARG_Ax;\nmodule.exports.SETARG_B            = SETARG_B;\nmodule.exports.SETARG_Bx           = SETARG_Bx;\nmodule.exports.SETARG_C            = SETARG_C;\nmodule.exports.SETARG_sBx          = SETARG_sBx;\nmodule.exports.SET_OPCODE          = SET_OPCODE;\nmodule.exports.SIZE_A              = SIZE_A;\nmodule.exports.SIZE_Ax             = SIZE_Ax;\nmodule.exports.SIZE_B              = SIZE_B;\nmodule.exports.SIZE_Bx             = SIZE_Bx;\nmodule.exports.SIZE_C              = SIZE_C;\nmodule.exports.SIZE_OP             = SIZE_OP;\nmodule.exports.fullins             = fullins;\nmodule.exports.getBMode            = getBMode;\nmodule.exports.getCMode            = getCMode;\nmodule.exports.getOpMode           = getOpMode;\nmodule.exports.iABC                = iABC;\nmodule.exports.iABx                = iABx;\nmodule.exports.iAsBx               = iAsBx;\nmodule.exports.iAx                 = iAx;\nmodule.exports.testAMode           = testAMode;\nmodule.exports.testTMode           = testTMode;\n","\"use strict\";\n\nconst {\n    LUA_MASKLINE,\n    LUA_MASKCOUNT,\n    LUA_MULTRET,\n    constant_types: {\n        LUA_TBOOLEAN,\n        LUA_TLCF,\n        LUA_TLIGHTUSERDATA,\n        LUA_TLNGSTR,\n        LUA_TNIL,\n        LUA_TNUMBER,\n        LUA_TNUMFLT,\n        LUA_TNUMINT,\n        LUA_TSHRSTR,\n        LUA_TTABLE,\n        LUA_TUSERDATA\n    },\n    to_luastring\n} = require('./defs.js');\nconst {\n    INDEXK,\n    ISK,\n    LFIELDS_PER_FLUSH,\n    OpCodesI: {\n        OP_ADD,\n        OP_BAND,\n        OP_BNOT,\n        OP_BOR,\n        OP_BXOR,\n        OP_CALL,\n        OP_CLOSURE,\n        OP_CONCAT,\n        OP_DIV,\n        OP_EQ,\n        OP_EXTRAARG,\n        OP_FORLOOP,\n        OP_FORPREP,\n        OP_GETTABLE,\n        OP_GETTABUP,\n        OP_GETUPVAL,\n        OP_IDIV,\n        OP_JMP,\n        OP_LE,\n        OP_LEN,\n        OP_LOADBOOL,\n        OP_LOADK,\n        OP_LOADKX,\n        OP_LOADNIL,\n        OP_LT,\n        OP_MOD,\n        OP_MOVE,\n        OP_MUL,\n        OP_NEWTABLE,\n        OP_NOT,\n        OP_POW,\n        OP_RETURN,\n        OP_SELF,\n        OP_SETLIST,\n        OP_SETTABLE,\n        OP_SETTABUP,\n        OP_SETUPVAL,\n        OP_SHL,\n        OP_SHR,\n        OP_SUB,\n        OP_TAILCALL,\n        OP_TEST,\n        OP_TESTSET,\n        OP_TFORCALL,\n        OP_TFORLOOP,\n        OP_UNM,\n        OP_VARARG\n    }\n} = require('./lopcodes.js');\nconst {\n    LUA_MAXINTEGER,\n    LUA_MININTEGER,\n    lua_numbertointeger\n} = require('./luaconf.js');\nconst {\n    lua_assert,\n    luai_nummod\n} = require('./llimits.js');\nconst lobject = require('./lobject.js');\nconst lfunc   = require('./lfunc.js');\nconst lstate  = require('./lstate.js');\nconst {\n    luaS_bless,\n    luaS_eqlngstr,\n    luaS_hashlongstr\n} = require('./lstring.js');\nconst ldo     = require('./ldo.js');\nconst ltm     = require('./ltm.js');\nconst ltable  = require('./ltable.js');\nconst ldebug  = require('./ldebug.js');\n\n/*\n** finish execution of an opcode interrupted by an yield\n*/\nconst luaV_finishOp = function(L) {\n    let ci = L.ci;\n    let base = ci.l_base;\n    let inst = ci.l_code[ci.l_savedpc - 1];  /* interrupted instruction */\n    let op = inst.opcode;\n\n    switch (op) {  /* finish its execution */\n        case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_IDIV:\n        case OP_BAND: case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR:\n        case OP_MOD: case OP_POW:\n        case OP_UNM: case OP_BNOT: case OP_LEN:\n        case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: {\n            lobject.setobjs2s(L, base + inst.A, L.top-1);\n            delete L.stack[--L.top];\n            break;\n        }\n        case OP_LE: case OP_LT: case OP_EQ: {\n            let res = !L.stack[L.top - 1].l_isfalse();\n            delete L.stack[--L.top];\n            if (ci.callstatus & lstate.CIST_LEQ) {  /* \"<=\" using \"<\" instead? */\n                lua_assert(op === OP_LE);\n                ci.callstatus ^= lstate.CIST_LEQ;  /* clear mark */\n                res = !res;  /* negate result */\n            }\n            lua_assert(ci.l_code[ci.l_savedpc].opcode === OP_JMP);\n            if (res !== (inst.A ? true : false))  /* condition failed? */\n                ci.l_savedpc++;  /* skip jump instruction */\n            break;\n        }\n        case OP_CONCAT: {\n            let top = L.top - 1;  /* top when 'luaT_trybinTM' was called */\n            let b = inst.B;  /* first element to concatenate */\n            let total = top - 1 - (base + b);  /* yet to concatenate */\n            lobject.setobjs2s(L, top - 2, top);  /* put TM result in proper position */\n            if (total > 1) {  /* are there elements to concat? */\n                L.top = top - 1;  /* top is one after last element (at top-2) */\n                luaV_concat(L, total);  /* concat them (may yield again) */\n            }\n            /* move final result to final position */\n            lobject.setobjs2s(L, ci.l_base + inst.A, L.top - 1);\n            ldo.adjust_top(L, ci.top);  /* restore top */\n            break;\n        }\n        case OP_TFORCALL: {\n            lua_assert(ci.l_code[ci.l_savedpc].opcode === OP_TFORLOOP);\n            ldo.adjust_top(L, ci.top);  /* correct top */\n            break;\n        }\n        case OP_CALL: {\n            if (inst.C - 1 >= 0)  /* nresults >= 0? */\n                ldo.adjust_top(L, ci.top);  /* adjust results */\n            break;\n        }\n    }\n};\n\nconst RA = function(L, base, i) {\n    return base + i.A;\n};\n\nconst RB = function(L, base, i) {\n    return base + i.B;\n};\n\n// const RC = function(L, base, i) {\n//     return base + i.C;\n// };\n\nconst RKB = function(L, base, k, i) {\n    return ISK(i.B) ? k[INDEXK(i.B)] : L.stack[base + i.B];\n};\n\nconst RKC = function(L, base, k, i) {\n    return ISK(i.C) ? k[INDEXK(i.C)] : L.stack[base + i.C];\n};\n\nconst luaV_execute = function(L) {\n    let ci = L.ci;\n\n    ci.callstatus |= lstate.CIST_FRESH;\n    newframe:\n    for (;;) {\n        lua_assert(ci === L.ci);\n        let cl = ci.func.value;\n        let k = cl.p.k;\n        let base = ci.l_base;\n\n        let i = ci.l_code[ci.l_savedpc++];\n\n        if (L.hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) {\n            ldebug.luaG_traceexec(L);\n        }\n\n        let ra = RA(L, base, i);\n        let opcode = i.opcode;\n\n        switch (opcode) {\n            case OP_MOVE: {\n                lobject.setobjs2s(L, ra, RB(L, base, i));\n                break;\n            }\n            case OP_LOADK: {\n                let konst = k[i.Bx];\n                lobject.setobj2s(L, ra, konst);\n                break;\n            }\n            case OP_LOADKX: {\n                lua_assert(ci.l_code[ci.l_savedpc].opcode === OP_EXTRAARG);\n                let konst = k[ci.l_code[ci.l_savedpc++].Ax];\n                lobject.setobj2s(L, ra, konst);\n                break;\n            }\n            case OP_LOADBOOL: {\n                L.stack[ra].setbvalue(i.B !== 0);\n\n                if (i.C !== 0)\n                    ci.l_savedpc++; /* skip next instruction (if C) */\n\n                break;\n            }\n            case OP_LOADNIL: {\n                for (let j = 0; j <= i.B; j++)\n                    L.stack[ra + j].setnilvalue();\n                break;\n            }\n            case OP_GETUPVAL: {\n                let b = i.B;\n                lobject.setobj2s(L, ra, cl.upvals[b]);\n                break;\n            }\n            case OP_GETTABUP: {\n                let upval = cl.upvals[i.B];\n                let rc = RKC(L, base, k, i);\n                luaV_gettable(L, upval, rc, ra);\n                break;\n            }\n            case OP_GETTABLE: {\n                let rb = L.stack[RB(L, base, i)];\n                let rc = RKC(L, base, k, i);\n                luaV_gettable(L, rb, rc, ra);\n                break;\n            }\n            case OP_SETTABUP: {\n                let upval = cl.upvals[i.A];\n                let rb = RKB(L, base, k, i);\n                let rc = RKC(L, base, k, i);\n                settable(L, upval, rb, rc);\n                break;\n            }\n            case OP_SETUPVAL: {\n                let uv = cl.upvals[i.B];\n                uv.setfrom(L.stack[ra]);\n                break;\n            }\n            case OP_SETTABLE: {\n                let table = L.stack[ra];\n                let key = RKB(L, base, k, i);\n                let v = RKC(L, base, k, i);\n\n                settable(L, table, key, v);\n                break;\n            }\n            case OP_NEWTABLE: {\n                L.stack[ra].sethvalue(ltable.luaH_new(L));\n                break;\n            }\n            case OP_SELF: {\n                let rb = RB(L, base, i);\n                let rc = RKC(L, base, k, i);\n                lobject.setobjs2s(L, ra + 1, rb);\n                luaV_gettable(L, L.stack[rb], rc, ra);\n                break;\n            }\n            case OP_ADD: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if (op1.ttisinteger() && op2.ttisinteger()) {\n                    L.stack[ra].setivalue((op1.value + op2.value)|0);\n                } else if ((numberop1 = tonumber(op1)) !== false && (numberop2 = tonumber(op2)) !== false) {\n                    L.stack[ra].setfltvalue(numberop1 + numberop2);\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_ADD);\n                }\n                break;\n            }\n            case OP_SUB: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if (op1.ttisinteger() && op2.ttisinteger()) {\n                    L.stack[ra].setivalue((op1.value - op2.value)|0);\n                } else if ((numberop1 = tonumber(op1)) !== false && (numberop2 = tonumber(op2)) !== false) {\n                    L.stack[ra].setfltvalue(numberop1 - numberop2);\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_SUB);\n                }\n                break;\n            }\n            case OP_MUL: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if (op1.ttisinteger() && op2.ttisinteger()) {\n                    L.stack[ra].setivalue(luaV_imul(op1.value, op2.value));\n                } else if ((numberop1 = tonumber(op1)) !== false && (numberop2 = tonumber(op2)) !== false) {\n                    L.stack[ra].setfltvalue(numberop1 * numberop2);\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_MUL);\n                }\n                break;\n            }\n            case OP_MOD: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if (op1.ttisinteger() && op2.ttisinteger()) {\n                    L.stack[ra].setivalue(luaV_mod(L, op1.value, op2.value));\n                } else if ((numberop1 = tonumber(op1)) !== false && (numberop2 = tonumber(op2)) !== false) {\n                    L.stack[ra].setfltvalue(luai_nummod(L, numberop1, numberop2));\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_MOD);\n                }\n                break;\n            }\n            case OP_POW: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if ((numberop1 = tonumber(op1)) !== false && (numberop2 = tonumber(op2)) !== false) {\n                    L.stack[ra].setfltvalue(Math.pow(numberop1, numberop2));\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_POW);\n                }\n                break;\n            }\n            case OP_DIV: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if ((numberop1 = tonumber(op1)) !== false && (numberop2 = tonumber(op2)) !== false) {\n                    L.stack[ra].setfltvalue(numberop1 / numberop2);\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_DIV);\n                }\n                break;\n            }\n            case OP_IDIV: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if (op1.ttisinteger() && op2.ttisinteger()) {\n                    L.stack[ra].setivalue(luaV_div(L, op1.value, op2.value));\n                } else if ((numberop1 = tonumber(op1)) !== false && (numberop2 = tonumber(op2)) !== false) {\n                    L.stack[ra].setfltvalue(Math.floor(numberop1 / numberop2));\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_IDIV);\n                }\n                break;\n            }\n            case OP_BAND: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if ((numberop1 = tointeger(op1)) !== false && (numberop2 = tointeger(op2)) !== false) {\n                    L.stack[ra].setivalue(numberop1 & numberop2);\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_BAND);\n                }\n                break;\n            }\n            case OP_BOR: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if ((numberop1 = tointeger(op1)) !== false && (numberop2 = tointeger(op2)) !== false) {\n                    L.stack[ra].setivalue(numberop1 | numberop2);\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_BOR);\n                }\n                break;\n            }\n            case OP_BXOR: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if ((numberop1 = tointeger(op1)) !== false && (numberop2 = tointeger(op2)) !== false) {\n                    L.stack[ra].setivalue(numberop1 ^ numberop2);\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_BXOR);\n                }\n                break;\n            }\n            case OP_SHL: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if ((numberop1 = tointeger(op1)) !== false && (numberop2 = tointeger(op2)) !== false) {\n                    L.stack[ra].setivalue(luaV_shiftl(numberop1, numberop2));\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_SHL);\n                }\n                break;\n            }\n            case OP_SHR: {\n                let op1 = RKB(L, base, k, i);\n                let op2 = RKC(L, base, k, i);\n                let numberop1, numberop2;\n\n                if ((numberop1 = tointeger(op1)) !== false && (numberop2 = tointeger(op2)) !== false) {\n                    L.stack[ra].setivalue(luaV_shiftl(numberop1, -numberop2));\n                } else {\n                    ltm.luaT_trybinTM(L, op1, op2, L.stack[ra], ltm.TMS.TM_SHR);\n                }\n                break;\n            }\n            case OP_UNM: {\n                let op = L.stack[RB(L, base, i)];\n                let numberop;\n\n                if (op.ttisinteger()) {\n                    L.stack[ra].setivalue((-op.value)|0);\n                } else if ((numberop = tonumber(op)) !== false) {\n                    L.stack[ra].setfltvalue(-numberop);\n                } else {\n                    ltm.luaT_trybinTM(L, op, op, L.stack[ra], ltm.TMS.TM_UNM);\n                }\n                break;\n            }\n            case OP_BNOT: {\n                let op = L.stack[RB(L, base, i)];\n\n                if (op.ttisinteger()) {\n                    L.stack[ra].setivalue(~op.value);\n                } else {\n                    ltm.luaT_trybinTM(L, op, op, L.stack[ra], ltm.TMS.TM_BNOT);\n                }\n                break;\n            }\n            case OP_NOT: {\n                let op = L.stack[RB(L, base, i)];\n                L.stack[ra].setbvalue(op.l_isfalse());\n                break;\n            }\n            case OP_LEN: {\n                luaV_objlen(L, L.stack[ra], L.stack[RB(L, base, i)]);\n                break;\n            }\n            case OP_CONCAT: {\n                let b = i.B;\n                let c = i.C;\n                L.top = base + c + 1; /* mark the end of concat operands */\n                luaV_concat(L, c - b + 1);\n                let rb = base + b;\n                lobject.setobjs2s(L, ra, rb);\n                ldo.adjust_top(L, ci.top); /* restore top */\n                break;\n            }\n            case OP_JMP: {\n                dojump(L, ci, i, 0);\n                break;\n            }\n            case OP_EQ: {\n                if (luaV_equalobj(L, RKB(L, base, k, i), RKC(L, base, k, i)) !== i.A)\n                    ci.l_savedpc++;\n                else\n                    donextjump(L, ci);\n                break;\n            }\n            case OP_LT: {\n                if (luaV_lessthan(L, RKB(L, base, k, i), RKC(L, base, k, i)) !== i.A)\n                    ci.l_savedpc++;\n                else\n                    donextjump(L, ci);\n                break;\n            }\n            case OP_LE: {\n                if (luaV_lessequal(L, RKB(L, base, k, i), RKC(L, base, k, i)) !== i.A)\n                    ci.l_savedpc++;\n                else\n                    donextjump(L, ci);\n                break;\n            }\n            case OP_TEST: {\n                if (i.C ? L.stack[ra].l_isfalse() : !L.stack[ra].l_isfalse())\n                    ci.l_savedpc++;\n                else\n                    donextjump(L, ci);\n                break;\n            }\n            case OP_TESTSET: {\n                let rbIdx = RB(L, base, i);\n                let rb = L.stack[rbIdx];\n                if (i.C ? rb.l_isfalse() : !rb.l_isfalse())\n                    ci.l_savedpc++;\n                else {\n                    lobject.setobjs2s(L, ra, rbIdx);\n                    donextjump(L, ci);\n                }\n                break;\n            }\n            case OP_CALL: {\n                let b = i.B;\n                let nresults = i.C - 1;\n                if (b !== 0) ldo.adjust_top(L, ra+b);  /* else previous instruction set top */\n                if (ldo.luaD_precall(L, ra, nresults)) {\n                    if (nresults >= 0)\n                        ldo.adjust_top(L, ci.top);  /* adjust results */\n                } else {\n                    ci = L.ci;\n                    continue newframe;\n                }\n\n                break;\n            }\n            case OP_TAILCALL: {\n                let b = i.B;\n                if (b !== 0) ldo.adjust_top(L, ra+b);  /* else previous instruction set top */\n                if (ldo.luaD_precall(L, ra, LUA_MULTRET)) { // JS function\n                } else {\n                    /* tail call: put called frame (n) in place of caller one (o) */\n                    let nci = L.ci;\n                    let oci = nci.previous;\n                    let nfunc = nci.func;\n                    let nfuncOff = nci.funcOff;\n                    let ofuncOff = oci.funcOff;\n                    let lim = nci.l_base + nfunc.value.p.numparams;\n                    if (cl.p.p.length > 0) lfunc.luaF_close(L, oci.l_base);\n                    for (let aux = 0; nfuncOff + aux < lim; aux++)\n                        lobject.setobjs2s(L, ofuncOff + aux, nfuncOff + aux);\n                    oci.l_base = ofuncOff + (nci.l_base - nfuncOff);\n                    oci.top = ofuncOff + (L.top - nfuncOff);\n                    ldo.adjust_top(L, oci.top);  /* correct top */\n                    oci.l_code = nci.l_code;\n                    oci.l_savedpc = nci.l_savedpc;\n                    oci.callstatus |= lstate.CIST_TAIL;\n                    oci.next = null;\n                    ci = L.ci = oci;\n\n                    lua_assert(L.top === oci.l_base + L.stack[ofuncOff].value.p.maxstacksize);\n\n                    continue newframe;\n                }\n                break;\n            }\n            case OP_RETURN: {\n                if (cl.p.p.length > 0) lfunc.luaF_close(L, base);\n                let b = ldo.luaD_poscall(L, ci, ra, (i.B !== 0 ? i.B - 1 : L.top - ra));\n\n                if (ci.callstatus & lstate.CIST_FRESH)\n                    return; /* external invocation: return */\n                /* invocation via reentry: continue execution */\n                ci = L.ci;\n                if (b) ldo.adjust_top(L, ci.top);\n                lua_assert(ci.callstatus & lstate.CIST_LUA);\n                lua_assert(ci.l_code[ci.l_savedpc - 1].opcode === OP_CALL);\n                continue newframe;\n            }\n            case OP_FORLOOP: {\n                if (L.stack[ra].ttisinteger()) { /* integer loop? */\n                    let step = L.stack[ra + 2].value;\n                    let idx = (L.stack[ra].value + step)|0;\n                    let limit = L.stack[ra + 1].value;\n\n                    if (0 < step ? idx <= limit : limit <= idx) {\n                        ci.l_savedpc += i.sBx;\n                        L.stack[ra].chgivalue(idx);  /* update internal index... */\n                        L.stack[ra + 3].setivalue(idx);\n                    }\n                } else { /* floating loop */\n                    let step = L.stack[ra + 2].value;\n                    let idx = L.stack[ra].value + step;\n                    let limit = L.stack[ra + 1].value;\n\n                    if (0 < step ? idx <= limit : limit <= idx) {\n                        ci.l_savedpc += i.sBx;\n                        L.stack[ra].chgfltvalue(idx);  /* update internal index... */\n                        L.stack[ra + 3].setfltvalue(idx);\n                    }\n                }\n                break;\n            }\n            case OP_FORPREP: {\n                let init = L.stack[ra];\n                let plimit = L.stack[ra + 1];\n                let pstep = L.stack[ra + 2];\n                let forlim;\n\n                if (init.ttisinteger() && pstep.ttisinteger() && (forlim = forlimit(plimit, pstep.value))) {\n                    /* all values are integer */\n                    let initv = forlim.stopnow ? 0 : init.value;\n                    plimit.value = forlim.ilimit;\n                    init.value = (initv - pstep.value)|0;\n                } else { /* try making all values floats */\n                    let nlimit, nstep, ninit;\n                    if ((nlimit = tonumber(plimit)) === false)\n                        ldebug.luaG_runerror(L, to_luastring(\"'for' limit must be a number\", true));\n                    L.stack[ra + 1].setfltvalue(nlimit);\n                    if ((nstep = tonumber(pstep)) === false)\n                        ldebug.luaG_runerror(L, to_luastring(\"'for' step must be a number\", true));\n                    L.stack[ra + 2].setfltvalue(nstep);\n                    if ((ninit = tonumber(init)) === false)\n                        ldebug.luaG_runerror(L, to_luastring(\"'for' initial value must be a number\", true));\n                    L.stack[ra].setfltvalue(ninit - nstep);\n                }\n\n                ci.l_savedpc += i.sBx;\n                break;\n            }\n            case OP_TFORCALL: {\n                let cb = ra + 3; /* call base */\n                lobject.setobjs2s(L, cb+2, ra+2);\n                lobject.setobjs2s(L, cb+1, ra+1);\n                lobject.setobjs2s(L, cb, ra);\n                ldo.adjust_top(L, cb+3);  /* func. + 2 args (state and index) */\n                ldo.luaD_call(L, cb, i.C);\n                ldo.adjust_top(L, ci.top);\n                /* go straight to OP_TFORLOOP */\n                i = ci.l_code[ci.l_savedpc++];\n                ra = RA(L, base, i);\n                lua_assert(i.opcode === OP_TFORLOOP);\n            }\n            /* fall through */\n            case OP_TFORLOOP: {\n                if (!L.stack[ra + 1].ttisnil()) { /* continue loop? */\n                    lobject.setobjs2s(L, ra, ra + 1); /* save control variable */\n                    ci.l_savedpc += i.sBx; /* jump back */\n                }\n                break;\n            }\n            case OP_SETLIST: {\n                let n = i.B;\n                let c = i.C;\n\n                if (n === 0) n = L.top - ra - 1;\n\n                if (c === 0) {\n                    lua_assert(ci.l_code[ci.l_savedpc].opcode === OP_EXTRAARG);\n                    c = ci.l_code[ci.l_savedpc++].Ax;\n                }\n\n                let h = L.stack[ra].value;\n                let last = ((c - 1) * LFIELDS_PER_FLUSH) + n;\n\n                for (; n > 0; n--) {\n                    ltable.luaH_setint(h, last--, L.stack[ra + n]);\n                }\n                ldo.adjust_top(L, ci.top);  /* correct top (in case of previous open call) */\n                break;\n            }\n            case OP_CLOSURE: {\n                let p = cl.p.p[i.Bx];\n                let ncl = getcached(p, cl.upvals, L.stack, base);  /* cached closure */\n                if (ncl === null)  /* no match? */\n                    pushclosure(L, p, cl.upvals, base, ra);  /* create a new one */\n                else\n                    L.stack[ra].setclLvalue(ncl);\n                break;\n            }\n            case OP_VARARG: {\n                let b = i.B - 1;\n                let n = base - ci.funcOff - cl.p.numparams - 1;\n                let j;\n\n                if (n < 0) /* less arguments than parameters? */\n                    n = 0; /* no vararg arguments */\n\n                if (b < 0) {\n                    b = n;  /* get all var. arguments */\n                    ldo.luaD_checkstack(L, n);\n                    ldo.adjust_top(L, ra + n);\n                }\n\n                for (j = 0; j < b && j < n; j++)\n                    lobject.setobjs2s(L, ra + j, base - n + j);\n\n                for (; j < b; j++) /* complete required results with nil */\n                    L.stack[ra + j].setnilvalue();\n                break;\n            }\n            case OP_EXTRAARG: {\n                throw Error(\"invalid opcode\");\n            }\n        }\n    }\n};\n\nconst dojump = function(L, ci, i, e) {\n    let a = i.A;\n    if (a !== 0) lfunc.luaF_close(L, ci.l_base + a - 1);\n    ci.l_savedpc += i.sBx + e;\n};\n\nconst donextjump = function(L, ci) {\n    dojump(L, ci, ci.l_code[ci.l_savedpc], 1);\n};\n\n\nconst luaV_lessthan = function(L, l, r) {\n    if (l.ttisnumber() && r.ttisnumber())\n        return LTnum(l, r) ? 1 : 0;\n    else if (l.ttisstring() && r.ttisstring())\n        return l_strcmp(l.tsvalue(), r.tsvalue()) < 0 ? 1 : 0;\n    else {\n        let res = ltm.luaT_callorderTM(L, l, r, ltm.TMS.TM_LT);\n        if (res === null)\n            ldebug.luaG_ordererror(L, l, r);\n        return res ? 1 : 0;\n    }\n};\n\nconst luaV_lessequal = function(L, l, r) {\n    let res;\n\n    if (l.ttisnumber() && r.ttisnumber())\n        return LEnum(l, r) ? 1 : 0;\n    else if (l.ttisstring() && r.ttisstring())\n        return l_strcmp(l.tsvalue(), r.tsvalue()) <= 0 ? 1 : 0;\n    else {\n        res = ltm.luaT_callorderTM(L, l, r, ltm.TMS.TM_LE);\n        if (res !== null)\n            return res ? 1 : 0;\n    }\n    /* try 'lt': */\n    L.ci.callstatus |= lstate.CIST_LEQ; /* mark it is doing 'lt' for 'le' */\n    res = ltm.luaT_callorderTM(L, r, l, ltm.TMS.TM_LT);\n    L.ci.callstatus ^= lstate.CIST_LEQ; /* clear mark */\n    if (res === null)\n        ldebug.luaG_ordererror(L, l, r);\n    return res ? 0 : 1; /* result is negated */\n};\n\nconst luaV_equalobj = function(L, t1, t2) {\n    if (t1.ttype() !== t2.ttype()) { /* not the same variant? */\n        if (t1.ttnov() !== t2.ttnov() || t1.ttnov() !== LUA_TNUMBER)\n            return 0; /* only numbers can be equal with different variants */\n        else { /* two numbers with different variants */\n            /* OPTIMIZATION: instead of calling luaV_tointeger we can just let JS do the comparison */\n            return (t1.value === t2.value) ? 1 : 0;\n        }\n    }\n\n    let tm;\n\n    /* values have same type and same variant */\n    switch(t1.ttype()) {\n        case LUA_TNIL:\n            return 1;\n        case LUA_TBOOLEAN:\n            return t1.value == t2.value ? 1 : 0; // Might be 1 or true\n        case LUA_TLIGHTUSERDATA:\n        case LUA_TNUMINT:\n        case LUA_TNUMFLT:\n        case LUA_TLCF:\n            return t1.value === t2.value ? 1 : 0;\n        case LUA_TSHRSTR:\n        case LUA_TLNGSTR: {\n            return luaS_eqlngstr(t1.tsvalue(), t2.tsvalue()) ? 1 : 0;\n        }\n        case LUA_TUSERDATA:\n        case LUA_TTABLE:\n            if (t1.value === t2.value) return 1;\n            else if (L === null) return 0;\n\n            tm = ltm.fasttm(L, t1.value.metatable, ltm.TMS.TM_EQ);\n            if (tm === null)\n                tm = ltm.fasttm(L, t2.value.metatable, ltm.TMS.TM_EQ);\n            break;\n        default:\n            return t1.value === t2.value ? 1 : 0;\n    }\n\n    if (tm === null) /* no TM? */\n        return 0;\n\n    let tv = new lobject.TValue(); /* doesn't use the stack */\n    ltm.luaT_callTM(L, tm, t1, t2, tv, 1);\n    return tv.l_isfalse() ? 0 : 1;\n};\n\nconst luaV_rawequalobj = function(t1, t2) {\n    return luaV_equalobj(null, t1, t2);\n};\n\nconst forlimit = function(obj, step) {\n    let stopnow = false;\n    let ilimit = luaV_tointeger(obj, step < 0 ? 2 : 1);\n    if (ilimit === false) {\n        let n = tonumber(obj);\n        if (n === false)\n            return false;\n\n        if (0 < n) {\n            ilimit = LUA_MAXINTEGER;\n            if (step < 0) stopnow = true;\n        } else {\n            ilimit = LUA_MININTEGER;\n            if (step >= 0) stopnow = true;\n        }\n    }\n\n    return {\n        stopnow: stopnow,\n        ilimit: ilimit\n    };\n};\n\n/*\n** try to convert a value to an integer, rounding according to 'mode':\n** mode === 0: accepts only integral values\n** mode === 1: takes the floor of the number\n** mode === 2: takes the ceil of the number\n*/\nconst luaV_tointeger = function(obj, mode) {\n    if (obj.ttisfloat()) {\n        let n = obj.value;\n        let f = Math.floor(n);\n\n        if (n !== f) { /* not an integral value? */\n            if (mode === 0)\n                return false;  /* fails if mode demands integral value */\n            else if (mode > 1)  /* needs ceil? */\n                f += 1;  /* convert floor to ceil (remember: n !== f) */\n        }\n\n        return lua_numbertointeger(f);\n    } else if (obj.ttisinteger()) {\n        return obj.value;\n    } else if (cvt2num(obj)) {\n        let v = new lobject.TValue();\n        if (lobject.luaO_str2num(obj.svalue(), v) === (obj.vslen() + 1))\n            return luaV_tointeger(v, mode);\n    }\n\n    return false;\n};\n\nconst tointeger = function(o) {\n    return o.ttisinteger() ? o.value : luaV_tointeger(o, 0);\n};\n\nconst tonumber = function(o) {\n    if (o.ttnov() === LUA_TNUMBER)\n        return o.value;\n\n    if (cvt2num(o)) {  /* string convertible to number? */\n        let v = new lobject.TValue();\n        if (lobject.luaO_str2num(o.svalue(), v) === (o.vslen() + 1))\n            return v.value;\n    }\n\n    return false;\n};\n\n/*\n** Return 'l < r', for numbers.\n** As fengari uses javascript numbers for both floats and integers and has\n** correct semantics, we can just compare values.\n*/\nconst LTnum = function(l, r) {\n    return l.value < r.value;\n};\n\n/*\n** Return 'l <= r', for numbers.\n*/\nconst LEnum = function(l, r) {\n    return l.value <= r.value;\n};\n\n/*\n** Compare two strings 'ls' x 'rs', returning an integer smaller-equal-\n** -larger than zero if 'ls' is smaller-equal-larger than 'rs'.\n*/\nconst l_strcmp = function(ls, rs) {\n    let l = luaS_hashlongstr(ls);\n    let r = luaS_hashlongstr(rs);\n    /* In fengari we assume string hash has same collation as byte values */\n    if (l === r)\n        return 0;\n    else if (l < r)\n        return -1;\n    else\n        return 1;\n};\n\n/*\n** Main operation 'ra' = #rb'.\n*/\nconst luaV_objlen = function(L, ra, rb) {\n    let tm;\n    switch(rb.ttype()) {\n        case LUA_TTABLE: {\n            let h = rb.value;\n            tm = ltm.fasttm(L, h.metatable, ltm.TMS.TM_LEN);\n            if (tm !== null) break; /* metamethod? break switch to call it */\n            ra.setivalue(ltable.luaH_getn(h)); /* else primitive len */\n            return;\n        }\n        case LUA_TSHRSTR:\n        case LUA_TLNGSTR:\n            ra.setivalue(rb.vslen());\n            return;\n        default: {\n            tm = ltm.luaT_gettmbyobj(L, rb, ltm.TMS.TM_LEN);\n            if (tm.ttisnil())\n                ldebug.luaG_typeerror(L, rb, to_luastring(\"get length of\", true));\n            break;\n        }\n    }\n\n    ltm.luaT_callTM(L, tm, rb, rb, ra, 1);\n};\n\n/* Shim taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul */\nconst luaV_imul = Math.imul || function(a, b) {\n    let aHi = (a >>> 16) & 0xffff;\n    let aLo = a & 0xffff;\n    let bHi = (b >>> 16) & 0xffff;\n    let bLo = b & 0xffff;\n    /*\n    ** the shift by 0 fixes the sign on the high part\n    ** the final |0 converts the unsigned value into a signed value\n    */\n    return ((aLo * bLo) + (((aHi * bLo + aLo * bHi) << 16) >>> 0) | 0);\n};\n\nconst luaV_div = function(L, m, n) {\n    if (n === 0)\n        ldebug.luaG_runerror(L, to_luastring(\"attempt to divide by zero\"));\n    return Math.floor(m / n)|0;\n};\n\n// % semantic on negative numbers is different in js\nconst luaV_mod = function(L, m, n) {\n    if (n === 0)\n        ldebug.luaG_runerror(L, to_luastring(\"attempt to perform 'n%%0'\"));\n    return (m - Math.floor(m / n) * n)|0;\n};\n\nconst NBITS = 32;\n\nconst luaV_shiftl = function(x, y) {\n    if (y < 0) {  /* shift right? */\n        if (y <= -NBITS) return 0;\n        else return x >>> -y;\n    }\n    else {  /* shift left */\n        if (y >= NBITS) return 0;\n        else return x << y;\n    }\n};\n\n/*\n** check whether cached closure in prototype 'p' may be reused, that is,\n** whether there is a cached closure with the same upvalues needed by\n** new closure to be created.\n*/\nconst getcached = function(p, encup, stack, base) {\n    let c = p.cache;\n    if (c !== null) {  /* is there a cached closure? */\n        let uv = p.upvalues;\n        let nup = uv.length;\n        for (let i = 0; i < nup; i++) {  /* check whether it has right upvalues */\n            let v = uv[i].instack ? stack[base + uv[i].idx] : encup[uv[i].idx];\n            if (c.upvals[i] !== v)\n                return null;  /* wrong upvalue; cannot reuse closure */\n        }\n    }\n    return c;  /* return cached closure (or NULL if no cached closure) */\n};\n\n/*\n** create a new Lua closure, push it in the stack, and initialize\n** its upvalues.\n*/\nconst pushclosure = function(L, p, encup, base, ra) {\n    let nup = p.upvalues.length;\n    let uv = p.upvalues;\n    let ncl = new lobject.LClosure(L, nup);\n    ncl.p = p;\n    L.stack[ra].setclLvalue(ncl);\n    for (let i = 0; i < nup; i++) {\n        if (uv[i].instack)\n            ncl.upvals[i] = lfunc.luaF_findupval(L, base + uv[i].idx);\n        else\n            ncl.upvals[i] = encup[uv[i].idx];\n    }\n    p.cache = ncl;  /* save it on cache for reuse */\n};\n\nconst cvt2str = function(o) {\n    return o.ttisnumber();\n};\n\nconst cvt2num = function(o) {\n    return o.ttisstring();\n};\n\nconst tostring = function(L, i) {\n    let o = L.stack[i];\n\n    if (o.ttisstring()) return true;\n\n    if (cvt2str(o)) {\n        lobject.luaO_tostring(L, o);\n        return true;\n    }\n\n    return false;\n};\n\nconst isemptystr = function(o) {\n    return o.ttisstring() && o.vslen() === 0;\n};\n\n/* copy strings in stack from top - n up to top - 1 to buffer */\nconst copy2buff = function(L, top, n, buff) {\n    let tl = 0;  /* size already copied */\n    do {\n        let tv = L.stack[top-n];\n        let l = tv.vslen();  /* length of string being copied */\n        let s = tv.svalue();\n        buff.set(s, tl);\n        tl += l;\n    } while (--n > 0);\n};\n\n/*\n** Main operation for concatenation: concat 'total' values in the stack,\n** from 'L->top - total' up to 'L->top - 1'.\n*/\nconst luaV_concat = function(L, total) {\n    lua_assert(total >= 2);\n    do {\n        let top = L.top;\n        let n = 2; /* number of elements handled in this pass (at least 2) */\n\n        if (!(L.stack[top-2].ttisstring() || cvt2str(L.stack[top-2])) || !tostring(L, top - 1)) {\n            ltm.luaT_trybinTM(L, L.stack[top-2], L.stack[top-1], L.stack[top-2], ltm.TMS.TM_CONCAT);\n        } else if (isemptystr(L.stack[top-1])) {\n            tostring(L, top - 2);\n        } else if (isemptystr(L.stack[top-2])) {\n            lobject.setobjs2s(L, top - 2, top - 1);\n        } else {\n            /* at least two non-empty string values; get as many as possible */\n            let tl = L.stack[top-1].vslen();\n            /* collect total length and number of strings */\n            for (n = 1; n < total && tostring(L, top - n - 1); n++) {\n                let l = L.stack[top - n - 1].vslen();\n                tl += l;\n            }\n            let buff = new Uint8Array(tl);\n            copy2buff(L, top, n, buff);\n            let ts = luaS_bless(L, buff);\n            lobject.setsvalue2s(L, top - n, ts);\n        }\n        total -= n - 1; /* got 'n' strings to create 1 new */\n        /* popped 'n' strings and pushed one */\n        for (; L.top > top-(n-1);)\n            delete L.stack[--L.top];\n    } while (total > 1); /* repeat until only 1 result left */\n};\n\nconst MAXTAGLOOP = 2000;\n\nconst luaV_gettable = function(L, t, key, ra) {\n    for (let loop = 0; loop < MAXTAGLOOP; loop++) {\n        let tm;\n\n        if (!t.ttistable()) {\n            tm = ltm.luaT_gettmbyobj(L, t, ltm.TMS.TM_INDEX);\n            if (tm.ttisnil())\n                ldebug.luaG_typeerror(L, t, to_luastring('index', true)); /* no metamethod */\n            /* else will try the metamethod */\n        } else {\n            let slot = ltable.luaH_get(L, t.value, key);\n            if (!slot.ttisnil()) {\n                lobject.setobj2s(L, ra, slot);\n                return;\n            } else { /* 't' is a table */\n                tm = ltm.fasttm(L, t.value.metatable, ltm.TMS.TM_INDEX);  /* table's metamethod */\n                if (tm === null) { /* no metamethod? */\n                    L.stack[ra].setnilvalue(); /* result is nil */\n                    return;\n                }\n            }\n            /* else will try the metamethod */\n        }\n        if (tm.ttisfunction()) { /* is metamethod a function? */\n            ltm.luaT_callTM(L, tm, t, key, L.stack[ra], 1); /* call it */\n            return;\n        }\n        t = tm;  /* else try to access 'tm[key]' */\n    }\n\n    ldebug.luaG_runerror(L, to_luastring(\"'__index' chain too long; possible loop\", true));\n};\n\nconst settable = function(L, t, key, val) {\n    for (let loop = 0; loop < MAXTAGLOOP; loop++) {\n        let tm;\n        if (t.ttistable()) {\n            let h = t.value; /* save 't' table */\n            let slot = ltable.luaH_set(L, h, key);\n            if (!slot.ttisnil() || (tm = ltm.fasttm(L, h.metatable, ltm.TMS.TM_NEWINDEX)) === null) {\n                if (val.ttisnil())\n                    ltable.luaH_delete(L, h, key);\n                else\n                    slot.setfrom(val);\n                ltable.invalidateTMcache(h);\n                return;\n            }\n            /* else will try the metamethod */\n        } else { /* not a table; check metamethod */\n            if ((tm = ltm.luaT_gettmbyobj(L, t, ltm.TMS.TM_NEWINDEX)).ttisnil())\n                ldebug.luaG_typeerror(L, t, to_luastring('index', true));\n        }\n        /* try the metamethod */\n        if (tm.ttisfunction()) {\n            ltm.luaT_callTM(L, tm, t, key, val, 0);\n            return;\n        }\n        t = tm;  /* else repeat assignment over 'tm' */\n    }\n\n    ldebug.luaG_runerror(L, to_luastring(\"'__newindex' chain too long; possible loop\", true));\n};\n\n\nmodule.exports.cvt2str          = cvt2str;\nmodule.exports.cvt2num          = cvt2num;\nmodule.exports.luaV_gettable    = luaV_gettable;\nmodule.exports.luaV_concat      = luaV_concat;\nmodule.exports.luaV_div         = luaV_div;\nmodule.exports.luaV_equalobj    = luaV_equalobj;\nmodule.exports.luaV_execute     = luaV_execute;\nmodule.exports.luaV_finishOp    = luaV_finishOp;\nmodule.exports.luaV_imul        = luaV_imul;\nmodule.exports.luaV_lessequal   = luaV_lessequal;\nmodule.exports.luaV_lessthan    = luaV_lessthan;\nmodule.exports.luaV_mod         = luaV_mod;\nmodule.exports.luaV_objlen      = luaV_objlen;\nmodule.exports.luaV_rawequalobj = luaV_rawequalobj;\nmodule.exports.luaV_shiftl      = luaV_shiftl;\nmodule.exports.luaV_tointeger   = luaV_tointeger;\nmodule.exports.settable         = settable;\nmodule.exports.tointeger        = tointeger;\nmodule.exports.tonumber         = tonumber;\n","\"use strict\";\n\nconst {\n    constant_types: {\n        LUA_TTABLE,\n        LUA_TUSERDATA\n    },\n    to_luastring\n} = require('./defs.js');\nconst { lua_assert } = require('./llimits.js');\nconst lobject = require('./lobject.js');\nconst ldo     = require('./ldo.js');\nconst lstate  = require('./lstate.js');\nconst {\n    luaS_bless,\n    luaS_new\n} = require('./lstring.js');\nconst ltable  = require('./ltable.js');\nconst ldebug  = require('./ldebug.js');\nconst lvm     = require('./lvm.js');\n\nconst luaT_typenames_ = [\n    \"no value\",\n    \"nil\",\n    \"boolean\",\n    \"userdata\",\n    \"number\",\n    \"string\",\n    \"table\",\n    \"function\",\n    \"userdata\",\n    \"thread\",\n    \"proto\" /* this last case is used for tests only */\n].map(e => to_luastring(e));\n\nconst ttypename = function(t) {\n    return luaT_typenames_[t + 1];\n};\n\n\n/*\n* WARNING: if you change the order of this enumeration,\n* grep \"ORDER TM\" and \"ORDER OP\"\n*/\nconst TMS = {\n    TM_INDEX:    0,\n    TM_NEWINDEX: 1,\n    TM_GC:       2,\n    TM_MODE:     3,\n    TM_LEN:      4,\n    TM_EQ:       5,  /* last tag method with fast access */\n    TM_ADD:      6,\n    TM_SUB:      7,\n    TM_MUL:      8,\n    TM_MOD:      9,\n    TM_POW:     10,\n    TM_DIV:     11,\n    TM_IDIV:    12,\n    TM_BAND:    13 ,\n    TM_BOR:     14,\n    TM_BXOR:    15,\n    TM_SHL:     16,\n    TM_SHR:     17,\n    TM_UNM:     18,\n    TM_BNOT:    19,\n    TM_LT:      20,\n    TM_LE:      21,\n    TM_CONCAT:  22,\n    TM_CALL:    23,\n    TM_N:       24  /* number of elements in the enum */\n};\n\nconst luaT_init = function(L) {\n    L.l_G.tmname[TMS.TM_INDEX]    = new luaS_new(L, to_luastring(\"__index\", true));\n    L.l_G.tmname[TMS.TM_NEWINDEX] = new luaS_new(L, to_luastring(\"__newindex\", true));\n    L.l_G.tmname[TMS.TM_GC]       = new luaS_new(L, to_luastring(\"__gc\", true));\n    L.l_G.tmname[TMS.TM_MODE]     = new luaS_new(L, to_luastring(\"__mode\", true));\n    L.l_G.tmname[TMS.TM_LEN]      = new luaS_new(L, to_luastring(\"__len\", true));\n    L.l_G.tmname[TMS.TM_EQ]       = new luaS_new(L, to_luastring(\"__eq\", true));\n    L.l_G.tmname[TMS.TM_ADD]      = new luaS_new(L, to_luastring(\"__add\", true));\n    L.l_G.tmname[TMS.TM_SUB]      = new luaS_new(L, to_luastring(\"__sub\", true));\n    L.l_G.tmname[TMS.TM_MUL]      = new luaS_new(L, to_luastring(\"__mul\", true));\n    L.l_G.tmname[TMS.TM_MOD]      = new luaS_new(L, to_luastring(\"__mod\", true));\n    L.l_G.tmname[TMS.TM_POW]      = new luaS_new(L, to_luastring(\"__pow\", true));\n    L.l_G.tmname[TMS.TM_DIV]      = new luaS_new(L, to_luastring(\"__div\", true));\n    L.l_G.tmname[TMS.TM_IDIV]     = new luaS_new(L, to_luastring(\"__idiv\", true));\n    L.l_G.tmname[TMS.TM_BAND]     = new luaS_new(L, to_luastring(\"__band\", true));\n    L.l_G.tmname[TMS.TM_BOR]      = new luaS_new(L, to_luastring(\"__bor\", true));\n    L.l_G.tmname[TMS.TM_BXOR]     = new luaS_new(L, to_luastring(\"__bxor\", true));\n    L.l_G.tmname[TMS.TM_SHL]      = new luaS_new(L, to_luastring(\"__shl\", true));\n    L.l_G.tmname[TMS.TM_SHR]      = new luaS_new(L, to_luastring(\"__shr\", true));\n    L.l_G.tmname[TMS.TM_UNM]      = new luaS_new(L, to_luastring(\"__unm\", true));\n    L.l_G.tmname[TMS.TM_BNOT]     = new luaS_new(L, to_luastring(\"__bnot\", true));\n    L.l_G.tmname[TMS.TM_LT]       = new luaS_new(L, to_luastring(\"__lt\", true));\n    L.l_G.tmname[TMS.TM_LE]       = new luaS_new(L, to_luastring(\"__le\", true));\n    L.l_G.tmname[TMS.TM_CONCAT]   = new luaS_new(L, to_luastring(\"__concat\", true));\n    L.l_G.tmname[TMS.TM_CALL]     = new luaS_new(L, to_luastring(\"__call\", true));\n};\n\n/*\n** Return the name of the type of an object. For tables and userdata\n** with metatable, use their '__name' metafield, if present.\n*/\nconst __name = to_luastring('__name', true);\nconst luaT_objtypename = function(L, o) {\n    let mt;\n    if ((o.ttistable() && (mt = o.value.metatable) !== null) ||\n        (o.ttisfulluserdata() && (mt = o.value.metatable) !== null)) {\n        let name = ltable.luaH_getstr(mt, luaS_bless(L, __name));\n        if (name.ttisstring())\n            return name.svalue();\n    }\n    return ttypename(o.ttnov());\n};\n\nconst luaT_callTM = function(L, f, p1, p2, p3, hasres) {\n    let func = L.top;\n\n    lobject.pushobj2s(L, f); /* push function (assume EXTRA_STACK) */\n    lobject.pushobj2s(L, p1); /* 1st argument */\n    lobject.pushobj2s(L, p2); /* 2nd argument */\n\n    if (!hasres)  /* no result? 'p3' is third argument */\n        lobject.pushobj2s(L, p3); /* 3rd argument */\n\n    if (L.ci.callstatus & lstate.CIST_LUA)\n        ldo.luaD_call(L, func, hasres);\n    else\n        ldo.luaD_callnoyield(L, func, hasres);\n\n    if (hasres) {  /* if has result, move it to its place */\n        let tv = L.stack[L.top-1];\n        delete L.stack[--L.top];\n        p3.setfrom(tv);\n    }\n};\n\nconst luaT_callbinTM = function(L, p1, p2, res, event) {\n    let tm = luaT_gettmbyobj(L, p1, event);\n    if (tm.ttisnil())\n        tm = luaT_gettmbyobj(L, p2, event);\n    if (tm.ttisnil()) return false;\n    luaT_callTM(L, tm, p1, p2, res, 1);\n    return true;\n};\n\nconst luaT_trybinTM = function(L, p1, p2, res, event) {\n    if (!luaT_callbinTM(L, p1, p2, res, event)) {\n        switch (event) {\n            case TMS.TM_CONCAT:\n                return ldebug.luaG_concaterror(L, p1, p2);\n            case TMS.TM_BAND: case TMS.TM_BOR: case TMS.TM_BXOR:\n            case TMS.TM_SHL: case TMS.TM_SHR: case TMS.TM_BNOT: {\n                let n1 = lvm.tonumber(p1);\n                let n2 = lvm.tonumber(p2);\n                if (n1 !== false && n2 !== false)\n                    return ldebug.luaG_tointerror(L, p1, p2);\n                else\n                    return ldebug.luaG_opinterror(L, p1, p2, to_luastring(\"perform bitwise operation on\", true));\n            }\n            default:\n                return ldebug.luaG_opinterror(L, p1, p2, to_luastring(\"perform arithmetic on\", true));\n        }\n    }\n};\n\nconst luaT_callorderTM = function(L, p1, p2, event) {\n    let res = new lobject.TValue();\n    if (!luaT_callbinTM(L, p1, p2, res, event))\n        return null;\n    else\n        return !res.l_isfalse();\n};\n\nconst fasttm = function(l, et, e) {\n    return et === null ? null :\n        (et.flags & (1 << e)) ? null : luaT_gettm(et, e, l.l_G.tmname[e]);\n};\n\nconst luaT_gettm = function(events, event, ename) {\n    const tm = ltable.luaH_getstr(events, ename);\n    lua_assert(event <= TMS.TM_EQ);\n    if (tm.ttisnil()) {  /* no tag method? */\n        events.flags |= 1<<event;  /* cache this fact */\n        return null;\n    }\n    else return tm;\n};\n\nconst luaT_gettmbyobj = function(L, o, event) {\n    let mt;\n    switch(o.ttnov()) {\n        case LUA_TTABLE:\n        case LUA_TUSERDATA:\n            mt = o.value.metatable;\n            break;\n        default:\n            mt = L.l_G.mt[o.ttnov()];\n    }\n\n    return mt ? ltable.luaH_getstr(mt, L.l_G.tmname[event]) : lobject.luaO_nilobject;\n};\n\nmodule.exports.fasttm           = fasttm;\nmodule.exports.TMS              = TMS;\nmodule.exports.luaT_callTM      = luaT_callTM;\nmodule.exports.luaT_callbinTM   = luaT_callbinTM;\nmodule.exports.luaT_trybinTM    = luaT_trybinTM;\nmodule.exports.luaT_callorderTM = luaT_callorderTM;\nmodule.exports.luaT_gettm       = luaT_gettm;\nmodule.exports.luaT_gettmbyobj  = luaT_gettmbyobj;\nmodule.exports.luaT_init        = luaT_init;\nmodule.exports.luaT_objtypename = luaT_objtypename;\nmodule.exports.ttypename        = ttypename;\n","\"use strict\";\n\nconst { constant_types: { LUA_TNIL } } = require('./defs.js');\nconst lobject = require('./lobject.js');\n\nclass Proto {\n    constructor(L) {\n        this.id = L.l_G.id_counter++;\n        this.k = [];              // constants used by the function\n        this.p = [];              // functions defined inside the function\n        this.code = [];           // opcodes\n        this.cache = null;        // last-created closure with this prototype\n        this.lineinfo = [];       // map from opcodes to source lines (debug information)\n        this.upvalues = [];       // upvalue information\n        this.numparams = 0;       // number of fixed parameters\n        this.is_vararg = false;\n        this.maxstacksize = 0;    // number of registers needed by this function\n        this.locvars = [];        // information about local variables (debug information)\n        this.linedefined = 0;     // debug information\n        this.lastlinedefined = 0; // debug information\n        this.source = null;       // used for debug information\n    }\n}\n\nconst luaF_newLclosure = function(L, n) {\n    return new lobject.LClosure(L, n);\n};\n\n\nconst luaF_findupval = function(L, level) {\n    return L.stack[level];\n};\n\nconst luaF_close = function(L, level) {\n    /* Create new TValues on stack;\n     * any closures will keep referencing old TValues */\n    for (let i=level; i<L.top; i++) {\n        let old = L.stack[i];\n        L.stack[i] = new lobject.TValue(old.type, old.value);\n    }\n};\n\n/*\n** fill a closure with new upvalues\n*/\nconst luaF_initupvals = function(L, cl) {\n    for (let i = 0; i < cl.nupvalues; i++)\n        cl.upvals[i] = new lobject.TValue(LUA_TNIL, null);\n};\n\n/*\n** Look for n-th local variable at line 'line' in function 'func'.\n** Returns null if not found.\n*/\nconst luaF_getlocalname = function(f, local_number, pc) {\n    for (let i = 0; i < f.locvars.length && f.locvars[i].startpc <= pc; i++) {\n        if (pc < f.locvars[i].endpc) {  /* is variable active? */\n            local_number--;\n            if (local_number === 0)\n                return f.locvars[i].varname.getstr();\n        }\n    }\n    return null;  /* not found */\n};\n\nmodule.exports.MAXUPVAL          = 255;\nmodule.exports.Proto             = Proto;\nmodule.exports.luaF_findupval    = luaF_findupval;\nmodule.exports.luaF_close        = luaF_close;\nmodule.exports.luaF_getlocalname = luaF_getlocalname;\nmodule.exports.luaF_initupvals   = luaF_initupvals;\nmodule.exports.luaF_newLclosure  = luaF_newLclosure;\n","\"use strict\";\n\nconst { lua_assert } = require(\"./llimits.js\");\n\nclass MBuffer {\n    constructor() {\n        this.buffer = null;\n        this.n = 0;\n    }\n}\n\nconst luaZ_buffer = function(buff) {\n    return buff.buffer.subarray(0, buff.n);\n};\n\nconst luaZ_buffremove = function(buff, i) {\n    buff.n -= i;\n};\n\nconst luaZ_resetbuffer = function(buff) {\n    buff.n = 0;\n};\n\nconst luaZ_resizebuffer = function(L, buff, size) {\n    let newbuff = new Uint8Array(size);\n    if (buff.buffer)\n        newbuff.set(buff.buffer);\n    buff.buffer = newbuff;\n};\n\nclass ZIO {\n    constructor(L, reader, data) {\n        this.L = L;           /* Lua state (for reader) */\n        lua_assert(typeof reader == \"function\", \"ZIO requires a reader\");\n        this.reader = reader; /* reader function */\n        this.data = data;     /* additional data */\n        this.n = 0;           /* bytes still unread */\n        this.buffer = null;\n        this.off = 0;         /* current position in buffer */\n    }\n\n    zgetc () {\n        return ((this.n--) > 0) ? this.buffer[this.off++] : luaZ_fill(this);\n    }\n}\n\nconst EOZ = -1;\n\nconst luaZ_fill = function(z) {\n    let buff = z.reader(z.L, z.data);\n    if (buff === null)\n        return EOZ;\n    lua_assert(buff instanceof Uint8Array, \"Should only load binary of array of bytes\");\n    let size = buff.length;\n    if (size === 0)\n        return EOZ;\n    z.buffer = buff;\n    z.off = 0;\n    z.n = size - 1;\n    return z.buffer[z.off++];\n};\n\n/* b should be an array-like that will be set to bytes\n * b_offset is the offset at which to start filling */\nconst luaZ_read = function(z, b, b_offset, n) {\n    while (n) {\n        if (z.n === 0) { /* no bytes in buffer? */\n            if (luaZ_fill(z) === EOZ)\n                return n; /* no more input; return number of missing bytes */\n            else {\n                z.n++;  /* luaZ_fill consumed first byte; put it back */\n                z.off--;\n            }\n        }\n        let m = (n <= z.n) ? n : z.n; /* min. between n and z->n */\n        for (let i=0; i<m; i++) {\n            b[b_offset++] = z.buffer[z.off++];\n        }\n        z.n -= m;\n        if (z.n === 0) // remove reference to input so it can get freed\n            z.buffer = null;\n        n -= m;\n    }\n\n    return 0;\n};\n\nmodule.exports.EOZ               = EOZ;\nmodule.exports.luaZ_buffer       = luaZ_buffer;\nmodule.exports.luaZ_buffremove   = luaZ_buffremove;\nmodule.exports.luaZ_fill         = luaZ_fill;\nmodule.exports.luaZ_read         = luaZ_read;\nmodule.exports.luaZ_resetbuffer  = luaZ_resetbuffer;\nmodule.exports.luaZ_resizebuffer = luaZ_resizebuffer;\nmodule.exports.MBuffer           = MBuffer;\nmodule.exports.ZIO               = ZIO;\n","\"use strict\";\n\nconst {\n    LUA_MULTRET,\n    LUA_OPBNOT,\n    LUA_OPEQ,\n    LUA_OPLE,\n    LUA_OPLT,\n    LUA_OPUNM,\n    LUA_REGISTRYINDEX,\n    LUA_RIDX_GLOBALS,\n    LUA_VERSION_NUM,\n    constant_types: {\n        LUA_NUMTAGS,\n        LUA_TBOOLEAN,\n        LUA_TCCL,\n        LUA_TFUNCTION,\n        LUA_TLCF,\n        LUA_TLCL,\n        LUA_TLIGHTUSERDATA,\n        LUA_TLNGSTR,\n        LUA_TNIL,\n        LUA_TNONE,\n        LUA_TNUMFLT,\n        LUA_TNUMINT,\n        LUA_TSHRSTR,\n        LUA_TTABLE,\n        LUA_TTHREAD,\n        LUA_TUSERDATA\n    },\n    thread_status: { LUA_OK },\n    from_userstring,\n    to_luastring,\n} = require('./defs.js');\nconst { api_check } = require('./llimits.js');\nconst ldebug    = require('./ldebug.js');\nconst ldo       = require('./ldo.js');\nconst { luaU_dump } = require('./ldump.js');\nconst lfunc     = require('./lfunc.js');\nconst lobject   = require('./lobject.js');\nconst lstate    = require('./lstate.js');\nconst {\n    luaS_bless,\n    luaS_new,\n    luaS_newliteral\n} = require('./lstring.js');\nconst ltm       = require('./ltm.js');\nconst { LUAI_MAXSTACK } = require('./luaconf.js');\nconst lvm       = require('./lvm.js');\nconst ltable    = require('./ltable.js');\nconst { ZIO } = require('./lzio.js');\nconst TValue    = lobject.TValue;\nconst CClosure  = lobject.CClosure;\n\nconst api_incr_top = function(L) {\n    L.top++;\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n};\n\nconst api_checknelems = function(L, n) {\n    api_check(L, n < (L.top - L.ci.funcOff), \"not enough elements in the stack\");\n};\n\nconst fengari_argcheck = function(c) {\n    if (!c) throw TypeError(\"invalid argument\");\n};\n\nconst fengari_argcheckinteger = function(n) {\n    fengari_argcheck(typeof n === \"number\" && (n|0) === n);\n};\n\nconst isvalid = function(o) {\n    return o !== lobject.luaO_nilobject;\n};\n\nconst lua_version = function(L) {\n    if (L === null) return LUA_VERSION_NUM;\n    else return L.l_G.version;\n};\n\nconst lua_atpanic = function(L, panicf) {\n    let old = L.l_G.panic;\n    L.l_G.panic = panicf;\n    return old;\n};\n\nconst lua_atnativeerror = function(L, errorf) {\n    let old = L.l_G.atnativeerror;\n    L.l_G.atnativeerror = errorf;\n    return old;\n};\n\n// Return value for idx on stack\nconst index2addr = function(L, idx) {\n    let ci = L.ci;\n    if (idx > 0) {\n        let o = ci.funcOff + idx;\n        api_check(L, idx <= ci.top - (ci.funcOff + 1), \"unacceptable index\");\n        if (o >= L.top) return lobject.luaO_nilobject;\n        else return L.stack[o];\n    } else if (idx > LUA_REGISTRYINDEX) {\n        api_check(L, idx !== 0 && -idx <= L.top, \"invalid index\");\n        return L.stack[L.top + idx];\n    } else if (idx === LUA_REGISTRYINDEX) {\n        return L.l_G.l_registry;\n    } else { /* upvalues */\n        idx = LUA_REGISTRYINDEX - idx;\n        api_check(L, idx <= lfunc.MAXUPVAL + 1, \"upvalue index too large\");\n        if (ci.func.ttislcf()) /* light C function? */\n            return lobject.luaO_nilobject; /* it has no upvalues */\n        else {\n            return idx <= ci.func.value.nupvalues ? ci.func.value.upvalue[idx - 1] : lobject.luaO_nilobject;\n        }\n    }\n};\n\n// Like index2addr but returns the index on stack; doesn't allow pseudo indices\nconst index2addr_ = function(L, idx) {\n    let ci = L.ci;\n    if (idx > 0) {\n        let o = ci.funcOff + idx;\n        api_check(L, idx <= ci.top - (ci.funcOff + 1), \"unacceptable index\");\n        if (o >= L.top) return null;\n        else return o;\n    } else if (idx > LUA_REGISTRYINDEX) {\n        api_check(L, idx !== 0 && -idx <= L.top, \"invalid index\");\n        return L.top + idx;\n    } else { /* registry or upvalue */\n        throw Error(\"attempt to use pseudo-index\");\n    }\n};\n\nconst lua_checkstack = function(L, n) {\n    let res;\n    let ci = L.ci;\n    api_check(L, n >= 0, \"negative 'n'\");\n    if (L.stack_last - L.top > n) /* stack large enough? */\n        res = true;\n    else { /* no; need to grow stack */\n        let inuse = L.top + lstate.EXTRA_STACK;\n        if (inuse > LUAI_MAXSTACK - n)  /* can grow without overflow? */\n            res = false;  /* no */\n        else { /* try to grow stack */\n            ldo.luaD_growstack(L, n);\n            res = true;\n        }\n    }\n\n    if (res && ci.top < L.top + n)\n        ci.top = L.top + n;  /* adjust frame top */\n\n    return res;\n};\n\nconst lua_xmove = function(from, to, n) {\n    if (from === to) return;\n    api_checknelems(from, n);\n    api_check(from, from.l_G === to.l_G, \"moving among independent states\");\n    api_check(from, to.ci.top - to.top >= n, \"stack overflow\");\n    from.top -= n;\n    for (let i = 0; i < n; i++) {\n        to.stack[to.top] = new lobject.TValue();\n        lobject.setobj2s(to, to.top, from.stack[from.top + i]);\n        delete from.stack[from.top + i];\n        to.top++;\n    }\n};\n\n/*\n** basic stack manipulation\n*/\n\n/*\n** convert an acceptable stack index into an absolute index\n*/\nconst lua_absindex = function(L, idx) {\n    return (idx > 0 || idx <= LUA_REGISTRYINDEX)\n        ? idx\n        : (L.top - L.ci.funcOff) + idx;\n};\n\nconst lua_gettop = function(L) {\n    return L.top - (L.ci.funcOff + 1);\n};\n\nconst lua_pushvalue = function(L, idx) {\n    lobject.pushobj2s(L, index2addr(L, idx));\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n};\n\nconst lua_settop = function(L, idx) {\n    let func = L.ci.funcOff;\n    let newtop;\n    if (idx >= 0) {\n        api_check(L, idx <= L.stack_last - (func + 1), \"new top too large\");\n        newtop = func + 1 + idx;\n    } else {\n        api_check(L, -(idx + 1) <= L.top - (func + 1), \"invalid new top\");\n        newtop = L.top + idx + 1; /* 'subtract' index (index is negative) */\n    }\n    ldo.adjust_top(L, newtop);\n};\n\nconst lua_pop = function(L, n) {\n    lua_settop(L, -n - 1);\n};\n\nconst reverse = function(L, from, to) {\n    for (; from < to; from++, to--) {\n        let fromtv = L.stack[from];\n        let temp = new TValue(fromtv.type, fromtv.value);\n        lobject.setobjs2s(L, from, to);\n        lobject.setobj2s(L, to, temp);\n    }\n};\n\n/*\n** Let x = AB, where A is a prefix of length 'n'. Then,\n** rotate x n === BA. But BA === (A^r . B^r)^r.\n*/\nconst lua_rotate = function(L, idx, n) {\n    let t = L.top - 1;\n    let pIdx = index2addr_(L, idx);\n    let p = L.stack[pIdx];\n    api_check(L, isvalid(p) && idx > LUA_REGISTRYINDEX, \"index not in the stack\");\n    api_check(L, (n >= 0 ? n : -n) <= (t - pIdx + 1), \"invalid 'n'\");\n    let m = n >= 0 ? t - n : pIdx - n - 1;  /* end of prefix */\n    reverse(L, pIdx, m);\n    reverse(L, m + 1, L.top - 1);\n    reverse(L, pIdx, L.top - 1);\n};\n\nconst lua_copy = function(L, fromidx, toidx) {\n    let from = index2addr(L, fromidx);\n    index2addr(L, toidx).setfrom(from);\n};\n\nconst lua_remove = function(L, idx) {\n    lua_rotate(L, idx, -1);\n    lua_pop(L, 1);\n};\n\nconst lua_insert = function(L, idx) {\n    lua_rotate(L, idx, 1);\n};\n\nconst lua_replace = function(L, idx) {\n    lua_copy(L, -1, idx);\n    lua_pop(L, 1);\n};\n\n/*\n** push functions (JS -> stack)\n*/\n\nconst lua_pushnil = function(L) {\n    L.stack[L.top] = new TValue(LUA_TNIL, null);\n    api_incr_top(L);\n};\n\nconst lua_pushnumber = function(L, n) {\n    fengari_argcheck(typeof n === \"number\");\n    L.stack[L.top] = new TValue(LUA_TNUMFLT, n);\n    api_incr_top(L);\n};\n\nconst lua_pushinteger = function(L, n) {\n    fengari_argcheckinteger(n);\n    L.stack[L.top] = new TValue(LUA_TNUMINT, n);\n    api_incr_top(L);\n};\n\nconst lua_pushlstring = function(L, s, len) {\n    fengari_argcheckinteger(len);\n    let ts;\n    if (len === 0) {\n        s = to_luastring(\"\", true);\n        ts = luaS_bless(L, s);\n    } else {\n        s = from_userstring(s);\n        api_check(L, s.length >= len, \"invalid length to lua_pushlstring\");\n        ts = luaS_new(L, s.subarray(0, len));\n    }\n    lobject.pushsvalue2s(L, ts);\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    return ts.value;\n};\n\nconst lua_pushstring = function (L, s) {\n    if (s === undefined || s === null) {\n        L.stack[L.top] = new TValue(LUA_TNIL, null);\n        L.top++;\n    } else {\n        let ts = luaS_new(L, from_userstring(s));\n        lobject.pushsvalue2s(L, ts);\n        s = ts.getstr(); /* internal copy */\n    }\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    return s;\n};\n\nconst lua_pushvfstring = function (L, fmt, argp) {\n    fmt = from_userstring(fmt);\n    return lobject.luaO_pushvfstring(L, fmt, argp);\n};\n\nconst lua_pushfstring = function (L, fmt, ...argp) {\n    fmt = from_userstring(fmt);\n    return lobject.luaO_pushvfstring(L, fmt, argp);\n};\n\n/* Similar to lua_pushstring, but takes a JS string */\nconst lua_pushliteral = function (L, s) {\n    if (s === undefined || s === null) {\n        L.stack[L.top] = new TValue(LUA_TNIL, null);\n        L.top++;\n    } else {\n        fengari_argcheck(typeof s === \"string\");\n        let ts = luaS_newliteral(L, s);\n        lobject.pushsvalue2s(L, ts);\n        s = ts.getstr(); /* internal copy */\n    }\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n\n    return s;\n};\n\nconst lua_pushcclosure = function(L, fn, n) {\n    fengari_argcheck(typeof fn === \"function\");\n    fengari_argcheckinteger(n);\n    if (n === 0)\n        L.stack[L.top] = new TValue(LUA_TLCF, fn);\n    else {\n        api_checknelems(L, n);\n        api_check(L, n <= lfunc.MAXUPVAL, \"upvalue index too large\");\n        let cl = new CClosure(L, fn, n);\n        for (let i=0; i<n; i++)\n            cl.upvalue[i].setfrom(L.stack[L.top - n + i]);\n        for (let i=1; i<n; i++)\n            delete L.stack[--L.top];\n        if (n>0)\n            --L.top;\n        L.stack[L.top].setclCvalue(cl);\n    }\n    api_incr_top(L);\n};\n\nconst lua_pushjsclosure = lua_pushcclosure;\n\nconst lua_pushcfunction = function(L, fn) {\n    lua_pushcclosure(L, fn, 0);\n};\n\nconst lua_pushjsfunction = lua_pushcfunction;\n\nconst lua_pushboolean = function(L, b) {\n    L.stack[L.top] = new TValue(LUA_TBOOLEAN, !!b);\n    api_incr_top(L);\n};\n\nconst lua_pushlightuserdata = function(L, p) {\n    L.stack[L.top] = new TValue(LUA_TLIGHTUSERDATA, p);\n    api_incr_top(L);\n};\n\nconst lua_pushthread = function(L) {\n    L.stack[L.top] = new TValue(LUA_TTHREAD, L);\n    api_incr_top(L);\n    return L.l_G.mainthread === L;\n};\n\nconst lua_pushglobaltable = function(L) {\n    lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);\n};\n\n/*\n** set functions (stack -> Lua)\n*/\n\n/*\n** t[k] = value at the top of the stack (where 'k' is a string)\n*/\nconst auxsetstr = function(L, t, k) {\n    let str = luaS_new(L, from_userstring(k));\n    api_checknelems(L, 1);\n    lobject.pushsvalue2s(L, str); /* push 'str' (to make it a TValue) */\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    lvm.settable(L, t, L.stack[L.top - 1], L.stack[L.top - 2]);\n    /* pop value and key */\n    delete L.stack[--L.top];\n    delete L.stack[--L.top];\n};\n\nconst lua_setglobal = function(L, name) {\n    auxsetstr(L, ltable.luaH_getint(L.l_G.l_registry.value, LUA_RIDX_GLOBALS), name);\n};\n\nconst lua_setmetatable = function(L, objindex) {\n    api_checknelems(L, 1);\n    let mt;\n    let obj = index2addr(L, objindex);\n    if (L.stack[L.top - 1].ttisnil())\n        mt = null;\n    else {\n        api_check(L, L.stack[L.top - 1].ttistable(), \"table expected\");\n        mt = L.stack[L.top - 1].value;\n    }\n\n    switch (obj.ttnov()) {\n        case LUA_TUSERDATA:\n        case LUA_TTABLE: {\n            obj.value.metatable = mt;\n            break;\n        }\n        default: {\n            L.l_G.mt[obj.ttnov()] = mt;\n            break;\n        }\n    }\n\n    delete L.stack[--L.top];\n    return true;\n};\n\nconst lua_settable = function(L, idx) {\n    api_checknelems(L, 2);\n    let t = index2addr(L, idx);\n    lvm.settable(L, t, L.stack[L.top - 2], L.stack[L.top - 1]);\n    delete L.stack[--L.top];\n    delete L.stack[--L.top];\n};\n\nconst lua_setfield = function(L, idx, k) {\n    auxsetstr(L, index2addr(L, idx), k);\n};\n\nconst lua_seti = function(L, idx, n) {\n    fengari_argcheckinteger(n);\n    api_checknelems(L, 1);\n    let t = index2addr(L, idx);\n    L.stack[L.top] = new TValue(LUA_TNUMINT, n);\n    api_incr_top(L);\n    lvm.settable(L, t, L.stack[L.top - 1], L.stack[L.top - 2]);\n    /* pop value and key */\n    delete L.stack[--L.top];\n    delete L.stack[--L.top];\n};\n\nconst lua_rawset = function(L, idx) {\n    api_checknelems(L, 2);\n    let o = index2addr(L, idx);\n    api_check(L, o.ttistable(), \"table expected\");\n    let k = L.stack[L.top - 2];\n    let v = L.stack[L.top - 1];\n    if (v.ttisnil()) {\n        ltable.luaH_delete(L, o.value, k);\n    } else {\n        let slot = ltable.luaH_set(L, o.value, k);\n        slot.setfrom(v);\n    }\n    ltable.invalidateTMcache(o.value);\n    delete L.stack[--L.top];\n    delete L.stack[--L.top];\n};\n\nconst lua_rawseti = function(L, idx, n) {\n    fengari_argcheckinteger(n);\n    api_checknelems(L, 1);\n    let o = index2addr(L, idx);\n    api_check(L, o.ttistable(), \"table expected\");\n    ltable.luaH_setint(o.value, n, L.stack[L.top - 1]);\n    delete L.stack[--L.top];\n};\n\nconst lua_rawsetp = function(L, idx, p) {\n    api_checknelems(L, 1);\n    let o = index2addr(L, idx);\n    api_check(L, o.ttistable(), \"table expected\");\n    let k = new TValue(LUA_TLIGHTUSERDATA, p);\n    let v = L.stack[L.top - 1];\n    if (v.ttisnil()) {\n        ltable.luaH_delete(L, o.value, k);\n    } else {\n        let slot = ltable.luaH_set(L, o.value, k);\n        slot.setfrom(v);\n    }\n    delete L.stack[--L.top];\n};\n\n/*\n** get functions (Lua -> stack)\n*/\n\nconst auxgetstr = function(L, t, k) {\n    let str = luaS_new(L, from_userstring(k));\n    lobject.pushsvalue2s(L, str);\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    lvm.luaV_gettable(L, t, L.stack[L.top - 1], L.top - 1);\n    return L.stack[L.top - 1].ttnov();\n};\n\nconst lua_rawgeti = function(L, idx, n) {\n    let t = index2addr(L, idx);\n    fengari_argcheckinteger(n);\n    api_check(L, t.ttistable(), \"table expected\");\n    lobject.pushobj2s(L, ltable.luaH_getint(t.value, n));\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    return L.stack[L.top - 1].ttnov();\n};\n\nconst lua_rawgetp = function(L, idx, p) {\n    let t = index2addr(L, idx);\n    api_check(L, t.ttistable(), \"table expected\");\n    let k = new TValue(LUA_TLIGHTUSERDATA, p);\n    lobject.pushobj2s(L, ltable.luaH_get(L, t.value, k));\n    api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    return L.stack[L.top - 1].ttnov();\n};\n\nconst lua_rawget = function(L, idx) {\n    let t = index2addr(L, idx);\n    api_check(L, t.ttistable(t), \"table expected\");\n    lobject.setobj2s(L, L.top - 1, ltable.luaH_get(L, t.value, L.stack[L.top - 1]));\n    return L.stack[L.top - 1].ttnov();\n};\n\n// narray and nrec are mostly useless for this implementation\nconst lua_createtable = function(L, narray, nrec) {\n    let t = new lobject.TValue(LUA_TTABLE, ltable.luaH_new(L));\n    L.stack[L.top] = t;\n    api_incr_top(L);\n};\n\nconst luaS_newudata = function(L, size) {\n    return new lobject.Udata(L, size);\n};\n\nconst lua_newuserdata = function(L, size) {\n    let u = luaS_newudata(L, size);\n    L.stack[L.top] = new lobject.TValue(LUA_TUSERDATA, u);\n    api_incr_top(L);\n    return u.data;\n};\n\nconst aux_upvalue = function(L, fi, n) {\n    fengari_argcheckinteger(n);\n    switch(fi.ttype()) {\n        case LUA_TCCL: {  /* C closure */\n            let f = fi.value;\n            if (!(1 <= n && n <= f.nupvalues)) return null;\n            return {\n                name: to_luastring(\"\", true),\n                val: f.upvalue[n-1]\n            };\n        }\n        case LUA_TLCL: {  /* Lua closure */\n            let f = fi.value;\n            let p = f.p;\n            if (!(1 <= n && n <= p.upvalues.length)) return null;\n            let name = p.upvalues[n-1].name;\n            return {\n                name: name ? name.getstr() : to_luastring(\"(*no name)\", true),\n                val: f.upvals[n-1]\n            };\n        }\n        default: return null;  /* not a closure */\n    }\n};\n\nconst lua_getupvalue = function(L, funcindex, n) {\n    let up = aux_upvalue(L, index2addr(L, funcindex), n);\n    if (up) {\n        let name = up.name;\n        let val = up.val;\n        lobject.pushobj2s(L, val);\n        api_check(L, L.top <= L.ci.top, \"stack overflow\");\n        return name;\n    }\n    return null;\n};\n\nconst lua_setupvalue = function(L, funcindex, n) {\n    let fi = index2addr(L, funcindex);\n    api_checknelems(L, 1);\n    let aux = aux_upvalue(L, fi, n);\n    if (aux) {\n        let name = aux.name;\n        let val = aux.val;\n        val.setfrom(L.stack[L.top-1]);\n        delete L.stack[--L.top];\n        return name;\n    }\n    return null;\n};\n\nconst lua_newtable = function(L) {\n    lua_createtable(L, 0, 0);\n};\n\nconst lua_register = function(L, n, f) {\n    lua_pushcfunction(L, f);\n    lua_setglobal(L, n);\n};\n\nconst lua_getmetatable = function(L, objindex) {\n    let obj = index2addr(L, objindex);\n    let mt;\n    let res = false;\n    switch (obj.ttnov()) {\n        case LUA_TTABLE:\n        case LUA_TUSERDATA:\n            mt = obj.value.metatable;\n            break;\n        default:\n            mt = L.l_G.mt[obj.ttnov()];\n            break;\n    }\n\n    if (mt !== null && mt !== undefined) {\n        L.stack[L.top] = new TValue(LUA_TTABLE, mt);\n        api_incr_top(L);\n        res = true;\n    }\n\n    return res;\n};\n\nconst lua_getuservalue = function(L, idx) {\n    let o = index2addr(L, idx);\n    api_check(L, o.ttisfulluserdata(), \"full userdata expected\");\n    let uv = o.value.uservalue;\n    L.stack[L.top] = new TValue(uv.type, uv.value);\n    api_incr_top(L);\n    return L.stack[L.top - 1].ttnov();\n};\n\nconst lua_gettable = function(L, idx) {\n    let t = index2addr(L, idx);\n    lvm.luaV_gettable(L, t, L.stack[L.top - 1], L.top - 1);\n    return L.stack[L.top - 1].ttnov();\n};\n\nconst lua_getfield = function(L, idx, k) {\n    return auxgetstr(L, index2addr(L, idx), k);\n};\n\nconst lua_geti = function(L, idx, n) {\n    let t = index2addr(L, idx);\n    fengari_argcheckinteger(n);\n    L.stack[L.top] = new TValue(LUA_TNUMINT, n);\n    api_incr_top(L);\n    lvm.luaV_gettable(L, t, L.stack[L.top - 1], L.top - 1);\n    return L.stack[L.top - 1].ttnov();\n};\n\nconst lua_getglobal = function(L, name) {\n    return auxgetstr(L, ltable.luaH_getint(L.l_G.l_registry.value, LUA_RIDX_GLOBALS), name);\n};\n\n/*\n** access functions (stack -> JS)\n*/\n\nconst lua_toboolean = function(L, idx) {\n    let o = index2addr(L, idx);\n    return !o.l_isfalse();\n};\n\nconst lua_tolstring = function(L, idx) {\n    let o = index2addr(L, idx);\n\n    if (!o.ttisstring()) {\n        if (!lvm.cvt2str(o)) {  /* not convertible? */\n            return null;\n        }\n        lobject.luaO_tostring(L, o);\n    }\n    return o.svalue();\n};\n\nconst lua_tostring =  lua_tolstring;\n\nconst lua_tojsstring = function(L, idx) {\n    let o = index2addr(L, idx);\n\n    if (!o.ttisstring()) {\n        if (!lvm.cvt2str(o)) {  /* not convertible? */\n            return null;\n        }\n        lobject.luaO_tostring(L, o);\n    }\n    return o.jsstring();\n};\n\nconst lua_todataview = function(L, idx) {\n    let u8 = lua_tolstring(L, idx);\n    return new DataView(u8.buffer, u8.byteOffset, u8.byteLength);\n};\n\nconst lua_rawlen = function(L, idx) {\n    let o = index2addr(L, idx);\n    switch (o.ttype()) {\n        case LUA_TSHRSTR:\n        case LUA_TLNGSTR:\n            return o.vslen();\n        case LUA_TUSERDATA:\n            return o.value.len;\n        case LUA_TTABLE:\n            return ltable.luaH_getn(o.value);\n        default:\n            return 0;\n    }\n};\n\nconst lua_tocfunction = function(L, idx) {\n    let o = index2addr(L, idx);\n    if (o.ttislcf() || o.ttisCclosure()) return o.value;\n    else return null;  /* not a C function */\n};\n\nconst lua_tointeger = function(L, idx) {\n    let n = lua_tointegerx(L, idx);\n    return n === false ? 0 : n;\n};\n\nconst lua_tointegerx = function(L, idx) {\n    return lvm.tointeger(index2addr(L, idx));\n};\n\nconst lua_tonumber = function(L, idx) {\n    let n = lua_tonumberx(L, idx);\n    return n === false ? 0 : n;\n};\n\nconst lua_tonumberx = function(L, idx) {\n    return lvm.tonumber(index2addr(L, idx));\n};\n\nconst lua_touserdata = function(L, idx) {\n    let o = index2addr(L, idx);\n    switch (o.ttnov()) {\n        case LUA_TUSERDATA:\n            return o.value.data;\n        case LUA_TLIGHTUSERDATA:\n            return o.value;\n        default: return null;\n    }\n};\n\nconst lua_tothread = function(L, idx) {\n    let o = index2addr(L, idx);\n    return o.ttisthread() ? o.value : null;\n};\n\nconst lua_topointer = function(L, idx) {\n    let o = index2addr(L, idx);\n    switch (o.ttype()) {\n        case LUA_TTABLE:\n        case LUA_TLCL:\n        case LUA_TCCL:\n        case LUA_TLCF:\n        case LUA_TTHREAD:\n        case LUA_TUSERDATA: /* note: this differs in behaviour to reference lua implementation */\n        case LUA_TLIGHTUSERDATA:\n            return o.value;\n        default:\n            return null;\n    }\n};\n\n\n/* A proxy is a function that the same lua value to the given lua state. */\n\n/* Having a weakmap of created proxies was only way I could think of to provide an 'isproxy' function */\nconst seen = new WeakMap();\n\n/* is the passed object a proxy? is it from the given state? (if passed) */\nconst lua_isproxy = function(p, L) {\n    let G = seen.get(p);\n    if (!G)\n        return false;\n    return (L === null) || (L.l_G === G);\n};\n\n/* Use 'create_proxy' helper function so that 'L' is not in scope */\nconst create_proxy = function(G, type, value) {\n    let proxy = function(L) {\n        api_check(L, L instanceof lstate.lua_State && G === L.l_G, \"must be from same global state\");\n        L.stack[L.top] = new TValue(type, value);\n        api_incr_top(L);\n    };\n    seen.set(proxy, G);\n    return proxy;\n};\n\nconst lua_toproxy = function(L, idx) {\n    let tv = index2addr(L, idx);\n    /* pass broken down tv incase it is an upvalue index */\n    return create_proxy(L.l_G, tv.type, tv.value);\n};\n\n\nconst lua_compare = function(L, index1, index2, op) {\n    let o1 = index2addr(L, index1);\n    let o2 = index2addr(L, index2);\n\n    let i = 0;\n\n    if (isvalid(o1) && isvalid(o2)) {\n        switch (op) {\n            case LUA_OPEQ: i = lvm.luaV_equalobj(L, o1, o2); break;\n            case LUA_OPLT: i = lvm.luaV_lessthan(L, o1, o2); break;\n            case LUA_OPLE: i = lvm.luaV_lessequal(L, o1, o2); break;\n            default: api_check(L, false, \"invalid option\");\n        }\n    }\n\n    return i;\n};\n\nconst lua_stringtonumber = function(L, s) {\n    let tv = new TValue();\n    let sz = lobject.luaO_str2num(s, tv);\n    if (sz !== 0) {\n        L.stack[L.top] = tv;\n        api_incr_top(L);\n    }\n    return sz;\n};\n\nconst f_call = function(L, ud) {\n    ldo.luaD_callnoyield(L, ud.funcOff, ud.nresults);\n};\n\nconst lua_type = function(L, idx) {\n    let o = index2addr(L, idx);\n    return isvalid(o) ?  o.ttnov() : LUA_TNONE;\n};\n\nconst lua_typename = function(L, t) {\n    api_check(L, LUA_TNONE <= t && t < LUA_NUMTAGS, \"invalid tag\");\n    return ltm.ttypename(t);\n};\n\nconst lua_iscfunction = function(L, idx) {\n    let o = index2addr(L, idx);\n    return o.ttislcf(o) || o.ttisCclosure();\n};\n\nconst lua_isnil = function(L, n) {\n    return lua_type(L, n) === LUA_TNIL;\n};\n\nconst lua_isboolean = function(L, n) {\n    return lua_type(L, n) === LUA_TBOOLEAN;\n};\n\nconst lua_isnone = function(L, n) {\n    return lua_type(L, n) === LUA_TNONE;\n};\n\nconst lua_isnoneornil = function(L, n) {\n    return lua_type(L, n) <= 0;\n};\n\nconst lua_istable = function(L, idx) {\n    return index2addr(L, idx).ttistable();\n};\n\nconst lua_isinteger = function(L, idx) {\n    return index2addr(L, idx).ttisinteger();\n};\n\nconst lua_isnumber = function(L, idx) {\n    return lvm.tonumber(index2addr(L, idx)) !== false;\n};\n\nconst lua_isstring = function(L, idx) {\n    let o = index2addr(L, idx);\n    return o.ttisstring() || lvm.cvt2str(o);\n};\n\nconst lua_isuserdata = function(L, idx) {\n    let o = index2addr(L, idx);\n    return o.ttisfulluserdata(o) || o.ttislightuserdata();\n};\n\nconst lua_isthread = function(L, idx) {\n    return lua_type(L, idx) === LUA_TTHREAD;\n};\n\nconst lua_isfunction = function(L, idx) {\n    return lua_type(L, idx) === LUA_TFUNCTION;\n};\n\nconst lua_islightuserdata = function(L, idx) {\n    return lua_type(L, idx) === LUA_TLIGHTUSERDATA;\n};\n\nconst lua_rawequal = function(L, index1, index2) {\n    let o1 = index2addr(L, index1);\n    let o2 = index2addr(L, index2);\n    return isvalid(o1) && isvalid(o2) ? lvm.luaV_equalobj(null, o1, o2) : 0;\n};\n\nconst lua_arith = function(L, op) {\n    if (op !== LUA_OPUNM && op !== LUA_OPBNOT)\n        api_checknelems(L, 2);  /* all other operations expect two operands */\n    else {  /* for unary operations, add fake 2nd operand */\n        api_checknelems(L, 1);\n        lobject.pushobj2s(L, L.stack[L.top-1]);\n        api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    }\n    /* first operand at top - 2, second at top - 1; result go to top - 2 */\n    lobject.luaO_arith(L, op, L.stack[L.top - 2], L.stack[L.top - 1], L.stack[L.top - 2]);\n    delete L.stack[--L.top];  /* remove second operand */\n};\n\n/*\n** 'load' and 'call' functions (run Lua code)\n*/\n\nconst default_chunkname = to_luastring(\"?\");\nconst lua_load = function(L, reader, data, chunkname, mode) {\n    if (!chunkname) chunkname = default_chunkname;\n    else chunkname = from_userstring(chunkname);\n    if (mode !== null) mode = from_userstring(mode);\n    let z = new ZIO(L, reader, data);\n    let status = ldo.luaD_protectedparser(L, z, chunkname, mode);\n    if (status === LUA_OK) {  /* no errors? */\n        let f = L.stack[L.top - 1].value; /* get newly created function */\n        if (f.nupvalues >= 1) {  /* does it have an upvalue? */\n            /* get global table from registry */\n            let gt = ltable.luaH_getint(L.l_G.l_registry.value, LUA_RIDX_GLOBALS);\n            /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */\n            f.upvals[0].setfrom(gt);\n        }\n    }\n    return status;\n};\n\nconst lua_dump = function(L, writer, data, strip) {\n    api_checknelems(L, 1);\n    let o = L.stack[L.top -1];\n    if (o.ttisLclosure())\n        return luaU_dump(L, o.value.p, writer, data, strip);\n    return 1;\n};\n\nconst lua_status = function(L) {\n    return L.status;\n};\n\nconst lua_setuservalue = function(L, idx) {\n    api_checknelems(L, 1);\n    let o = index2addr(L, idx);\n    api_check(L, o.ttisfulluserdata(), \"full userdata expected\");\n    o.value.uservalue.setfrom(L.stack[L.top - 1]);\n    delete L.stack[--L.top];\n};\n\nconst checkresults = function(L,na,nr) {\n    api_check(L, nr === LUA_MULTRET || (L.ci.top - L.top >= (nr) - (na)),\n        \"results from function overflow current stack size\");\n};\n\nconst lua_callk = function(L, nargs, nresults, ctx, k) {\n    api_check(L, k === null || !(L.ci.callstatus & lstate.CIST_LUA), \"cannot use continuations inside hooks\");\n    api_checknelems(L, nargs + 1);\n    api_check(L, L.status === LUA_OK, \"cannot do calls on non-normal thread\");\n    checkresults(L, nargs, nresults);\n    let func = L.top - (nargs + 1);\n    if (k !== null && L.nny === 0) { /* need to prepare continuation? */\n        L.ci.c_k = k;\n        L.ci.c_ctx = ctx;\n        ldo.luaD_call(L, func, nresults);\n    } else { /* no continuation or no yieldable */\n        ldo.luaD_callnoyield(L, func, nresults);\n    }\n\n    if (nresults === LUA_MULTRET && L.ci.top < L.top)\n        L.ci.top = L.top;\n};\n\nconst lua_call = function(L, n, r) {\n    lua_callk(L, n, r, 0, null);\n};\n\nconst lua_pcallk = function(L, nargs, nresults, errfunc, ctx, k) {\n    api_check(L, k === null || !(L.ci.callstatus & lstate.CIST_LUA), \"cannot use continuations inside hooks\");\n    api_checknelems(L, nargs + 1);\n    api_check(L, L.status === LUA_OK, \"cannot do calls on non-normal thread\");\n    checkresults(L, nargs, nresults);\n    let status;\n    let func;\n    if (errfunc === 0)\n        func = 0;\n    else {\n        func = index2addr_(L, errfunc);\n    }\n    let funcOff = L.top - (nargs + 1); /* function to be called */\n    if (k === null || L.nny > 0) { /* no continuation or no yieldable? */\n        let c = {\n            funcOff: funcOff,\n            nresults: nresults /* do a 'conventional' protected call */\n        };\n        status = ldo.luaD_pcall(L, f_call, c, funcOff, func);\n    } else { /* prepare continuation (call is already protected by 'resume') */\n        let ci = L.ci;\n        ci.c_k = k;  /* prepare continuation (call is already protected by 'resume') */\n        ci.c_ctx = ctx;  /* prepare continuation (call is already protected by 'resume') */\n        /* save information for error recovery */\n        ci.extra = funcOff;\n        ci.c_old_errfunc = L.errfunc;\n        L.errfunc = func;\n        ci.callstatus &= ~lstate.CIST_OAH | L.allowhook;\n        ci.callstatus |= lstate.CIST_YPCALL;  /* function can do error recovery */\n        ldo.luaD_call(L, funcOff, nresults);  /* do the call */\n        ci.callstatus &= ~lstate.CIST_YPCALL;\n        L.errfunc = ci.c_old_errfunc;\n        status = LUA_OK;\n    }\n\n    if (nresults === LUA_MULTRET && L.ci.top < L.top)\n        L.ci.top = L.top;\n\n    return status;\n};\n\nconst lua_pcall = function(L, n, r, f) {\n    return lua_pcallk(L, n, r, f, 0, null);\n};\n\n/*\n** miscellaneous functions\n*/\n\nconst lua_error = function(L) {\n    api_checknelems(L, 1);\n    ldebug.luaG_errormsg(L);\n};\n\nconst lua_next = function(L, idx) {\n    let t = index2addr(L, idx);\n    api_check(L, t.ttistable(), \"table expected\");\n    L.stack[L.top] = new TValue();\n    let more = ltable.luaH_next(L, t.value, L.top - 1);\n    if (more) {\n        api_incr_top(L);\n        return 1;\n    } else {\n        delete L.stack[L.top];\n        delete L.stack[--L.top];\n        return 0;\n    }\n};\n\nconst lua_concat = function(L, n) {\n    api_checknelems(L, n);\n    if (n >= 2)\n        lvm.luaV_concat(L, n);\n    else if (n === 0) {\n        lobject.pushsvalue2s(L, luaS_bless(L, to_luastring(\"\", true)));\n        api_check(L, L.top <= L.ci.top, \"stack overflow\");\n    }\n};\n\nconst lua_len = function(L, idx) {\n    let t = index2addr(L, idx);\n    let tv = new TValue();\n    lvm.luaV_objlen(L, tv, t);\n    L.stack[L.top] = tv;\n    api_incr_top(L);\n};\n\nconst getupvalref = function(L, fidx, n) {\n    let fi = index2addr(L, fidx);\n    api_check(L, fi.ttisLclosure(), \"Lua function expected\");\n    let f = fi.value;\n    fengari_argcheckinteger(n);\n    api_check(L, 1 <= n && n <= f.p.upvalues.length, \"invalid upvalue index\");\n    return {\n        f: f,\n        i: n - 1\n    };\n};\n\nconst lua_upvalueid = function(L, fidx, n) {\n    let fi = index2addr(L, fidx);\n    switch (fi.ttype()) {\n        case LUA_TLCL: {  /* lua closure */\n            let ref = getupvalref(L, fidx, n);\n            return ref.f.upvals[ref.i];\n        }\n        case LUA_TCCL: {  /* C closure */\n            let f = fi.value;\n            api_check(L, n|0 === n && 1 <= n && n <= f.nupvalues, \"invalid upvalue index\");\n            return f.upvalue[n - 1];\n        }\n        default: {\n            api_check(L, false, \"closure expected\");\n            return null;\n        }\n    }\n};\n\nconst lua_upvaluejoin = function(L, fidx1, n1, fidx2, n2) {\n    let ref1 = getupvalref(L, fidx1, n1);\n    let ref2 = getupvalref(L, fidx2, n2);\n    let up2 = ref2.f.upvals[ref2.i];\n    ref1.f.upvals[ref1.i] = up2;\n};\n\n// This functions are only there for compatibility purposes\nconst lua_gc = function () {};\n\nconst lua_getallocf = function () {\n    console.warn(\"lua_getallocf is not available\");\n    return 0;\n};\n\nconst lua_setallocf = function () {\n    console.warn(\"lua_setallocf is not available\");\n    return 0;\n};\n\nconst lua_getextraspace = function () {\n    console.warn(\"lua_getextraspace is not available\");\n    return 0;\n};\n\nmodule.exports.api_incr_top          = api_incr_top;\nmodule.exports.api_checknelems       = api_checknelems;\nmodule.exports.lua_absindex          = lua_absindex;\nmodule.exports.lua_arith             = lua_arith;\nmodule.exports.lua_atpanic           = lua_atpanic;\nmodule.exports.lua_atnativeerror     = lua_atnativeerror;\nmodule.exports.lua_call              = lua_call;\nmodule.exports.lua_callk             = lua_callk;\nmodule.exports.lua_checkstack        = lua_checkstack;\nmodule.exports.lua_compare           = lua_compare;\nmodule.exports.lua_concat            = lua_concat;\nmodule.exports.lua_copy              = lua_copy;\nmodule.exports.lua_createtable       = lua_createtable;\nmodule.exports.lua_dump              = lua_dump;\nmodule.exports.lua_error             = lua_error;\nmodule.exports.lua_gc                = lua_gc;\nmodule.exports.lua_getallocf         = lua_getallocf;\nmodule.exports.lua_getextraspace     = lua_getextraspace;\nmodule.exports.lua_getfield          = lua_getfield;\nmodule.exports.lua_getglobal         = lua_getglobal;\nmodule.exports.lua_geti              = lua_geti;\nmodule.exports.lua_getmetatable      = lua_getmetatable;\nmodule.exports.lua_gettable          = lua_gettable;\nmodule.exports.lua_gettop            = lua_gettop;\nmodule.exports.lua_getupvalue        = lua_getupvalue;\nmodule.exports.lua_getuservalue      = lua_getuservalue;\nmodule.exports.lua_insert            = lua_insert;\nmodule.exports.lua_isboolean         = lua_isboolean;\nmodule.exports.lua_iscfunction       = lua_iscfunction;\nmodule.exports.lua_isfunction        = lua_isfunction;\nmodule.exports.lua_isinteger         = lua_isinteger;\nmodule.exports.lua_islightuserdata   = lua_islightuserdata;\nmodule.exports.lua_isnil             = lua_isnil;\nmodule.exports.lua_isnone            = lua_isnone;\nmodule.exports.lua_isnoneornil       = lua_isnoneornil;\nmodule.exports.lua_isnumber          = lua_isnumber;\nmodule.exports.lua_isproxy           = lua_isproxy;\nmodule.exports.lua_isstring          = lua_isstring;\nmodule.exports.lua_istable           = lua_istable;\nmodule.exports.lua_isthread          = lua_isthread;\nmodule.exports.lua_isuserdata        = lua_isuserdata;\nmodule.exports.lua_len               = lua_len;\nmodule.exports.lua_load              = lua_load;\nmodule.exports.lua_newtable          = lua_newtable;\nmodule.exports.lua_newuserdata       = lua_newuserdata;\nmodule.exports.lua_next              = lua_next;\nmodule.exports.lua_pcall             = lua_pcall;\nmodule.exports.lua_pcallk            = lua_pcallk;\nmodule.exports.lua_pop               = lua_pop;\nmodule.exports.lua_pushboolean       = lua_pushboolean;\nmodule.exports.lua_pushcclosure      = lua_pushcclosure;\nmodule.exports.lua_pushcfunction     = lua_pushcfunction;\nmodule.exports.lua_pushfstring       = lua_pushfstring;\nmodule.exports.lua_pushglobaltable   = lua_pushglobaltable;\nmodule.exports.lua_pushinteger       = lua_pushinteger;\nmodule.exports.lua_pushjsclosure     = lua_pushjsclosure;\nmodule.exports.lua_pushjsfunction    = lua_pushjsfunction;\nmodule.exports.lua_pushlightuserdata = lua_pushlightuserdata;\nmodule.exports.lua_pushliteral       = lua_pushliteral;\nmodule.exports.lua_pushlstring       = lua_pushlstring;\nmodule.exports.lua_pushnil           = lua_pushnil;\nmodule.exports.lua_pushnumber        = lua_pushnumber;\nmodule.exports.lua_pushstring        = lua_pushstring;\nmodule.exports.lua_pushthread        = lua_pushthread;\nmodule.exports.lua_pushvalue         = lua_pushvalue;\nmodule.exports.lua_pushvfstring      = lua_pushvfstring;\nmodule.exports.lua_rawequal          = lua_rawequal;\nmodule.exports.lua_rawget            = lua_rawget;\nmodule.exports.lua_rawgeti           = lua_rawgeti;\nmodule.exports.lua_rawgetp           = lua_rawgetp;\nmodule.exports.lua_rawlen            = lua_rawlen;\nmodule.exports.lua_rawset            = lua_rawset;\nmodule.exports.lua_rawseti           = lua_rawseti;\nmodule.exports.lua_rawsetp           = lua_rawsetp;\nmodule.exports.lua_register          = lua_register;\nmodule.exports.lua_remove            = lua_remove;\nmodule.exports.lua_replace           = lua_replace;\nmodule.exports.lua_rotate            = lua_rotate;\nmodule.exports.lua_setallocf         = lua_setallocf;\nmodule.exports.lua_setfield          = lua_setfield;\nmodule.exports.lua_setglobal         = lua_setglobal;\nmodule.exports.lua_seti              = lua_seti;\nmodule.exports.lua_setmetatable      = lua_setmetatable;\nmodule.exports.lua_settable          = lua_settable;\nmodule.exports.lua_settop            = lua_settop;\nmodule.exports.lua_setupvalue        = lua_setupvalue;\nmodule.exports.lua_setuservalue      = lua_setuservalue;\nmodule.exports.lua_status            = lua_status;\nmodule.exports.lua_stringtonumber    = lua_stringtonumber;\nmodule.exports.lua_toboolean         = lua_toboolean;\nmodule.exports.lua_tocfunction       = lua_tocfunction;\nmodule.exports.lua_todataview        = lua_todataview;\nmodule.exports.lua_tointeger         = lua_tointeger;\nmodule.exports.lua_tointegerx        = lua_tointegerx;\nmodule.exports.lua_tojsstring        = lua_tojsstring;\nmodule.exports.lua_tolstring         = lua_tolstring;\nmodule.exports.lua_tonumber          = lua_tonumber;\nmodule.exports.lua_tonumberx         = lua_tonumberx;\nmodule.exports.lua_topointer         = lua_topointer;\nmodule.exports.lua_toproxy           = lua_toproxy;\nmodule.exports.lua_tostring          = lua_tostring;\nmodule.exports.lua_tothread          = lua_tothread;\nmodule.exports.lua_touserdata        = lua_touserdata;\nmodule.exports.lua_type              = lua_type;\nmodule.exports.lua_typename          = lua_typename;\nmodule.exports.lua_upvalueid         = lua_upvalueid;\nmodule.exports.lua_upvaluejoin       = lua_upvaluejoin;\nmodule.exports.lua_version           = lua_version;\nmodule.exports.lua_xmove             = lua_xmove;\n","\"use strict\";\n\nconst {\n    constant_types: { LUA_TLNGSTR },\n    thread_status: { LUA_ERRSYNTAX },\n    to_luastring\n} = require('./defs.js');\nconst {\n    LUA_MINBUFFER,\n    MAX_INT,\n    lua_assert\n} = require('./llimits.js');\nconst ldebug   = require('./ldebug.js');\nconst ldo      = require('./ldo.js');\nconst {\n    lisdigit,\n    lislalnum,\n    lislalpha,\n    lisspace,\n    lisxdigit\n} = require('./ljstype.js');\nconst lobject  = require('./lobject.js');\nconst {\n    luaS_bless,\n    luaS_hash,\n    luaS_hashlongstr,\n    luaS_new\n} = require('./lstring.js');\nconst ltable   = require('./ltable.js');\nconst {\n    EOZ,\n    luaZ_buffer,\n    luaZ_buffremove,\n    luaZ_resetbuffer,\n    luaZ_resizebuffer\n} = require('./lzio.js');\n\nconst FIRST_RESERVED = 257;\n\nconst LUA_ENV = to_luastring(\"_ENV\", true);\n\n/* terminal symbols denoted by reserved words */\nconst TK_AND      = FIRST_RESERVED;\nconst TK_BREAK    = FIRST_RESERVED + 1;\nconst TK_DO       = FIRST_RESERVED + 2;\nconst TK_ELSE     = FIRST_RESERVED + 3;\nconst TK_ELSEIF   = FIRST_RESERVED + 4;\nconst TK_END      = FIRST_RESERVED + 5;\nconst TK_FALSE    = FIRST_RESERVED + 6;\nconst TK_FOR      = FIRST_RESERVED + 7;\nconst TK_FUNCTION = FIRST_RESERVED + 8;\nconst TK_GOTO     = FIRST_RESERVED + 9;\nconst TK_IF       = FIRST_RESERVED + 10;\nconst TK_IN       = FIRST_RESERVED + 11;\nconst TK_LOCAL    = FIRST_RESERVED + 12;\nconst TK_NIL      = FIRST_RESERVED + 13;\nconst TK_NOT      = FIRST_RESERVED + 14;\nconst TK_OR       = FIRST_RESERVED + 15;\nconst TK_REPEAT   = FIRST_RESERVED + 16;\nconst TK_RETURN   = FIRST_RESERVED + 17;\nconst TK_THEN     = FIRST_RESERVED + 18;\nconst TK_TRUE     = FIRST_RESERVED + 19;\nconst TK_UNTIL    = FIRST_RESERVED + 20;\nconst TK_WHILE    = FIRST_RESERVED + 21;\n/* other terminal symbols */\nconst TK_IDIV     = FIRST_RESERVED + 22;\nconst TK_CONCAT   = FIRST_RESERVED + 23;\nconst TK_DOTS     = FIRST_RESERVED + 24;\nconst TK_EQ       = FIRST_RESERVED + 25;\nconst TK_GE       = FIRST_RESERVED + 26;\nconst TK_LE       = FIRST_RESERVED + 27;\nconst TK_NE       = FIRST_RESERVED + 28;\nconst TK_SHL      = FIRST_RESERVED + 29;\nconst TK_SHR      = FIRST_RESERVED + 30;\nconst TK_DBCOLON  = FIRST_RESERVED + 31;\nconst TK_EOS      = FIRST_RESERVED + 32;\nconst TK_FLT      = FIRST_RESERVED + 33;\nconst TK_INT      = FIRST_RESERVED + 34;\nconst TK_NAME     = FIRST_RESERVED + 35;\nconst TK_STRING   = FIRST_RESERVED + 36;\n\nconst RESERVED = {\n    \"TK_AND\":      TK_AND,\n    \"TK_BREAK\":    TK_BREAK,\n    \"TK_DO\":       TK_DO,\n    \"TK_ELSE\":     TK_ELSE,\n    \"TK_ELSEIF\":   TK_ELSEIF,\n    \"TK_END\":      TK_END,\n    \"TK_FALSE\":    TK_FALSE,\n    \"TK_FOR\":      TK_FOR,\n    \"TK_FUNCTION\": TK_FUNCTION,\n    \"TK_GOTO\":     TK_GOTO,\n    \"TK_IF\":       TK_IF,\n    \"TK_IN\":       TK_IN,\n    \"TK_LOCAL\":    TK_LOCAL,\n    \"TK_NIL\":      TK_NIL,\n    \"TK_NOT\":      TK_NOT,\n    \"TK_OR\":       TK_OR,\n    \"TK_REPEAT\":   TK_REPEAT,\n    \"TK_RETURN\":   TK_RETURN,\n    \"TK_THEN\":     TK_THEN,\n    \"TK_TRUE\":     TK_TRUE,\n    \"TK_UNTIL\":    TK_UNTIL,\n    \"TK_WHILE\":    TK_WHILE,\n    \"TK_IDIV\":     TK_IDIV,\n    \"TK_CONCAT\":   TK_CONCAT,\n    \"TK_DOTS\":     TK_DOTS,\n    \"TK_EQ\":       TK_EQ,\n    \"TK_GE\":       TK_GE,\n    \"TK_LE\":       TK_LE,\n    \"TK_NE\":       TK_NE,\n    \"TK_SHL\":      TK_SHL,\n    \"TK_SHR\":      TK_SHR,\n    \"TK_DBCOLON\":  TK_DBCOLON,\n    \"TK_EOS\":      TK_EOS,\n    \"TK_FLT\":      TK_FLT,\n    \"TK_INT\":      TK_INT,\n    \"TK_NAME\":     TK_NAME,\n    \"TK_STRING\":   TK_STRING\n};\n\nconst luaX_tokens = [\n    \"and\", \"break\", \"do\", \"else\", \"elseif\",\n    \"end\", \"false\", \"for\", \"function\", \"goto\", \"if\",\n    \"in\", \"local\", \"nil\", \"not\", \"or\", \"repeat\",\n    \"return\", \"then\", \"true\", \"until\", \"while\",\n    \"//\", \"..\", \"...\", \"==\", \">=\", \"<=\", \"~=\",\n    \"<<\", \">>\", \"::\", \"<eof>\",\n    \"<number>\", \"<integer>\", \"<name>\", \"<string>\"\n].map((e, i)=>to_luastring(e));\n\nclass SemInfo {\n    constructor() {\n        this.r = NaN;\n        this.i = NaN;\n        this.ts = null;\n    }\n}\n\nclass Token {\n    constructor() {\n        this.token = NaN;\n        this.seminfo = new SemInfo();\n    }\n}\n\n/* state of the lexer plus state of the parser when shared by all\n   functions */\nclass LexState {\n    constructor() {\n        this.current = NaN;  /* current character (charint) */\n        this.linenumber = NaN;  /* input line counter */\n        this.lastline = NaN;  /* line of last token 'consumed' */\n        this.t = new Token();  /* current token */\n        this.lookahead = new Token();  /* look ahead token */\n        this.fs = null;  /* current function (parser) */\n        this.L = null;\n        this.z = null; /* input stream */\n        this.buff = null;  /* buffer for tokens */\n        this.h = null;  /* to reuse strings */\n        this.dyd = null;  /* dynamic structures used by the parser */\n        this.source = null;  /* current source name */\n        this.envn = null;  /* environment variable name */\n    }\n}\n\nconst save = function(ls, c) {\n    let b = ls.buff;\n    if (b.n + 1 > b.buffer.length) {\n        if (b.buffer.length >= MAX_INT/2)\n            lexerror(ls, to_luastring(\"lexical element too long\", true), 0);\n        let newsize = b.buffer.length*2;\n        luaZ_resizebuffer(ls.L, b, newsize);\n    }\n    b.buffer[b.n++] = c < 0 ? 255 + c + 1 : c;\n};\n\nconst luaX_token2str = function(ls, token) {\n    if (token < FIRST_RESERVED) {  /* single-byte symbols? */\n        return lobject.luaO_pushfstring(ls.L, to_luastring(\"'%c'\", true), token);\n    } else {\n        let s = luaX_tokens[token - FIRST_RESERVED];\n        if (token < TK_EOS)  /* fixed format (symbols and reserved words)? */\n            return lobject.luaO_pushfstring(ls.L, to_luastring(\"'%s'\", true), s);\n        else  /* names, strings, and numerals */\n            return s;\n    }\n};\n\nconst currIsNewline = function(ls) {\n    return ls.current === 10 /* ('\\n').charCodeAt(0) */ || ls.current === 13 /* ('\\r').charCodeAt(0) */;\n};\n\nconst next = function(ls) {\n    ls.current = ls.z.zgetc();\n};\n\nconst save_and_next = function(ls) {\n    save(ls, ls.current);\n    next(ls);\n};\n\n/*\n** creates a new string and anchors it in scanner's table so that\n** it will not be collected until the end of the compilation\n** (by that time it should be anchored somewhere)\n*/\nconst luaX_newstring = function(ls, str) {\n    let L = ls.L;\n    let ts = luaS_new(L, str);\n    let o = ltable.luaH_set(L, ls.h, new lobject.TValue(LUA_TLNGSTR, ts));\n    if (o.ttisnil()) { /* not in use yet? */\n        o.setbvalue(true);\n    } else { /* string already present */\n        /* HACK: Workaround lack of ltable 'keyfromval' */\n        let tpair = ls.h.strong.get(luaS_hashlongstr(ts));\n        lua_assert(tpair.value == o); /* fengari addition */\n        ts = tpair.key.tsvalue(); /* re-use value previously stored */\n    }\n    return ts;\n};\n\n/*\n** increment line number and skips newline sequence (any of\n** \\n, \\r, \\n\\r, or \\r\\n)\n*/\nconst inclinenumber = function(ls) {\n    let old = ls.current;\n    lua_assert(currIsNewline(ls));\n    next(ls);  /* skip '\\n' or '\\r' */\n    if (currIsNewline(ls) && ls.current !== old)\n        next(ls);  /* skip '\\n\\r' or '\\r\\n' */\n    if (++ls.linenumber >= MAX_INT)\n        lexerror(ls, to_luastring(\"chunk has too many lines\", true), 0);\n};\n\nconst luaX_setinput = function(L, ls, z, source, firstchar) {\n    ls.t = {\n        token: 0,\n        seminfo: new SemInfo()\n    };\n    ls.L = L;\n    ls.current = firstchar;\n    ls.lookahead = {\n        token: TK_EOS,\n        seminfo: new SemInfo()\n    };\n    ls.z = z;\n    ls.fs = null;\n    ls.linenumber = 1;\n    ls.lastline = 1;\n    ls.source = source;\n    ls.envn = luaS_bless(L, LUA_ENV);\n    luaZ_resizebuffer(L, ls.buff, LUA_MINBUFFER);  /* initialize buffer */\n};\n\nconst check_next1 = function(ls, c) {\n    if (ls.current === c) {\n        next(ls);\n        return true;\n    }\n\n    return false;\n};\n\n/*\n** Check whether current char is in set 'set' (with two chars) and\n** saves it\n*/\nconst check_next2 = function(ls, set) {\n    if (ls.current === set[0].charCodeAt(0) || ls.current === set[1].charCodeAt(0)) {\n        save_and_next(ls);\n        return true;\n    }\n\n    return false;\n};\n\nconst read_numeral = function(ls, seminfo) {\n    let expo = \"Ee\";\n    let first = ls.current;\n    lua_assert(lisdigit(ls.current));\n    save_and_next(ls);\n    if (first === 48 /* ('0').charCodeAt(0) */ && check_next2(ls, \"xX\"))  /* hexadecimal? */\n        expo = \"Pp\";\n\n    for (;;) {\n        if (check_next2(ls, expo))  /* exponent part? */\n            check_next2(ls, \"-+\");  /* optional exponent sign */\n        if (lisxdigit(ls.current))\n            save_and_next(ls);\n        else if (ls.current === 46 /* ('.').charCodeAt(0) */)\n            save_and_next(ls);\n        else break;\n    }\n\n    // save(ls, 0);\n\n    let obj = new lobject.TValue();\n    if (lobject.luaO_str2num(luaZ_buffer(ls.buff), obj) === 0)  /* format error? */\n        lexerror(ls, to_luastring(\"malformed number\", true), TK_FLT);\n    if (obj.ttisinteger()) {\n        seminfo.i = obj.value;\n        return TK_INT;\n    } else {\n        lua_assert(obj.ttisfloat());\n        seminfo.r = obj.value;\n        return TK_FLT;\n    }\n};\n\nconst txtToken = function(ls, token) {\n    switch (token) {\n        case TK_NAME: case TK_STRING:\n        case TK_FLT: case TK_INT:\n            // save(ls, 0);\n            return lobject.luaO_pushfstring(ls.L, to_luastring(\"'%s'\", true), luaZ_buffer(ls.buff));\n        default:\n            return luaX_token2str(ls, token);\n    }\n};\n\nconst lexerror = function(ls, msg, token) {\n    msg = ldebug.luaG_addinfo(ls.L, msg, ls.source, ls.linenumber);\n    if (token)\n        lobject.luaO_pushfstring(ls.L, to_luastring(\"%s near %s\"), msg, txtToken(ls, token));\n    ldo.luaD_throw(ls.L, LUA_ERRSYNTAX);\n};\n\nconst luaX_syntaxerror = function(ls, msg) {\n    lexerror(ls, msg, ls.t.token);\n};\n\n/*\n** skip a sequence '[=*[' or ']=*]'; if sequence is well formed, return\n** its number of '='s; otherwise, return a negative number (-1 iff there\n** are no '='s after initial bracket)\n*/\nconst skip_sep = function(ls) {\n    let count = 0;\n    let s = ls.current;\n    lua_assert(s === 91 /* ('[').charCodeAt(0) */ || s === 93 /* (']').charCodeAt(0) */);\n    save_and_next(ls);\n    while (ls.current === 61 /* ('=').charCodeAt(0) */) {\n        save_and_next(ls);\n        count++;\n    }\n    return ls.current === s ? count : (-count) - 1;\n};\n\nconst read_long_string = function(ls, seminfo, sep) {\n    let line = ls.linenumber;  /* initial line (for error message) */\n    save_and_next(ls);  /* skip 2nd '[' */\n\n    if (currIsNewline(ls))  /* string starts with a newline? */\n        inclinenumber(ls);  /* skip it */\n\n    let skip = false;\n    for (; !skip ;) {\n        switch (ls.current) {\n            case EOZ: {  /* error */\n                let what = seminfo ? \"string\" : \"comment\";\n                let msg = `unfinished long ${what} (starting at line ${line})`;\n                lexerror(ls, to_luastring(msg), TK_EOS);\n                break;\n            }\n            case 93 /* (']').charCodeAt(0) */: {\n                if (skip_sep(ls) === sep) {\n                    save_and_next(ls);  /* skip 2nd ']' */\n                    skip = true;\n                }\n                break;\n            }\n            case 10 /* ('\\n').charCodeAt(0) */:\n            case 13 /* ('\\r').charCodeAt(0) */: {\n                save(ls, 10 /* ('\\n').charCodeAt(0) */);\n                inclinenumber(ls);\n                if (!seminfo) luaZ_resetbuffer(ls.buff);\n                break;\n            }\n            default: {\n                if (seminfo) save_and_next(ls);\n                else next(ls);\n            }\n        }\n    }\n\n    if (seminfo)\n        seminfo.ts = luaX_newstring(ls, ls.buff.buffer.subarray(2 + sep, ls.buff.n - (2 + sep)));\n};\n\nconst esccheck = function(ls, c, msg) {\n    if (!c) {\n        if (ls.current !== EOZ)\n            save_and_next(ls);  /* add current to buffer for error message */\n        lexerror(ls, msg, TK_STRING);\n    }\n};\n\nconst gethexa = function(ls) {\n    save_and_next(ls);\n    esccheck(ls, lisxdigit(ls.current), to_luastring(\"hexadecimal digit expected\", true));\n    return lobject.luaO_hexavalue(ls.current);\n};\n\nconst readhexaesc = function(ls) {\n    let r = gethexa(ls);\n    r = (r << 4) + gethexa(ls);\n    luaZ_buffremove(ls.buff, 2);  /* remove saved chars from buffer */\n    return r;\n};\n\nconst readutf8desc = function(ls) {\n    let i = 4;  /* chars to be removed: '\\', 'u', '{', and first digit */\n    save_and_next(ls);  /* skip 'u' */\n    esccheck(ls, ls.current === 123 /* ('{').charCodeAt(0) */, to_luastring(\"missing '{'\", true));\n    let r = gethexa(ls);  /* must have at least one digit */\n\n    save_and_next(ls);\n    while (lisxdigit(ls.current)) {\n        i++;\n        r = (r << 4) + lobject.luaO_hexavalue(ls.current);\n        esccheck(ls, r <= 0x10FFFF, to_luastring(\"UTF-8 value too large\", true));\n        save_and_next(ls);\n    }\n    esccheck(ls, ls.current === 125 /* ('}').charCodeAt(0) */, to_luastring(\"missing '}'\", true));\n    next(ls);  /* skip '}' */\n    luaZ_buffremove(ls.buff, i);  /* remove saved chars from buffer */\n    return r;\n};\n\nconst utf8esc = function(ls) {\n    let buff = new Uint8Array(lobject.UTF8BUFFSZ);\n    let n = lobject.luaO_utf8esc(buff, readutf8desc(ls));\n    for (; n > 0; n--)  /* add 'buff' to string */\n        save(ls, buff[lobject.UTF8BUFFSZ - n]);\n};\n\nconst readdecesc = function(ls) {\n    let r = 0;  /* result accumulator */\n    let i;\n    for (i = 0; i < 3 && lisdigit(ls.current); i++) {  /* read up to 3 digits */\n        r = 10 * r + ls.current - 48 /* ('0').charCodeAt(0) */;\n        save_and_next(ls);\n    }\n    esccheck(ls, r <= 255, to_luastring(\"decimal escape too large\", true));\n    luaZ_buffremove(ls.buff, i);  /* remove read digits from buffer */\n    return r;\n};\n\nconst read_string = function(ls, del, seminfo) {\n    save_and_next(ls);  /* keep delimiter (for error messages) */\n\n    while (ls.current !== del) {\n        switch (ls.current) {\n            case EOZ:\n                lexerror(ls, to_luastring(\"unfinished string\", true), TK_EOS);\n                break;\n            case 10 /* ('\\n').charCodeAt(0) */:\n            case 13 /* ('\\r').charCodeAt(0) */:\n                lexerror(ls, to_luastring(\"unfinished string\", true), TK_STRING);\n                break;\n            case 92 /* ('\\\\').charCodeAt(0) */: {  /* escape sequences */\n                save_and_next(ls);  /* keep '\\\\' for error messages */\n                let will;\n                let c;\n                switch(ls.current) {\n                    case 97 /* ('a').charCodeAt(0) */: c = 7 /* \\a isn't valid JS */; will = 'read_save'; break;\n                    case 98 /* ('b').charCodeAt(0) */: c = 8 /* ('\\b').charCodeAt(0) */; will = 'read_save'; break;\n                    case 102 /* ('f').charCodeAt(0) */: c = 12 /* ('\\f').charCodeAt(0) */; will = 'read_save'; break;\n                    case 110 /* ('n').charCodeAt(0) */: c = 10 /* ('\\n').charCodeAt(0) */; will = 'read_save'; break;\n                    case 114 /* ('r').charCodeAt(0) */: c = 13 /* ('\\r').charCodeAt(0) */; will = 'read_save'; break;\n                    case 116 /* ('t').charCodeAt(0) */: c = 9 /* ('\\t').charCodeAt(0) */; will = 'read_save'; break;\n                    case 118 /* ('v').charCodeAt(0) */: c = 11 /* ('\\v').charCodeAt(0) */; will = 'read_save'; break;\n                    case 120 /* ('x').charCodeAt(0) */: c = readhexaesc(ls); will = 'read_save'; break;\n                    case 117 /* ('u').charCodeAt(0) */: utf8esc(ls); will = 'no_save'; break;\n                    case 10 /* ('\\n').charCodeAt(0) */:\n                    case 13 /* ('\\r').charCodeAt(0) */:\n                        inclinenumber(ls); c = 10 /* ('\\n').charCodeAt(0) */; will = 'only_save'; break;\n                    case 92 /* ('\\\\').charCodeAt(0) */:\n                    case 34 /* ('\"').charCodeAt(0) */:\n                    case 39 /* ('\\'').charCodeAt(0) */:\n                        c = ls.current; will = 'read_save'; break;\n                    case EOZ: will = 'no_save'; break;  /* will raise an error next loop */\n                    case 122 /* ('z').charCodeAt(0) */: {  /* zap following span of spaces */\n                        luaZ_buffremove(ls.buff, 1);  /* remove '\\\\' */\n                        next(ls);  /* skip the 'z' */\n                        while (lisspace(ls.current)) {\n                            if (currIsNewline(ls)) inclinenumber(ls);\n                            else next(ls);\n                        }\n                        will = 'no_save'; break;\n                    }\n                    default: {\n                        esccheck(ls, lisdigit(ls.current), to_luastring(\"invalid escape sequence\", true));\n                        c = readdecesc(ls);  /* digital escape '\\ddd' */\n                        will = 'only_save'; break;\n                    }\n                }\n\n                if (will === 'read_save')\n                    next(ls);\n\n                if (will === 'read_save' || will === 'only_save') {\n                    luaZ_buffremove(ls.buff, 1);  /* remove '\\\\' */\n                    save(ls, c);\n                }\n\n                break;\n            }\n            default:\n                save_and_next(ls);\n        }\n    }\n    save_and_next(ls);  /* skip delimiter */\n\n    seminfo.ts = luaX_newstring(ls, ls.buff.buffer.subarray(1, ls.buff.n-1));\n};\n\nconst token_to_index = Object.create(null); /* don't want to return true for e.g. 'hasOwnProperty' */\nluaX_tokens.forEach((e, i)=>token_to_index[luaS_hash(e)] = i);\n\nconst isreserved = function(w) {\n    let kidx = token_to_index[luaS_hashlongstr(w)];\n    return kidx !== void 0 && kidx <= 22;\n};\n\nconst llex = function(ls, seminfo) {\n    luaZ_resetbuffer(ls.buff);\n    for (;;) {\n        lua_assert(typeof ls.current == \"number\"); /* fengari addition */\n        switch (ls.current) {\n            case 10 /* ('\\n').charCodeAt(0) */:\n            case 13 /* ('\\r').charCodeAt(0) */: {  /* line breaks */\n                inclinenumber(ls);\n                break;\n            }\n            case 32 /* (' ').charCodeAt(0) */:\n            case 12 /* ('\\f').charCodeAt(0) */:\n            case 9 /* ('\\t').charCodeAt(0) */:\n            case 11 /* ('\\v').charCodeAt(0) */: {  /* spaces */\n                next(ls);\n                break;\n            }\n            case 45 /* ('-').charCodeAt(0) */: {  /* '-' or '--' (comment) */\n                next(ls);\n                if (ls.current !== 45 /* ('-').charCodeAt(0) */) return 45 /* ('-').charCodeAt(0) */;\n                /* else is a comment */\n                next(ls);\n                if (ls.current === 91 /* ('[').charCodeAt(0) */) {  /* long comment? */\n                    let sep = skip_sep(ls);\n                    luaZ_resetbuffer(ls.buff);  /* 'skip_sep' may dirty the buffer */\n                    if (sep >= 0) {\n                        read_long_string(ls, null, sep);  /* skip long comment */\n                        luaZ_resetbuffer(ls.buff);  /* previous call may dirty the buff. */\n                        break;\n                    }\n                }\n\n                /* else short comment */\n                while (!currIsNewline(ls) && ls.current !== EOZ)\n                    next(ls);  /* skip until end of line (or end of file) */\n                break;\n            }\n            case 91 /* ('[').charCodeAt(0) */: {  /* long string or simply '[' */\n                let sep = skip_sep(ls);\n                if (sep >= 0) {\n                    read_long_string(ls, seminfo, sep);\n                    return TK_STRING;\n                } else if (sep !== -1)  /* '[=...' missing second bracket */\n                    lexerror(ls, to_luastring(\"invalid long string delimiter\", true), TK_STRING);\n                return 91 /* ('[').charCodeAt(0) */;\n            }\n            case 61 /* ('=').charCodeAt(0) */: {\n                next(ls);\n                if (check_next1(ls, 61 /* ('=').charCodeAt(0) */)) return TK_EQ;\n                else return 61 /* ('=').charCodeAt(0) */;\n            }\n            case 60 /* ('<').charCodeAt(0) */: {\n                next(ls);\n                if (check_next1(ls, 61 /* ('=').charCodeAt(0) */)) return TK_LE;\n                else if (check_next1(ls, 60 /* ('<').charCodeAt(0) */)) return TK_SHL;\n                else return 60 /* ('<').charCodeAt(0) */;\n            }\n            case 62 /* ('>').charCodeAt(0) */: {\n                next(ls);\n                if (check_next1(ls, 61 /* ('=').charCodeAt(0) */)) return TK_GE;\n                else if (check_next1(ls, 62 /* ('>').charCodeAt(0) */)) return TK_SHR;\n                else return 62 /* ('>').charCodeAt(0) */;\n            }\n            case 47 /* ('/').charCodeAt(0) */: {\n                next(ls);\n                if (check_next1(ls, 47 /* ('/').charCodeAt(0) */)) return TK_IDIV;\n                else return 47 /* ('/').charCodeAt(0) */;\n            }\n            case 126 /* ('~').charCodeAt(0) */: {\n                next(ls);\n                if (check_next1(ls, 61 /* ('=').charCodeAt(0) */)) return TK_NE;\n                else return 126 /* ('~').charCodeAt(0) */;\n            }\n            case 58 /* (':').charCodeAt(0) */: {\n                next(ls);\n                if (check_next1(ls, 58 /* (':').charCodeAt(0) */)) return TK_DBCOLON;\n                else return 58 /* (':').charCodeAt(0) */;\n            }\n            case 34 /* ('\"').charCodeAt(0) */:\n            case 39 /* ('\\'').charCodeAt(0) */: {  /* short literal strings */\n                read_string(ls, ls.current, seminfo);\n                return TK_STRING;\n            }\n            case 46 /* ('.').charCodeAt(0) */: {  /* '.', '..', '...', or number */\n                save_and_next(ls);\n                if (check_next1(ls, 46 /* ('.').charCodeAt(0) */)) {\n                    if (check_next1(ls, 46 /* ('.').charCodeAt(0) */))\n                        return TK_DOTS;   /* '...' */\n                    else return TK_CONCAT;   /* '..' */\n                }\n                else if (!lisdigit(ls.current)) return 46 /* ('.').charCodeAt(0) */;\n                else return read_numeral(ls, seminfo);\n            }\n            case 48 /* ('0').charCodeAt(0) */: case 49 /* ('1').charCodeAt(0) */: case 50 /* ('2').charCodeAt(0) */: case 51 /* ('3').charCodeAt(0) */: case 52 /* ('4').charCodeAt(0) */:\n            case 53 /* ('5').charCodeAt(0) */: case 54 /* ('6').charCodeAt(0) */: case 55 /* ('7').charCodeAt(0) */: case 56 /* ('8').charCodeAt(0) */: case 57 /* ('9').charCodeAt(0) */: {\n                return read_numeral(ls, seminfo);\n            }\n            case EOZ: {\n                return TK_EOS;\n            }\n            default: {\n                if (lislalpha(ls.current)) {  /* identifier or reserved word? */\n                    do {\n                        save_and_next(ls);\n                    } while (lislalnum(ls.current));\n                    let ts = luaX_newstring(ls, luaZ_buffer(ls.buff));\n                    seminfo.ts = ts;\n                    let kidx = token_to_index[luaS_hashlongstr(ts)];\n                    if (kidx !== void 0 && kidx <= 22)  /* reserved word? */\n                        return kidx + FIRST_RESERVED;\n                    else\n                        return TK_NAME;\n                } else {  /* single-char tokens (+ - / ...) */\n                    let c = ls.current;\n                    next(ls);\n                    return c;\n                }\n            }\n        }\n    }\n};\n\nconst luaX_next = function(ls) {\n    ls.lastline = ls.linenumber;\n    if (ls.lookahead.token !== TK_EOS) {  /* is there a look-ahead token? */\n        ls.t.token = ls.lookahead.token;  /* use this one */\n        ls.t.seminfo.i = ls.lookahead.seminfo.i;\n        ls.t.seminfo.r = ls.lookahead.seminfo.r;\n        ls.t.seminfo.ts = ls.lookahead.seminfo.ts;\n        ls.lookahead.token = TK_EOS;  /* and discharge it */\n    } else\n        ls.t.token = llex(ls, ls.t.seminfo);  /* read next token */\n};\n\nconst luaX_lookahead = function(ls) {\n    lua_assert(ls.lookahead.token === TK_EOS);\n    ls.lookahead.token = llex(ls, ls.lookahead.seminfo);\n    return ls.lookahead.token;\n};\n\nmodule.exports.FIRST_RESERVED   = FIRST_RESERVED;\nmodule.exports.LUA_ENV          = LUA_ENV;\nmodule.exports.LexState         = LexState;\nmodule.exports.RESERVED         = RESERVED;\nmodule.exports.isreserved       = isreserved;\nmodule.exports.luaX_lookahead   = luaX_lookahead;\nmodule.exports.luaX_newstring   = luaX_newstring;\nmodule.exports.luaX_next        = luaX_next;\nmodule.exports.luaX_setinput    = luaX_setinput;\nmodule.exports.luaX_syntaxerror = luaX_syntaxerror;\nmodule.exports.luaX_token2str   = luaX_token2str;\nmodule.exports.luaX_tokens      = luaX_tokens;\n","/**\n@license MIT\n\nCopyright © 2017-2018 Benoit Giannangeli\nCopyright © 2017-2018 Daurnimator\nCopyright © 1994–2017 Lua.org, PUC-Rio.\n*/\n\n\"use strict\";\n\nconst core = require(\"./fengaricore.js\");\n\nmodule.exports.FENGARI_AUTHORS         = core.FENGARI_AUTHORS;\nmodule.exports.FENGARI_COPYRIGHT       = core.FENGARI_COPYRIGHT;\nmodule.exports.FENGARI_RELEASE         = core.FENGARI_RELEASE;\nmodule.exports.FENGARI_VERSION         = core.FENGARI_VERSION;\nmodule.exports.FENGARI_VERSION_MAJOR   = core.FENGARI_VERSION_MAJOR;\nmodule.exports.FENGARI_VERSION_MINOR   = core.FENGARI_VERSION_MINOR;\nmodule.exports.FENGARI_VERSION_NUM     = core.FENGARI_VERSION_NUM;\nmodule.exports.FENGARI_VERSION_RELEASE = core.FENGARI_VERSION_RELEASE;\n\nmodule.exports.luastring_eq      = core.luastring_eq;\nmodule.exports.luastring_indexOf = core.luastring_indexOf;\nmodule.exports.luastring_of      = core.luastring_of;\nmodule.exports.to_jsstring       = core.to_jsstring;\nmodule.exports.to_luastring      = core.to_luastring;\nmodule.exports.to_uristring      = core.to_uristring;\n\nconst luaconf  = require('./luaconf.js');\nconst lua      = require('./lua.js');\nconst lauxlib  = require('./lauxlib.js');\nconst lualib   = require('./lualib.js');\n\nmodule.exports.luaconf = luaconf;\nmodule.exports.lua     = lua;\nmodule.exports.lauxlib = lauxlib;\nmodule.exports.lualib  = lualib;\n","const {\n    lua_pushinteger,\n    lua_pushliteral,\n    lua_setfield\n} = require('./lua.js');\nconst {\n    luaL_newlib\n} = require('./lauxlib.js');\nconst {\n    FENGARI_AUTHORS,\n    FENGARI_COPYRIGHT,\n    FENGARI_RELEASE,\n    FENGARI_VERSION,\n    FENGARI_VERSION_MAJOR,\n    FENGARI_VERSION_MINOR,\n    FENGARI_VERSION_NUM,\n    FENGARI_VERSION_RELEASE,\n    to_luastring\n} = require(\"./fengaricore.js\");\n\nconst luaopen_fengari = function(L) {\n    luaL_newlib(L, {});\n    lua_pushliteral(L, FENGARI_AUTHORS);\n    lua_setfield(L, -2, to_luastring(\"AUTHORS\"));\n    lua_pushliteral(L, FENGARI_COPYRIGHT);\n    lua_setfield(L, -2, to_luastring(\"COPYRIGHT\"));\n    lua_pushliteral(L, FENGARI_RELEASE);\n    lua_setfield(L, -2, to_luastring(\"RELEASE\"));\n    lua_pushliteral(L, FENGARI_VERSION);\n    lua_setfield(L, -2, to_luastring(\"VERSION\"));\n    lua_pushliteral(L, FENGARI_VERSION_MAJOR);\n    lua_setfield(L, -2, to_luastring(\"VERSION_MAJOR\"));\n    lua_pushliteral(L, FENGARI_VERSION_MINOR);\n    lua_setfield(L, -2, to_luastring(\"VERSION_MINOR\"));\n    lua_pushinteger(L, FENGARI_VERSION_NUM);\n    lua_setfield(L, -2, to_luastring(\"VERSION_NUM\"));\n    lua_pushliteral(L, FENGARI_VERSION_RELEASE);\n    lua_setfield(L, -2, to_luastring(\"VERSION_RELEASE\"));\n    return 1;\n};\n\nmodule.exports.luaopen_fengari = luaopen_fengari;\n","\"use strict\";\n\nconst {\n    LUA_DIRSEP,\n    LUA_EXEC_DIR,\n    LUA_JSPATH_DEFAULT,\n    LUA_PATH_DEFAULT,\n    LUA_PATH_MARK,\n    LUA_PATH_SEP\n} = require('./luaconf.js');\nconst {\n    LUA_OK,\n    LUA_REGISTRYINDEX,\n    LUA_TNIL,\n    LUA_TTABLE,\n    lua_callk,\n    lua_createtable,\n    lua_getfield,\n    lua_insert,\n    lua_isfunction,\n    lua_isnil,\n    lua_isstring,\n    lua_newtable,\n    lua_pop,\n    lua_pushboolean,\n    lua_pushcclosure,\n    lua_pushcfunction,\n    lua_pushfstring,\n    lua_pushglobaltable,\n    lua_pushlightuserdata,\n    lua_pushliteral,\n    lua_pushlstring,\n    lua_pushnil,\n    lua_pushstring,\n    lua_pushvalue,\n    lua_rawgeti,\n    lua_rawgetp,\n    lua_rawseti,\n    lua_rawsetp,\n    lua_remove,\n    lua_setfield,\n    lua_setmetatable,\n    lua_settop,\n    lua_toboolean,\n    lua_tostring,\n    lua_touserdata,\n    lua_upvalueindex\n} = require('./lua.js');\nconst {\n    LUA_LOADED_TABLE,\n    LUA_PRELOAD_TABLE,\n    luaL_Buffer,\n    luaL_addvalue,\n    luaL_buffinit,\n    luaL_checkstring,\n    luaL_error,\n    luaL_getsubtable,\n    luaL_gsub,\n    luaL_len,\n    luaL_loadfile,\n    luaL_newlib,\n    luaL_optstring,\n    luaL_pushresult,\n    luaL_setfuncs\n} = require('./lauxlib.js');\nconst lualib = require('./lualib.js');\nconst {\n    luastring_indexOf,\n    to_jsstring,\n    to_luastring,\n    to_uristring\n} = require(\"./fengaricore.js\");\nconst fengari  = require('./fengari.js');\n\nconst global_env = (function() {\n    /* global WorkerGlobalScope */ /* see https://github.com/sindresorhus/globals/issues/127 */\n    if (typeof process !== \"undefined\") {\n        /* node */\n        return global;\n    } else if (typeof window !== \"undefined\") {\n        /* browser window */\n        return window;\n    } else if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {\n        /* web worker */\n        return self;\n    } else {\n        /* unknown global env */\n        return (0, eval)('this'); /* use non-strict mode to get global env */\n    }\n})();\n\nconst JSLIBS = to_luastring(\"__JSLIBS__\");\nconst LUA_PATH_VAR = \"LUA_PATH\";\nconst LUA_JSPATH_VAR = \"LUA_JSPATH\";\n\nconst LUA_IGMARK = \"-\";\n\n/*\n** LUA_CSUBSEP is the character that replaces dots in submodule names\n** when searching for a JS loader.\n** LUA_LSUBSEP is the character that replaces dots in submodule names\n** when searching for a Lua loader.\n*/\nconst LUA_CSUBSEP = LUA_DIRSEP;\nconst LUA_LSUBSEP = LUA_DIRSEP;\n\n/* prefix for open functions in JS libraries */\nconst LUA_POF = to_luastring(\"luaopen_\");\n\n/* separator for open functions in JS libraries */\nconst LUA_OFSEP = to_luastring(\"_\");\nconst LIB_FAIL = \"open\";\n\nconst AUXMARK = to_luastring(\"\\x01\");\n\n\n/*\n** load JS library in file 'path'. If 'seeglb', load with all names in\n** the library global.\n** Returns the library; in case of error, returns NULL plus an\n** error string in the stack.\n*/\nlet lsys_load;\nif (typeof process === \"undefined\") {\n    lsys_load = function(L, path, seeglb) {\n        path = to_uristring(path);\n        let xhr = new XMLHttpRequest();\n        xhr.open(\"GET\", path, false);\n        xhr.send();\n\n        if (xhr.status < 200 || xhr.status >= 300) {\n            lua_pushstring(L, to_luastring(`${xhr.status}: ${xhr.statusText}`));\n            return null;\n        }\n\n        let code = xhr.response;\n        /* Add sourceURL comment to get path in debugger+tracebacks */\n        if (!/\\/\\/[#@] sourceURL=/.test(code))\n            code += \" //# sourceURL=\" + path;\n        let func;\n        try {\n            func = Function(\"fengari\", code);\n        } catch (e) {\n            lua_pushstring(L, to_luastring(`${e.name}: ${e.message}`));\n            return null;\n        }\n        let res = func(fengari);\n        if (typeof res === \"function\" || (typeof res === \"object\" && res !== null)) {\n            return res;\n        } else if (res === void 0) { /* assume library added symbols to global environment */\n            return global_env;\n        } else {\n            lua_pushstring(L, to_luastring(`library returned unexpected type (${typeof res})`));\n            return null;\n        }\n    };\n} else {\n    const pathlib = require('path');\n    lsys_load = function(L, path, seeglb) {\n        path = to_jsstring(path);\n        /* relative paths should be relative to cwd, not this js file */\n        path = pathlib.resolve(process.cwd(), path);\n        try {\n            return require(path);\n        } catch (e) {\n            lua_pushstring(L, to_luastring(e.message));\n            return null;\n        }\n    };\n}\n\n/*\n** Try to find a function named 'sym' in library 'lib'.\n** Returns the function; in case of error, returns NULL plus an\n** error string in the stack.\n*/\nconst lsys_sym = function(L, lib, sym) {\n    let f = lib[to_jsstring(sym)];\n\n    if (f && typeof f === 'function')\n        return f;\n    else {\n        lua_pushfstring(L, to_luastring(\"undefined symbol: %s\"), sym);\n        return null;\n    }\n};\n\n/*\n** return registry.LUA_NOENV as a boolean\n*/\nconst noenv = function(L) {\n    lua_getfield(L, LUA_REGISTRYINDEX, to_luastring(\"LUA_NOENV\"));\n    let b = lua_toboolean(L, -1);\n    lua_pop(L, 1);  /* remove value */\n    return b;\n};\n\nlet readable;\nif (typeof process !== \"undefined\") { // Only with Node\n    const fs = require('fs');\n\n    readable = function(filename) {\n        try {\n            let fd = fs.openSync(filename, 'r');\n            fs.closeSync(fd);\n        } catch (e) {\n            return false;\n        }\n        return true;\n    };\n} else {\n    readable = function(path) {\n        path = to_uristring(path);\n        let xhr = new XMLHttpRequest();\n        /* Following GET request done by searcher_Web will be cached */\n        xhr.open(\"GET\", path, false);\n        xhr.send();\n\n        return xhr.status >= 200 && xhr.status <= 299;\n    };\n}\n\n\n/* error codes for 'lookforfunc' */\nconst ERRLIB  = 1;\nconst ERRFUNC = 2;\n\n/*\n** Look for a C function named 'sym' in a dynamically loaded library\n** 'path'.\n** First, check whether the library is already loaded; if not, try\n** to load it.\n** Then, if 'sym' is '*', return true (as library has been loaded).\n** Otherwise, look for symbol 'sym' in the library and push a\n** C function with that symbol.\n** Return 0 and 'true' or a function in the stack; in case of\n** errors, return an error code and an error message in the stack.\n*/\nconst lookforfunc = function(L, path, sym) {\n    let reg = checkjslib(L, path);  /* check loaded JS libraries */\n    if (reg === null) {  /* must load library? */\n        reg = lsys_load(L, path, sym[0] === '*'.charCodeAt(0));  /* a global symbols if 'sym'=='*' */\n        if (reg === null) return ERRLIB;  /* unable to load library */\n        addtojslib(L, path, reg);\n    }\n    if (sym[0] === '*'.charCodeAt(0)) {  /* loading only library (no function)? */\n        lua_pushboolean(L, 1);  /* return 'true' */\n        return 0;  /* no errors */\n    }\n    else {\n        let f = lsys_sym(L, reg, sym);\n        if (f === null)\n            return ERRFUNC;  /* unable to find function */\n        lua_pushcfunction(L, f);  /* else create new function */\n        return 0;  /* no errors */\n    }\n};\n\nconst ll_loadlib = function(L) {\n    let path = luaL_checkstring(L, 1);\n    let init = luaL_checkstring(L, 2);\n    let stat = lookforfunc(L, path, init);\n    if (stat === 0)  /* no errors? */\n        return 1;  /* return the loaded function */\n    else {  /* error; error message is on stack top */\n        lua_pushnil(L);\n        lua_insert(L, -2);\n        lua_pushliteral(L, (stat === ERRLIB) ? LIB_FAIL : \"init\");\n        return 3;  /* return nil, error message, and where */\n    }\n};\n\nconst env = (function() {\n    if (typeof process !== \"undefined\") {\n        /* node */\n        return process.env;\n    } else {\n        return global_env;\n    }\n})();\n\n/*\n** Set a path\n*/\nconst setpath = function(L, fieldname, envname, dft) {\n    let nver = `${envname}${lualib.LUA_VERSUFFIX}`;\n    lua_pushstring(L, to_luastring(nver));\n    let path = env[nver];  /* use versioned name */\n    if (path === undefined)  /* no environment variable? */\n        path = env[envname];  /* try unversioned name */\n    if (path === undefined || noenv(L))  /* no environment variable? */\n        lua_pushstring(L, dft);  /* use default */\n    else {\n        /* replace \";;\" by \";AUXMARK;\" and then AUXMARK by default path */\n        path = luaL_gsub(\n            L,\n            to_luastring(path),\n            to_luastring(LUA_PATH_SEP + LUA_PATH_SEP, true),\n            to_luastring(LUA_PATH_SEP + to_jsstring(AUXMARK) + LUA_PATH_SEP, true)\n        );\n        luaL_gsub(L, path, AUXMARK, dft);\n        lua_remove(L, -2); /* remove result from 1st 'gsub' */\n    }\n    lua_setfield(L, -3, fieldname);  /* package[fieldname] = path value */\n    lua_pop(L, 1);  /* pop versioned variable name */\n};\n\n/*\n** return registry.JSLIBS[path]\n*/\nconst checkjslib = function(L, path) {\n    lua_rawgetp(L, LUA_REGISTRYINDEX, JSLIBS);\n    lua_getfield(L, -1, path);\n    let plib = lua_touserdata(L, -1);  /* plib = JSLIBS[path] */\n    lua_pop(L, 2);  /* pop JSLIBS table and 'plib' */\n    return plib;\n};\n\n/*\n** registry.JSLIBS[path] = plib        -- for queries\n** registry.JSLIBS[#JSLIBS + 1] = plib  -- also keep a list of all libraries\n*/\nconst addtojslib = function(L, path, plib) {\n    lua_rawgetp(L, LUA_REGISTRYINDEX, JSLIBS);\n    lua_pushlightuserdata(L, plib);\n    lua_pushvalue(L, -1);\n    lua_setfield(L, -3, path);  /* JSLIBS[path] = plib */\n    lua_rawseti(L, -2, luaL_len(L, -2) + 1);  /* JSLIBS[#JSLIBS + 1] = plib */\n    lua_pop(L, 1);  /* pop JSLIBS table */\n};\n\nconst pushnexttemplate = function(L, path) {\n    while (path[0] === LUA_PATH_SEP.charCodeAt(0)) path = path.subarray(1);  /* skip separators */\n    if (path.length === 0) return null;  /* no more templates */\n    let l = luastring_indexOf(path, LUA_PATH_SEP.charCodeAt(0));  /* find next separator */\n    if (l < 0) l = path.length;\n    lua_pushlstring(L, path, l);  /* template */\n    return path.subarray(l);\n};\n\nconst searchpath = function(L, name, path, sep, dirsep) {\n    let msg = new luaL_Buffer();  /* to build error message */\n    luaL_buffinit(L, msg);\n    if (sep[0] !== 0)  /* non-empty separator? */\n        name = luaL_gsub(L, name, sep, dirsep);  /* replace it by 'dirsep' */\n    while ((path = pushnexttemplate(L, path)) !== null) {\n        let filename = luaL_gsub(L, lua_tostring(L, -1), to_luastring(LUA_PATH_MARK, true), name);\n        lua_remove(L, -2);  /* remove path template */\n        if (readable(filename))  /* does file exist and is readable? */\n            return filename;  /* return that file name */\n        lua_pushfstring(L, to_luastring(\"\\n\\tno file '%s'\"), filename);\n        lua_remove(L, -2);  /* remove file name */\n        luaL_addvalue(msg);\n    }\n    luaL_pushresult(msg);  /* create error message */\n    return null;  /* not found */\n};\n\nconst ll_searchpath = function(L) {\n    let f = searchpath(\n        L,\n        luaL_checkstring(L, 1),\n        luaL_checkstring(L, 2),\n        luaL_optstring(L, 3, \".\"),\n        luaL_optstring(L, 4, LUA_DIRSEP)\n    );\n    if (f !== null) return 1;\n    else {  /* error message is on top of the stack */\n        lua_pushnil(L);\n        lua_insert(L, -2);\n        return 2;  /* return nil + error message */\n    }\n};\n\nconst findfile = function(L, name, pname, dirsep) {\n    lua_getfield(L, lua_upvalueindex(1), pname);\n    let path = lua_tostring(L, -1);\n    if (path === null)\n        luaL_error(L, to_luastring(\"'package.%s' must be a string\"), pname);\n    return searchpath(L, name, path, to_luastring(\".\"), dirsep);\n};\n\nconst checkload = function(L, stat, filename) {\n    if (stat) {  /* module loaded successfully? */\n        lua_pushstring(L, filename);  /* will be 2nd argument to module */\n        return 2;  /* return open function and file name */\n    } else\n        return luaL_error(L, to_luastring(\"error loading module '%s' from file '%s':\\n\\t%s\"),\n            lua_tostring(L, 1), filename, lua_tostring(L, -1));\n};\n\nconst searcher_Lua = function(L) {\n    let name = luaL_checkstring(L, 1);\n    let filename = findfile(L, name, to_luastring(\"path\", true), to_luastring(LUA_LSUBSEP, true));\n    if (filename === null) return 1;  /* module not found in this path */\n    return checkload(L, luaL_loadfile(L, filename) === LUA_OK, filename);\n};\n\n/*\n** Try to find a load function for module 'modname' at file 'filename'.\n** First, change '.' to '_' in 'modname'; then, if 'modname' has\n** the form X-Y (that is, it has an \"ignore mark\"), build a function\n** name \"luaopen_X\" and look for it. (For compatibility, if that\n** fails, it also tries \"luaopen_Y\".) If there is no ignore mark,\n** look for a function named \"luaopen_modname\".\n*/\nconst loadfunc = function(L, filename, modname) {\n    let openfunc;\n    modname = luaL_gsub(L, modname, to_luastring(\".\"), LUA_OFSEP);\n    let mark = luastring_indexOf(modname, LUA_IGMARK.charCodeAt(0));\n    if (mark >= 0) {\n        openfunc = lua_pushlstring(L, modname, mark);\n        openfunc = lua_pushfstring(L, to_luastring(\"%s%s\"), LUA_POF, openfunc);\n        let stat = lookforfunc(L, filename, openfunc);\n        if (stat !== ERRFUNC) return stat;\n        modname = mark + 1;  /* else go ahead and try old-style name */\n    }\n    openfunc = lua_pushfstring(L, to_luastring(\"%s%s\"), LUA_POF, modname);\n    return lookforfunc(L, filename, openfunc);\n};\n\nconst searcher_C = function(L) {\n    let name = luaL_checkstring(L, 1);\n    let filename = findfile(L, name, to_luastring(\"jspath\", true), to_luastring(LUA_CSUBSEP, true));\n    if (filename === null) return 1;  /* module not found in this path */\n    return checkload(L, (loadfunc(L, filename, name) === 0), filename);\n};\n\nconst searcher_Croot = function(L) {\n    let name = luaL_checkstring(L, 1);\n    let p = luastring_indexOf(name, '.'.charCodeAt(0));\n    let stat;\n    if (p < 0) return 0;  /* is root */\n    lua_pushlstring(L, name, p);\n    let filename = findfile(L, lua_tostring(L, -1), to_luastring(\"jspath\", true), to_luastring(LUA_CSUBSEP, true));\n    if (filename === null) return 1;  /* root not found */\n    if ((stat = loadfunc(L, filename, name)) !== 0) {\n        if (stat != ERRFUNC)\n            return checkload(L, 0, filename);  /* real error */\n        else {  /* open function not found */\n            lua_pushstring(L, to_luastring(\"\\n\\tno module '%s' in file '%s'\"), name, filename);\n            return 1;\n        }\n    }\n    lua_pushstring(L, filename);  /* will be 2nd argument to module */\n    return 2;\n};\n\nconst searcher_preload = function(L) {\n    let name = luaL_checkstring(L, 1);\n    lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);\n    if (lua_getfield(L, -1, name) === LUA_TNIL)  /* not found? */\n        lua_pushfstring(L, to_luastring(\"\\n\\tno field package.preload['%s']\"), name);\n    return 1;\n};\n\nconst findloader = function(L, name, ctx, k) {\n    let msg = new luaL_Buffer();  /* to build error message */\n    luaL_buffinit(L, msg);\n    /* push 'package.searchers' to index 3 in the stack */\n    if (lua_getfield(L, lua_upvalueindex(1), to_luastring(\"searchers\", true)) !== LUA_TTABLE)\n        luaL_error(L, to_luastring(\"'package.searchers' must be a table\"));\n    let ctx2 = {name: name, i: 1, msg: msg, ctx: ctx, k: k};\n    return findloader_cont(L, LUA_OK, ctx2);\n};\n\nconst findloader_cont = function(L, status, ctx) {\n    /*  iterate over available searchers to find a loader */\n    for (; ; ctx.i++) {\n        if (status === LUA_OK) {\n            if (lua_rawgeti(L, 3, ctx.i) === LUA_TNIL) {  /* no more searchers? */\n                lua_pop(L, 1);  /* remove nil */\n                luaL_pushresult(ctx.msg);  /* create error message */\n                luaL_error(L, to_luastring(\"module '%s' not found:%s\"), ctx.name, lua_tostring(L, -1));\n            }\n            lua_pushstring(L, ctx.name);\n            lua_callk(L, 1, 2, ctx, findloader_cont);  /* call it */\n        } else {\n            status = LUA_OK;\n        }\n        if (lua_isfunction(L, -2))  /* did it find a loader? */\n            break;  /* module loader found */\n        else if (lua_isstring(L, -2)) {  /* searcher returned error message? */\n            lua_pop(L, 1);  /* remove extra return */\n            luaL_addvalue(ctx.msg);  /* concatenate error message */\n        }\n        else\n            lua_pop(L, 2);  /* remove both returns */\n    }\n    return ctx.k(L, LUA_OK, ctx.ctx);\n};\n\nconst ll_require = function(L) {\n    let name = luaL_checkstring(L, 1);\n    lua_settop(L, 1);  /* LOADED table will be at index 2 */\n    lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);\n    lua_getfield(L, 2, name);  /* LOADED[name] */\n    if (lua_toboolean(L, -1))  /* is it there? */\n        return 1;  /* package is already loaded */\n    /* else must load package */\n    lua_pop(L, 1);  /* remove 'getfield' result */\n    let ctx = name;\n    return findloader(L, name, ctx, ll_require_cont);\n};\n\nconst ll_require_cont = function(L, status, ctx) {\n    let name = ctx;\n    lua_pushstring(L, name);  /* pass name as argument to module loader */\n    lua_insert(L, -2);  /* name is 1st argument (before search data) */\n    lua_callk(L, 2, 1, ctx, ll_require_cont2);\n    return ll_require_cont2(L, LUA_OK, ctx);  /* run loader to load module */\n};\n\nconst ll_require_cont2 = function(L, status, ctx) {\n    let name = ctx;\n    if (!lua_isnil(L, -1))  /* non-nil return? */\n        lua_setfield(L, 2, name);  /* LOADED[name] = returned value */\n    if (lua_getfield(L, 2, name) == LUA_TNIL) {   /* module set no value? */\n        lua_pushboolean(L, 1);  /* use true as result */\n        lua_pushvalue(L, -1);  /* extra copy to be returned */\n        lua_setfield(L, 2, name);  /* LOADED[name] = true */\n    }\n    return 1;\n};\n\nconst pk_funcs = {\n    \"loadlib\": ll_loadlib,\n    \"searchpath\": ll_searchpath\n};\n\nconst ll_funcs = {\n    \"require\": ll_require\n};\n\nconst createsearcherstable = function(L) {\n    let searchers = [searcher_preload, searcher_Lua, searcher_C, searcher_Croot, null];\n    /* create 'searchers' table */\n    lua_createtable(L);\n    /* fill it with predefined searchers */\n    for (let i = 0; searchers[i]; i++) {\n        lua_pushvalue(L, -2);  /* set 'package' as upvalue for all searchers */\n        lua_pushcclosure(L, searchers[i], 1);\n        lua_rawseti(L, -2, i+1);\n    }\n    lua_setfield(L, -2, to_luastring(\"searchers\", true));  /* put it in field 'searchers' */\n};\n\n/*\n** create table JSLIBS to keep track of loaded JS libraries,\n** setting a finalizer to close all libraries when closing state.\n*/\nconst createjslibstable = function(L) {\n    lua_newtable(L);  /* create JSLIBS table */\n    lua_createtable(L, 0, 1);  /* create metatable for JSLIBS */\n    lua_setmetatable(L, -2);\n    lua_rawsetp(L, LUA_REGISTRYINDEX, JSLIBS);  /* set JSLIBS table in registry */\n};\n\nconst luaopen_package = function(L) {\n    createjslibstable(L);\n    luaL_newlib(L, pk_funcs);  /* create 'package' table */\n    createsearcherstable(L);\n    /* set paths */\n    setpath(L, to_luastring(\"path\", true), LUA_PATH_VAR, LUA_PATH_DEFAULT);\n    setpath(L, to_luastring(\"jspath\", true), LUA_JSPATH_VAR, LUA_JSPATH_DEFAULT);\n    /* store config information */\n    lua_pushliteral(L, LUA_DIRSEP + \"\\n\" + LUA_PATH_SEP + \"\\n\" + LUA_PATH_MARK + \"\\n\" +\n                        LUA_EXEC_DIR + \"\\n\" + LUA_IGMARK + \"\\n\");\n    lua_setfield(L, -2, to_luastring(\"config\", true));\n    /* set field 'loaded' */\n    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);\n    lua_setfield(L, -2, to_luastring(\"loaded\", true));\n    /* set field 'preload' */\n    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);\n    lua_setfield(L, -2, to_luastring(\"preload\", true));\n    lua_pushglobaltable(L);\n    lua_pushvalue(L, -2);  /* set 'package' as upvalue for next lib */\n    luaL_setfuncs(L, ll_funcs, 1);  /* open lib into global table */\n    lua_pop(L, 1);  /* pop global table */\n    return 1;  /* return 'package' table */\n};\n\nmodule.exports.luaopen_package = luaopen_package;\n","\"use strict\";\n\nconst {\n    LUA_MASKCALL,\n    LUA_MASKCOUNT,\n    LUA_MASKLINE,\n    LUA_MASKRET,\n    LUA_REGISTRYINDEX,\n    LUA_TFUNCTION,\n    LUA_TNIL,\n    LUA_TTABLE,\n    LUA_TUSERDATA,\n    lua_Debug,\n    lua_call,\n    lua_checkstack,\n    lua_gethook,\n    lua_gethookcount,\n    lua_gethookmask,\n    lua_getinfo,\n    lua_getlocal,\n    lua_getmetatable,\n    lua_getstack,\n    lua_getupvalue,\n    lua_getuservalue,\n    lua_insert,\n    lua_iscfunction,\n    lua_isfunction,\n    lua_isnoneornil,\n    lua_isthread,\n    lua_newtable,\n    lua_pcall,\n    lua_pop,\n    lua_pushboolean,\n    lua_pushfstring,\n    lua_pushinteger,\n    lua_pushlightuserdata,\n    lua_pushliteral,\n    lua_pushnil,\n    lua_pushstring,\n    lua_pushvalue,\n    lua_rawgetp,\n    lua_rawsetp,\n    lua_rotate,\n    lua_setfield,\n    lua_sethook,\n    lua_setlocal,\n    lua_setmetatable,\n    lua_settop,\n    lua_setupvalue,\n    lua_setuservalue,\n    lua_tojsstring,\n    lua_toproxy,\n    lua_tostring,\n    lua_tothread,\n    lua_touserdata,\n    lua_type,\n    lua_upvalueid,\n    lua_upvaluejoin,\n    lua_xmove\n} = require('./lua.js');\nconst {\n    luaL_argcheck,\n    luaL_argerror,\n    luaL_checkany,\n    luaL_checkinteger,\n    luaL_checkstring,\n    luaL_checktype,\n    luaL_error,\n    luaL_loadbuffer,\n    luaL_newlib,\n    luaL_optinteger,\n    luaL_optstring,\n    luaL_traceback,\n    lua_writestringerror\n} = require('./lauxlib.js');\nconst lualib = require('./lualib.js');\nconst {\n    luastring_indexOf,\n    to_luastring\n} = require(\"./fengaricore.js\");\n\n/*\n** If L1 != L, L1 can be in any state, and therefore there are no\n** guarantees about its stack space; any push in L1 must be\n** checked.\n*/\nconst checkstack = function(L, L1, n) {\n    if (L !== L1 && !lua_checkstack(L1, n))\n        luaL_error(L, to_luastring(\"stack overflow\", true));\n};\n\nconst db_getregistry = function(L) {\n    lua_pushvalue(L, LUA_REGISTRYINDEX);\n    return 1;\n};\n\nconst db_getmetatable = function(L) {\n    luaL_checkany(L, 1);\n    if (!lua_getmetatable(L, 1)) {\n        lua_pushnil(L);  /* no metatable */\n    }\n    return 1;\n};\n\nconst db_setmetatable = function(L) {\n    const t = lua_type(L, 2);\n    luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2, \"nil or table expected\");\n    lua_settop(L, 2);\n    lua_setmetatable(L, 1);\n    return 1;  /* return 1st argument */\n};\n\nconst db_getuservalue = function(L) {\n    if (lua_type(L, 1) !== LUA_TUSERDATA)\n        lua_pushnil(L);\n    else\n        lua_getuservalue(L, 1);\n    return 1;\n};\n\n\nconst db_setuservalue = function(L) {\n    luaL_checktype(L, 1, LUA_TUSERDATA);\n    luaL_checkany(L, 2);\n    lua_settop(L, 2);\n    lua_setuservalue(L, 1);\n    return 1;\n};\n\n/*\n** Auxiliary function used by several library functions: check for\n** an optional thread as function's first argument and set 'arg' with\n** 1 if this argument is present (so that functions can skip it to\n** access their other arguments)\n*/\nconst getthread = function(L) {\n    if (lua_isthread(L, 1)) {\n        return {\n            arg: 1,\n            thread: lua_tothread(L, 1)\n        };\n    } else {\n        return {\n            arg: 0,\n            thread: L\n        };  /* function will operate over current thread */\n    }\n};\n\n/*\n** Variations of 'lua_settable', used by 'db_getinfo' to put results\n** from 'lua_getinfo' into result table. Key is always a string;\n** value can be a string, an int, or a boolean.\n*/\nconst settabss = function(L, k, v) {\n    lua_pushstring(L, v);\n    lua_setfield(L, -2, k);\n};\n\nconst settabsi = function(L, k, v) {\n    lua_pushinteger(L, v);\n    lua_setfield(L, -2, k);\n};\n\nconst settabsb = function(L, k, v) {\n    lua_pushboolean(L, v);\n    lua_setfield(L, -2, k);\n};\n\n\n/*\n** In function 'db_getinfo', the call to 'lua_getinfo' may push\n** results on the stack; later it creates the result table to put\n** these objects. Function 'treatstackoption' puts the result from\n** 'lua_getinfo' on top of the result table so that it can call\n** 'lua_setfield'.\n*/\nconst treatstackoption = function(L, L1, fname) {\n    if (L == L1)\n        lua_rotate(L, -2, 1);  /* exchange object and table */\n    else\n        lua_xmove(L1, L, 1);  /* move object to the \"main\" stack */\n    lua_setfield(L, -2, fname);  /* put object into table */\n};\n\n/*\n** Calls 'lua_getinfo' and collects all results in a new table.\n** L1 needs stack space for an optional input (function) plus\n** two optional outputs (function and line table) from function\n** 'lua_getinfo'.\n*/\nconst db_getinfo = function(L) {\n    let ar = new lua_Debug();\n    let thread = getthread(L);\n    let arg = thread.arg;\n    let L1 = thread.thread;\n    let options = luaL_optstring(L, arg + 2, \"flnStu\");\n    checkstack(L, L1, 3);\n    if (lua_isfunction(L, arg + 1)) {  /* info about a function? */\n        options = lua_pushfstring(L, to_luastring(\">%s\"), options);  /* add '>' to 'options' */\n        lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */\n        lua_xmove(L, L1, 1);\n    } else {  /* stack level */\n        if (!lua_getstack(L1, luaL_checkinteger(L, arg + 1), ar)) {\n            lua_pushnil(L);  /* level out of range */\n            return 1;\n        }\n    }\n\n    if (!lua_getinfo(L1, options, ar))\n        luaL_argerror(L, arg + 2, \"invalid option\");\n    lua_newtable(L);  /* table to collect results */\n    if (luastring_indexOf(options, 83 /* 'S'.charCodeAt(0) */) > -1) {\n        settabss(L, to_luastring(\"source\", true), ar.source);\n        settabss(L, to_luastring(\"short_src\", true), ar.short_src);\n        settabsi(L, to_luastring(\"linedefined\", true), ar.linedefined);\n        settabsi(L, to_luastring(\"lastlinedefined\", true), ar.lastlinedefined);\n        settabss(L, to_luastring(\"what\", true), ar.what);\n    }\n    if (luastring_indexOf(options, 108 /* 'l'.charCodeAt(0) */) > -1)\n        settabsi(L, to_luastring(\"currentline\", true), ar.currentline);\n    if (luastring_indexOf(options, 117 /* 'u'.charCodeAt(0) */) > -1) {\n        settabsi(L, to_luastring(\"nups\", true), ar.nups);\n        settabsi(L, to_luastring(\"nparams\", true), ar.nparams);\n        settabsb(L, to_luastring(\"isvararg\", true), ar.isvararg);\n    }\n    if (luastring_indexOf(options, 110 /* 'n'.charCodeAt(0) */) > -1) {\n        settabss(L, to_luastring(\"name\", true), ar.name);\n        settabss(L, to_luastring(\"namewhat\", true), ar.namewhat);\n    }\n    if (luastring_indexOf(options, 116 /* 't'.charCodeAt(0) */) > -1)\n        settabsb(L, to_luastring(\"istailcall\", true), ar.istailcall);\n    if (luastring_indexOf(options, 76 /* 'L'.charCodeAt(0) */) > -1)\n        treatstackoption(L, L1, to_luastring(\"activelines\", true));\n    if (luastring_indexOf(options, 102 /* 'f'.charCodeAt(0) */) > -1)\n        treatstackoption(L, L1, to_luastring(\"func\", true));\n    return 1;  /* return table */\n};\n\nconst db_getlocal = function(L) {\n    let thread = getthread(L);\n    let L1 = thread.thread;\n    let arg = thread.arg;\n    let ar = new lua_Debug();\n    let nvar = luaL_checkinteger(L, arg + 2);  /* local-variable index */\n    if (lua_isfunction(L, arg + 1)) {\n        lua_pushvalue(L, arg + 1);  /* push function */\n        lua_pushstring(L, lua_getlocal(L, null, nvar));  /* push local name */\n        return 1;  /* return only name (there is no value) */\n    } else {  /* stack-level argument */\n        let level = luaL_checkinteger(L, arg + 1);\n        if (!lua_getstack(L1, level, ar))  /* out of range? */\n            return luaL_argerror(L, arg+1, \"level out of range\");\n        checkstack(L, L1, 1);\n        let name = lua_getlocal(L1, ar, nvar);\n        if (name) {\n            lua_xmove(L1, L, 1);  /* move local value */\n            lua_pushstring(L, name);  /* push name */\n            lua_rotate(L, -2, 1);  /* re-order */\n            return 2;\n        }\n        else {\n            lua_pushnil(L);  /* no name (nor value) */\n            return 1;\n        }\n    }\n};\n\nconst db_setlocal = function(L) {\n    let thread = getthread(L);\n    let L1 = thread.thread;\n    let arg = thread.arg;\n    let ar = new lua_Debug();\n    let level = luaL_checkinteger(L, arg + 1);\n    let nvar = luaL_checkinteger(L, arg + 2);\n    if (!lua_getstack(L1, level, ar))  /* out of range? */\n        return luaL_argerror(L, arg + 1, \"level out of range\");\n    luaL_checkany(L, arg + 3);\n    lua_settop(L, arg + 3);\n    checkstack(L, L1, 1);\n    lua_xmove(L, L1, 1);\n    let name = lua_setlocal(L1, ar, nvar);\n    if (name === null)\n        lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */\n    lua_pushstring(L, name);\n    return 1;\n};\n\n/*\n** get (if 'get' is true) or set an upvalue from a closure\n*/\nconst auxupvalue = function(L, get) {\n    let n = luaL_checkinteger(L, 2);  /* upvalue index */\n    luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */\n    let name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);\n    if (name === null) return 0;\n    lua_pushstring(L, name);\n    lua_insert(L, -(get+1));  /* no-op if get is false */\n    return get + 1;\n};\n\n\nconst db_getupvalue = function(L) {\n    return auxupvalue(L, 1);\n};\n\nconst db_setupvalue = function(L) {\n    luaL_checkany(L, 3);\n    return auxupvalue(L, 0);\n};\n\n/*\n** Check whether a given upvalue from a given closure exists and\n** returns its index\n*/\nconst checkupval = function(L, argf, argnup) {\n    let nup = luaL_checkinteger(L, argnup);  /* upvalue index */\n    luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */\n    luaL_argcheck(L, (lua_getupvalue(L, argf, nup) !== null), argnup, \"invalid upvalue index\");\n    return nup;\n};\n\nconst db_upvalueid = function(L) {\n    let n = checkupval(L, 1, 2);\n    lua_pushlightuserdata(L, lua_upvalueid(L, 1, n));\n    return 1;\n};\n\nconst db_upvaluejoin = function(L) {\n    let n1 = checkupval(L, 1, 2);\n    let n2 = checkupval(L, 3, 4);\n    luaL_argcheck(L, !lua_iscfunction(L, 1), 1, \"Lua function expected\");\n    luaL_argcheck(L, !lua_iscfunction(L, 3), 3, \"Lua function expected\");\n    lua_upvaluejoin(L, 1, n1, 3, n2);\n    return 0;\n};\n\n/*\n** The hook table at registry[HOOKKEY] maps threads to their current\n** hook function. (We only need the unique address of 'HOOKKEY'.)\n*/\nconst HOOKKEY = to_luastring(\"__hooks__\", true);\n\nconst hooknames = [\"call\", \"return\", \"line\", \"count\", \"tail call\"].map(e => to_luastring(e));\n\n/*\n** Call hook function registered at hook table for the current\n** thread (if there is one)\n*/\nconst hookf = function(L, ar) {\n    lua_rawgetp(L, LUA_REGISTRYINDEX, HOOKKEY);\n    let hooktable = lua_touserdata(L, -1);\n    let proxy = hooktable.get(L);\n    if (proxy) {  /* is there a hook function? */\n        proxy(L);\n        lua_pushstring(L, hooknames[ar.event]);  /* push event name */\n        if (ar.currentline >= 0)\n            lua_pushinteger(L, ar.currentline);  /* push current line */\n        else lua_pushnil(L);\n        lualib.lua_assert(lua_getinfo(L, to_luastring(\"lS\"), ar));\n        lua_call(L, 2, 0);  /* call hook function */\n    }\n};\n\n/*\n** Convert a string mask (for 'sethook') into a bit mask\n*/\nconst makemask = function(smask, count) {\n    let mask = 0;\n    if (luastring_indexOf(smask, 99 /* 'c'.charCodeAt(0) */) > -1) mask |= LUA_MASKCALL;\n    if (luastring_indexOf(smask, 114 /* 'r'.charCodeAt(0) */) > -1) mask |= LUA_MASKRET;\n    if (luastring_indexOf(smask, 108 /* 'l'.charCodeAt(0) */) > -1) mask |= LUA_MASKLINE;\n    if (count > 0) mask |= LUA_MASKCOUNT;\n    return mask;\n};\n\n/*\n** Convert a bit mask (for 'gethook') into a string mask\n*/\nconst unmakemask = function(mask, smask) {\n    let i = 0;\n    if (mask & LUA_MASKCALL) smask[i++] = 99 /* 'c'.charCodeAt(0) */;\n    if (mask & LUA_MASKRET) smask[i++] = 114 /* 'r'.charCodeAt(0) */;\n    if (mask & LUA_MASKLINE) smask[i++] = 108 /* 'l'.charCodeAt(0) */;\n    return smask.subarray(0, i);\n};\n\nconst db_sethook = function(L) {\n    let mask, count, func;\n    let thread = getthread(L);\n    let L1 = thread.thread;\n    let arg = thread.arg;\n    if (lua_isnoneornil(L, arg+1)) {  /* no hook? */\n        lua_settop(L, arg+1);\n        func = null; mask = 0; count = 0;  /* turn off hooks */\n    }\n    else {\n        const smask = luaL_checkstring(L, arg + 2);\n        luaL_checktype(L, arg+1, LUA_TFUNCTION);\n        count = luaL_optinteger(L, arg + 3, 0);\n        func = hookf; mask = makemask(smask, count);\n    }\n    /* as weak tables are not supported; use a JS weak-map */\n    let hooktable;\n    if (lua_rawgetp(L, LUA_REGISTRYINDEX, HOOKKEY) === LUA_TNIL) {\n        hooktable = new WeakMap();\n        lua_pushlightuserdata(L, hooktable);\n        lua_rawsetp(L, LUA_REGISTRYINDEX, HOOKKEY);  /* set it in position */\n    } else {\n        hooktable = lua_touserdata(L, -1);\n    }\n    let proxy = lua_toproxy(L, arg + 1);  /* value (hook function) */\n    hooktable.set(L1, proxy);\n    lua_sethook(L1, func, mask, count);\n    return 0;\n};\n\nconst db_gethook = function(L) {\n    let thread = getthread(L);\n    let L1 = thread.thread;\n    let buff = new Uint8Array(5);\n    let mask = lua_gethookmask(L1);\n    let hook = lua_gethook(L1);\n    if (hook === null)  /* no hook? */\n        lua_pushnil(L);\n    else if (hook !== hookf)  /* external hook? */\n        lua_pushliteral(L, \"external hook\");\n    else {  /* hook table must exist */\n        lua_rawgetp(L, LUA_REGISTRYINDEX, HOOKKEY);\n        let hooktable = lua_touserdata(L, -1);\n        let proxy = hooktable.get(L1);\n        proxy(L);\n    }\n    lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */\n    lua_pushinteger(L, lua_gethookcount(L1));  /* 3rd result = count */\n    return 3;\n};\n\nconst db_traceback = function(L) {\n    let thread = getthread(L);\n    let L1 = thread.thread;\n    let arg = thread.arg;\n    let msg = lua_tostring(L, arg + 1);\n    if (msg === null && !lua_isnoneornil(L, arg + 1))  /* non-string 'msg'? */\n        lua_pushvalue(L, arg + 1);  /* return it untouched */\n    else {\n        let level = luaL_optinteger(L, arg + 2, L === L1 ? 1 : 0);\n        luaL_traceback(L, L1, msg, level);\n    }\n    return 1;\n};\n\nconst dblib = {\n    \"gethook\":      db_gethook,\n    \"getinfo\":      db_getinfo,\n    \"getlocal\":     db_getlocal,\n    \"getmetatable\": db_getmetatable,\n    \"getregistry\":  db_getregistry,\n    \"getupvalue\":   db_getupvalue,\n    \"getuservalue\": db_getuservalue,\n    \"sethook\":      db_sethook,\n    \"setlocal\":     db_setlocal,\n    \"setmetatable\": db_setmetatable,\n    \"setupvalue\":   db_setupvalue,\n    \"setuservalue\": db_setuservalue,\n    \"traceback\":    db_traceback,\n    \"upvalueid\":    db_upvalueid,\n    \"upvaluejoin\":  db_upvaluejoin\n};\n\nlet getinput;\nif (typeof process !== \"undefined\") { // Only with Node\n    const readlineSync = require('readline-sync');\n    readlineSync.setDefaultOptions({\n        prompt: 'lua_debug> '\n    });\n    getinput = function() {\n        return readlineSync.prompt();\n    };\n} else if (typeof window !== \"undefined\") {\n    /* if in browser use window.prompt. Doesn't work from web workers.\n       See https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt\n    */\n    getinput = function() {\n        let input = prompt(\"lua_debug>\", \"\");\n        return (input !== null) ? input : \"\";\n    };\n}\nif (getinput) {\n    dblib.debug = function(L) {\n        for (;;) {\n            let input = getinput();\n\n            if (input === \"cont\")\n                return 0;\n\n            if (input.length === 0)\n                continue;\n\n            let buffer = to_luastring(input);\n            if (luaL_loadbuffer(L, buffer, buffer.length, to_luastring(\"=(debug command)\", true))\n                || lua_pcall(L, 0, 0, 0)) {\n                lua_writestringerror(lua_tojsstring(L, -1), \"\\n\");\n            }\n            lua_settop(L, 0);  /* remove eventual returns */\n        }\n    };\n}\n\nconst luaopen_debug = function(L) {\n    luaL_newlib(L, dblib);\n    return 1;\n};\n\nmodule.exports.luaopen_debug = luaopen_debug;\n","\"use strict\";\n\nconst {\n    LUA_OPLT,\n    LUA_TNUMBER,\n    lua_compare,\n    lua_gettop,\n    lua_isinteger,\n    lua_isnoneornil,\n    lua_pushboolean,\n    lua_pushinteger,\n    lua_pushliteral,\n    lua_pushnil,\n    lua_pushnumber,\n    lua_pushvalue,\n    lua_setfield,\n    lua_settop,\n    lua_tointeger,\n    lua_tointegerx,\n    lua_type\n} = require('./lua.js');\nconst {\n    luaL_argcheck,\n    luaL_argerror,\n    luaL_checkany,\n    luaL_checkinteger,\n    luaL_checknumber,\n    luaL_error,\n    luaL_newlib,\n    luaL_optnumber\n} = require('./lauxlib.js');\nconst {\n    LUA_MAXINTEGER,\n    LUA_MININTEGER,\n    lua_numbertointeger\n} = require('./luaconf.js');\nconst { to_luastring } = require(\"./fengaricore.js\");\n\nlet rand_state;\n/* use same parameters as glibc LCG */\nconst l_rand = function() {\n    rand_state = (1103515245 * rand_state + 12345) & 0x7fffffff;\n    return rand_state;\n};\nconst l_srand = function(x) {\n    rand_state = x|0;\n    if (rand_state === 0)\n        rand_state = 1;\n};\n\nconst math_random = function(L) {\n    let low, up;\n    /* use Math.random until randomseed is called */\n    let r = (rand_state === void 0)?Math.random():(l_rand() / 0x80000000);\n    switch (lua_gettop(L)) {  /* check number of arguments */\n        case 0:\n            lua_pushnumber(L, r);  /* Number between 0 and 1 */\n            return 1;\n        case 1: {\n            low = 1;\n            up = luaL_checkinteger(L, 1);\n            break;\n        }\n        case 2: {\n            low = luaL_checkinteger(L, 1);\n            up = luaL_checkinteger(L, 2);\n            break;\n        }\n        default: return luaL_error(L, \"wrong number of arguments\");\n    }\n\n    /* random integer in the interval [low, up] */\n    luaL_argcheck(L, low <= up, 1, \"interval is empty\");\n    luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,\n        \"interval too large\");\n\n    r *= (up - low) + 1;\n    lua_pushinteger(L, Math.floor(r) + low);\n    return 1;\n};\n\nconst math_randomseed = function(L) {\n    l_srand(luaL_checknumber(L, 1));\n    l_rand(); /* discard first value to avoid undesirable correlations */\n    return 0;\n};\n\nconst math_abs = function(L) {\n    if (lua_isinteger(L, 1)) {\n        let n = lua_tointeger(L, 1);\n        if (n < 0) n = (-n)|0;\n        lua_pushinteger(L, n);\n    }\n    else\n        lua_pushnumber(L, Math.abs(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_sin = function(L) {\n    lua_pushnumber(L, Math.sin(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_cos = function(L) {\n    lua_pushnumber(L, Math.cos(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_tan = function(L) {\n    lua_pushnumber(L, Math.tan(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_asin = function(L) {\n    lua_pushnumber(L, Math.asin(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_acos = function(L) {\n    lua_pushnumber(L, Math.acos(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_atan = function(L) {\n    let y = luaL_checknumber(L, 1);\n    let x = luaL_optnumber(L, 2, 1);\n    lua_pushnumber(L, Math.atan2(y, x));\n    return 1;\n};\n\nconst math_toint = function(L) {\n    let n = lua_tointegerx(L, 1);\n    if (n !== false)\n        lua_pushinteger(L, n);\n    else {\n        luaL_checkany(L, 1);\n        lua_pushnil(L);  /* value is not convertible to integer */\n    }\n    return 1;\n};\n\nconst pushnumint = function(L, d) {\n    let n = lua_numbertointeger(d);\n    if (n !== false)  /* does 'd' fit in an integer? */\n        lua_pushinteger(L, n);  /* result is integer */\n    else\n        lua_pushnumber(L, d);  /* result is float */\n};\n\nconst math_floor = function(L) {\n    if (lua_isinteger(L, 1))\n        lua_settop(L, 1);\n    else\n        pushnumint(L, Math.floor(luaL_checknumber(L, 1)));\n\n    return 1;\n};\n\nconst math_ceil = function(L) {\n    if (lua_isinteger(L, 1))\n        lua_settop(L, 1);\n    else\n        pushnumint(L, Math.ceil(luaL_checknumber(L, 1)));\n\n    return 1;\n};\n\nconst math_sqrt = function(L) {\n    lua_pushnumber(L, Math.sqrt(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_ult = function(L) {\n    let a = luaL_checkinteger(L, 1);\n    let b = luaL_checkinteger(L, 2);\n    lua_pushboolean(L, (a >= 0)?(b<0 || a<b):(b<0 && a<b));\n    return 1;\n};\n\nconst math_log = function(L) {\n    let x = luaL_checknumber(L, 1);\n    let res;\n    if (lua_isnoneornil(L, 2))\n        res = Math.log(x);\n    else {\n        let base = luaL_checknumber(L, 2);\n        if (base === 2)\n            res = Math.log2(x);\n        else if (base === 10)\n            res = Math.log10(x);\n        else\n            res = Math.log(x)/Math.log(base);\n    }\n    lua_pushnumber(L, res);\n    return 1;\n};\n\nconst math_exp = function(L) {\n    lua_pushnumber(L, Math.exp(luaL_checknumber(L, 1)));\n    return 1;\n};\n\nconst math_deg = function(L) {\n    lua_pushnumber(L, luaL_checknumber(L, 1) * (180 / Math.PI));\n    return 1;\n};\n\nconst math_rad = function(L) {\n    lua_pushnumber(L, luaL_checknumber(L, 1) * (Math.PI / 180));\n    return 1;\n};\n\nconst math_min = function(L) {\n    let n = lua_gettop(L);  /* number of arguments */\n    let imin = 1;  /* index of current minimum value */\n    luaL_argcheck(L, n >= 1, 1, \"value expected\");\n    for (let i = 2; i <= n; i++){\n        if (lua_compare(L, i, imin, LUA_OPLT))\n            imin = i;\n    }\n    lua_pushvalue(L, imin);\n    return 1;\n};\n\nconst math_max = function(L) {\n    let n = lua_gettop(L);  /* number of arguments */\n    let imax = 1;  /* index of current minimum value */\n    luaL_argcheck(L, n >= 1, 1, \"value expected\");\n    for (let i = 2; i <= n; i++){\n        if (lua_compare(L, imax, i, LUA_OPLT))\n            imax = i;\n    }\n    lua_pushvalue(L, imax);\n    return 1;\n};\n\nconst math_type = function(L) {\n    if (lua_type(L, 1) === LUA_TNUMBER) {\n        if (lua_isinteger(L, 1))\n            lua_pushliteral(L, \"integer\");\n        else\n            lua_pushliteral(L, \"float\");\n    } else {\n        luaL_checkany(L, 1);\n        lua_pushnil(L);\n    }\n    return 1;\n};\n\nconst math_fmod = function(L) {\n    if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {\n        let d = lua_tointeger(L, 2);\n        /* no special case needed for -1 in javascript */\n        if (d === 0) {\n            luaL_argerror(L, 2, \"zero\");\n        } else\n            lua_pushinteger(L, (lua_tointeger(L, 1) % d)|0);\n    } else {\n        let a = luaL_checknumber(L, 1);\n        let b = luaL_checknumber(L, 2);\n        lua_pushnumber(L, a%b);\n    }\n    return 1;\n};\n\nconst math_modf = function(L) {\n    if (lua_isinteger(L, 1)) {\n        lua_settop(L, 1);  /* number is its own integer part */\n        lua_pushnumber(L, 0);  /* no fractional part */\n    } else {\n        let n = luaL_checknumber(L, 1);\n        let ip = n < 0 ? Math.ceil(n) : Math.floor(n);\n        pushnumint(L, ip);\n        lua_pushnumber(L, n === ip ? 0 : n - ip);\n    }\n    return 2;\n};\n\nconst mathlib = {\n    \"abs\":        math_abs,\n    \"acos\":       math_acos,\n    \"asin\":       math_asin,\n    \"atan\":       math_atan,\n    \"ceil\":       math_ceil,\n    \"cos\":        math_cos,\n    \"deg\":        math_deg,\n    \"exp\":        math_exp,\n    \"floor\":      math_floor,\n    \"fmod\":       math_fmod,\n    \"log\":        math_log,\n    \"max\":        math_max,\n    \"min\":        math_min,\n    \"modf\":       math_modf,\n    \"rad\":        math_rad,\n    \"random\":     math_random,\n    \"randomseed\": math_randomseed,\n    \"sin\":        math_sin,\n    \"sqrt\":       math_sqrt,\n    \"tan\":        math_tan,\n    \"tointeger\":  math_toint,\n    \"type\":       math_type,\n    \"ult\":        math_ult\n};\n\nconst luaopen_math = function(L) {\n    luaL_newlib(L, mathlib);\n    lua_pushnumber(L, Math.PI);\n    lua_setfield(L, -2, to_luastring(\"pi\", true));\n    lua_pushnumber(L, Infinity);\n    lua_setfield(L, -2, to_luastring(\"huge\", true));\n    lua_pushinteger(L, LUA_MAXINTEGER);\n    lua_setfield(L, -2, to_luastring(\"maxinteger\", true));\n    lua_pushinteger(L, LUA_MININTEGER);\n    lua_setfield(L, -2, to_luastring(\"mininteger\", true));\n    return 1;\n};\n\nmodule.exports.luaopen_math = luaopen_math;\n","\"use strict\";\n\nconst {\n    lua_gettop,\n    lua_pushcfunction,\n    lua_pushfstring,\n    lua_pushinteger,\n    lua_pushnil,\n    lua_pushstring,\n    lua_pushvalue,\n    lua_setfield,\n    lua_tointeger\n} = require('./lua.js');\nconst {\n    luaL_Buffer,\n    luaL_addvalue,\n    luaL_argcheck,\n    luaL_buffinit,\n    luaL_checkinteger,\n    luaL_checkstack,\n    luaL_checkstring,\n    luaL_error,\n    luaL_newlib,\n    luaL_optinteger,\n    luaL_pushresult\n} = require('./lauxlib.js');\nconst {\n    luastring_of,\n    to_luastring\n} = require(\"./fengaricore.js\");\n\nconst MAXUNICODE = 0x10FFFF;\n\nconst iscont = function(p) {\n    let c = p & 0xC0;\n    return c === 0x80;\n};\n\n/* translate a relative string position: negative means back from end */\nconst u_posrelat = function(pos, len) {\n    if (pos >= 0) return pos;\n    else if (0 - pos > len) return 0;\n    else return len + pos + 1;\n};\n\n/*\n** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid.\n*/\nconst limits = [0xFF, 0x7F, 0x7FF, 0xFFFF];\nconst utf8_decode = function(s, pos) {\n    let c = s[pos];\n    let res = 0;  /* final result */\n    if (c < 0x80)  /* ascii? */\n        res = c;\n    else {\n        let count = 0;  /* to count number of continuation bytes */\n        while (c & 0x40) {  /* still have continuation bytes? */\n            let cc = s[pos + (++count)];  /* read next byte */\n            if ((cc & 0xC0) !== 0x80)  /* not a continuation byte? */\n                return null;  /* invalid byte sequence */\n            res = (res << 6) | (cc & 0x3F);  /* add lower 6 bits from cont. byte */\n            c <<= 1;  /* to test next bit */\n        }\n        res |= ((c & 0x7F) << (count * 5));  /* add first byte */\n        if (count > 3 || res > MAXUNICODE || res <= limits[count])\n            return null;  /* invalid byte sequence */\n        pos += count;  /* skip continuation bytes read */\n    }\n\n    return {\n        code: res,\n        pos: pos + 1\n    };\n};\n\n/*\n** utf8len(s [, i [, j]]) --> number of characters that start in the\n** range [i,j], or nil + current position if 's' is not well formed in\n** that interval\n*/\nconst utflen = function(L) {\n    let n = 0;\n    let s = luaL_checkstring(L, 1);\n    let len = s.length;\n    let posi = u_posrelat(luaL_optinteger(L, 2, 1), len);\n    let posj = u_posrelat(luaL_optinteger(L, 3, -1), len);\n\n    luaL_argcheck(L, 1 <= posi && --posi <= len, 2, \"initial position out of string\");\n    luaL_argcheck(L, --posj < len, 3, \"final position out of string\");\n\n    while (posi <= posj) {\n        let dec = utf8_decode(s, posi);\n        if (dec === null) { /* conversion error? */\n            lua_pushnil(L);  /* return nil ... */\n            lua_pushinteger(L, posi + 1);  /* ... and current position */\n            return 2;\n        }\n        posi = dec.pos;\n        n++;\n    }\n    lua_pushinteger(L, n);\n    return 1;\n};\n\nconst p_U = to_luastring(\"%U\");\nconst pushutfchar = function(L, arg) {\n    let code = luaL_checkinteger(L, arg);\n    luaL_argcheck(L, 0 <= code && code <= MAXUNICODE, arg, \"value out of range\");\n    lua_pushfstring(L, p_U, code);\n};\n\n/*\n** utfchar(n1, n2, ...)  -> char(n1)..char(n2)...\n*/\nconst utfchar = function(L) {\n    let n = lua_gettop(L);  /* number of arguments */\n    if (n === 1)  /* optimize common case of single char */\n        pushutfchar(L, 1);\n    else {\n        let b = new luaL_Buffer();\n        luaL_buffinit(L, b);\n        for (let i = 1; i <= n; i++) {\n            pushutfchar(L, i);\n            luaL_addvalue(b);\n        }\n        luaL_pushresult(b);\n    }\n    return 1;\n};\n\n/*\n** offset(s, n, [i])  -> index where n-th character counting from\n**   position 'i' starts; 0 means character at 'i'.\n*/\nconst byteoffset = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let n = luaL_checkinteger(L, 2);\n    let posi = n >= 0 ? 1 : s.length + 1;\n    posi = u_posrelat(luaL_optinteger(L, 3, posi), s.length);\n\n    luaL_argcheck(L, 1 <= posi && --posi <= s.length, 3, \"position out of range\");\n\n    if (n === 0) {\n        /* find beginning of current byte sequence */\n        while (posi > 0 && iscont(s[posi])) posi--;\n    } else {\n        if (iscont(s[posi]))\n            luaL_error(L, \"initial position is a continuation byte\");\n\n        if (n < 0) {\n            while (n < 0 && posi > 0) {  /* move back */\n                do {  /* find beginning of previous character */\n                    posi--;\n                } while (posi > 0 && iscont(s[posi]));\n                n++;\n            }\n        } else {\n            n--;  /* do not move for 1st character */\n            while (n > 0 && posi < s.length) {\n                do {  /* find beginning of next character */\n                    posi++;\n                } while (iscont(s[posi]));  /* (cannot pass final '\\0') */\n                n--;\n            }\n        }\n    }\n\n    if (n === 0)  /* did it find given character? */\n        lua_pushinteger(L, posi + 1);\n    else  /* no such character */\n        lua_pushnil(L);\n\n    return 1;\n};\n\n/*\n** codepoint(s, [i, [j]])  -> returns codepoints for all characters\n** that start in the range [i,j]\n*/\nconst codepoint = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let posi = u_posrelat(luaL_optinteger(L, 2, 1), s.length);\n    let pose = u_posrelat(luaL_optinteger(L, 3, posi), s.length);\n\n    luaL_argcheck(L, posi >= 1, 2, \"out of range\");\n    luaL_argcheck(L, pose <= s.length, 3, \"out of range\");\n\n    if (posi > pose) return 0;  /* empty interval; return no values */\n    if (pose - posi >= Number.MAX_SAFE_INTEGER)\n        return luaL_error(L, \"string slice too long\");\n    let n = (pose - posi) + 1;\n    luaL_checkstack(L, n, \"string slice too long\");\n    n = 0;\n    for (posi -= 1; posi < pose;) {\n        let dec = utf8_decode(s, posi);\n        if (dec === null)\n            return luaL_error(L, \"invalid UTF-8 code\");\n        lua_pushinteger(L, dec.code);\n        posi = dec.pos;\n        n++;\n    }\n    return n;\n};\n\nconst iter_aux = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let len = s.length;\n    let n = lua_tointeger(L, 2) - 1;\n\n    if (n < 0)  /* first iteration? */\n        n = 0;  /* start from here */\n    else if (n < len) {\n        n++;  /* skip current byte */\n        while (iscont(s[n])) n++;  /* and its continuations */\n    }\n\n    if (n >= len)\n        return 0;  /* no more codepoints */\n    else {\n        let dec = utf8_decode(s, n);\n        if (dec === null || iscont(s[dec.pos]))\n            return luaL_error(L, to_luastring(\"invalid UTF-8 code\"));\n        lua_pushinteger(L, n + 1);\n        lua_pushinteger(L, dec.code);\n        return 2;\n    }\n};\n\nconst iter_codes = function(L) {\n    luaL_checkstring(L, 1);\n    lua_pushcfunction(L, iter_aux);\n    lua_pushvalue(L, 1);\n    lua_pushinteger(L, 0);\n    return 3;\n};\n\nconst funcs = {\n    \"char\":      utfchar,\n    \"codepoint\": codepoint,\n    \"codes\":     iter_codes,\n    \"len\":       utflen,\n    \"offset\":    byteoffset\n};\n\n/* pattern to match a single UTF-8 character */\nconst UTF8PATT = luastring_of(91, 0, 45, 127, 194, 45, 244, 93, 91, 128, 45, 191, 93, 42);\n\nconst luaopen_utf8 = function(L) {\n    luaL_newlib(L, funcs);\n    lua_pushstring(L, UTF8PATT);\n    lua_setfield(L, -2, to_luastring(\"charpattern\", true));\n    return 1;\n};\n\nmodule.exports.luaopen_utf8 = luaopen_utf8;\n","\"use strict\";\n\nconst { sprintf } = require('sprintf-js');\n\nconst {\n    LUA_INTEGER_FMT,\n    LUA_INTEGER_FRMLEN,\n    LUA_MININTEGER,\n    LUA_NUMBER_FMT,\n    LUA_NUMBER_FRMLEN,\n    frexp,\n    lua_getlocaledecpoint\n} = require('./luaconf.js');\nconst {\n    LUA_TBOOLEAN,\n    LUA_TFUNCTION,\n    LUA_TNIL,\n    LUA_TNUMBER,\n    LUA_TSTRING,\n    LUA_TTABLE,\n    lua_call,\n    lua_createtable,\n    lua_dump,\n    lua_gettable,\n    lua_gettop,\n    lua_isinteger,\n    lua_isstring,\n    lua_pop,\n    lua_pushcclosure,\n    lua_pushinteger,\n    lua_pushlightuserdata,\n    lua_pushliteral,\n    lua_pushlstring,\n    lua_pushnil,\n    lua_pushnumber,\n    lua_pushstring,\n    lua_pushvalue,\n    lua_remove,\n    lua_setfield,\n    lua_setmetatable,\n    lua_settop,\n    lua_toboolean,\n    lua_tointeger,\n    lua_tonumber,\n    lua_tostring,\n    lua_touserdata,\n    lua_type,\n    lua_upvalueindex\n} = require('./lua.js');\nconst {\n    luaL_Buffer,\n    luaL_addchar,\n    luaL_addlstring,\n    luaL_addsize,\n    luaL_addstring,\n    luaL_addvalue,\n    luaL_argcheck,\n    luaL_argerror,\n    luaL_buffinit,\n    luaL_buffinitsize,\n    luaL_checkinteger,\n    luaL_checknumber,\n    luaL_checkstack,\n    luaL_checkstring,\n    luaL_checktype,\n    luaL_error,\n    luaL_newlib,\n    luaL_optinteger,\n    luaL_optstring,\n    luaL_prepbuffsize,\n    luaL_pushresult,\n    luaL_pushresultsize,\n    luaL_tolstring,\n    luaL_typename\n} = require('./lauxlib.js');\nconst lualib = require('./lualib.js');\nconst {\n    luastring_eq,\n    luastring_indexOf,\n    to_jsstring,\n    to_luastring\n} = require(\"./fengaricore.js\");\n\nconst sL_ESC  = '%';\nconst L_ESC   = sL_ESC.charCodeAt(0);\n\n/*\n** maximum number of captures that a pattern can do during\n** pattern-matching. This limit is arbitrary, but must fit in\n** an unsigned char.\n*/\nconst LUA_MAXCAPTURES = 32;\n\n// (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))\nconst MAXSIZE = 2147483647;\n\n/* Give natural (i.e. strings end at the first \\0) length of a string represented by an array of bytes */\nconst strlen = function(s) {\n    let len = luastring_indexOf(s, 0);\n    return len > -1 ? len : s.length;\n};\n\n/* translate a relative string position: negative means back from end */\nconst posrelat = function(pos, len) {\n    if (pos >= 0) return pos;\n    else if (0 - pos > len) return 0;\n    else return len + pos + 1;\n};\n\nconst str_sub = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let l = s.length;\n    let start = posrelat(luaL_checkinteger(L, 2), l);\n    let end = posrelat(luaL_optinteger(L, 3, -1), l);\n    if (start < 1) start = 1;\n    if (end > l) end = l;\n    if (start <= end)\n        lua_pushstring(L, s.subarray(start - 1, (start - 1) + (end - start + 1)));\n    else lua_pushliteral(L, \"\");\n    return 1;\n};\n\nconst str_len = function(L) {\n    lua_pushinteger(L, luaL_checkstring(L, 1).length);\n    return 1;\n};\n\nconst str_char = function(L) {\n    let n = lua_gettop(L);  /* number of arguments */\n    let b = new luaL_Buffer();\n    let p = luaL_buffinitsize(L, b, n);\n    for (let i = 1; i <= n; i++) {\n        let c = luaL_checkinteger(L, i);\n        luaL_argcheck(L, c >= 0 && c <= 255, \"value out of range\"); // Strings are 8-bit clean\n        p[i-1] = c;\n    }\n    luaL_pushresultsize(b, n);\n    return 1;\n};\n\nconst writer = function(L, b, size, B) {\n    luaL_addlstring(B, b, size);\n    return 0;\n};\n\nconst str_dump = function(L) {\n    let b = new luaL_Buffer();\n    let strip = lua_toboolean(L, 2);\n    luaL_checktype(L, 1, LUA_TFUNCTION);\n    lua_settop(L, 1);\n    luaL_buffinit(L, b);\n    if (lua_dump(L, writer, b, strip) !== 0)\n        return luaL_error(L, to_luastring(\"unable to dump given function\"));\n    luaL_pushresult(b);\n    return 1;\n};\n\nconst SIZELENMOD = LUA_NUMBER_FRMLEN.length + 1;\n\nconst L_NBFD = 1;\n\nconst num2straux = function(x) {\n    /* if 'inf' or 'NaN', format it like '%g' */\n    if (Object.is(x, Infinity))\n        return to_luastring('inf');\n    else if (Object.is(x, -Infinity))\n        return to_luastring('-inf');\n    else if (Number.isNaN(x))\n        return to_luastring('nan');\n    else if (x === 0) {  /* can be -0... */\n        /* create \"0\" or \"-0\" followed by exponent */\n        let zero = sprintf(LUA_NUMBER_FMT + \"x0p+0\", x);\n        if (Object.is(x, -0))\n            zero = \"-\" + zero;\n        return to_luastring(zero);\n    } else {\n        let buff = \"\";\n        let fe = frexp(x);  /* 'x' fraction and exponent */\n        let m = fe[0];\n        let e = fe[1];\n        if (m < 0) {  /* is number negative? */\n            buff += '-';  /* add signal */\n            m = -m;  /* make it positive */\n        }\n        buff += \"0x\";  /* add \"0x\" */\n        buff += (m * (1<<L_NBFD)).toString(16);\n        e -= L_NBFD;  /* this digit goes before the radix point */\n        buff += sprintf(\"p%+d\", e);  /* add exponent */\n        return to_luastring(buff);\n    }\n};\n\nconst lua_number2strx = function(L, fmt, x) {\n    let buff = num2straux(x);\n    if (fmt[SIZELENMOD] === 65 /* 'A'.charCodeAt(0) */) {\n        for (let i = 0; i < buff.length; i++) {\n            let c = buff[i];\n            if (c >= 97) /* toupper */\n                buff[i] = c & 0xdf;\n        }\n    } else if (fmt[SIZELENMOD] !== 97 /* 'a'.charCodeAt(0) */)\n        luaL_error(L, to_luastring(\"modifiers for format '%%a'/'%%A' not implemented\"));\n    return buff;\n};\n\n/*\n** Maximum size of each formatted item. This maximum size is produced\n** by format('%.99f', -maxfloat), and is equal to 99 + 3 ('-', '.',\n** and '\\0') + number of decimal digits to represent maxfloat (which\n** is maximum exponent + 1). (99+3+1 then rounded to 120 for \"extra\n** expenses\", such as locale-dependent stuff)\n*/\n// const MAX_ITEM   = 120;// TODO: + l_mathlim(MAX_10_EXP);\n\n\n/* valid flags in a format specification */\nconst FLAGS = to_luastring(\"-+ #0\");\n\n/*\n** maximum size of each format specification (such as \"%-099.99d\")\n*/\n// const MAX_FORMAT = 32;\n\nconst isalpha = e => (97 <= e && e <= 122) || (65 <= e && e <= 90);\nconst isdigit = e => 48 <= e && e <= 57;\nconst iscntrl = e => (0x00 <= e && e <= 0x1f) || e === 0x7f;\nconst isgraph = e => 33 <= e && e <= 126;\nconst islower = e => 97 <= e && e <= 122;\nconst isupper = e => 65 <= e && e <= 90;\nconst isalnum = e => (97 <= e && e <= 122) || (65 <= e && e <= 90) || (48 <= e && e <= 57);\nconst ispunct = e => isgraph(e) && !isalnum(e);\nconst isspace = e => e === 32 || (e >= 9 && e <= 13);\nconst isxdigit = e => (48 <= e && e <= 57) || (65 <= e && e <= 70) || (97 <= e && e <= 102);\n\nconst addquoted = function(b, s, len) {\n    luaL_addchar(b, 34 /* '\"'.charCodeAt(0) */);\n    let i = 0;\n    while (len--) {\n        if (s[i] === 34 /* '\"'.charCodeAt(0) */ ||\n            s[i] === 92 /* '\\\\'.charCodeAt(0) */ ||\n            s[i] === 10 /* '\\n'.charCodeAt(0) */) {\n            luaL_addchar(b, 92 /* '\\\\'.charCodeAt(0) */);\n            luaL_addchar(b, s[i]);\n        } else if (iscntrl(s[i])) {\n            let buff = ''+s[i];\n            if (isdigit(s[i+1]))\n                buff = '0'.repeat(3-buff.length) + buff; /* pad to 3 '0's */\n            luaL_addstring(b, to_luastring(\"\\\\\" + buff));\n        } else\n            luaL_addchar(b, s[i]);\n        i++;\n    }\n    luaL_addchar(b, 34 /* '\"'.charCodeAt(0) */);\n};\n\n/*\n** Ensures the 'buff' string uses a dot as the radix character.\n*/\nconst checkdp = function(buff) {\n    if (luastring_indexOf(buff, 46 /* ('.').charCodeAt(0) */) < 0) {  /* no dot? */\n        let point = lua_getlocaledecpoint();  /* try locale point */\n        let ppoint = luastring_indexOf(buff, point);\n        if (ppoint) buff[ppoint] = 46 /* ('.').charCodeAt(0) */;  /* change it to a dot */\n    }\n};\n\nconst addliteral = function(L, b, arg) {\n    switch(lua_type(L, arg)) {\n        case LUA_TSTRING: {\n            let s = lua_tostring(L, arg);\n            addquoted(b, s, s.length);\n            break;\n        }\n        case LUA_TNUMBER: {\n            let buff;\n            if (!lua_isinteger(L, arg)) {  /* float? */\n                let n = lua_tonumber(L, arg);  /* write as hexa ('%a') */\n                buff = lua_number2strx(L, to_luastring(`%${LUA_INTEGER_FRMLEN}a`), n);\n                checkdp(buff);  /* ensure it uses a dot */\n            } else {  /* integers */\n                let n = lua_tointeger(L, arg);\n                let format = (n === LUA_MININTEGER)  /* corner case? */\n                    ? \"0x%\" + LUA_INTEGER_FRMLEN + \"x\"  /* use hexa */\n                    : LUA_INTEGER_FMT;  /* else use default format */\n                buff = to_luastring(sprintf(format, n));\n            }\n            luaL_addstring(b, buff);\n            break;\n        }\n        case LUA_TNIL: case LUA_TBOOLEAN: {\n            luaL_tolstring(L, arg);\n            luaL_addvalue(b);\n            break;\n        }\n        default: {\n            luaL_argerror(L, arg, to_luastring(\"value has no literal form\"));\n        }\n    }\n};\n\nconst scanformat = function(L, strfrmt, i, form) {\n    let p = i;\n    while (strfrmt[p] !== 0 && luastring_indexOf(FLAGS, strfrmt[p]) >= 0) p++;  /* skip flags */\n    if (p - i >= FLAGS.length)\n        luaL_error(L, to_luastring(\"invalid format (repeated flags)\"));\n    if (isdigit(strfrmt[p])) p++;  /* skip width */\n    if (isdigit(strfrmt[p])) p++;  /* (2 digits at most) */\n    if (strfrmt[p] === 46 /* '.'.charCodeAt(0) */) {\n        p++;\n        if (isdigit(strfrmt[p])) p++;  /* skip precision */\n        if (isdigit(strfrmt[p])) p++;  /* (2 digits at most) */\n    }\n    if (isdigit(strfrmt[p]))\n        luaL_error(L, to_luastring(\"invalid format (width or precision too long)\"));\n    form[0] = 37 /* \"%\".charCodeAt(0) */;\n    for (let j = 0; j < p - i + 1; j++)\n        form[j+1] = strfrmt[i+j];\n    return p;\n};\n\n/*\n** add length modifier into formats\n*/\nconst addlenmod = function(form, lenmod) {\n    let l = form.length;\n    let lm = lenmod.length;\n    let spec = form[l - 1];\n    for (let i = 0; i < lm; i++)\n        form[i + l - 1] = lenmod[i];\n    form[l + lm - 1] = spec;\n    // form[l + lm] = 0;\n};\n\nconst str_format = function(L) {\n    let top = lua_gettop(L);\n    let arg = 1;\n    let strfrmt = luaL_checkstring(L, arg);\n    let i = 0;\n    let b = new luaL_Buffer();\n    luaL_buffinit(L, b);\n    while (i < strfrmt.length) {\n        if (strfrmt[i] !== L_ESC) {\n            luaL_addchar(b, strfrmt[i++]);\n        } else if (strfrmt[++i] === L_ESC) {\n            luaL_addchar(b, strfrmt[i++]); /* %% */\n        } else { /* format item */\n            let form = [];  /* to store the format ('%...') */\n            if (++arg > top)\n                luaL_argerror(L, arg, to_luastring(\"no value\"));\n            i = scanformat(L, strfrmt, i, form);\n            switch (String.fromCharCode(strfrmt[i++])) {\n                case 'c': {\n                    // sprintf(String.fromCharCode(...form), luaL_checkinteger(L, arg));\n                    luaL_addchar(b, luaL_checkinteger(L, arg));\n                    break;\n                }\n                case 'd': case 'i':\n                case 'o': case 'u': case 'x': case 'X': {\n                    let n = luaL_checkinteger(L, arg);\n                    addlenmod(form, to_luastring(LUA_INTEGER_FRMLEN, true));\n                    luaL_addstring(b, to_luastring(sprintf(String.fromCharCode(...form), n)));\n                    break;\n                }\n                case 'a': case 'A': {\n                    addlenmod(form, to_luastring(LUA_INTEGER_FRMLEN, true));\n                    luaL_addstring(b, lua_number2strx(L, form, luaL_checknumber(L, arg)));\n                    break;\n                }\n                case 'e': case 'E': case 'f':\n                case 'g': case 'G': {\n                    let n = luaL_checknumber(L, arg);\n                    addlenmod(form, to_luastring(LUA_INTEGER_FRMLEN, true));\n                    luaL_addstring(b, to_luastring(sprintf(String.fromCharCode(...form), n)));\n                    break;\n                }\n                case 'q': {\n                    addliteral(L, b, arg);\n                    break;\n                }\n                case 's': {\n                    let s = luaL_tolstring(L, arg);\n                    if (form.length <= 2 || form[2] === 0) {  /* no modifiers? */\n                        luaL_addvalue(b);  /* keep entire string */\n                    } else {\n                        luaL_argcheck(L, s.length === strlen(s), arg, \"string contains zeros\");\n                        if (luastring_indexOf(form, 46 /* '.'.charCodeAt(0) */) < 0 && s.length >= 100) {\n                            /* no precision and string is too long to be formatted */\n                            luaL_addvalue(b);  /* keep entire string */\n                        } else {  /* format the string into 'buff' */\n                            // TODO: will fail if s is not valid UTF-8\n                            luaL_addstring(b, to_luastring(sprintf(String.fromCharCode(...form), to_jsstring(s))));\n                            lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */\n                        }\n                    }\n                    break;\n                }\n                default: {  /* also treat cases 'pnLlh' */\n                    return luaL_error(L, to_luastring(\"invalid option '%%%c' to 'format'\"), strfrmt[i-1]);\n                }\n            }\n        }\n    }\n    luaL_pushresult(b);\n    return 1;\n};\n\n/* value used for padding */\nconst LUAL_PACKPADBYTE = 0x00;\n\n/* maximum size for the binary representation of an integer */\nconst MAXINTSIZE = 16;\n\nconst SZINT = 4; // Size of lua_Integer\n\n/* number of bits in a character */\nconst NB = 8;\n\n/* mask for one character (NB 1's) */\nconst MC = ((1 << NB) - 1);\n\nconst MAXALIGN = 8;\n\n/*\n** information to pack/unpack stuff\n*/\nclass Header {\n    constructor(L) {\n        this.L = L;\n        this.islittle = true;\n        this.maxalign = 1;\n    }\n}\n\n/*\n** options for pack/unpack\n*/\nconst Kint       = 0; /* signed integers */\nconst Kuint      = 1; /* unsigned integers */\nconst Kfloat     = 2; /* floating-point numbers */\nconst Kchar      = 3; /* fixed-length strings */\nconst Kstring    = 4; /* strings with prefixed length */\nconst Kzstr      = 5; /* zero-terminated strings */\nconst Kpadding   = 6; /* padding */\nconst Kpaddalign = 7; /* padding for alignment */\nconst Knop       = 8; /* no-op (configuration or spaces) */\n\nconst digit = isdigit;\n\nconst getnum = function(fmt, df) {\n    if (fmt.off >= fmt.s.length || !digit(fmt.s[fmt.off]))  /* no number? */\n        return df;  /* return default value */\n    else {\n        let a = 0;\n        do {\n            a = a * 10 + (fmt.s[fmt.off++] - 48 /* '0'.charCodeAt(0) */);\n        } while (fmt.off < fmt.s.length && digit(fmt.s[fmt.off]) && a <= (MAXSIZE - 9)/10);\n        return a;\n    }\n};\n\n/*\n** Read an integer numeral and raises an error if it is larger\n** than the maximum size for integers.\n*/\nconst getnumlimit = function(h, fmt, df) {\n    let sz = getnum(fmt, df);\n    if (sz > MAXINTSIZE || sz <= 0)\n        luaL_error(h.L, to_luastring(\"integral size (%d) out of limits [1,%d]\"), sz, MAXINTSIZE);\n    return sz;\n};\n\n/*\n** Read and classify next option. 'size' is filled with option's size.\n*/\nconst getoption = function(h, fmt) {\n    let r = {\n        opt: fmt.s[fmt.off++],\n        size: 0  /* default */\n    };\n    switch (r.opt) {\n        case 98  /*'b'*/: r.size = 1; r.opt = Kint;   return r; // sizeof(char): 1\n        case 66  /*'B'*/: r.size = 1; r.opt = Kuint;  return r;\n        case 104 /*'h'*/: r.size = 2; r.opt = Kint;   return r; // sizeof(short): 2\n        case 72  /*'H'*/: r.size = 2; r.opt = Kuint;  return r;\n        case 108 /*'l'*/: r.size = 4; r.opt = Kint;   return r; // sizeof(long): 4\n        case 76  /*'L'*/: r.size = 4; r.opt = Kuint;  return r;\n        case 106 /*'j'*/: r.size = 4; r.opt = Kint;   return r; // sizeof(lua_Integer): 4\n        case 74  /*'J'*/: r.size = 4; r.opt = Kuint;  return r;\n        case 84  /*'T'*/: r.size = 4; r.opt = Kuint;  return r; // sizeof(size_t): 4\n        case 102 /*'f'*/: r.size = 4; r.opt = Kfloat; return r; // sizeof(float): 4\n        case 100 /*'d'*/: r.size = 8; r.opt = Kfloat; return r; // sizeof(double): 8\n        case 110 /*'n'*/: r.size = 8; r.opt = Kfloat; return r; // sizeof(lua_Number): 8\n        case 105 /*'i'*/: r.size = getnumlimit(h, fmt, 4); r.opt = Kint;    return r; // sizeof(int): 4\n        case 73  /*'I'*/: r.size = getnumlimit(h, fmt, 4); r.opt = Kuint;   return r;\n        case 115 /*'s'*/: r.size = getnumlimit(h, fmt, 4); r.opt = Kstring; return r;\n        case 99  /*'c'*/: {\n            r.size = getnum(fmt, -1);\n            if (r.size === -1)\n                luaL_error(h.L, to_luastring(\"missing size for format option 'c'\"));\n            r.opt = Kchar;\n            return r;\n        }\n        case 122 /*'z'*/:             r.opt = Kzstr;      return r;\n        case 120 /*'x'*/: r.size = 1; r.opt = Kpadding;   return r;\n        case 88  /*'X'*/:             r.opt = Kpaddalign; return r;\n        case 32  /*' '*/: break;\n        case 60  /*'<'*/: h.islittle = true; break;\n        case 62  /*'>'*/: h.islittle = false; break;\n        case 61  /*'='*/: h.islittle = true; break;\n        case 33  /*'!'*/: h.maxalign = getnumlimit(h, fmt, MAXALIGN); break;\n        default: luaL_error(h.L, to_luastring(\"invalid format option '%c'\"), r.opt);\n    }\n    r.opt = Knop;\n    return r;\n};\n\n/*\n** Read, classify, and fill other details about the next option.\n** 'psize' is filled with option's size, 'notoalign' with its\n** alignment requirements.\n** Local variable 'size' gets the size to be aligned. (Kpadal option\n** always gets its full alignment, other options are limited by\n** the maximum alignment ('maxalign'). Kchar option needs no alignment\n** despite its size.\n*/\nconst getdetails = function(h, totalsize, fmt) {\n    let r = {\n        opt: NaN,\n        size: NaN,\n        ntoalign: NaN\n    };\n\n    let opt = getoption(h, fmt);\n    r.size = opt.size;\n    r.opt = opt.opt;\n    let align = r.size;  /* usually, alignment follows size */\n    if (r.opt === Kpaddalign) {  /* 'X' gets alignment from following option */\n        if (fmt.off >= fmt.s.length || fmt.s[fmt.off] === 0)\n            luaL_argerror(h.L, 1, to_luastring(\"invalid next option for option 'X'\"));\n        else {\n            let o = getoption(h, fmt);\n            align = o.size;\n            o = o.opt;\n            if (o === Kchar || align === 0)\n                luaL_argerror(h.L, 1, to_luastring(\"invalid next option for option 'X'\"));\n        }\n    }\n    if (align <= 1 || r.opt === Kchar)  /* need no alignment? */\n        r.ntoalign = 0;\n    else {\n        if (align > h.maxalign)  /* enforce maximum alignment */\n            align = h.maxalign;\n        if ((align & (align -1)) !== 0)  /* is 'align' not a power of 2? */\n            luaL_argerror(h.L, 1, to_luastring(\"format asks for alignment not power of 2\"));\n        r.ntoalign = (align - (totalsize & (align - 1))) & (align - 1);\n    }\n    return r;\n};\n\n/*\n** Pack integer 'n' with 'size' bytes and 'islittle' endianness.\n** The final 'if' handles the case when 'size' is larger than\n** the size of a Lua integer, correcting the extra sign-extension\n** bytes if necessary (by default they would be zeros).\n*/\nconst packint = function(b, n, islittle, size, neg) {\n    let buff = luaL_prepbuffsize(b, size);\n    buff[islittle ? 0 : size - 1] = n & MC;  /* first byte */\n    for (let i = 1; i < size; i++) {\n        n >>= NB;\n        buff[islittle ? i : size - 1 - i] = n & MC;\n    }\n    if (neg && size > SZINT) {  /* negative number need sign extension? */\n        for (let i = SZINT; i < size; i++)  /* correct extra bytes */\n            buff[islittle ? i : size - 1 - i] = MC;\n    }\n    luaL_addsize(b, size);  /* add result to buffer */\n};\n\nconst str_pack = function(L) {\n    let b = new luaL_Buffer();\n    let h = new Header(L);\n    let fmt = {\n        s: luaL_checkstring(L, 1),  /* format string */\n        off: 0\n    };\n    let arg = 1;  /* current argument to pack */\n    let totalsize = 0;  /* accumulate total size of result */\n    lua_pushnil(L);  /* mark to separate arguments from string buffer */\n    luaL_buffinit(L, b);\n    while (fmt.off < fmt.s.length) {\n        let details = getdetails(h, totalsize, fmt);\n        let opt = details.opt;\n        let size = details.size;\n        let ntoalign = details.ntoalign;\n        totalsize += ntoalign + size;\n        while (ntoalign-- > 0)\n            luaL_addchar(b, LUAL_PACKPADBYTE);  /* fill alignment */\n        arg++;\n        switch (opt) {\n            case Kint: {  /* signed integers */\n                let n = luaL_checkinteger(L, arg);\n                if (size < SZINT) {  /* need overflow check? */\n                    let lim = 1 << (size * 8) - 1;\n                    luaL_argcheck(L, -lim <= n && n < lim, arg, \"integer overflow\");\n                }\n                packint(b, n, h.islittle, size, n < 0);\n                break;\n            }\n            case Kuint: {  /* unsigned integers */\n                let n = luaL_checkinteger(L, arg);\n                if (size < SZINT)\n                    luaL_argcheck(L, (n>>>0) < (1 << (size * NB)), arg, \"unsigned overflow\");\n                packint(b, n>>>0, h.islittle, size, false);\n                break;\n            }\n            case Kfloat: {  /* floating-point options */\n                let buff = luaL_prepbuffsize(b, size);\n                let n = luaL_checknumber(L, arg);  /* get argument */\n                let dv = new DataView(buff.buffer, buff.byteOffset, buff.byteLength);\n                if (size === 4) dv.setFloat32(0, n, h.islittle);\n                else dv.setFloat64(0, n, h.islittle);\n                luaL_addsize(b, size);\n                break;\n            }\n            case Kchar: {  /* fixed-size string */\n                let s = luaL_checkstring(L, arg);\n                let len = s.length;\n                luaL_argcheck(L, len <= size, arg, \"string longer than given size\");\n                luaL_addlstring(b, s, len);  /* add string */\n                while (len++ < size)  /* pad extra space */\n                    luaL_addchar(b, LUAL_PACKPADBYTE);\n                break;\n            }\n            case Kstring: {  /* strings with length count */\n                let s = luaL_checkstring(L, arg);\n                let len = s.length;\n                luaL_argcheck(L,\n                    size >= 4 /* sizeof(size_t) */ || len < (1 << (size * NB)),\n                    arg, \"string length does not fit in given size\");\n                packint(b, len, h.islittle, size, 0);  /* pack length */\n                luaL_addlstring(b, s, len);\n                totalsize += len;\n                break;\n            }\n            case Kzstr: {  /* zero-terminated string */\n                let s = luaL_checkstring(L, arg);\n                let len = s.length;\n                luaL_argcheck(L, luastring_indexOf(s, 0) < 0, arg, \"strings contains zeros\");\n                luaL_addlstring(b, s, len);\n                luaL_addchar(b, 0);  /* add zero at the end */\n                totalsize += len + 1;\n                break;\n            }\n            case Kpadding: luaL_addchar(b, LUAL_PACKPADBYTE); /* fall through */\n            case Kpaddalign: case Knop:\n                arg--;  /* undo increment */\n                break;\n        }\n    }\n    luaL_pushresult(b);\n    return 1;\n};\n\nconst str_reverse = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let l = s.length;\n    let r = new Uint8Array(l);\n    for (let i=0; i<l; i++)\n        r[i] = s[l-1-i];\n    lua_pushstring(L, r);\n    return 1;\n};\n\nconst str_lower = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let l = s.length;\n    let r = new Uint8Array(l);\n    for (let i=0; i<l; i++) {\n        let c = s[i];\n        if (isupper(c))\n            c = c | 0x20;\n        r[i] = c;\n    }\n    lua_pushstring(L, r);\n    return 1;\n};\n\nconst str_upper = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let l = s.length;\n    let r = new Uint8Array(l);\n    for (let i=0; i<l; i++) {\n        let c = s[i];\n        if (islower(c))\n            c = c & 0xdf;\n        r[i] = c;\n    }\n    lua_pushstring(L, r);\n    return 1;\n};\n\nconst str_rep = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let l = s.length;\n    let n = luaL_checkinteger(L, 2);\n    let sep = luaL_optstring(L, 3, \"\");\n    let lsep = sep.length;\n    if (n <= 0) lua_pushliteral(L, \"\");\n    else if (l + lsep < l || l + lsep > MAXSIZE / n)  /* may overflow? */\n        return luaL_error(L, to_luastring(\"resulting string too large\"));\n    else {\n        let totallen = n * l + (n - 1) * lsep;\n        let b = new luaL_Buffer();\n        let p = luaL_buffinitsize(L, b, totallen);\n        let pi = 0;\n        while (n-- > 1) {  /* first n-1 copies (followed by separator) */\n            p.set(s, pi);\n            pi += l;\n            if (lsep > 0) {  /* empty 'memcpy' is not that cheap */\n                p.set(sep, pi);\n                pi += lsep;\n            }\n        }\n        p.set(s, pi);  /* last copy (not followed by separator) */\n        luaL_pushresultsize(b, totallen);\n    }\n    return 1;\n};\n\nconst str_byte = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let l = s.length;\n    let posi = posrelat(luaL_optinteger(L, 2, 1), l);\n    let pose = posrelat(luaL_optinteger(L, 3, posi), l);\n\n    if (posi < 1) posi = 1;\n    if (pose > l) pose = l;\n    if (posi > pose) return 0;  /* empty interval; return no values */\n    if (pose - posi >= Number.MAX_SAFE_INTEGER)  /* arithmetic overflow? */\n        return luaL_error(L, \"string slice too long\");\n\n    let n = (pose - posi) + 1;\n    luaL_checkstack(L, n, \"string slice too long\");\n    for (let i = 0; i < n; i++)\n        lua_pushinteger(L, s[posi + i - 1]);\n    return n;\n};\n\nconst str_packsize = function(L) {\n    let h = new Header(L);\n    let fmt = {\n        s: luaL_checkstring(L, 1),\n        off: 0\n    };\n    let totalsize = 0;  /* accumulate total size of result */\n    while (fmt.off < fmt.s.length) {\n        let details = getdetails(h, totalsize, fmt);\n        let opt = details.opt;\n        let size = details.size;\n        let ntoalign = details.ntoalign;\n        size += ntoalign;  /* total space used by option */\n        luaL_argcheck(L, totalsize <= MAXSIZE - size, 1, \"format result too large\");\n        totalsize += size;\n        switch (opt) {\n            case Kstring:  /* strings with length count */\n            case Kzstr:    /* zero-terminated string */\n                luaL_argerror(L, 1, \"variable-length format\");\n                /* call never return, but to avoid warnings: *//* fall through */\n            default:  break;\n        }\n    }\n    lua_pushinteger(L, totalsize);\n    return 1;\n};\n\n/*\n** Unpack an integer with 'size' bytes and 'islittle' endianness.\n** If size is smaller than the size of a Lua integer and integer\n** is signed, must do sign extension (propagating the sign to the\n** higher bits); if size is larger than the size of a Lua integer,\n** it must check the unread bytes to see whether they do not cause an\n** overflow.\n*/\nconst unpackint = function(L, str, islittle, size, issigned) {\n    let res = 0;\n    let limit = size <= SZINT ? size : SZINT;\n    for (let i = limit - 1; i >= 0; i--) {\n        res <<= NB;\n        res |= str[islittle ? i : size - 1 - i];\n    }\n    if (size < SZINT) {  /* real size smaller than lua_Integer? */\n        if (issigned) {  /* needs sign extension? */\n            let mask = 1 << (size * NB - 1);\n            res = ((res ^ mask) - mask);  /* do sign extension */\n        }\n    } else if (size > SZINT) {  /* must check unread bytes */\n        let mask = !issigned || res >= 0 ? 0 : MC;\n        for (let i = limit; i < size; i++) {\n            if (str[islittle ? i : size - 1 - i] !== mask)\n                luaL_error(L, to_luastring(\"%d-byte integer does not fit into Lua Integer\"), size);\n        }\n    }\n    return res;\n};\n\nconst unpacknum = function(L, b, islittle, size) {\n    lualib.lua_assert(b.length >= size);\n\n    let dv = new DataView(new ArrayBuffer(size));\n    for (let i = 0; i < size; i++)\n        dv.setUint8(i, b[i], islittle);\n\n    if (size == 4) return dv.getFloat32(0, islittle);\n    else return dv.getFloat64(0, islittle);\n};\n\nconst str_unpack = function(L) {\n    let h = new Header(L);\n    let fmt = {\n        s: luaL_checkstring(L, 1),\n        off: 0\n    };\n    let data = luaL_checkstring(L, 2);\n    let ld = data.length;\n    let pos = posrelat(luaL_optinteger(L, 3, 1), ld) - 1;\n    let n = 0;  /* number of results */\n    luaL_argcheck(L, pos <= ld && pos >= 0, 3, \"initial position out of string\");\n    while (fmt.off < fmt.s.length) {\n        let details = getdetails(h, pos, fmt);\n        let opt = details.opt;\n        let size = details.size;\n        let ntoalign = details.ntoalign;\n        if (/*ntoalign + size > ~pos ||*/ pos + ntoalign + size > ld)\n            luaL_argerror(L, 2, to_luastring(\"data string too short\"));\n        pos += ntoalign;  /* skip alignment */\n        /* stack space for item + next position */\n        luaL_checkstack(L, 2, \"too many results\");\n        n++;\n        switch (opt) {\n            case Kint:\n            case Kuint: {\n                let res = unpackint(L, data.subarray(pos), h.islittle, size, opt === Kint);\n                lua_pushinteger(L, res);\n                break;\n            }\n            case Kfloat: {\n                let res = unpacknum(L, data.subarray(pos), h.islittle, size);\n                lua_pushnumber(L, res);\n                break;\n            }\n            case Kchar: {\n                lua_pushstring(L, data.subarray(pos, pos + size));\n                break;\n            }\n            case Kstring: {\n                let len = unpackint(L, data.subarray(pos), h.islittle, size, 0);\n                luaL_argcheck(L, pos + len + size <= ld, 2, \"data string too short\");\n                lua_pushstring(L, data.subarray(pos + size, pos + size + len));\n                pos += len;  /* skip string */\n                break;\n            }\n            case Kzstr: {\n                let e = luastring_indexOf(data, 0, pos);\n                if (e === -1) e = data.length - pos;\n                lua_pushstring(L, data.subarray(pos, e));\n                pos = e + 1;  /* skip string plus final '\\0' */\n                break;\n            }\n            case Kpaddalign: case Kpadding: case Knop:\n                n--;  /* undo increment */\n                break;\n        }\n        pos += size;\n    }\n    lua_pushinteger(L, pos + 1);  /* next position */\n    return n + 1;\n};\n\nconst CAP_UNFINISHED = -1;\nconst CAP_POSITION   = -2;\nconst MAXCCALLS      = 200;\nconst SPECIALS       = to_luastring(\"^$*+?.([%-\");\n\nclass MatchState {\n    constructor(L) {\n        this.src = null;  /* unmodified source string */\n        this.src_init = null;  /* init of source string */\n        this.src_end = null;  /* end ('\\0') of source string */\n        this.p = null;  /* unmodified pattern string */\n        this.p_end = null;  /* end ('\\0') of pattern */\n        this.L = L;\n        this.matchdepth = NaN;  /* control for recursive depth */\n        this.level = NaN;  /* total number of captures (finished or unfinished) */\n        this.capture = [];\n    }\n}\n\nconst check_capture = function(ms, l) {\n    l = l - 49 /* '1'.charCodeAt(0) */;\n    if (l < 0 || l >= ms.level || ms.capture[l].len === CAP_UNFINISHED)\n        return luaL_error(ms.L, to_luastring(\"invalid capture index %%%d\"), l + 1);\n    return l;\n};\n\nconst capture_to_close = function(ms) {\n    let level = ms.level;\n    for (level--; level >= 0; level--)\n        if (ms.capture[level].len === CAP_UNFINISHED) return level;\n    return luaL_error(ms.L, to_luastring(\"invalid pattern capture\"));\n};\n\nconst classend = function(ms, p) {\n    switch(ms.p[p++]) {\n        case L_ESC: {\n            if (p === ms.p_end)\n                luaL_error(ms.L, to_luastring(\"malformed pattern (ends with '%%')\"));\n            return p + 1;\n        }\n        case 91 /* '['.charCodeAt(0) */: {\n            if (ms.p[p] === 94 /* '^'.charCodeAt(0) */) p++;\n            do {  /* look for a ']' */\n                if (p === ms.p_end)\n                    luaL_error(ms.L, to_luastring(\"malformed pattern (missing ']')\"));\n                if (ms.p[p++] === L_ESC && p < ms.p_end)\n                    p++;  /* skip escapes (e.g. '%]') */\n            } while (ms.p[p] !== 93 /* ']'.charCodeAt(0) */);\n            return p + 1;\n        }\n        default: {\n            return p;\n        }\n    }\n};\n\nconst match_class = function(c, cl) {\n    switch (cl) {\n        case 97  /* 'a'.charCodeAt(0) */: return  isalpha(c);\n        case 65  /* 'A'.charCodeAt(0) */: return !isalpha(c);\n        case 99  /* 'c'.charCodeAt(0) */: return  iscntrl(c);\n        case 67  /* 'C'.charCodeAt(0) */: return !iscntrl(c);\n        case 100 /* 'd'.charCodeAt(0) */: return  isdigit(c);\n        case 68  /* 'D'.charCodeAt(0) */: return !isdigit(c);\n        case 103 /* 'g'.charCodeAt(0) */: return  isgraph(c);\n        case 71  /* 'G'.charCodeAt(0) */: return !isgraph(c);\n        case 108 /* 'l'.charCodeAt(0) */: return  islower(c);\n        case 76  /* 'L'.charCodeAt(0) */: return !islower(c);\n        case 112 /* 'p'.charCodeAt(0) */: return  ispunct(c);\n        case 80  /* 'P'.charCodeAt(0) */: return !ispunct(c);\n        case 115 /* 's'.charCodeAt(0) */: return  isspace(c);\n        case 83  /* 'S'.charCodeAt(0) */: return !isspace(c);\n        case 117 /* 'u'.charCodeAt(0) */: return  isupper(c);\n        case 85  /* 'U'.charCodeAt(0) */: return !isupper(c);\n        case 119 /* 'w'.charCodeAt(0) */: return  isalnum(c);\n        case 87  /* 'W'.charCodeAt(0) */: return !isalnum(c);\n        case 120 /* 'x'.charCodeAt(0) */: return  isxdigit(c);\n        case 88  /* 'X'.charCodeAt(0) */: return !isxdigit(c);\n        case 122 /* 'z'.charCodeAt(0) */: return (c === 0);  /* deprecated option */\n        case 90  /* 'z'.charCodeAt(0) */: return (c !== 0);  /* deprecated option */\n        default: return (cl === c);\n    }\n};\n\nconst matchbracketclass = function(ms, c, p, ec) {\n    let sig = true;\n    if (ms.p[p + 1] === 94 /* '^'.charCodeAt(0) */) {\n        sig = false;\n        p++;  /* skip the '^' */\n    }\n    while (++p < ec) {\n        if (ms.p[p] === L_ESC) {\n            p++;\n            if (match_class(c, ms.p[p]))\n                return sig;\n        } else if (ms.p[p + 1] === 45 /* '-'.charCodeAt(0) */ && p + 2 < ec) {\n            p += 2;\n            if (ms.p[p - 2] <= c && c <= ms.p[p])\n                return sig;\n        } else if (ms.p[p] === c) return sig;\n    }\n    return !sig;\n};\n\nconst singlematch = function(ms, s, p, ep) {\n    if (s >= ms.src_end)\n        return false;\n    else {\n        let c = ms.src[s];\n        switch (ms.p[p]) {\n            case 46 /* '.'.charCodeAt(0) */: return true;  /* matches any char */\n            case L_ESC: return match_class(c, ms.p[p + 1]);\n            case 91 /* '['.charCodeAt(0) */: return matchbracketclass(ms, c, p, ep - 1);\n            default: return ms.p[p] === c;\n        }\n    }\n};\n\nconst matchbalance = function(ms, s, p) {\n    if (p >= ms.p_end - 1)\n        luaL_error(ms.L, to_luastring(\"malformed pattern (missing arguments to '%%b'\"));\n    if (ms.src[s] !== ms.p[p])\n        return null;\n    else {\n        let b = ms.p[p];\n        let e = ms.p[p + 1];\n        let cont = 1;\n        while (++s < ms.src_end) {\n            if (ms.src[s] === e) {\n                if (--cont === 0) return s + 1;\n            }\n            else if (ms.src[s] === b) cont++;\n        }\n    }\n    return null;  /* string ends out of balance */\n};\n\nconst max_expand = function(ms, s, p, ep) {\n    let i = 0;  /* counts maximum expand for item */\n    while (singlematch(ms, s + i, p, ep))\n        i++;\n    /* keeps trying to match with the maximum repetitions */\n    while (i >= 0) {\n        let res = match(ms, s + i, ep + 1);\n        if (res) return res;\n        i--;  /* else didn't match; reduce 1 repetition to try again */\n    }\n    return null;\n};\n\nconst min_expand = function(ms, s, p, ep) {\n    for (;;) {\n        let res = match(ms, s, ep + 1);\n        if (res !== null)\n            return res;\n        else if (singlematch(ms, s, p, ep))\n            s++;  /* try with one more repetition */\n        else return null;\n    }\n};\n\nconst start_capture = function(ms, s, p, what) {\n    let level = ms.level;\n    if (level >= LUA_MAXCAPTURES) luaL_error(ms.L, to_luastring(\"too many captures\"));\n    ms.capture[level] = ms.capture[level] ? ms.capture[level] : {};\n    ms.capture[level].init = s;\n    ms.capture[level].len = what;\n    ms.level = level + 1;\n    let res;\n    if ((res = match(ms, s, p)) === null)  /* match failed? */\n        ms.level--;  /* undo capture */\n    return res;\n};\n\nconst end_capture = function(ms, s, p) {\n    let l = capture_to_close(ms);\n    ms.capture[l].len = s - ms.capture[l].init;  /* close capture */\n    let res;\n    if ((res = match(ms, s, p)) === null)  /* match failed? */\n        ms.capture[l].len = CAP_UNFINISHED;  /* undo capture */\n    return res;\n};\n\n/* Compare the elements of arrays 'a' and 'b' to see if they contain the same elements */\nconst array_cmp = function(a, ai, b, bi, len) {\n    return luastring_eq(a.subarray(ai, ai+len), b.subarray(bi, bi+len));\n};\n\nconst match_capture = function(ms, s, l) {\n    l = check_capture(ms, l);\n    let len = ms.capture[l].len;\n    if ((ms.src_end-s) >= len && array_cmp(ms.src, ms.capture[l].init, ms.src, s, len))\n        return s+len;\n    else return null;\n};\n\nconst match = function(ms, s, p) {\n    let gotodefault = false;\n    let gotoinit = true;\n\n    if (ms.matchdepth-- === 0)\n        luaL_error(ms.L, to_luastring(\"pattern too complex\"));\n\n    while (gotoinit || gotodefault) {\n        gotoinit = false;\n        if (p !== ms.p_end) {  /* end of pattern? */\n            switch (gotodefault ? void 0 : ms.p[p]) {\n                case 40 /* '('.charCodeAt(0) */: {  /* start capture */\n                    if (ms.p[p + 1] === 41 /* ')'.charCodeAt(0) */)  /* position capture? */\n                        s = start_capture(ms, s, p + 2, CAP_POSITION);\n                    else\n                        s = start_capture(ms, s, p + 1, CAP_UNFINISHED);\n                    break;\n                }\n                case 41 /* ')'.charCodeAt(0) */: {  /* end capture */\n                    s = end_capture(ms, s, p + 1);\n                    break;\n                }\n                case 36 /* '$'.charCodeAt(0) */: {\n                    if (p + 1 !== ms.p_end) {  /* is the '$' the last char in pattern? */\n                        gotodefault = true;  /* no; go to default */\n                        break;\n                    }\n                    s = (ms.src.length - s) === 0 ? s : null;  /* check end of string */\n                    break;\n                }\n                case L_ESC: {  /* escaped sequences not in the format class[*+?-]? */\n                    switch (ms.p[p + 1]) {\n                        case 98 /* 'b'.charCodeAt(0) */: {  /* balanced string? */\n                            s = matchbalance(ms, s, p + 2);\n                            if (s !== null) {\n                                p += 4;\n                                gotoinit = true;\n                            }\n                            break;\n                        }\n                        case 102 /* 'f'.charCodeAt(0) */: {  /* frontier? */\n                            p += 2;\n                            if (ms.p[p] !== 91 /* '['.charCodeAt(0) */)\n                                luaL_error(ms.L, to_luastring(\"missing '[' after '%%f' in pattern\"));\n                            let ep = classend(ms, p);  /* points to what is next */\n                            let previous = s === ms.src_init ? 0 : ms.src[s-1];\n                            if (!matchbracketclass(ms, previous, p, ep - 1) && matchbracketclass(ms, (s===ms.src_end)?0:ms.src[s], p, ep - 1)) {\n                                p = ep; gotoinit = true; break;\n                            }\n                            s = null;  /* match failed */\n                            break;\n                        }\n                        case 48: case 49: case 50: case 51: case 52:\n                        case 53: case 54: case 55: case 56: case 57: {  /* capture results (%0-%9)? */\n                            s = match_capture(ms, s, ms.p[p + 1]);\n                            if (s !== null) {\n                                p += 2; gotoinit = true;\n                            }\n                            break;\n                        }\n                        default: gotodefault = true;\n                    }\n                    break;\n                }\n                default: {  /* pattern class plus optional suffix */\n                    gotodefault = false;\n                    let ep = classend(ms, p);  /* points to optional suffix */\n                    /* does not match at least once? */\n                    if (!singlematch(ms, s, p, ep)) {\n                        if (ms.p[ep] === 42 /* '*'.charCodeAt(0) */ ||\n                            ms.p[ep] === 63 /* '?'.charCodeAt(0) */ ||\n                            ms.p[ep] === 45 /* '-'.charCodeAt(0) */\n                        ) {  /* accept empty? */\n                            p = ep + 1; gotoinit = true; break;\n                        } else  /* '+' or no suffix */\n                            s = null;  /* fail */\n                    } else {  /* matched once */\n                        switch (ms.p[ep]) {  /* handle optional suffix */\n                            case 63 /* '?'.charCodeAt(0) */: {  /* optional */\n                                let res;\n                                if ((res = match(ms, s + 1, ep + 1)) !== null)\n                                    s = res;\n                                else {\n                                    p = ep + 1; gotoinit = true;\n                                }\n                                break;\n                            }\n                            case 43 /* '+'.charCodeAt(0) */:  /* 1 or more repetitions */\n                                s++;  /* 1 match already done */\n                                /* fall through */\n                            case 42 /* '*'.charCodeAt(0) */:  /* 0 or more repetitions */\n                                s = max_expand(ms, s, p, ep);\n                                break;\n                            case 45 /* '-'.charCodeAt(0) */:  /* 0 or more repetitions (minimum) */\n                                s = min_expand(ms, s, p, ep);\n                                break;\n                            default:  /* no suffix */\n                                s++; p = ep; gotoinit = true;\n                        }\n                    }\n                    break;\n                }\n            }\n        }\n    }\n    ms.matchdepth++;\n    return s;\n};\n\nconst push_onecapture = function(ms, i, s, e) {\n    if (i >= ms.level) {\n        if (i === 0)\n            lua_pushlstring(ms.L, ms.src.subarray(s, e), e - s);  /* add whole match */\n        else\n            luaL_error(ms.L, to_luastring(\"invalid capture index %%%d\"), i + 1);\n    } else {\n        let l = ms.capture[i].len;\n        if (l === CAP_UNFINISHED) luaL_error(ms.L, to_luastring(\"unfinished capture\"));\n        if (l === CAP_POSITION)\n            lua_pushinteger(ms.L, ms.capture[i].init - ms.src_init + 1);\n        else\n            lua_pushlstring(ms.L, ms.src.subarray(ms.capture[i].init), l);\n    }\n};\n\nconst push_captures = function(ms, s, e) {\n    let nlevels = ms.level === 0 && ms.src.subarray(s) ? 1 : ms.level;\n    luaL_checkstack(ms.L, nlevels, \"too many captures\");\n    for (let i = 0; i < nlevels; i++)\n        push_onecapture(ms, i, s, e);\n    return nlevels;  /* number of strings pushed */\n};\n\nconst nospecials = function(p, l) {\n    for (let i=0; i<l; i++) {\n        if (luastring_indexOf(SPECIALS, p[i]) !== -1)\n            return false;\n    }\n    return true;\n};\n\nconst prepstate = function(ms, L, s, ls, p, lp) {\n    ms.L = L;\n    ms.matchdepth = MAXCCALLS;\n    ms.src = s;\n    ms.src_init = 0;\n    ms.src_end = ls;\n    ms.p = p;\n    ms.p_end = lp;\n};\n\nconst reprepstate = function(ms) {\n    ms.level = 0;\n    lualib.lua_assert(ms.matchdepth === MAXCCALLS);\n};\n\nconst find_subarray = function(arr, subarr, from_index) {\n    var i = from_index >>> 0,\n        sl = subarr.length;\n\n    if (sl === 0)\n        return i;\n\n    for (; (i = arr.indexOf(subarr[0], i)) !== -1; i++) {\n        if (luastring_eq(arr.subarray(i, i+sl), subarr))\n            return i;\n    }\n\n    return -1;\n};\n\nconst str_find_aux = function(L, find) {\n    let s = luaL_checkstring(L, 1);\n    let p = luaL_checkstring(L, 2);\n    let ls = s.length;\n    let lp = p.length;\n    let init = posrelat(luaL_optinteger(L, 3, 1), ls);\n    if (init < 1) init = 1;\n    else if (init > ls + 1) {  /* start after string's end? */\n        lua_pushnil(L);  /* cannot find anything */\n        return 1;\n    }\n    /* explicit request or no special characters? */\n    if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {\n        /* do a plain search */\n        let f = find_subarray(s.subarray(init - 1), p, 0);\n        if (f > -1) {\n            lua_pushinteger(L, init + f);\n            lua_pushinteger(L, init + f + lp - 1);\n            return 2;\n        }\n    } else {\n        let ms = new MatchState(L);\n        let s1 = init - 1;\n        let anchor = p[0] === 94 /* '^'.charCodeAt(0) */;\n        if (anchor) {\n            p = p.subarray(1); lp--;  /* skip anchor character */\n        }\n        prepstate(ms, L, s, ls, p, lp);\n        do {\n            let res;\n            reprepstate(ms);\n            if ((res = match(ms, s1, 0)) !== null) {\n                if (find) {\n                    lua_pushinteger(L, s1 + 1);  /* start */\n                    lua_pushinteger(L, res);   /* end */\n                    return push_captures(ms, null, 0) + 2;\n                } else\n                    return push_captures(ms, s1, res);\n            }\n        } while (s1++ < ms.src_end && !anchor);\n    }\n    lua_pushnil(L);  /* not found */\n    return 1;\n};\n\nconst str_find = function(L) {\n    return str_find_aux(L, 1);\n};\n\nconst str_match = function(L) {\n    return str_find_aux(L, 0);\n};\n\n/* state for 'gmatch' */\nclass GMatchState {\n    constructor() {\n        this.src = NaN;  /* current position */\n        this.p = NaN;  /* pattern */\n        this.lastmatch = NaN;  /* end of last match */\n        this.ms = new MatchState();  /* match state */\n    }\n}\n\nconst gmatch_aux = function(L) {\n    let gm = lua_touserdata(L, lua_upvalueindex(3));\n    gm.ms.L = L;\n    for (let src = gm.src; src <= gm.ms.src_end; src++) {\n        reprepstate(gm.ms);\n        let e;\n        if ((e = match(gm.ms, src, gm.p)) !== null && e !== gm.lastmatch) {\n            gm.src = gm.lastmatch = e;\n            return push_captures(gm.ms, src, e);\n        }\n    }\n    return 0;  /* not found */\n};\n\nconst str_gmatch = function(L) {\n    let s = luaL_checkstring(L, 1);\n    let p = luaL_checkstring(L, 2);\n    let ls = s.length;\n    let lp = p.length;\n    lua_settop(L, 2);  /* keep them on closure to avoid being collected */\n    let gm = new GMatchState();\n    lua_pushlightuserdata(L, gm);\n    prepstate(gm.ms, L, s, ls, p, lp);\n    gm.src = 0;\n    gm.p = 0;\n    gm.lastmatch = null;\n    lua_pushcclosure(L, gmatch_aux, 3);\n    return 1;\n};\n\nconst add_s = function(ms, b, s, e) {\n    let L = ms.L;\n    let news = lua_tostring(L, 3);\n    let l = news.length;\n    for (let i = 0; i < l; i++) {\n        if (news[i] !== L_ESC)\n            luaL_addchar(b, news[i]);\n        else {\n            i++;  /* skip ESC */\n            if (!isdigit(news[i])) {\n                if (news[i] !== L_ESC)\n                    luaL_error(L, to_luastring(\"invalid use of '%c' in replacement string\"), L_ESC);\n                luaL_addchar(b, news[i]);\n            } else if (news[i] === 48 /* '0'.charCodeAt(0) */)\n                luaL_addlstring(b, ms.src.subarray(s, e), e - s);\n            else {\n                push_onecapture(ms, news[i] - 49 /* '1'.charCodeAt(0) */, s, e);\n                luaL_tolstring(L, -1);\n                lua_remove(L, -2);  /* remove original value */\n                luaL_addvalue(b);  /* add capture to accumulated result */\n            }\n        }\n    }\n};\n\nconst add_value = function(ms, b, s, e, tr) {\n    let L = ms.L;\n    switch (tr) {\n        case LUA_TFUNCTION: {\n            lua_pushvalue(L, 3);\n            let n = push_captures(ms, s, e);\n            lua_call(L, n, 1);\n            break;\n        }\n        case LUA_TTABLE: {\n            push_onecapture(ms, 0, s, e);\n            lua_gettable(L, 3);\n            break;\n        }\n        default: {  /* LUA_TNUMBER or LUA_TSTRING */\n            add_s(ms, b, s, e);\n            return;\n        }\n    }\n    if (!lua_toboolean(L, -1)) {  /* nil or false? */\n        lua_pop(L, 1);\n        lua_pushlstring(L, ms.src.subarray(s, e), e - s);  /* keep original text */\n    } else if (!lua_isstring(L, -1))\n        luaL_error(L, to_luastring(\"invalid replacement value (a %s)\"), luaL_typename(L, -1));\n    luaL_addvalue(b);  /* add result to accumulator */\n};\n\nconst str_gsub = function(L) {\n    let src = luaL_checkstring(L, 1);  /* subject */\n    let srcl = src.length;\n    let p = luaL_checkstring(L, 2);  /* pattern */\n    let lp = p.length;\n    let lastmatch = null;  /* end of last match */\n    let tr = lua_type(L, 3);  /* replacement type */\n    let max_s = luaL_optinteger(L, 4, srcl + 1);  /* max replacements */\n    let anchor = p[0] === 94 /* '^'.charCodeAt(0) */;\n    let n = 0;  /* replacement count */\n    let ms = new MatchState(L);\n    let b = new luaL_Buffer();\n    luaL_argcheck(L, tr === LUA_TNUMBER || tr === LUA_TSTRING || tr === LUA_TFUNCTION || tr === LUA_TTABLE, 3,\n        \"string/function/table expected\");\n    luaL_buffinit(L, b);\n    if (anchor) {\n        p = p.subarray(1); lp--;  /* skip anchor character */\n    }\n    prepstate(ms, L, src, srcl, p, lp);\n    src = 0; p = 0;\n    while (n < max_s) {\n        let e;\n        reprepstate(ms);\n        if ((e = match(ms, src, p)) !== null && e !== lastmatch) {  /* match? */\n            n++;\n            add_value(ms, b, src, e, tr);  /* add replacement to buffer */\n            src = lastmatch = e;\n        } else if (src < ms.src_end)  /* otherwise, skip one character */\n            luaL_addchar(b, ms.src[src++]);\n        else break;  /* end of subject */\n        if (anchor) break;\n    }\n    luaL_addlstring(b, ms.src.subarray(src, ms.src_end), ms.src_end - src);\n    luaL_pushresult(b);\n    lua_pushinteger(L, n);  /* number of substitutions */\n    return 2;\n};\n\nconst strlib = {\n    \"byte\":     str_byte,\n    \"char\":     str_char,\n    \"dump\":     str_dump,\n    \"find\":     str_find,\n    \"format\":   str_format,\n    \"gmatch\":   str_gmatch,\n    \"gsub\":     str_gsub,\n    \"len\":      str_len,\n    \"lower\":    str_lower,\n    \"match\":    str_match,\n    \"pack\":     str_pack,\n    \"packsize\": str_packsize,\n    \"rep\":      str_rep,\n    \"reverse\":  str_reverse,\n    \"sub\":      str_sub,\n    \"unpack\":   str_unpack,\n    \"upper\":    str_upper\n};\n\nconst createmetatable = function(L) {\n    lua_createtable(L, 0, 1);  /* table to be metatable for strings */\n    lua_pushliteral(L, \"\");  /* dummy string */\n    lua_pushvalue(L, -2);  /* copy table */\n    lua_setmetatable(L, -2);  /* set table as metatable for strings */\n    lua_pop(L, 1);  /* pop dummy string */\n    lua_pushvalue(L, -2);  /* get string library */\n    lua_setfield(L, -2, to_luastring(\"__index\", true));  /* metatable.__index = string */\n    lua_pop(L, 1);  /* pop metatable */\n};\n\nconst luaopen_string = function(L) {\n    luaL_newlib(L, strlib);\n    createmetatable(L);\n    return 1;\n};\n\nmodule.exports.luaopen_string = luaopen_string;\n","\"use strict\";\n\nconst {\n    LUA_TNIL,\n    LUA_TTABLE,\n    lua_close,\n    lua_createtable,\n    lua_getfield,\n    lua_isboolean,\n    lua_isnoneornil,\n    lua_pop,\n    lua_pushboolean,\n    lua_pushfstring,\n    lua_pushinteger,\n    lua_pushliteral,\n    lua_pushnil,\n    lua_pushnumber,\n    lua_pushstring,\n    lua_setfield,\n    lua_settop,\n    lua_toboolean,\n    lua_tointegerx\n} = require('./lua.js');\nconst {\n    luaL_Buffer,\n    luaL_addchar,\n    luaL_addstring,\n    // luaL_argcheck,\n    luaL_argerror,\n    luaL_buffinit,\n    luaL_checkinteger,\n    luaL_checkstring,\n    luaL_checktype,\n    luaL_error,\n    luaL_execresult,\n    luaL_fileresult,\n    luaL_newlib,\n    luaL_optinteger,\n    luaL_optlstring,\n    luaL_optstring,\n    luaL_pushresult\n} = require('./lauxlib.js');\nconst {\n    luastring_eq,\n    to_jsstring,\n    to_luastring\n} = require(\"./fengaricore.js\");\n\n/* options for ANSI C 89 (only 1-char options) */\n// const L_STRFTIMEC89 = to_luastring(\"aAbBcdHIjmMpSUwWxXyYZ%\");\n// const LUA_STRFTIMEOPTIONS = L_STRFTIMEC89;\n\n/* options for ISO C 99 and POSIX */\n// const L_STRFTIMEC99 = to_luastring(\"aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%||EcECExEXEyEYOdOeOHOIOmOMOSOuOUOVOwOWOy\");  /* two-char options */\n// const LUA_STRFTIMEOPTIONS = L_STRFTIMEC99;\n\n/* options for Windows */\n// const L_STRFTIMEWIN = to_luastring(\"aAbBcdHIjmMpSUwWxXyYzZ%||#c#x#d#H#I#j#m#M#S#U#w#W#y#Y\");  /* two-char options */\n// const LUA_STRFTIMEOPTIONS = L_STRFTIMEWIN;\n\n/* options for our own strftime implementation\n  - should be superset of C89 options for compat\n  - missing from C99:\n      - ISO 8601 week specifiers: gGV\n      - > single char specifiers\n  - beyond C99:\n      - %k: TZ extension: space-padded 24-hour\n      - %l: TZ extension: space-padded 12-hour\n      - %P: GNU extension: lower-case am/pm\n*/\nconst LUA_STRFTIMEOPTIONS = to_luastring(\"aAbBcCdDeFhHIjklmMnpPrRStTuUwWxXyYzZ%\");\n\n\nconst setfield = function(L, key, value) {\n    lua_pushinteger(L, value);\n    lua_setfield(L, -2, to_luastring(key, true));\n};\n\nconst setallfields = function(L, time, utc) {\n    setfield(L, \"sec\",   utc ? time.getUTCSeconds()  : time.getSeconds());\n    setfield(L, \"min\",   utc ? time.getUTCMinutes()  : time.getMinutes());\n    setfield(L, \"hour\",  utc ? time.getUTCHours()    : time.getHours());\n    setfield(L, \"day\",   utc ? time.getUTCDate()     : time.getDate());\n    setfield(L, \"month\", (utc ? time.getUTCMonth()   : time.getMonth()) + 1);\n    setfield(L, \"year\",  utc ? time.getUTCFullYear() : time.getFullYear());\n    setfield(L, \"wday\",  (utc ? time.getUTCDay()     : time.getDay()) + 1);\n    setfield(L, \"yday\", Math.floor((time - (new Date(time.getFullYear(), 0, 0 /* shortcut to correct day by one */))) / 86400000));\n    // setboolfield(L, \"isdst\", time.get);\n};\n\nconst L_MAXDATEFIELD = (Number.MAX_SAFE_INTEGER / 2);\n\nconst getfield = function(L, key, d, delta) {\n    let t = lua_getfield(L, -1, to_luastring(key, true));  /* get field and its type */\n    let res = lua_tointegerx(L, -1);\n    if (res === false) {  /* field is not an integer? */\n        if (t !== LUA_TNIL)  /* some other value? */\n            return luaL_error(L, to_luastring(\"field '%s' is not an integer\"), key);\n        else if (d < 0)  /* absent field; no default? */\n            return luaL_error(L, to_luastring(\"field '%s' missing in date table\"), key);\n        res = d;\n    }\n    else {\n        if (!(-L_MAXDATEFIELD <= res && res <= L_MAXDATEFIELD))\n            return luaL_error(L, to_luastring(\"field '%s' is out-of-bound\"), key);\n        res -= delta;\n    }\n    lua_pop(L, 1);\n    return res;\n};\n\n\nconst locale = {\n    days: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\" ].map((s) => to_luastring(s)),\n    shortDays: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"].map((s) => to_luastring(s)),\n    months: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"].map((s) => to_luastring(s)),\n    shortMonths: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"].map((s) => to_luastring(s)),\n    AM: to_luastring(\"AM\"),\n    PM: to_luastring(\"PM\"),\n    am: to_luastring(\"am\"),\n    pm: to_luastring(\"pm\"),\n    formats: {\n        c: to_luastring(\"%a %b %e %H:%M:%S %Y\"),\n        D: to_luastring(\"%m/%d/%y\"),\n        F: to_luastring(\"%Y-%m-%d\"),\n        R: to_luastring(\"%H:%M\"),\n        r: to_luastring(\"%I:%M:%S %p\"),\n        T: to_luastring(\"%H:%M:%S\"),\n        X: to_luastring(\"%T\"),\n        x: to_luastring(\"%D\")\n    }\n};\n\nconst week_number = function(date, start_of_week) {\n    // This works by shifting the weekday back by one day if we\n    // are treating Monday as the first day of the week.\n    let weekday = date.getDay();\n    if (start_of_week === 'monday') {\n        if (weekday === 0) // Sunday\n            weekday = 6;\n        else\n            weekday--;\n    }\n    let yday = (date - new Date(date.getFullYear(), 0, 1)) / 86400000;\n    return Math.floor((yday + 7 - weekday) / 7);\n};\n\nconst push_pad_2 = function(b, n, pad) {\n    if (n < 10)\n        luaL_addchar(b, pad);\n    luaL_addstring(b, to_luastring(String(n)));\n};\n\nconst strftime = function(L, b, s, date) {\n    let i = 0;\n    while (i < s.length) {\n        if (s[i] !== 37 /* % */) {  /* not a conversion specifier? */\n            luaL_addchar(b, s[i++]);\n        } else {\n            i++;  /* skip '%' */\n            let len = checkoption(L, s, i);\n            /* each `case` has an example output above it for the UTC epoch */\n            switch(s[i]) {\n                // '%'\n                case 37 /* % */:\n                    luaL_addchar(b, 37);\n                    break;\n\n                // 'Thursday'\n                case 65 /* A */:\n                    luaL_addstring(b, locale.days[date.getDay()]);\n                    break;\n\n                // 'January'\n                case 66 /* B */:\n                    luaL_addstring(b, locale.months[date.getMonth()]);\n                    break;\n\n                // '19'\n                case 67 /* C */:\n                    push_pad_2(b, Math.floor(date.getFullYear() / 100), 48 /* 0 */);\n                    break;\n\n                // '01/01/70'\n                case 68 /* D */:\n                    strftime(L, b, locale.formats.D, date);\n                    break;\n\n                // '1970-01-01'\n                case 70 /* F */:\n                    strftime(L, b, locale.formats.F, date);\n                    break;\n\n                // '00'\n                case 72 /* H */:\n                    push_pad_2(b, date.getHours(), 48 /* 0 */);\n                    break;\n\n                // '12'\n                case 73 /* I */:\n                    push_pad_2(b, (date.getHours() + 11) % 12 + 1, 48 /* 0 */);\n                    break;\n\n                // '00'\n                case 77 /* M */:\n                    push_pad_2(b, date.getMinutes(), 48 /* 0 */);\n                    break;\n\n                // 'am'\n                case 80 /* P */:\n                    luaL_addstring(b, date.getHours() < 12 ? locale.am : locale.pm);\n                    break;\n\n                // '00:00'\n                case 82 /* R */:\n                    strftime(L, b, locale.formats.R, date);\n                    break;\n\n                // '00'\n                case 83 /* S */:\n                    push_pad_2(b, date.getSeconds(), 48 /* 0 */);\n                    break;\n\n                // '00:00:00'\n                case 84 /* T */:\n                    strftime(L, b, locale.formats.T, date);\n                    break;\n\n                // '00'\n                case 85 /* U */:\n                    push_pad_2(b, week_number(date, \"sunday\"), 48 /* 0 */);\n                    break;\n\n                // '00'\n                case 87 /* W */:\n                    push_pad_2(b, week_number(date, \"monday\"), 48 /* 0 */);\n                    break;\n\n                // '16:00:00'\n                case 88 /* X */:\n                    strftime(L, b, locale.formats.X, date);\n                    break;\n\n                // '1970'\n                case 89 /* Y */:\n                    luaL_addstring(b, to_luastring(String(date.getFullYear())));\n                    break;\n\n                // 'GMT'\n                case 90 /* Z */: {\n                    let tzString = date.toString().match(/\\(([\\w\\s]+)\\)/);\n                    if (tzString)\n                        luaL_addstring(b, to_luastring(tzString[1]));\n                    break;\n                }\n\n                // 'Thu'\n                case 97 /* a */:\n                    luaL_addstring(b, locale.shortDays[date.getDay()]);\n                    break;\n\n                // 'Jan'\n                case 98 /* b */:\n                case 104 /* h */:\n                    luaL_addstring(b, locale.shortMonths[date.getMonth()]);\n                    break;\n\n                // ''\n                case 99 /* c */:\n                    strftime(L, b, locale.formats.c, date);\n                    break;\n\n                // '01'\n                case 100 /* d */:\n                    push_pad_2(b, date.getDate(), 48 /* 0 */);\n                    break;\n\n                // ' 1'\n                case 101 /* e */:\n                    push_pad_2(b, date.getDate(), 32 /* space */);\n                    break;\n\n                // '000'\n                case 106 /* j */: {\n                    let yday = Math.floor((date - new Date(date.getFullYear(), 0, 1)) / 86400000);\n                    if (yday < 100) {\n                        if (yday < 10)\n                            luaL_addchar(b, 48 /* 0 */);\n                        luaL_addchar(b, 48 /* 0 */);\n                    }\n                    luaL_addstring(b, to_luastring(String(yday)));\n                    break;\n                }\n\n                // ' 0'\n                case 107 /* k */:\n                    push_pad_2(b, date.getHours(), 32 /* space */);\n                    break;\n\n                // '12'\n                case 108 /* l */:\n                    push_pad_2(b, (date.getHours() + 11) % 12 + 1, 32 /* space */);\n                    break;\n\n                // '01'\n                case 109 /* m */:\n                    push_pad_2(b, date.getMonth() + 1, 48 /* 0 */);\n                    break;\n\n                // '\\n'\n                case 110 /* n */:\n                    luaL_addchar(b, 10);\n                    break;\n\n                // 'AM'\n                case 112 /* p */:\n                    luaL_addstring(b, date.getHours() < 12 ? locale.AM : locale.PM);\n                    break;\n\n                // '12:00:00 AM'\n                case 114 /* r */:\n                    strftime(L, b, locale.formats.r, date);\n                    break;\n\n                // '0'\n                case 115 /* s */:\n                    luaL_addstring(b, to_luastring(String(Math.floor(date / 1000))));\n                    break;\n\n                // '\\t'\n                case 116 /* t */:\n                    luaL_addchar(b, 8);\n                    break;\n\n                // '4'\n                case 117 /* u */: {\n                    let day = date.getDay();\n                    luaL_addstring(b, to_luastring(String(day === 0 ? 7 : day)));\n                    break;\n                }\n\n                // '4'\n                case 119 /* w */:\n                    luaL_addstring(b, to_luastring(String(date.getDay())));\n                    break;\n\n                // '12/31/69'\n                case 120 /* x */:\n                    strftime(L, b, locale.formats.x, date);\n                    break;\n\n                // '70'\n                case 121 /* y */:\n                    push_pad_2(b, date.getFullYear() % 100, 48 /* 0 */);\n                    break;\n\n                // '+0000'\n                case 122 /* z */: {\n                    let off = date.getTimezoneOffset();\n                    if (off > 0) {\n                        luaL_addchar(b, 45 /* - */);\n                    } else {\n                        off = -off;\n                        luaL_addchar(b, 43 /* + */);\n                    }\n                    push_pad_2(b, Math.floor(off/60), 48 /* 0 */);\n                    push_pad_2(b, off % 60, 48 /* 0 */);\n                    break;\n                }\n            }\n            i += len;\n        }\n    }\n};\n\n\nconst checkoption = function(L, conv, i) {\n    let option = LUA_STRFTIMEOPTIONS;\n    let o = 0;\n    let oplen = 1;  /* length of options being checked */\n    for (; o < option.length && oplen <= (conv.length - i); o += oplen) {\n        if (option[o] === '|'.charCodeAt(0))  /* next block? */\n            oplen++;  /* will check options with next length (+1) */\n        else if (luastring_eq(conv.subarray(i, i+oplen), option.subarray(o, o+oplen))) {  /* match? */\n            return oplen;  /* return length */\n        }\n    }\n    luaL_argerror(L, 1,\n        lua_pushfstring(L, to_luastring(\"invalid conversion specifier '%%%s'\"), conv));\n};\n\n/* maximum size for an individual 'strftime' item */\n// const SIZETIMEFMT = 250;\n\n\nconst os_date = function(L) {\n    let s = luaL_optlstring(L, 1, \"%c\");\n    let stm = lua_isnoneornil(L, 2) ? new Date() : new Date(l_checktime(L, 2) * 1000);\n    let utc = false;\n    let i = 0;\n    if (s[i] === '!'.charCodeAt(0)) {  /* UTC? */\n        utc = true;\n        i++;  /* skip '!' */\n    }\n    if (s[i] === \"*\".charCodeAt(0) && s[i+1] === \"t\".charCodeAt(0)) {\n        lua_createtable(L, 0, 9);  /* 9 = number of fields */\n        setallfields(L, stm, utc);\n    } else {\n        let cc = new Uint8Array(4);\n        cc[0] = \"%\".charCodeAt(0);\n        let b = new luaL_Buffer();\n        luaL_buffinit(L, b);\n        strftime(L, b, s, stm);\n        luaL_pushresult(b);\n    }\n    return 1;\n};\n\nconst os_time = function(L) {\n    let t;\n    if (lua_isnoneornil(L, 1))  /* called without args? */\n        t = new Date();  /* get current time */\n    else {\n        luaL_checktype(L, 1, LUA_TTABLE);\n        lua_settop(L, 1);  /* make sure table is at the top */\n        t = new Date(\n            getfield(L, \"year\", -1, 0),\n            getfield(L, \"month\", -1, 1),\n            getfield(L, \"day\", -1, 0),\n            getfield(L, \"hour\", 12, 0),\n            getfield(L, \"min\", 0, 0),\n            getfield(L, \"sec\", 0, 0)\n        );\n        setallfields(L, t);\n    }\n\n    lua_pushinteger(L, Math.floor(t / 1000));\n    return 1;\n};\n\nconst l_checktime = function(L, arg) {\n    let t = luaL_checkinteger(L, arg);\n    // luaL_argcheck(L, t, arg, \"time out-of-bounds\");\n    return t;\n};\n\nconst os_difftime = function(L) {\n    let t1 = l_checktime(L, 1);\n    let t2 = l_checktime(L, 2);\n    lua_pushnumber(L, t1 - t2);\n    return 1;\n};\n\nconst syslib = {\n    \"date\": os_date,\n    \"difftime\": os_difftime,\n    \"time\": os_time\n};\n\nif (typeof process === \"undefined\") {\n    syslib.clock = function(L) {\n        lua_pushnumber(L, performance.now()/1000);\n        return 1;\n    };\n} else {\n    /* Only with Node */\n    const fs = require('fs');\n    const tmp = require('tmp');\n    const child_process = require('child_process');\n\n    syslib.exit = function(L) {\n        let status;\n        if (lua_isboolean(L, 1))\n            status = (lua_toboolean(L, 1) ? 0 : 1);\n        else\n            status = luaL_optinteger(L, 1, 0);\n        if (lua_toboolean(L, 2))\n            lua_close(L);\n        if (L) process.exit(status);  /* 'if' to avoid warnings for unreachable 'return' */\n        return 0;\n    };\n\n    syslib.getenv = function(L) {\n        let key = luaL_checkstring(L, 1);\n        key = to_jsstring(key); /* https://github.com/nodejs/node/issues/16961 */\n        if (Object.prototype.hasOwnProperty.call(process.env, key)) {\n            lua_pushliteral(L, process.env[key]);\n        } else {\n            lua_pushnil(L);\n        }\n        return 1;\n    };\n\n    syslib.clock = function(L) {\n        lua_pushnumber(L, process.uptime());\n        return 1;\n    };\n\n    const lua_tmpname = function() {\n        return tmp.tmpNameSync();\n    };\n\n    syslib.remove = function(L) {\n        let filename = luaL_checkstring(L, 1);\n        try {\n            fs.unlinkSync(filename);\n        } catch (e) {\n            if (e.code === 'EISDIR') {\n                try {\n                    fs.rmdirSync(filename);\n                } catch (e) {\n                    return luaL_fileresult(L, false, filename, e);\n                }\n            } else {\n                return luaL_fileresult(L, false, filename, e);\n            }\n        }\n        return luaL_fileresult(L, true);\n    };\n\n    syslib.rename = function(L) {\n        let fromname = luaL_checkstring(L, 1);\n        let toname = luaL_checkstring(L, 2);\n        try {\n            fs.renameSync(fromname, toname);\n        } catch (e) {\n            return luaL_fileresult(L, false, false, e);\n        }\n        return luaL_fileresult(L, true);\n    };\n\n    syslib.tmpname = function(L) {\n        let name = lua_tmpname();\n        if (!name)\n            return luaL_error(L, to_luastring(\"unable to generate a unique filename\"));\n        lua_pushstring(L, to_luastring(name));\n        return 1;\n    };\n\n    syslib.execute = function(L) {\n        let cmd = luaL_optstring(L, 1, null);\n        if (cmd !== null) {\n            try {\n                child_process.execSync(\n                    cmd,\n                    {\n                        stdio: [process.stdin, process.stdout, process.stderr]\n                    }\n                );\n            } catch (e) {\n                return luaL_execresult(L, e);\n            }\n\n            return luaL_execresult(L, null);\n        } else {\n            /* Assume a shell is available.\n               If it's good enough for musl it's good enough for us.\n               http://git.musl-libc.org/cgit/musl/tree/src/process/system.c?id=ac45692a53a1b8d2ede329d91652d43c1fb5dc8d#n22\n            */\n            lua_pushboolean(L, 1);\n            return 1;\n        }\n    };\n}\n\nconst luaopen_os = function(L) {\n    luaL_newlib(L, syslib);\n    return 1;\n};\n\nmodule.exports.luaopen_os = luaopen_os;\n","\"use strict\";\n\nconst { LUA_MAXINTEGER } = require('./luaconf.js');\nconst {\n    LUA_OPEQ,\n    LUA_OPLT,\n    LUA_TFUNCTION,\n    LUA_TNIL,\n    LUA_TTABLE,\n    lua_call,\n    lua_checkstack,\n    lua_compare,\n    lua_createtable,\n    lua_geti,\n    lua_getmetatable,\n    lua_gettop,\n    lua_insert,\n    lua_isnil,\n    lua_isnoneornil,\n    lua_isstring,\n    lua_pop,\n    lua_pushinteger,\n    lua_pushnil,\n    lua_pushstring,\n    lua_pushvalue,\n    lua_rawget,\n    lua_setfield,\n    lua_seti,\n    lua_settop,\n    lua_toboolean,\n    lua_type\n} = require('./lua.js');\nconst {\n    luaL_Buffer,\n    luaL_addlstring,\n    luaL_addvalue,\n    luaL_argcheck,\n    luaL_buffinit,\n    luaL_checkinteger,\n    luaL_checktype,\n    luaL_error,\n    luaL_len,\n    luaL_newlib,\n    luaL_opt,\n    luaL_optinteger,\n    luaL_optlstring,\n    luaL_pushresult,\n    luaL_typename\n} = require('./lauxlib.js');\nconst lualib = require('./lualib.js');\nconst { to_luastring } = require(\"./fengaricore.js\");\n\n/*\n** Operations that an object must define to mimic a table\n** (some functions only need some of them)\n*/\nconst TAB_R  = 1;               /* read */\nconst TAB_W  = 2;               /* write */\nconst TAB_L  = 4;               /* length */\nconst TAB_RW = (TAB_R | TAB_W); /* read/write */\n\nconst checkfield = function(L, key, n) {\n    lua_pushstring(L, key);\n    return lua_rawget(L, -n) !== LUA_TNIL;\n};\n\n/*\n** Check that 'arg' either is a table or can behave like one (that is,\n** has a metatable with the required metamethods)\n*/\nconst checktab = function(L, arg, what) {\n    if (lua_type(L, arg) !== LUA_TTABLE) {  /* is it not a table? */\n        let n = 1;\n        if (lua_getmetatable(L, arg) &&  /* must have metatable */\n            (!(what & TAB_R) || checkfield(L, to_luastring(\"__index\", true), ++n)) &&\n            (!(what & TAB_W) || checkfield(L, to_luastring(\"__newindex\", true), ++n)) &&\n            (!(what & TAB_L) || checkfield(L, to_luastring(\"__len\", true), ++n))) {\n            lua_pop(L, n);  /* pop metatable and tested metamethods */\n        }\n        else\n            luaL_checktype(L, arg, LUA_TTABLE);  /* force an error */\n    }\n};\n\nconst aux_getn = function(L, n, w) {\n    checktab(L, n, w | TAB_L);\n    return luaL_len(L, n);\n};\n\nconst addfield = function(L, b, i) {\n    lua_geti(L, 1, i);\n    if (!lua_isstring(L, -1))\n        luaL_error(L, to_luastring(\"invalid value (%s) at index %d in table for 'concat'\"),\n            luaL_typename(L, -1), i);\n\n    luaL_addvalue(b);\n};\n\nconst tinsert = function(L) {\n    let e = aux_getn(L, 1, TAB_RW) + 1;  /* first empty element */\n    let pos;\n    switch (lua_gettop(L)) {\n        case 2:\n            pos = e;\n            break;\n        case 3: {\n            pos = luaL_checkinteger(L, 2);  /* 2nd argument is the position */\n            luaL_argcheck(L, 1 <= pos && pos <= e, 2, \"position out of bounds\");\n            for (let i = e; i > pos; i--) {  /* move up elements */\n                lua_geti(L, 1, i - 1);\n                lua_seti(L, 1, i);  /* t[i] = t[i - 1] */\n            }\n            break;\n        }\n        default: {\n            return luaL_error(L, \"wrong number of arguments to 'insert'\");\n        }\n    }\n\n    lua_seti(L, 1, pos);  /* t[pos] = v */\n    return 0;\n};\n\nconst tremove = function(L) {\n    let size = aux_getn(L, 1, TAB_RW);\n    let pos = luaL_optinteger(L, 2, size);\n    if (pos !== size)  /* validate 'pos' if given */\n        luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, \"position out of bounds\");\n    lua_geti(L, 1, pos);  /* result = t[pos] */\n    for (; pos < size; pos++) {\n        lua_geti(L, 1, pos + 1);\n        lua_seti(L, 1, pos);  /* t[pos] = t[pos + 1] */\n    }\n    lua_pushnil(L);\n    lua_seti(L, 1, pos);  /* t[pos] = nil */\n    return 1;\n};\n\n/*\n** Copy elements (1[f], ..., 1[e]) into (tt[t], tt[t+1], ...). Whenever\n** possible, copy in increasing order, which is better for rehashing.\n** \"possible\" means destination after original range, or smaller\n** than origin, or copying to another table.\n*/\nconst tmove = function(L) {\n    let f = luaL_checkinteger(L, 2);\n    let e = luaL_checkinteger(L, 3);\n    let t = luaL_checkinteger(L, 4);\n    let tt = !lua_isnoneornil(L, 5) ? 5 : 1;  /* destination table */\n    checktab(L, 1, TAB_R);\n    checktab(L, tt, TAB_W);\n    if (e >= f) {  /* otherwise, nothing to move */\n        luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3, \"too many elements to move\");\n        let n = e - f + 1;  /* number of elements to move */\n        luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4, \"destination wrap around\");\n\n        if (t > e || t <= f || (tt !== 1 && lua_compare(L, 1, tt, LUA_OPEQ) !== 1)) {\n            for (let i = 0; i < n; i++) {\n                lua_geti(L, 1, f + i);\n                lua_seti(L, tt, t + i);\n            }\n        } else {\n            for (let i = n - 1; i >= 0; i--) {\n                lua_geti(L, 1, f + i);\n                lua_seti(L, tt, t + i);\n            }\n        }\n    }\n\n    lua_pushvalue(L, tt);  /* return destination table */\n    return 1;\n};\n\nconst tconcat = function(L) {\n    let last = aux_getn(L, 1, TAB_R);\n    let sep = luaL_optlstring(L, 2, \"\");\n    let lsep = sep.length;\n    let i = luaL_optinteger(L, 3, 1);\n    last = luaL_optinteger(L, 4, last);\n\n    let b = new luaL_Buffer();\n    luaL_buffinit(L, b);\n\n    for (; i < last; i++) {\n        addfield(L, b, i);\n        luaL_addlstring(b, sep, lsep);\n    }\n\n    if (i === last)\n        addfield(L, b, i);\n\n    luaL_pushresult(b);\n\n    return 1;\n};\n\nconst pack = function(L) {\n    let n = lua_gettop(L);  /* number of elements to pack */\n    lua_createtable(L, n, 1);  /* create result table */\n    lua_insert(L, 1);  /* put it at index 1 */\n    for (let i = n; i >= 1; i--)  /* assign elements */\n        lua_seti(L, 1, i);\n    lua_pushinteger(L, n);\n    lua_setfield(L, 1, to_luastring(\"n\"));  /* t.n = number of elements */\n    return 1;  /* return table */\n};\n\nconst unpack = function(L) {\n    let i = luaL_optinteger(L, 2, 1);\n    let e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));\n    if (i > e) return 0;  /* empty range */\n    let n = e - i;  /* number of elements minus 1 (avoid overflows) */\n    if (n >= Number.MAX_SAFE_INTEGER || !lua_checkstack(L, ++n))\n        return luaL_error(L, to_luastring(\"too many results to unpack\"));\n    for (; i < e; i++)  /* push arg[i..e - 1] (to avoid overflows) */\n        lua_geti(L, 1, i);\n    lua_geti(L, 1, e);  /* push last element */\n    return n;\n};\n\nconst l_randomizePivot = function() {\n    return Math.floor(Math.random()*1<<32);\n};\n\nconst RANLIMIT = 100;\n\nconst set2 = function(L, i, j) {\n    lua_seti(L, 1, i);\n    lua_seti(L, 1, j);\n};\n\nconst sort_comp = function(L, a, b) {\n    if (lua_isnil(L, 2))  /* no function? */\n        return lua_compare(L, a, b, LUA_OPLT);  /* a < b */\n    else {  /* function */\n        lua_pushvalue(L, 2);    /* push function */\n        lua_pushvalue(L, a-1);  /* -1 to compensate function */\n        lua_pushvalue(L, b-2);  /* -2 to compensate function and 'a' */\n        lua_call(L, 2, 1);      /* call function */\n        let res = lua_toboolean(L, -1);  /* get result */\n        lua_pop(L, 1);          /* pop result */\n        return res;\n    }\n};\n\nconst partition = function(L, lo, up) {\n    let i = lo;  /* will be incremented before first use */\n    let j = up - 1;  /* will be decremented before first use */\n    /* loop invariant: a[lo .. i] <= P <= a[j .. up] */\n    for (;;) {\n        /* next loop: repeat ++i while a[i] < P */\n        while (lua_geti(L, 1, ++i), sort_comp(L, -1, -2)) {\n            if (i == up - 1)  /* a[i] < P  but a[up - 1] == P  ?? */\n                luaL_error(L, to_luastring(\"invalid order function for sorting\"));\n            lua_pop(L, 1);  /* remove a[i] */\n        }\n        /* after the loop, a[i] >= P and a[lo .. i - 1] < P */\n        /* next loop: repeat --j while P < a[j] */\n        while (lua_geti(L, 1, --j), sort_comp(L, -3, -1)) {\n            if (j < i)  /* j < i  but  a[j] > P ?? */\n                luaL_error(L, to_luastring(\"invalid order function for sorting\"));\n            lua_pop(L, 1);  /* remove a[j] */\n        }\n        /* after the loop, a[j] <= P and a[j + 1 .. up] >= P */\n        if (j < i) {  /* no elements out of place? */\n            /* a[lo .. i - 1] <= P <= a[j + 1 .. i .. up] */\n            lua_pop(L, 1);  /* pop a[j] */\n            /* swap pivot (a[up - 1]) with a[i] to satisfy pos-condition */\n            set2(L, up - 1, i);\n            return i;\n        }\n        /* otherwise, swap a[i] - a[j] to restore invariant and repeat */\n        set2(L, i, j);\n    }\n};\n\nconst choosePivot = function(lo, up, rnd) {\n    let r4 = Math.floor((up - lo) / 4);  /* range/4 */\n    let p = rnd % (r4 * 2) + (lo + r4);\n    lualib.lua_assert(lo + r4 <= p && p <= up - r4);\n    return p;\n};\n\nconst auxsort = function(L, lo, up, rnd) {\n    while (lo < up) {  /* loop for tail recursion */\n        /* sort elements 'lo', 'p', and 'up' */\n        lua_geti(L, 1, lo);\n        lua_geti(L, 1, up);\n        if (sort_comp(L, -1, -2))  /* a[up] < a[lo]? */\n            set2(L, lo, up);  /* swap a[lo] - a[up] */\n        else\n            lua_pop(L, 2);  /* remove both values */\n        if (up - lo == 1)  /* only 2 elements? */\n            return;  /* already sorted */\n        let p;  /* Pivot index */\n        if (up - lo < RANLIMIT || rnd === 0)  /* small interval or no randomize? */\n            p = Math.floor((lo + up)/2);  /* middle element is a good pivot */\n        else  /* for larger intervals, it is worth a random pivot */\n            p = choosePivot(lo, up, rnd);\n        lua_geti(L, 1, p);\n        lua_geti(L, 1, lo);\n        if (sort_comp(L, -2, -1))  /* a[p] < a[lo]? */\n            set2(L, p, lo);  /* swap a[p] - a[lo] */\n        else {\n            lua_pop(L, 1);  /* remove a[lo] */\n            lua_geti(L, 1, up);\n            if (sort_comp(L, -1, -2))  /* a[up] < a[p]? */\n                set2(L, p, up);  /* swap a[up] - a[p] */\n            else\n                lua_pop(L, 2);\n        }\n        if (up - lo == 2)  /* only 3 elements? */\n            return;  /* already sorted */\n        lua_geti(L, 1, p);  /* get middle element (Pivot) */\n        lua_pushvalue(L, -1);  /* push Pivot */\n        lua_geti(L, 1, up - 1);  /* push a[up - 1] */\n        set2(L, p, up - 1);  /* swap Pivot (a[p]) with a[up - 1] */\n        p = partition(L, lo, up);\n        let n;\n        /* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */\n        if (p - lo < up - p) {  /* lower interval is smaller? */\n            auxsort(L, lo, p - 1, rnd);  /* call recursively for lower interval */\n            n = p - lo;  /* size of smaller interval */\n            lo = p + 1;  /* tail call for [p + 1 .. up] (upper interval) */\n        } else {\n            auxsort(L, p + 1, up, rnd);  /* call recursively for upper interval */\n            n = up - p;  /* size of smaller interval */\n            up = p - 1;  /* tail call for [lo .. p - 1]  (lower interval) */\n        }\n        if ((up - lo) / 128 > n) /* partition too imbalanced? */\n            rnd = l_randomizePivot();  /* try a new randomization */\n    }  /* tail call auxsort(L, lo, up, rnd) */\n};\n\nconst sort = function(L) {\n    let n = aux_getn(L, 1, TAB_RW);\n    if (n > 1) {  /* non-trivial interval? */\n        luaL_argcheck(L, n < LUA_MAXINTEGER, 1, \"array too big\");\n        if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */\n            luaL_checktype(L, 2, LUA_TFUNCTION);  /* must be a function */\n        lua_settop(L, 2);  /* make sure there are two arguments */\n        auxsort(L, 1, n, 0);\n    }\n    return 0;\n};\n\nconst tab_funcs = {\n    \"concat\": tconcat,\n    \"insert\": tinsert,\n    \"move\":   tmove,\n    \"pack\":   pack,\n    \"remove\": tremove,\n    \"sort\":   sort,\n    \"unpack\": unpack\n};\n\nconst luaopen_table = function(L) {\n    luaL_newlib(L, tab_funcs);\n    return 1;\n};\n\nmodule.exports.luaopen_table = luaopen_table;\n","\"use strict\";\n\nconst {\n    LUA_OK,\n    LUA_TFUNCTION,\n    LUA_TSTRING,\n    LUA_YIELD,\n    lua_Debug,\n    lua_checkstack,\n    lua_concat,\n    lua_error,\n    lua_getstack,\n    lua_gettop,\n    lua_insert,\n    lua_isyieldable,\n    lua_newthread,\n    lua_pop,\n    lua_pushboolean,\n    lua_pushcclosure,\n    lua_pushliteral,\n    lua_pushthread,\n    lua_pushvalue,\n    lua_resume,\n    lua_status,\n    lua_tothread,\n    lua_type,\n    lua_upvalueindex,\n    lua_xmove,\n    lua_yield\n} = require('./lua.js');\nconst {\n    luaL_argcheck,\n    luaL_checktype,\n    luaL_newlib,\n    luaL_where\n} = require('./lauxlib.js');\n\nconst getco = function(L) {\n    let co = lua_tothread(L, 1);\n    luaL_argcheck(L, co, 1, \"thread expected\");\n    return co;\n};\n\nconst auxresume = function(L, co, narg) {\n    if (!lua_checkstack(co, narg)) {\n        lua_pushliteral(L, \"too many arguments to resume\");\n        return -1;  /* error flag */\n    }\n\n    if (lua_status(co) === LUA_OK && lua_gettop(co) === 0) {\n        lua_pushliteral(L, \"cannot resume dead coroutine\");\n        return -1;  /* error flag */\n    }\n\n    lua_xmove(L, co, narg);\n    let status = lua_resume(co, L, narg);\n    if (status === LUA_OK || status === LUA_YIELD) {\n        let nres = lua_gettop(co);\n        if (!lua_checkstack(L, nres + 1)) {\n            lua_pop(co, nres);  /* remove results anyway */\n            lua_pushliteral(L, \"too many results to resume\");\n            return -1;  /* error flag */\n        }\n\n        lua_xmove(co,  L, nres);  /* move yielded values */\n        return nres;\n    } else {\n        lua_xmove(co, L, 1);  /* move error message */\n        return -1;  /* error flag */\n    }\n};\n\nconst luaB_coresume = function(L) {\n    let co = getco(L);\n    let r = auxresume(L, co, lua_gettop(L) - 1);\n    if (r < 0) {\n        lua_pushboolean(L, 0);\n        lua_insert(L, -2);\n        return 2;  /* return false + error message */\n    } else {\n        lua_pushboolean(L, 1);\n        lua_insert(L, -(r + 1));\n        return r + 1;  /* return true + 'resume' returns */\n    }\n};\n\nconst luaB_auxwrap = function(L) {\n    let co = lua_tothread(L, lua_upvalueindex(1));\n    let r = auxresume(L, co, lua_gettop(L));\n    if (r < 0) {\n        if (lua_type(L, -1) === LUA_TSTRING) {  /* error object is a string? */\n            luaL_where(L, 1);  /* add extra info */\n            lua_insert(L, -2);\n            lua_concat(L, 2);\n        }\n\n        return lua_error(L);  /* propagate error */\n    }\n\n    return r;\n};\n\nconst luaB_cocreate = function(L) {\n    luaL_checktype(L, 1, LUA_TFUNCTION);\n    let NL = lua_newthread(L);\n    lua_pushvalue(L, 1);  /* move function to top */\n    lua_xmove(L, NL, 1);  /* move function from L to NL */\n    return 1;\n};\n\nconst luaB_cowrap = function(L) {\n    luaB_cocreate(L);\n    lua_pushcclosure(L, luaB_auxwrap, 1);\n    return 1;\n};\n\nconst luaB_yield = function(L) {\n    return lua_yield(L, lua_gettop(L));\n};\n\nconst luaB_costatus = function(L) {\n    let co = getco(L);\n    if (L === co) lua_pushliteral(L, \"running\");\n    else {\n        switch (lua_status(co)) {\n            case LUA_YIELD:\n                lua_pushliteral(L, \"suspended\");\n                break;\n            case LUA_OK: {\n                let ar = new lua_Debug();\n                if (lua_getstack(co, 0, ar) > 0)  /* does it have frames? */\n                    lua_pushliteral(L, \"normal\");  /* it is running */\n                else if (lua_gettop(co) === 0)\n                    lua_pushliteral(L, \"dead\");\n                else\n                    lua_pushliteral(L, \"suspended\");  /* initial state */\n                break;\n            }\n            default:  /* some error occurred */\n                lua_pushliteral(L, \"dead\");\n                break;\n        }\n    }\n\n    return 1;\n};\n\nconst luaB_yieldable = function(L) {\n    lua_pushboolean(L, lua_isyieldable(L));\n    return 1;\n};\n\nconst luaB_corunning = function(L) {\n    lua_pushboolean(L, lua_pushthread(L));\n    return 2;\n};\n\nconst co_funcs = {\n    \"create\":      luaB_cocreate,\n    \"isyieldable\": luaB_yieldable,\n    \"resume\":      luaB_coresume,\n    \"running\":     luaB_corunning,\n    \"status\":      luaB_costatus,\n    \"wrap\":        luaB_cowrap,\n    \"yield\":       luaB_yield\n};\n\nconst luaopen_coroutine = function(L) {\n    luaL_newlib(L, co_funcs);\n    return 1;\n};\n\nmodule.exports.luaopen_coroutine = luaopen_coroutine;\n","\"use strict\";\n\nconst {\n    LUA_MULTRET,\n    to_luastring\n} = require('./defs.js');\nconst {\n    BinOpr: {\n        OPR_ADD,\n        OPR_AND,\n        OPR_BAND,\n        OPR_BOR,\n        OPR_BXOR,\n        OPR_CONCAT,\n        OPR_DIV,\n        OPR_EQ,\n        OPR_GE,\n        OPR_GT,\n        OPR_IDIV,\n        OPR_LE,\n        OPR_LT,\n        OPR_MOD,\n        OPR_MUL,\n        OPR_NE,\n        OPR_NOBINOPR,\n        OPR_OR,\n        OPR_POW,\n        OPR_SHL,\n        OPR_SHR,\n        OPR_SUB\n    },\n    UnOpr: {\n        OPR_BNOT,\n        OPR_LEN,\n        OPR_MINUS,\n        OPR_NOT,\n        OPR_NOUNOPR\n    },\n    NO_JUMP,\n    getinstruction,\n    luaK_checkstack,\n    luaK_codeABC,\n    luaK_codeABx,\n    luaK_codeAsBx,\n    luaK_codek,\n    luaK_concat,\n    luaK_dischargevars,\n    luaK_exp2RK,\n    luaK_exp2anyreg,\n    luaK_exp2anyregup,\n    luaK_exp2nextreg,\n    luaK_exp2val,\n    luaK_fixline,\n    luaK_getlabel,\n    luaK_goiffalse,\n    luaK_goiftrue,\n    luaK_indexed,\n    luaK_infix,\n    luaK_intK,\n    luaK_jump,\n    luaK_jumpto,\n    luaK_nil,\n    luaK_patchclose,\n    luaK_patchlist,\n    luaK_patchtohere,\n    luaK_posfix,\n    luaK_prefix,\n    luaK_reserveregs,\n    luaK_ret,\n    luaK_self,\n    luaK_setlist,\n    luaK_setmultret,\n    luaK_setoneret,\n    luaK_setreturns,\n    luaK_storevar,\n    luaK_stringK\n} = require('./lcode.js');\nconst ldo      = require('./ldo.js');\nconst lfunc    = require('./lfunc.js');\nconst llex     = require('./llex.js');\nconst {\n    LUAI_MAXCCALLS,\n    MAX_INT,\n    lua_assert\n}  = require('./llimits.js');\nconst lobject  = require('./lobject.js');\nconst {\n    OpCodesI: {\n        OP_CALL,\n        OP_CLOSURE,\n        OP_FORLOOP,\n        OP_FORPREP,\n        OP_GETUPVAL,\n        OP_MOVE,\n        OP_NEWTABLE,\n        OP_SETTABLE,\n        OP_TAILCALL,\n        OP_TFORCALL,\n        OP_TFORLOOP,\n        OP_VARARG\n    },\n    LFIELDS_PER_FLUSH,\n    SETARG_B,\n    SETARG_C,\n    SET_OPCODE\n} = require('./lopcodes.js');\nconst {\n    luaS_eqlngstr,\n    luaS_new,\n    luaS_newliteral\n} = require('./lstring.js');\nconst ltable   = require('./ltable.js');\nconst Proto    = lfunc.Proto;\nconst R        = llex.RESERVED;\n\nconst MAXVARS = 200;\n\nconst hasmultret = function(k) {\n    return k === expkind.VCALL || k === expkind.VVARARG;\n};\n\nconst eqstr = function(a, b) {\n    /* TODO: use plain equality as strings are cached */\n    return luaS_eqlngstr(a, b);\n};\n\nclass BlockCnt {\n    constructor() {\n        this.previous = null;  /* chain */\n        this.firstlabel = NaN; /* index of first label in this block */\n        this.firstgoto = NaN;  /* index of first pending goto in this block */\n        this.nactvar = NaN;    /* # active locals outside the block */\n        this.upval = NaN;      /* true if some variable in the block is an upvalue */\n        this.isloop = NaN;     /* true if 'block' is a loop */\n    }\n}\n\nconst expkind = {\n    VVOID: 0,        /* when 'expdesc' describes the last expression a list,\n                        this kind means an empty list (so, no expression) */\n    VNIL: 1,         /* constant nil */\n    VTRUE: 2,        /* constant true */\n    VFALSE: 3,       /* constant false */\n    VK: 4,           /* constant in 'k'; info = index of constant in 'k' */\n    VKFLT: 5,        /* floating constant; nval = numerical float value */\n    VKINT: 6,        /* integer constant; nval = numerical integer value */\n    VNONRELOC: 7,    /* expression has its value in a fixed register;\n                        info = result register */\n    VLOCAL: 8,       /* local variable; info = local register */\n    VUPVAL: 9,       /* upvalue variable; info = index of upvalue in 'upvalues' */\n    VINDEXED: 10,    /* indexed variable;\n                        ind.vt = whether 't' is register or upvalue;\n                        ind.t = table register or upvalue;\n                        ind.idx = key's R/K index */\n    VJMP: 11,        /* expression is a test/comparison;\n                        info = pc of corresponding jump instruction */\n    VRELOCABLE: 12,  /* expression can put result in any register;\n                        info = instruction pc */\n    VCALL: 13,       /* expression is a function call; info = instruction pc */\n    VVARARG: 14      /* vararg expression; info = instruction pc */\n};\n\nconst vkisvar = function(k) {\n    return expkind.VLOCAL <= k && k <= expkind.VINDEXED;\n};\n\nconst vkisinreg = function(k) {\n    return k === expkind.VNONRELOC || k === expkind.VLOCAL;\n};\n\nclass expdesc {\n    constructor() {\n        this.k = NaN;\n        this.u = {\n            ival: NaN,    /* for VKINT */\n            nval: NaN,    /* for VKFLT */\n            info: NaN,    /* for generic use */\n            ind: {        /* for indexed variables (VINDEXED) */\n                idx: NaN, /* index (R/K) */\n                t: NaN,   /* table (register or upvalue) */\n                vt: NaN   /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */\n            }\n        };\n        this.t = NaN;     /* patch list of 'exit when true' */\n        this.f = NaN;     /* patch list of 'exit when false' */\n    }\n\n    to(e) { // Copy e content to this, cf. luaK_posfix\n        this.k = e.k;\n        this.u = e.u;\n        this.t = e.t;\n        this.f = e.f;\n    }\n}\n\nclass FuncState {\n    constructor() {\n        this.f = null;         /* current function header */\n        this.prev = null;      /* enclosing function */\n        this.ls = null;        /* lexical state */\n        this.bl = null;        /* chain of current blocks */\n        this.pc = NaN;         /* next position to code (equivalent to 'ncode') */\n        this.lasttarget = NaN; /* 'label' of last 'jump label' */\n        this.jpc = NaN;        /* list of pending jumps to 'pc' */\n        this.nk = NaN;         /* number of elements in 'k' */\n        this.np = NaN;         /* number of elements in 'p' */\n        this.firstlocal = NaN; /* index of first local var (in Dyndata array) */\n        this.nlocvars = NaN;   /* number of elements in 'f->locvars' */\n        this.nactvar = NaN;    /* number of active local variables */\n        this.nups = NaN;       /* number of upvalues */\n        this.freereg = NaN;    /* first free register */\n    }\n}\n\n/* description of active local variable */\nclass Vardesc {\n    constructor() {\n        this.idx = NaN;  /* variable index in stack */\n    }\n}\n\n\n/* description of pending goto statements and label statements */\nclass Labeldesc {\n    constructor() {\n        this.name = null;  /* label identifier */\n        this.pc = NaN;  /* position in code */\n        this.line = NaN;  /* line where it appeared */\n        this.nactvar = NaN;  /* local level where it appears in current block */\n    }\n}\n\n\n/* list of labels or gotos */\nclass Labellist {\n    constructor() {\n        this.arr = []; /* array */\n        this.n = NaN;  /* number of entries in use */\n        this.size = NaN;  /* array size */\n    }\n}\n\n/* dynamic structures used by the parser */\nclass Dyndata {\n    constructor() {\n        this.actvar = {  /* list of active local variables */\n            arr: [],\n            n: NaN,\n            size: NaN\n        };\n        this.gt = new Labellist();\n        this.label = new Labellist();\n    }\n}\n\nconst semerror = function(ls, msg) {\n    ls.t.token = 0;  /* remove \"near <token>\" from final message */\n    llex.luaX_syntaxerror(ls, msg);\n};\n\nconst error_expected = function(ls, token) {\n    llex.luaX_syntaxerror(ls, lobject.luaO_pushfstring(ls.L, to_luastring(\"%s expected\", true), llex.luaX_token2str(ls, token)));\n};\n\nconst errorlimit = function(fs, limit, what) {\n    let L = fs.ls.L;\n    let line = fs.f.linedefined;\n    let where = (line === 0)\n        ? to_luastring(\"main function\", true)\n        : lobject.luaO_pushfstring(L, to_luastring(\"function at line %d\", true), line);\n    let msg = lobject.luaO_pushfstring(L, to_luastring(\"too many %s (limit is %d) in %s\", true),\n        what, limit, where);\n    llex.luaX_syntaxerror(fs.ls, msg);\n};\n\nconst checklimit = function(fs, v, l, what) {\n    if (v > l) errorlimit(fs, l, what);\n};\n\nconst testnext = function(ls, c) {\n    if (ls.t.token === c) {\n        llex.luaX_next(ls);\n        return true;\n    }\n\n    return false;\n};\n\nconst check = function(ls, c) {\n    if (ls.t.token !== c)\n        error_expected(ls, c);\n};\n\nconst checknext = function(ls, c) {\n    check(ls, c);\n    llex.luaX_next(ls);\n};\n\nconst check_condition = function(ls, c, msg) {\n    if (!c)\n        llex.luaX_syntaxerror(ls, msg);\n};\n\nconst check_match = function(ls, what, who, where) {\n    if (!testnext(ls, what)) {\n        if (where === ls.linenumber)\n            error_expected(ls, what);\n        else\n            llex.luaX_syntaxerror(ls, lobject.luaO_pushfstring(ls.L,\n                to_luastring(\"%s expected (to close %s at line %d)\"),\n                llex.luaX_token2str(ls, what), llex.luaX_token2str(ls, who), where));\n    }\n};\n\nconst str_checkname = function(ls) {\n    check(ls, R.TK_NAME);\n    let ts = ls.t.seminfo.ts;\n    llex.luaX_next(ls);\n    return ts;\n};\n\nconst init_exp = function(e, k, i) {\n    e.f = e.t = NO_JUMP;\n    e.k = k;\n    e.u.info = i;\n};\n\nconst codestring = function(ls, e, s) {\n    init_exp(e, expkind.VK, luaK_stringK(ls.fs, s));\n};\n\nconst checkname = function(ls, e) {\n    codestring(ls, e, str_checkname(ls));\n};\n\nconst registerlocalvar = function(ls, varname) {\n    let fs = ls.fs;\n    let f = fs.f;\n    f.locvars[fs.nlocvars] = new lobject.LocVar();\n    f.locvars[fs.nlocvars].varname = varname;\n    return fs.nlocvars++;\n};\n\nconst new_localvar = function(ls, name) {\n    let fs = ls.fs;\n    let dyd = ls.dyd;\n    let reg = registerlocalvar(ls, name);\n    checklimit(fs, dyd.actvar.n + 1 - fs.firstlocal, MAXVARS, to_luastring(\"local variables\", true));\n    dyd.actvar.arr[dyd.actvar.n] = new Vardesc();\n    dyd.actvar.arr[dyd.actvar.n].idx = reg;\n    dyd.actvar.n++;\n};\n\nconst new_localvarliteral = function(ls, name) {\n    new_localvar(ls, llex.luaX_newstring(ls, to_luastring(name, true)));\n};\n\nconst getlocvar = function(fs, i) {\n    let idx = fs.ls.dyd.actvar.arr[fs.firstlocal + i].idx;\n    lua_assert(idx < fs.nlocvars);\n    return fs.f.locvars[idx];\n};\n\nconst adjustlocalvars = function(ls, nvars) {\n    let fs = ls.fs;\n    fs.nactvar = fs.nactvar + nvars;\n    for (; nvars; nvars--)\n        getlocvar(fs, fs.nactvar - nvars).startpc = fs.pc;\n};\n\nconst removevars = function(fs, tolevel) {\n    fs.ls.dyd.actvar.n -= fs.nactvar - tolevel;\n    while (fs.nactvar > tolevel)\n        getlocvar(fs, --fs.nactvar).endpc = fs.pc;\n};\n\nconst searchupvalue = function(fs, name) {\n    let up = fs.f.upvalues;\n    for (let i = 0; i < fs.nups; i++) {\n        if (eqstr(up[i].name, name))\n            return i;\n    }\n    return -1;  /* not found */\n};\n\nconst newupvalue = function(fs, name, v) {\n    let f = fs.f;\n    checklimit(fs, fs.nups + 1, lfunc.MAXUPVAL, to_luastring(\"upvalues\", true));\n    f.upvalues[fs.nups] = {\n        instack: v.k === expkind.VLOCAL,\n        idx: v.u.info,\n        name: name\n    };\n    return fs.nups++;\n};\n\nconst searchvar = function(fs, n) {\n    for (let i = fs.nactvar - 1; i >= 0; i--) {\n        if (eqstr(n, getlocvar(fs, i).varname))\n            return i;\n    }\n\n    return -1;\n};\n\n/*\n** Mark block where variable at given level was defined\n** (to emit close instructions later).\n*/\nconst markupval = function(fs, level) {\n    let bl = fs.bl;\n    while (bl.nactvar > level)\n        bl = bl.previous;\n    bl.upval = 1;\n};\n\n/*\n** Find variable with given name 'n'. If it is an upvalue, add this\n** upvalue into all intermediate functions.\n*/\nconst singlevaraux = function(fs, n, vr, base) {\n    if (fs === null)  /* no more levels? */\n        init_exp(vr, expkind.VVOID, 0);  /* default is global */\n    else {\n        let v = searchvar(fs, n);  /* look up locals at current level */\n        if (v >= 0) {  /* found? */\n            init_exp(vr, expkind.VLOCAL, v);  /* variable is local */\n            if (!base)\n                markupval(fs, v);  /* local will be used as an upval */\n        } else {  /* not found as local at current level; try upvalues */\n            let idx = searchupvalue(fs, n);  /* try existing upvalues */\n            if (idx < 0) {  /* not found? */\n                singlevaraux(fs.prev, n, vr, 0);  /* try upper levels */\n                if (vr.k === expkind.VVOID)  /* not found? */\n                    return;  /* it is a global */\n                /* else was LOCAL or UPVAL */\n                idx = newupvalue(fs, n, vr);  /* will be a new upvalue */\n            }\n            init_exp(vr, expkind.VUPVAL, idx);  /* new or old upvalue */\n        }\n    }\n};\n\nconst singlevar = function(ls, vr) {\n    let varname = str_checkname(ls);\n    let fs = ls.fs;\n    singlevaraux(fs, varname, vr, 1);\n    if (vr.k === expkind.VVOID) {  /* is global name? */\n        let key = new expdesc();\n        singlevaraux(fs, ls.envn, vr, 1);  /* get environment variable */\n        lua_assert(vr.k !== expkind.VVOID);  /* this one must exist */\n        codestring(ls, key, varname);  /* key is variable name */\n        luaK_indexed(fs, vr, key);  /* env[varname] */\n    }\n};\n\nconst adjust_assign = function(ls, nvars, nexps, e) {\n    let fs = ls.fs;\n    let extra = nvars - nexps;\n    if (hasmultret(e.k)) {\n        extra++;  /* includes call itself */\n        if (extra < 0) extra = 0;\n        luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */\n        if (extra > 1) luaK_reserveregs(fs, extra - 1);\n    } else {\n        if (e.k !== expkind.VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */\n        if (extra > 0) {\n            let reg = fs.freereg;\n            luaK_reserveregs(fs, extra);\n            luaK_nil(fs, reg, extra);\n        }\n    }\n    if (nexps > nvars)\n        ls.fs.freereg -= nexps - nvars;  /* remove extra values */\n};\n\nconst enterlevel = function(ls) {\n    let L = ls.L;\n    ++L.nCcalls;\n    checklimit(ls.fs, L.nCcalls, LUAI_MAXCCALLS, to_luastring(\"JS levels\", true));\n};\n\nconst leavelevel = function(ls) {\n    return ls.L.nCcalls--;\n};\n\nconst closegoto = function(ls, g, label) {\n    let fs = ls.fs;\n    let gl = ls.dyd.gt;\n    let gt = gl.arr[g];\n    lua_assert(eqstr(gt.name, label.name));\n    if (gt.nactvar < label.nactvar) {\n        let vname = getlocvar(fs, gt.nactvar).varname;\n        let msg = lobject.luaO_pushfstring(ls.L,\n            to_luastring(\"<goto %s> at line %d jumps into the scope of local '%s'\"),\n            gt.name.getstr(), gt.line, vname.getstr());\n        semerror(ls, msg);\n    }\n    luaK_patchlist(fs, gt.pc, label.pc);\n    /* remove goto from pending list */\n    for (let i = g; i < gl.n - 1; i++)\n        gl.arr[i] = gl.arr[i + 1];\n    gl.n--;\n};\n\n/*\n** try to close a goto with existing labels; this solves backward jumps\n*/\nconst findlabel = function(ls, g) {\n    let bl = ls.fs.bl;\n    let dyd = ls.dyd;\n    let gt = dyd.gt.arr[g];\n    /* check labels in current block for a match */\n    for (let i = bl.firstlabel; i < dyd.label.n; i++) {\n        let lb = dyd.label.arr[i];\n        if (eqstr(lb.name, gt.name)) {  /* correct label? */\n            if (gt.nactvar > lb.nactvar && (bl.upval || dyd.label.n > bl.firstlabel))\n                luaK_patchclose(ls.fs, gt.pc, lb.nactvar);\n            closegoto(ls, g, lb);  /* close it */\n            return true;\n        }\n    }\n    return false;  /* label not found; cannot close goto */\n};\n\nconst newlabelentry = function(ls, l, name, line, pc) {\n    let n = l.n;\n    l.arr[n] = new Labeldesc();\n    l.arr[n].name = name;\n    l.arr[n].line = line;\n    l.arr[n].nactvar = ls.fs.nactvar;\n    l.arr[n].pc = pc;\n    l.n = n + 1;\n    return n;\n};\n\n/*\n** check whether new label 'lb' matches any pending gotos in current\n** block; solves forward jumps\n*/\nconst findgotos = function(ls, lb) {\n    let gl = ls.dyd.gt;\n    let i = ls.fs.bl.firstgoto;\n    while (i < gl.n) {\n        if (eqstr(gl.arr[i].name, lb.name))\n            closegoto(ls, i, lb);\n        else\n            i++;\n    }\n};\n\n/*\n** export pending gotos to outer level, to check them against\n** outer labels; if the block being exited has upvalues, and\n** the goto exits the scope of any variable (which can be the\n** upvalue), close those variables being exited.\n*/\nconst movegotosout = function(fs, bl) {\n    let i = bl.firstgoto;\n    let gl = fs.ls.dyd.gt;\n    /* correct pending gotos to current block and try to close it\n       with visible labels */\n    while (i < gl.n) {\n        let gt = gl.arr[i];\n        if (gt.nactvar > bl.nactvar) {\n            if (bl.upval)\n                luaK_patchclose(fs, gt.pc, bl.nactvar);\n            gt.nactvar = bl.nactvar;\n        }\n        if (!findlabel(fs.ls, i))\n            i++;  /* move to next one */\n    }\n};\n\nconst enterblock = function(fs, bl, isloop) {\n    bl.isloop = isloop;\n    bl.nactvar = fs.nactvar;\n    bl.firstlabel = fs.ls.dyd.label.n;\n    bl.firstgoto = fs.ls.dyd.gt.n;\n    bl.upval = 0;\n    bl.previous = fs.bl;\n    fs.bl = bl;\n    lua_assert(fs.freereg === fs.nactvar);\n};\n\n/*\n** create a label named 'break' to resolve break statements\n*/\nconst breaklabel = function(ls) {\n    let n = luaS_newliteral(ls.L, \"break\");\n    let l = newlabelentry(ls, ls.dyd.label, n, 0, ls.fs.pc);\n    findgotos(ls, ls.dyd.label.arr[l]);\n};\n\n/*\n** generates an error for an undefined 'goto'; choose appropriate\n** message when label name is a reserved word (which can only be 'break')\n*/\nconst undefgoto = function(ls, gt) {\n    let msg = llex.isreserved(gt.name)\n        ? \"<%s> at line %d not inside a loop\"\n        : \"no visible label '%s' for <goto> at line %d\";\n    msg = lobject.luaO_pushfstring(ls.L, to_luastring(msg), gt.name.getstr(), gt.line);\n    semerror(ls, msg);\n};\n\n/*\n** adds a new prototype into list of prototypes\n*/\nconst addprototype = function(ls) {\n    let L = ls.L;\n    let clp = new Proto(L);\n    let fs = ls.fs;\n    let f = fs.f;  /* prototype of current function */\n    f.p[fs.np++] = clp;\n    return clp;\n};\n\n/*\n** codes instruction to create new closure in parent function.\n*/\nconst codeclosure = function(ls, v) {\n    let fs = ls.fs.prev;\n    init_exp(v, expkind.VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs.np -1));\n    luaK_exp2nextreg(fs, v);  /* fix it at the last register */\n};\n\nconst open_func = function(ls, fs, bl) {\n    fs.prev = ls.fs;  /* linked list of funcstates */\n    fs.ls = ls;\n    ls.fs = fs;\n    fs.pc = 0;\n    fs.lasttarget = 0;\n    fs.jpc = NO_JUMP;\n    fs.freereg = 0;\n    fs.nk = 0;\n    fs.np = 0;\n    fs.nups = 0;\n    fs.nlocvars = 0;\n    fs.nactvar = 0;\n    fs.firstlocal = ls.dyd.actvar.n;\n    fs.bl = null;\n    let f = new Proto(ls.L);\n    f = fs.f;\n    f.source = ls.source;\n    f.maxstacksize = 2;  /* registers 0/1 are always valid */\n    enterblock(fs, bl, false);\n};\n\nconst leaveblock = function(fs) {\n    let bl = fs.bl;\n    let ls = fs.ls;\n    if (bl.previous && bl.upval) {\n        /* create a 'jump to here' to close upvalues */\n        let j = luaK_jump(fs);\n        luaK_patchclose(fs, j , bl.nactvar);\n        luaK_patchtohere(fs, j);\n    }\n\n    if (bl.isloop)\n        breaklabel(ls);  /* close pending breaks */\n\n    fs.bl = bl.previous;\n    removevars(fs, bl.nactvar);\n    lua_assert(bl.nactvar === fs.nactvar);\n    fs.freereg = fs.nactvar;  /* free registers */\n    ls.dyd.label.n = bl.firstlabel;  /* remove local labels */\n    if (bl.previous)  /* inner block? */\n        movegotosout(fs, bl);  /* update pending gotos to outer block */\n    else if (bl.firstgoto < ls.dyd.gt.n)  /* pending gotos in outer block? */\n        undefgoto(ls, ls.dyd.gt.arr[bl.firstgoto]);  /* error */\n};\n\nconst close_func = function(ls) {\n    let fs = ls.fs;\n    luaK_ret(fs, 0, 0);  /* final return */\n    leaveblock(fs);\n    lua_assert(fs.bl === null);\n    ls.fs = fs.prev;\n};\n\n/*============================================================*/\n/* GRAMMAR RULES */\n/*============================================================*/\n\nconst block_follow = function(ls, withuntil) {\n    switch (ls.t.token) {\n        case R.TK_ELSE: case R.TK_ELSEIF:\n        case R.TK_END: case R.TK_EOS:\n            return true;\n        case R.TK_UNTIL: return withuntil;\n        default: return false;\n    }\n};\n\nconst statlist = function(ls) {\n    /* statlist -> { stat [';'] } */\n    while (!block_follow(ls, 1)) {\n        if (ls.t.token === R.TK_RETURN) {\n            statement(ls);\n            return;  /* 'return' must be last statement */\n        }\n        statement(ls);\n    }\n};\n\nconst fieldsel = function(ls, v) {\n    /* fieldsel -> ['.' | ':'] NAME */\n    let fs = ls.fs;\n    let key = new expdesc();\n    luaK_exp2anyregup(fs, v);\n    llex.luaX_next(ls);  /* skip the dot or colon */\n    checkname(ls, key);\n    luaK_indexed(fs, v, key);\n};\n\nconst yindex = function(ls, v) {\n    /* index -> '[' expr ']' */\n    llex.luaX_next(ls);  /* skip the '[' */\n    expr(ls, v);\n    luaK_exp2val(ls.fs, v);\n    checknext(ls, 93 /* (']').charCodeAt(0) */);\n};\n\n/*\n** {======================================================================\n** Rules for Constructors\n** =======================================================================\n*/\n\nclass ConsControl {\n    constructor() {\n        this.v = new expdesc(); /* last list item read */\n        this.t = new expdesc(); /* table descriptor */\n        this.nh = NaN;          /* total number of 'record' elements */\n        this.na = NaN;          /* total number of array elements */\n        this.tostore = NaN;     /* number of array elements pending to be stored */\n    }\n}\n\nconst recfield = function(ls, cc) {\n    /* recfield -> (NAME | '['exp1']') = exp1 */\n    let fs = ls.fs;\n    let reg = ls.fs.freereg;\n    let key = new expdesc();\n    let val = new expdesc();\n\n    if (ls.t.token === R.TK_NAME) {\n        checklimit(fs, cc.nh, MAX_INT, to_luastring(\"items in a constructor\", true));\n        checkname(ls, key);\n    } else  /* ls->t.token === '[' */\n        yindex(ls, key);\n    cc.nh++;\n    checknext(ls, 61 /* ('=').charCodeAt(0) */);\n    let rkkey = luaK_exp2RK(fs, key);\n    expr(ls, val);\n    luaK_codeABC(fs, OP_SETTABLE, cc.t.u.info, rkkey, luaK_exp2RK(fs, val));\n    fs.freereg = reg;  /* free registers */\n};\n\nconst closelistfield = function(fs, cc) {\n    if (cc.v.k === expkind.VVOID) return;  /* there is no list item */\n    luaK_exp2nextreg(fs, cc.v);\n    cc.v.k = expkind.VVOID;\n    if (cc.tostore === LFIELDS_PER_FLUSH) {\n        luaK_setlist(fs, cc.t.u.info, cc.na, cc.tostore);  /* flush */\n        cc.tostore = 0;  /* no more items pending */\n    }\n};\n\nconst lastlistfield = function(fs, cc) {\n    if (cc.tostore === 0) return;\n    if (hasmultret(cc.v.k)) {\n        luaK_setmultret(fs, cc.v);\n        luaK_setlist(fs, cc.t.u.info, cc.na, LUA_MULTRET);\n        cc.na--;  /* do not count last expression (unknown number of elements) */\n    } else {\n        if (cc.v.k !== expkind.VVOID)\n            luaK_exp2nextreg(fs, cc.v);\n        luaK_setlist(fs, cc.t.u.info, cc.na, cc.tostore);\n    }\n};\n\nconst listfield = function(ls, cc) {\n    /* listfield -> exp */\n    expr(ls, cc.v);\n    checklimit(ls.fs, cc.na, MAX_INT, to_luastring(\"items in a constructor\", true));\n    cc.na++;\n    cc.tostore++;\n};\n\nconst field = function(ls, cc) {\n    /* field -> listfield | recfield */\n    switch (ls.t.token) {\n        case R.TK_NAME: {  /* may be 'listfield' or 'recfield' */\n            if (llex.luaX_lookahead(ls) !== 61 /* ('=').charCodeAt(0) */)  /* expression? */\n                listfield(ls, cc);\n            else\n                recfield(ls, cc);\n            break;\n        }\n        case 91 /* ('[').charCodeAt(0) */: {\n            recfield(ls, cc);\n            break;\n        }\n        default: {\n            listfield(ls, cc);\n            break;\n        }\n    }\n};\n\nconst constructor = function(ls, t) {\n    /* constructor -> '{' [ field { sep field } [sep] ] '}'\n       sep -> ',' | ';' */\n    let fs = ls.fs;\n    let line = ls.linenumber;\n    let pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);\n    let cc = new ConsControl();\n    cc.na = cc.nh = cc.tostore = 0;\n    cc.t = t;\n    init_exp(t, expkind.VRELOCABLE, pc);\n    init_exp(cc.v, expkind.VVOID, 0);  /* no value (yet) */\n    luaK_exp2nextreg(ls.fs, t);  /* fix it at stack top */\n    checknext(ls, 123 /* ('{').charCodeAt(0) */);\n    do {\n        lua_assert(cc.v.k === expkind.VVOID || cc.tostore > 0);\n        if (ls.t.token === 125 /* ('}').charCodeAt(0) */) break;\n        closelistfield(fs, cc);\n        field(ls, cc);\n    } while (testnext(ls, 44 /* (',').charCodeAt(0) */) || testnext(ls, 59 /* (';').charCodeAt(0) */));\n    check_match(ls, 125 /* ('}').charCodeAt(0) */, 123 /* ('{').charCodeAt(0) */, line);\n    lastlistfield(fs, cc);\n    SETARG_B(fs.f.code[pc], lobject.luaO_int2fb(cc.na));  /* set initial array size */\n    SETARG_C(fs.f.code[pc], lobject.luaO_int2fb(cc.nh));  /* set initial table size */\n};\n\n/* }====================================================================== */\n\nconst parlist = function(ls) {\n    /* parlist -> [ param { ',' param } ] */\n    let fs = ls.fs;\n    let f = fs.f;\n    let nparams = 0;\n    f.is_vararg = false;\n    if (ls.t.token !== 41 /* (')').charCodeAt(0) */) {  /* is 'parlist' not empty? */\n        do {\n            switch (ls.t.token) {\n                case R.TK_NAME: {  /* param -> NAME */\n                    new_localvar(ls, str_checkname(ls));\n                    nparams++;\n                    break;\n                }\n                case R.TK_DOTS: {  /* param -> '...' */\n                    llex.luaX_next(ls);\n                    f.is_vararg = true;  /* declared vararg */\n                    break;\n                }\n                default: llex.luaX_syntaxerror(ls, to_luastring(\"<name> or '...' expected\", true));\n            }\n        } while(!f.is_vararg && testnext(ls, 44 /* (',').charCodeAt(0) */));\n    }\n    adjustlocalvars(ls, nparams);\n    f.numparams = fs.nactvar;\n    luaK_reserveregs(fs, fs.nactvar);  /* reserve register for parameters */\n};\n\nconst body = function(ls, e, ismethod, line) {\n    /* body ->  '(' parlist ')' block END */\n    let new_fs = new FuncState();\n    let bl = new BlockCnt();\n    new_fs.f = addprototype(ls);\n    new_fs.f.linedefined = line;\n    open_func(ls, new_fs, bl);\n    checknext(ls, 40 /* ('(').charCodeAt(0) */);\n    if (ismethod) {\n        new_localvarliteral(ls, \"self\");  /* create 'self' parameter */\n        adjustlocalvars(ls, 1);\n    }\n    parlist(ls);\n    checknext(ls, 41 /* (')').charCodeAt(0) */);\n    statlist(ls);\n    new_fs.f.lastlinedefined = ls.linenumber;\n    check_match(ls, R.TK_END, R.TK_FUNCTION, line);\n    codeclosure(ls, e);\n    close_func(ls);\n};\n\nconst explist = function(ls, v) {\n    /* explist -> expr { ',' expr } */\n    let n = 1;  /* at least one expression */\n    expr(ls, v);\n    while (testnext(ls, 44 /* (',').charCodeAt(0) */)) {\n        luaK_exp2nextreg(ls.fs, v);\n        expr(ls, v);\n        n++;\n    }\n    return n;\n};\n\nconst funcargs = function(ls, f, line) {\n    let fs = ls.fs;\n    let args = new expdesc();\n    switch (ls.t.token) {\n        case 40 /* ('(').charCodeAt(0) */: {  /* funcargs -> '(' [ explist ] ')' */\n            llex.luaX_next(ls);\n            if (ls.t.token === 41 /* (')').charCodeAt(0) */)  /* arg list is empty? */\n                args.k = expkind.VVOID;\n            else {\n                explist(ls, args);\n                luaK_setmultret(fs, args);\n            }\n            check_match(ls, 41 /* (')').charCodeAt(0) */, 40 /* ('(').charCodeAt(0) */, line);\n            break;\n        }\n        case 123 /* ('{').charCodeAt(0) */: {  /* funcargs -> constructor */\n            constructor(ls, args);\n            break;\n        }\n        case R.TK_STRING: {  /* funcargs -> STRING */\n            codestring(ls, args, ls.t.seminfo.ts);\n            llex.luaX_next(ls);  /* must use 'seminfo' before 'next' */\n            break;\n        }\n        default: {\n            llex.luaX_syntaxerror(ls, to_luastring(\"function arguments expected\", true));\n        }\n    }\n    lua_assert(f.k === expkind.VNONRELOC);\n    let nparams;\n    let base = f.u.info;  /* base register for call */\n    if (hasmultret(args.k))\n        nparams = LUA_MULTRET;  /* open call */\n    else {\n        if (args.k !== expkind.VVOID)\n            luaK_exp2nextreg(fs, args);  /* close last argument */\n        nparams = fs.freereg - (base+1);\n    }\n    init_exp(f, expkind.VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));\n    luaK_fixline(fs, line);\n    fs.freereg = base + 1; /* call remove function and arguments and leaves (unless changed) one result */\n};\n\n/*\n** {======================================================================\n** Expression parsing\n** =======================================================================\n*/\n\nconst primaryexp = function(ls, v) {\n    /* primaryexp -> NAME | '(' expr ')' */\n    switch (ls.t.token) {\n        case 40 /* ('(').charCodeAt(0) */: {\n            let line = ls.linenumber;\n            llex.luaX_next(ls);\n            expr(ls, v);\n            check_match(ls, 41 /* (')').charCodeAt(0) */, 40 /* ('(').charCodeAt(0) */, line);\n            luaK_dischargevars(ls.fs, v);\n            return;\n        }\n        case R.TK_NAME: {\n            singlevar(ls, v);\n            return;\n        }\n        default: {\n            llex.luaX_syntaxerror(ls, to_luastring(\"unexpected symbol\", true));\n        }\n    }\n};\n\nconst suffixedexp = function(ls, v) {\n    /* suffixedexp ->\n       primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */\n    let fs = ls.fs;\n    let line = ls.linenumber;\n    primaryexp(ls, v);\n    for (;;) {\n        switch (ls.t.token) {\n            case 46 /* ('.').charCodeAt(0) */: {  /* fieldsel */\n                fieldsel(ls, v);\n                break;\n            }\n            case 91 /* ('[').charCodeAt(0) */: {  /* '[' exp1 ']' */\n                let key = new expdesc();\n                luaK_exp2anyregup(fs, v);\n                yindex(ls, key);\n                luaK_indexed(fs, v, key);\n                break;\n            }\n            case 58 /* (':').charCodeAt(0) */: {  /* ':' NAME funcargs */\n                let key = new expdesc();\n                llex.luaX_next(ls);\n                checkname(ls, key);\n                luaK_self(fs, v, key);\n                funcargs(ls, v, line);\n                break;\n            }\n            case 40 /* ('(').charCodeAt(0) */: case R.TK_STRING: case 123 /* ('{').charCodeAt(0) */: {  /* funcargs */\n                luaK_exp2nextreg(fs, v);\n                funcargs(ls, v, line);\n                break;\n            }\n            default: return;\n        }\n    }\n};\n\nconst simpleexp = function(ls, v) {\n    /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |\n       constructor | FUNCTION body | suffixedexp */\n    switch (ls.t.token) {\n        case R.TK_FLT: {\n            init_exp(v, expkind.VKFLT, 0);\n            v.u.nval = ls.t.seminfo.r;\n            break;\n        }\n        case R.TK_INT: {\n            init_exp(v, expkind.VKINT, 0);\n            v.u.ival = ls.t.seminfo.i;\n            break;\n        }\n        case R.TK_STRING: {\n            codestring(ls, v, ls.t.seminfo.ts);\n            break;\n        }\n        case R.TK_NIL: {\n            init_exp(v, expkind.VNIL, 0);\n            break;\n        }\n        case R.TK_TRUE: {\n            init_exp(v, expkind.VTRUE, 0);\n            break;\n        }\n        case R.TK_FALSE: {\n            init_exp(v, expkind.VFALSE, 0);\n            break;\n        }\n        case R.TK_DOTS: {  /* vararg */\n            let fs = ls.fs;\n            check_condition(ls, fs.f.is_vararg, to_luastring(\"cannot use '...' outside a vararg function\", true));\n            init_exp(v, expkind.VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));\n            break;\n        }\n        case 123 /* ('{').charCodeAt(0) */: {  /* constructor */\n            constructor(ls, v);\n            return;\n        }\n        case R.TK_FUNCTION: {\n            llex.luaX_next(ls);\n            body(ls, v, 0, ls.linenumber);\n            return;\n        }\n        default: {\n            suffixedexp(ls, v);\n            return;\n        }\n    }\n    llex.luaX_next(ls);\n};\n\nconst getunopr = function(op) {\n    switch (op) {\n        case R.TK_NOT: return OPR_NOT;\n        case 45 /* ('-').charCodeAt(0) */: return OPR_MINUS;\n        case 126 /* ('~').charCodeAt(0) */: return OPR_BNOT;\n        case 35 /* ('#').charCodeAt(0) */: return OPR_LEN;\n        default: return OPR_NOUNOPR;\n    }\n};\n\nconst getbinopr = function(op) {\n    switch (op) {\n        case 43 /* ('+').charCodeAt(0) */: return OPR_ADD;\n        case 45 /* ('-').charCodeAt(0) */: return OPR_SUB;\n        case 42 /* ('*').charCodeAt(0) */: return OPR_MUL;\n        case 37 /* ('%').charCodeAt(0) */: return OPR_MOD;\n        case 94 /* ('^').charCodeAt(0) */: return OPR_POW;\n        case 47 /* ('/').charCodeAt(0) */: return OPR_DIV;\n        case R.TK_IDIV:   return OPR_IDIV;\n        case 38 /* ('&').charCodeAt(0) */: return OPR_BAND;\n        case 124 /* ('|').charCodeAt(0) */: return OPR_BOR;\n        case 126 /* ('~').charCodeAt(0) */: return OPR_BXOR;\n        case R.TK_SHL:    return OPR_SHL;\n        case R.TK_SHR:    return OPR_SHR;\n        case R.TK_CONCAT: return OPR_CONCAT;\n        case R.TK_NE:     return OPR_NE;\n        case R.TK_EQ:     return OPR_EQ;\n        case 60 /* ('<').charCodeAt(0) */: return OPR_LT;\n        case R.TK_LE:     return OPR_LE;\n        case 62 /* ('>').charCodeAt(0) */: return OPR_GT;\n        case R.TK_GE:     return OPR_GE;\n        case R.TK_AND:    return OPR_AND;\n        case R.TK_OR:     return OPR_OR;\n        default:          return OPR_NOBINOPR;\n    }\n};\n\nconst priority = [  /* ORDER OPR */\n    {left: 10, right: 10}, {left: 10, right: 10},     /* '+' '-' */\n    {left: 11, right: 11}, {left: 11, right: 11},     /* '*' '%' */\n    {left: 14, right: 13},               /* '^' (right associative) */\n    {left: 11, right: 11}, {left: 11, right: 11},     /* '/' '//' */\n    {left: 6, right: 6}, {left: 4, right: 4}, {left: 5, right: 5}, /* '&' '|' '~' */\n    {left: 7, right: 7}, {left: 7, right: 7},         /* '<<' '>>' */\n    {left: 9, right: 8},                 /* '..' (right associative) */\n    {left: 3, right: 3}, {left: 3, right: 3}, {left: 3, right: 3}, /* ==, <, <= */\n    {left: 3, right: 3}, {left: 3, right: 3}, {left: 3, right: 3}, /* ~=, >, >= */\n    {left: 2, right: 2}, {left: 1, right: 1}          /* and, or */\n];\n\nconst UNARY_PRIORITY = 12;\n\n/*\n** subexpr -> (simpleexp | unop subexpr) { binop subexpr }\n** where 'binop' is any binary operator with a priority higher than 'limit'\n*/\nconst subexpr = function(ls, v, limit) {\n    enterlevel(ls);\n    let uop = getunopr(ls.t.token);\n    if (uop !== OPR_NOUNOPR) {\n        let line = ls.linenumber;\n        llex.luaX_next(ls);\n        subexpr(ls, v, UNARY_PRIORITY);\n        luaK_prefix(ls.fs, uop, v, line);\n    } else\n        simpleexp(ls, v);\n    /* expand while operators have priorities higher than 'limit' */\n    let op = getbinopr(ls.t.token);\n    while (op !== OPR_NOBINOPR && priority[op].left > limit) {\n        let v2 = new expdesc();\n        let line = ls.linenumber;\n        llex.luaX_next(ls);\n        luaK_infix(ls.fs, op, v);\n        /* read sub-expression with higher priority */\n        let nextop = subexpr(ls, v2, priority[op].right);\n        luaK_posfix(ls.fs, op, v, v2, line);\n        op = nextop;\n    }\n    leavelevel(ls);\n    return op;  /* return first untreated operator */\n};\n\nconst expr = function(ls, v) {\n    subexpr(ls, v, 0);\n};\n\n/* }==================================================================== */\n\n\n\n/*\n** {======================================================================\n** Rules for Statements\n** =======================================================================\n*/\n\nconst block = function(ls) {\n    /* block -> statlist */\n    let fs = ls.fs;\n    let bl = new BlockCnt();\n    enterblock(fs, bl, 0);\n    statlist(ls);\n    leaveblock(fs);\n};\n\n/*\n** structure to chain all variables in the left-hand side of an\n** assignment\n*/\nclass LHS_assign {\n    constructor() {\n        this.prev = null;\n        this.v = new expdesc();  /* variable (global, local, upvalue, or indexed) */\n    }\n}\n\n/*\n** check whether, in an assignment to an upvalue/local variable, the\n** upvalue/local variable is begin used in a previous assignment to a\n** table. If so, save original upvalue/local value in a safe place and\n** use this safe copy in the previous assignment.\n*/\nconst check_conflict = function(ls, lh, v) {\n    let fs = ls.fs;\n    let extra = fs.freereg;  /* eventual position to save local variable */\n    let conflict = false;\n    for (; lh; lh = lh.prev) {  /* check all previous assignments */\n        if (lh.v.k === expkind.VINDEXED) {  /* assigning to a table? */\n            /* table is the upvalue/local being assigned now? */\n            if (lh.v.u.ind.vt === v.k && lh.v.u.ind.t === v.u.info) {\n                conflict = true;\n                lh.v.u.ind.vt = expkind.VLOCAL;\n                lh.v.u.ind.t = extra;  /* previous assignment will use safe copy */\n            }\n            /* index is the local being assigned? (index cannot be upvalue) */\n            if (v.k === expkind.VLOCAL && lh.v.u.ind.idx === v.u.info) {\n                conflict = true;\n                lh.v.u.ind.idx = extra;  /* previous assignment will use safe copy */\n            }\n        }\n    }\n    if (conflict) {\n        /* copy upvalue/local value to a temporary (in position 'extra') */\n        let op = v.k === expkind.VLOCAL ? OP_MOVE : OP_GETUPVAL;\n        luaK_codeABC(fs, op, extra, v.u.info, 0);\n        luaK_reserveregs(fs, 1);\n    }\n};\n\nconst assignment = function(ls, lh, nvars) {\n    let e = new expdesc();\n    check_condition(ls, vkisvar(lh.v.k), to_luastring(\"syntax error\", true));\n    if (testnext(ls, 44 /* (',').charCodeAt(0) */)) {  /* assignment -> ',' suffixedexp assignment */\n        let nv = new LHS_assign();\n        nv.prev = lh;\n        suffixedexp(ls, nv.v);\n        if (nv.v.k !== expkind.VINDEXED)\n            check_conflict(ls, lh, nv.v);\n        checklimit(ls.fs, nvars + ls.L.nCcalls, LUAI_MAXCCALLS, to_luastring(\"JS levels\", true));\n        assignment(ls, nv, nvars + 1);\n    } else {  /* assignment -> '=' explist */\n        checknext(ls, 61 /* ('=').charCodeAt(0) */);\n        let nexps = explist(ls, e);\n        if (nexps !== nvars)\n            adjust_assign(ls, nvars, nexps, e);\n        else {\n            luaK_setoneret(ls.fs, e);  /* close last expression */\n            luaK_storevar(ls.fs, lh.v, e);\n            return;  /* avoid default */\n        }\n    }\n    init_exp(e, expkind.VNONRELOC, ls.fs.freereg-1);  /* default assignment */\n    luaK_storevar(ls.fs, lh.v, e);\n};\n\nconst cond = function(ls) {\n    /* cond -> exp */\n    let v = new expdesc();\n    expr(ls, v);  /* read condition */\n    if (v.k === expkind.VNIL) v.k = expkind.VFALSE;  /* 'falses' are all equal here */\n    luaK_goiftrue(ls.fs, v);\n    return v.f;\n};\n\nconst gotostat = function(ls, pc) {\n    let line = ls.linenumber;\n    let label;\n    if (testnext(ls, R.TK_GOTO))\n        label = str_checkname(ls);\n    else {\n        llex.luaX_next(ls);  /* skip break */\n        label = luaS_newliteral(ls.L, \"break\");\n    }\n    let g = newlabelentry(ls, ls.dyd.gt, label, line, pc);\n    findlabel(ls, g);  /* close it if label already defined */\n};\n\n/* check for repeated labels on the same block */\nconst checkrepeated = function(fs, ll, label) {\n    for (let i = fs.bl.firstlabel; i < ll.n; i++) {\n        if (eqstr(label, ll.arr[i].name)) {\n            let msg = lobject.luaO_pushfstring(fs.ls.L,\n                to_luastring(\"label '%s' already defined on line %d\", true),\n                label.getstr(), ll.arr[i].line);\n            semerror(fs.ls, msg);\n        }\n    }\n};\n\n/* skip no-op statements */\nconst skipnoopstat = function(ls) {\n    while (ls.t.token === 59 /* (';').charCodeAt(0) */ || ls.t.token === R.TK_DBCOLON)\n        statement(ls);\n};\n\nconst labelstat = function(ls, label, line) {\n    /* label -> '::' NAME '::' */\n    let fs = ls.fs;\n    let ll = ls.dyd.label;\n    let l;  /* index of new label being created */\n    checkrepeated(fs, ll, label);  /* check for repeated labels */\n    checknext(ls, R.TK_DBCOLON);  /* skip double colon */\n    /* create new entry for this label */\n    l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs));\n    skipnoopstat(ls);  /* skip other no-op statements */\n    if (block_follow(ls, 0)) {  /* label is last no-op statement in the block? */\n        /* assume that locals are already out of scope */\n        ll.arr[l].nactvar = fs.bl.nactvar;\n    }\n    findgotos(ls, ll.arr[l]);\n};\n\nconst whilestat = function(ls, line) {\n    /* whilestat -> WHILE cond DO block END */\n    let fs = ls.fs;\n    let bl = new BlockCnt();\n    llex.luaX_next(ls);  /* skip WHILE */\n    let whileinit = luaK_getlabel(fs);\n    let condexit = cond(ls);\n    enterblock(fs, bl, 1);\n    checknext(ls, R.TK_DO);\n    block(ls);\n    luaK_jumpto(fs, whileinit);\n    check_match(ls, R.TK_END, R.TK_WHILE, line);\n    leaveblock(fs);\n    luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */\n};\n\nconst repeatstat = function(ls, line) {\n    /* repeatstat -> REPEAT block UNTIL cond */\n    let fs = ls.fs;\n    let repeat_init = luaK_getlabel(fs);\n    let bl1 = new BlockCnt();\n    let bl2 = new BlockCnt();\n    enterblock(fs, bl1, 1);  /* loop block */\n    enterblock(fs, bl2, 0);  /* scope block */\n    llex.luaX_next(ls);  /* skip REPEAT */\n    statlist(ls);\n    check_match(ls, R.TK_UNTIL, R.TK_REPEAT, line);\n    let condexit = cond(ls);  /* read condition (inside scope block) */\n    if (bl2.upval)  /* upvalues? */\n        luaK_patchclose(fs, condexit, bl2.nactvar);\n    leaveblock(fs);  /* finish scope */\n    luaK_patchlist(fs, condexit, repeat_init);  /* close the loop */\n    leaveblock(fs);  /* finish loop */\n};\n\nconst exp1 = function(ls) {\n    let e = new expdesc();\n    expr(ls, e);\n    luaK_exp2nextreg(ls.fs, e);\n    lua_assert(e.k === expkind.VNONRELOC);\n    let reg = e.u.info;\n    return reg;\n};\n\nconst forbody = function(ls, base, line, nvars, isnum) {\n    /* forbody -> DO block */\n    let bl = new BlockCnt();\n    let fs = ls.fs;\n    let endfor;\n    adjustlocalvars(ls, 3);  /* control variables */\n    checknext(ls, R.TK_DO);\n    let prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);\n    enterblock(fs, bl, 0);  /* scope for declared variables */\n    adjustlocalvars(ls, nvars);\n    luaK_reserveregs(fs, nvars);\n    block(ls);\n    leaveblock(fs);  /* end of scope for declared variables */\n    luaK_patchtohere(fs, prep);\n    if (isnum)  /* end of scope for declared variables */\n        endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP);\n    else {  /* generic for */\n        luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);\n        luaK_fixline(fs, line);\n        endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP);\n    }\n    luaK_patchlist(fs, endfor, prep + 1);\n    luaK_fixline(fs, line);\n};\n\nconst fornum = function(ls, varname, line) {\n    /* fornum -> NAME = exp1,exp1[,exp1] forbody */\n    let fs = ls.fs;\n    let base = fs.freereg;\n    new_localvarliteral(ls, \"(for index)\");\n    new_localvarliteral(ls, \"(for limit)\");\n    new_localvarliteral(ls, \"(for step)\");\n    new_localvar(ls, varname);\n    checknext(ls, 61 /* ('=').charCodeAt(0) */);\n    exp1(ls);  /* initial value */\n    checknext(ls, 44 /* (',').charCodeAt(0) */);\n    exp1(ls);  /* limit */\n    if (testnext(ls, 44 /* (',').charCodeAt(0) */))\n        exp1(ls);  /* optional step */\n    else {  /* default step = 1 */\n        luaK_codek(fs, fs.freereg, luaK_intK(fs, 1));\n        luaK_reserveregs(fs, 1);\n    }\n    forbody(ls, base, line, 1, 1);\n};\n\nconst forlist = function(ls, indexname) {\n    /* forlist -> NAME {,NAME} IN explist forbody */\n    let fs = ls.fs;\n    let e = new expdesc();\n    let nvars = 4;  /* gen, state, control, plus at least one declared var */\n    let base = fs.freereg;\n    /* create control variables */\n    new_localvarliteral(ls, \"(for generator)\");\n    new_localvarliteral(ls, \"(for state)\");\n    new_localvarliteral(ls, \"(for control)\");\n    /* create declared variables */\n    new_localvar(ls, indexname);\n    while (testnext(ls, 44 /* (',').charCodeAt(0) */)) {\n        new_localvar(ls, str_checkname(ls));\n        nvars++;\n    }\n    checknext(ls, R.TK_IN);\n    let line = ls.linenumber;\n    adjust_assign(ls, 3, explist(ls, e), e);\n    luaK_checkstack(fs, 3);  /* extra space to call generator */\n    forbody(ls, base, line, nvars - 3, 0);\n};\n\nconst forstat = function(ls, line) {\n    /* forstat -> FOR (fornum | forlist) END */\n    let fs = ls.fs;\n    let bl = new BlockCnt();\n    enterblock(fs, bl, 1);  /* scope for loop and control variables */\n    llex.luaX_next(ls);  /* skip 'for' */\n    let varname = str_checkname(ls);  /* first variable name */\n    switch (ls.t.token) {\n        case 61 /* ('=').charCodeAt(0) */: fornum(ls, varname, line); break;\n        case 44 /* (',').charCodeAt(0) */: case R.TK_IN: forlist(ls, varname); break;\n        default: llex.luaX_syntaxerror(ls, to_luastring(\"'=' or 'in' expected\", true));\n    }\n    check_match(ls, R.TK_END, R.TK_FOR, line);\n    leaveblock(fs);  /* loop scope ('break' jumps to this point) */\n};\n\nconst test_then_block = function(ls, escapelist) {\n    /* test_then_block -> [IF | ELSEIF] cond THEN block */\n    let bl = new BlockCnt();\n    let fs = ls.fs;\n    let v = new expdesc();\n    let jf;  /* instruction to skip 'then' code (if condition is false) */\n\n    llex.luaX_next(ls);  /* skip IF or ELSEIF */\n    expr(ls, v);  /* read condition */\n    checknext(ls, R.TK_THEN);\n\n    if (ls.t.token === R.TK_GOTO || ls.t.token === R.TK_BREAK) {\n        luaK_goiffalse(ls.fs, v);  /* will jump to label if condition is true */\n        enterblock(fs, bl, false);  /* must enter block before 'goto' */\n        gotostat(ls, v.t);   /* handle goto/break */\n        while (testnext(ls, 59 /* (';').charCodeAt(0) */));  /* skip colons */\n        if (block_follow(ls, 0)) {  /* 'goto' is the entire block? */\n            leaveblock(fs);\n            return escapelist;  /* and that is it */\n        } else  /* must skip over 'then' part if condition is false */\n            jf = luaK_jump(fs);\n    } else {  /* regular case (not goto/break) */\n        luaK_goiftrue(ls.fs, v);  /* skip over block if condition is false */\n        enterblock(fs, bl, false);\n        jf = v.f;\n    }\n\n    statlist(ls);  /* 'then' part */\n    leaveblock(fs);\n    if (ls.t.token === R.TK_ELSE || ls.t.token === R.TK_ELSEIF)  /* followed by 'else'/'elseif'? */\n        escapelist = luaK_concat(fs, escapelist, luaK_jump(fs));  /* must jump over it */\n    luaK_patchtohere(fs, jf);\n\n    return escapelist;\n};\n\nconst ifstat = function(ls, line) {\n    /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */\n    let fs = ls.fs;\n    let escapelist = NO_JUMP;  /* exit list for finished parts */\n    escapelist = test_then_block(ls, escapelist);  /* IF cond THEN block */\n    while (ls.t.token === R.TK_ELSEIF)\n        escapelist = test_then_block(ls, escapelist);  /* ELSEIF cond THEN block */\n    if (testnext(ls, R.TK_ELSE))\n        block(ls);  /* 'else' part */\n    check_match(ls, R.TK_END, R.TK_IF, line);\n    luaK_patchtohere(fs, escapelist);  /* patch escape list to 'if' end */\n};\n\nconst localfunc = function(ls) {\n    let b = new expdesc();\n    let fs = ls.fs;\n    new_localvar(ls, str_checkname(ls));  /* new local variable */\n    adjustlocalvars(ls, 1);  /* enter its scope */\n    body(ls, b, 0, ls.linenumber);  /* function created in next register */\n    /* debug information will only see the variable after this point! */\n    getlocvar(fs, b.u.info).startpc = fs.pc;\n};\n\nconst localstat = function(ls) {\n    /* stat -> LOCAL NAME {',' NAME} ['=' explist] */\n    let nvars = 0;\n    let nexps;\n    let e = new expdesc();\n    do {\n        new_localvar(ls, str_checkname(ls));\n        nvars++;\n    } while (testnext(ls, 44 /* (',').charCodeAt(0) */));\n    if (testnext(ls, 61 /* ('=').charCodeAt(0) */))\n        nexps = explist(ls, e);\n    else {\n        e.k = expkind.VVOID;\n        nexps = 0;\n    }\n    adjust_assign(ls, nvars, nexps, e);\n    adjustlocalvars(ls, nvars);\n};\n\nconst funcname = function(ls, v) {\n    /* funcname -> NAME {fieldsel} [':' NAME] */\n    let ismethod = 0;\n    singlevar(ls, v);\n    while (ls.t.token === 46 /* ('.').charCodeAt(0) */)\n        fieldsel(ls, v);\n    if (ls.t.token === 58 /* (':').charCodeAt(0) */) {\n        ismethod = 1;\n        fieldsel(ls, v);\n    }\n    return ismethod;\n};\n\nconst funcstat = function(ls, line) {\n    /* funcstat -> FUNCTION funcname body */\n    let v = new expdesc();\n    let b = new expdesc();\n    llex.luaX_next(ls);  /* skip FUNCTION */\n    let ismethod = funcname(ls, v);\n    body(ls, b, ismethod, line);\n    luaK_storevar(ls.fs, v, b);\n    luaK_fixline(ls.fs, line);  /* definition \"happens\" in the first line */\n};\n\nconst exprstat= function(ls) {\n    /* stat -> func | assignment */\n    let fs = ls.fs;\n    let v = new LHS_assign();\n    suffixedexp(ls, v.v);\n    if (ls.t.token === 61 /* ('=').charCodeAt(0) */ || ls.t.token === 44 /* (',').charCodeAt(0) */) { /* stat . assignment ? */\n        v.prev = null;\n        assignment(ls, v, 1);\n    }\n    else {  /* stat -> func */\n        check_condition(ls, v.v.k === expkind.VCALL, to_luastring(\"syntax error\", true));\n        SETARG_C(getinstruction(fs, v.v), 1);  /* call statement uses no results */\n    }\n};\n\nconst retstat = function(ls) {\n    /* stat -> RETURN [explist] [';'] */\n    let fs = ls.fs;\n    let e = new expdesc();\n    let first, nret;  /* registers with returned values */\n    if (block_follow(ls, 1) || ls.t.token === 59 /* (';').charCodeAt(0) */)\n        first = nret = 0;  /* return no values */\n    else {\n        nret = explist(ls, e);  /* optional return values */\n        if (hasmultret(e.k)) {\n            luaK_setmultret(fs, e);\n            if (e.k === expkind.VCALL && nret === 1) {  /* tail call? */\n                SET_OPCODE(getinstruction(fs, e), OP_TAILCALL);\n                lua_assert(getinstruction(fs, e).A === fs.nactvar);\n            }\n            first = fs.nactvar;\n            nret = LUA_MULTRET;  /* return all values */\n        } else {\n            if (nret === 1)  /* only one single value? */\n                first = luaK_exp2anyreg(fs, e);\n            else {\n                luaK_exp2nextreg(fs, e);  /* values must go to the stack */\n                first = fs.nactvar;  /* return all active values */\n                lua_assert(nret === fs.freereg - first);\n            }\n        }\n    }\n    luaK_ret(fs, first, nret);\n    testnext(ls, 59 /* (';').charCodeAt(0) */);  /* skip optional semicolon */\n};\n\nconst statement = function(ls) {\n    let line = ls.linenumber;  /* may be needed for error messages */\n    enterlevel(ls);\n    switch(ls.t.token) {\n        case 59 /* (';').charCodeAt(0) */: {  /* stat -> ';' (empty statement) */\n            llex.luaX_next(ls);  /* skip ';' */\n            break;\n        }\n        case R.TK_IF: {  /* stat -> ifstat */\n            ifstat(ls, line);\n            break;\n        }\n        case R.TK_WHILE: {  /* stat -> whilestat */\n            whilestat(ls, line);\n            break;\n        }\n        case R.TK_DO: {  /* stat -> DO block END */\n            llex.luaX_next(ls);  /* skip DO */\n            block(ls);\n            check_match(ls, R.TK_END, R.TK_DO, line);\n            break;\n        }\n        case R.TK_FOR: {  /* stat -> forstat */\n            forstat(ls, line);\n            break;\n        }\n        case R.TK_REPEAT: {  /* stat -> repeatstat */\n            repeatstat(ls, line);\n            break;\n        }\n        case R.TK_FUNCTION: {  /* stat -> funcstat */\n            funcstat(ls, line);\n            break;\n        }\n        case R.TK_LOCAL: {  /* stat -> localstat */\n            llex.luaX_next(ls);  /* skip LOCAL */\n            if (testnext(ls, R.TK_FUNCTION))  /* local function? */\n                localfunc(ls);\n            else\n                localstat(ls);\n            break;\n        }\n        case R.TK_DBCOLON: {  /* stat -> label */\n            llex.luaX_next(ls);  /* skip double colon */\n            labelstat(ls, str_checkname(ls), line);\n            break;\n        }\n        case R.TK_RETURN: {  /* skip double colon */\n            llex.luaX_next(ls);  /* skip RETURN */\n            retstat(ls);\n            break;\n        }\n        case R.TK_BREAK:   /* stat -> breakstat */\n        case R.TK_GOTO: {  /* stat -> 'goto' NAME */\n            gotostat(ls, luaK_jump(ls.fs));\n            break;\n        }\n        default: {  /* stat -> func | assignment */\n            exprstat(ls);\n            break;\n        }\n    }\n    lua_assert(ls.fs.f.maxstacksize >= ls.fs.freereg && ls.fs.freereg >= ls.fs.nactvar);\n    ls.fs.freereg = ls.fs.nactvar;  /* free registers */\n    leavelevel(ls);\n};\n\n/*\n** compiles the main function, which is a regular vararg function with an\n** upvalue named LUA_ENV\n*/\nconst mainfunc = function(ls, fs) {\n    let bl = new BlockCnt();\n    let v = new expdesc();\n    open_func(ls, fs, bl);\n    fs.f.is_vararg = true;  /* main function is always declared vararg */\n    init_exp(v, expkind.VLOCAL, 0);  /* create and... */\n    newupvalue(fs, ls.envn, v);  /* ...set environment upvalue */\n    llex.luaX_next(ls);  /* read first token */\n    statlist(ls);  /* parse main body */\n    check(ls, R.TK_EOS);\n    close_func(ls);\n};\n\nconst luaY_parser = function(L, z, buff, dyd, name, firstchar) {\n    let lexstate = new llex.LexState();\n    let funcstate = new FuncState();\n    let cl = lfunc.luaF_newLclosure(L, 1);  /* create main closure */\n    ldo.luaD_inctop(L);\n    L.stack[L.top-1].setclLvalue(cl);\n    lexstate.h = ltable.luaH_new(L);  /* create table for scanner */\n    ldo.luaD_inctop(L);\n    L.stack[L.top-1].sethvalue(lexstate.h);\n    funcstate.f = cl.p = new Proto(L);\n    funcstate.f.source = luaS_new(L, name);\n    lexstate.buff = buff;\n    lexstate.dyd = dyd;\n    dyd.actvar.n = dyd.gt.n = dyd.label.n = 0;\n    llex.luaX_setinput(L, lexstate, z, funcstate.f.source, firstchar);\n    mainfunc(lexstate, funcstate);\n    lua_assert(!funcstate.prev && funcstate.nups === 1 && !lexstate.fs);\n    /* all scopes should be correctly finished */\n    lua_assert(dyd.actvar.n === 0 && dyd.gt.n === 0 && dyd.label.n === 0);\n    delete L.stack[--L.top];  /* remove scanner's table */\n    return cl;  /* closure is on the stack, too */\n};\n\n\nmodule.exports.Dyndata     = Dyndata;\nmodule.exports.expkind     = expkind;\nmodule.exports.expdesc     = expdesc;\nmodule.exports.luaY_parser = luaY_parser;\nmodule.exports.vkisinreg   = vkisinreg;\n","\"use strict\";\n\nconst { luastring_of } = require('./defs.js');\n\nconst luai_ctype_ = luastring_of(\n    0x00,  /* EOZ */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* 0. */\n    0x00,  0x08,  0x08,  0x08,  0x08,  0x08,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* 1. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x0c,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,        /* 2. */\n    0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,\n    0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,        /* 3. */\n    0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,\n    0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,        /* 4. */\n    0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,\n    0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,        /* 5. */\n    0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,\n    0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,        /* 6. */\n    0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,\n    0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,        /* 7. */\n    0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* 8. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* 9. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* a. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* b. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* c. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* d. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* e. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,        /* f. */\n    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00\n);\n\nconst ALPHABIT = 0;\nconst DIGITBIT = 1;\nconst PRINTBIT = 2;\nconst SPACEBIT = 3;\nconst XDIGITBIT = 4;\n\nconst lisdigit = function(c) {\n    return (luai_ctype_[c+1] & (1<<DIGITBIT)) !== 0;\n};\n\nconst lisxdigit = function(c) {\n    return (luai_ctype_[c+1] & (1<<XDIGITBIT)) !== 0;\n};\n\nconst lisprint = function(c) {\n    return (luai_ctype_[c+1] & (1<<PRINTBIT)) !== 0;\n};\n\nconst lisspace = function(c) {\n    return (luai_ctype_[c+1] & (1<<SPACEBIT)) !== 0;\n};\n\nconst lislalpha = function(c) {\n    return (luai_ctype_[c+1] & (1<<ALPHABIT)) !== 0;\n};\n\nconst lislalnum = function(c) {\n    return (luai_ctype_[c+1] & ((1<<ALPHABIT)|(1<<DIGITBIT))) !== 0;\n};\n\nmodule.exports.lisdigit   = lisdigit;\nmodule.exports.lislalnum  = lislalnum;\nmodule.exports.lislalpha  = lislalpha;\nmodule.exports.lisprint   = lisprint;\nmodule.exports.lisspace   = lisspace;\nmodule.exports.lisxdigit  = lisxdigit;\n","\"use strict\";\n\nconst {\n\tlua,\n\tlauxlib,\n\tlualib,\n\tto_luastring\n} = require('fengari');\nconst {\n\tLUA_MULTRET,\n\tLUA_OK,\n\tLUA_REGISTRYINDEX,\n\tLUA_RIDX_MAINTHREAD,\n\tLUA_TBOOLEAN,\n\tLUA_TFUNCTION,\n\tLUA_TLIGHTUSERDATA,\n\tLUA_TNIL,\n\tLUA_TNONE,\n\tLUA_TNUMBER,\n\tLUA_TSTRING,\n\tLUA_TTABLE,\n\tLUA_TTHREAD,\n\tLUA_TUSERDATA,\n\tlua_atnativeerror,\n\tlua_call,\n\tlua_getfield,\n\tlua_gettable,\n\tlua_gettop,\n\tlua_isnil,\n\tlua_isproxy,\n\tlua_newuserdata,\n\tlua_pcall,\n\tlua_pop,\n\tlua_pushboolean,\n\tlua_pushcfunction,\n\tlua_pushinteger,\n\tlua_pushlightuserdata,\n\tlua_pushliteral,\n\tlua_pushnil,\n\tlua_pushnumber,\n\tlua_pushstring,\n\tlua_pushvalue,\n\tlua_rawgeti,\n\tlua_rawgetp,\n\tlua_rawsetp,\n\tlua_rotate,\n\tlua_setfield,\n\tlua_settable,\n\tlua_settop,\n\tlua_toboolean,\n\tlua_tojsstring,\n\tlua_tonumber,\n\tlua_toproxy,\n\tlua_tothread,\n\tlua_touserdata,\n\tlua_type\n} = lua;\nconst {\n\tluaL_argerror,\n\tluaL_checkany,\n\tluaL_checkoption,\n\tluaL_checkstack,\n\tluaL_checkudata,\n\tluaL_error,\n\tluaL_getmetafield,\n\tluaL_newlib,\n\tluaL_newmetatable,\n\tluaL_requiref,\n\tluaL_setfuncs,\n\tluaL_setmetatable,\n\tluaL_testudata,\n\tluaL_tolstring\n} = lauxlib;\nconst {\n\tluaopen_base\n} = lualib;\n\nconst FENGARI_INTEROP_VERSION_MAJOR   = \"0\";\nconst FENGARI_INTEROP_VERSION_MINOR   = \"1\";\nconst FENGARI_INTEROP_VERSION_NUM     = 1;\nconst FENGARI_INTEROP_VERSION_RELEASE = \"2\";\nconst FENGARI_INTEROP_VERSION         = FENGARI_INTEROP_VERSION_MAJOR + \".\" + FENGARI_INTEROP_VERSION_MINOR;\nconst FENGARI_INTEROP_RELEASE         = FENGARI_INTEROP_VERSION + \".\" + FENGARI_INTEROP_VERSION_RELEASE;\n\nlet custom_inspect_symbol;\nif (typeof process !== \"undefined\") {\n\ttry { /* for node.js */\n\t\tcustom_inspect_symbol = require('util').inspect.custom;\n\t} catch (e) {}\n}\n\nconst global_env = (function() {\n\t/* global WorkerGlobalScope */ /* see https://github.com/sindresorhus/globals/issues/127 */\n\tif (typeof process !== \"undefined\") {\n\t\t/* node */\n\t\treturn global;\n\t} else if (typeof window !== \"undefined\") {\n\t\t/* browser window */\n\t\treturn window;\n\t} else if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {\n\t\t/* web worker */\n\t\treturn self;\n\t} else {\n\t\t/* unknown global env */\n\t\treturn (0, eval)('this'); /* use non-strict mode to get global env */\n\t}\n})();\n\nlet apply, construct, Reflect_deleteProperty;\nif (typeof Reflect !== \"undefined\") {\n\tapply = Reflect.apply;\n\tconstruct = Reflect.construct;\n\tReflect_deleteProperty = Reflect.deleteProperty;\n} else {\n\tconst fApply = Function.apply;\n\tconst bind = Function.bind;\n\tapply = function(target, thisArgument, argumentsList) {\n\t\treturn fApply.call(target, thisArgument, argumentsList);\n\t};\n\tconstruct = function(target, argumentsList /*, newTarget */) {\n\t\tswitch (argumentsList.length) {\n\t\t\tcase 0: return new target();\n\t\t\tcase 1: return new target(argumentsList[0]);\n\t\t\tcase 2: return new target(argumentsList[0], argumentsList[1]);\n\t\t\tcase 3: return new target(argumentsList[0], argumentsList[1], argumentsList[2]);\n\t\t\tcase 4: return new target(argumentsList[0], argumentsList[1], argumentsList[2], argumentsList[3]);\n\t\t}\n\t\tlet args = [null];\n\t\targs.push.apply(args, argumentsList);\n\t\treturn new (bind.apply(target, args))();\n\t};\n\t/* need to be in non-strict mode */\n\tReflect_deleteProperty = Function(\"t\", \"k\", \"delete t[k]\");\n}\n\n/*\nString.concat coerces to string with correct hint for Symbol.toPrimitive\n`this` isn't allowed to be null, so bind the empty string\n*/\nconst toString = String.prototype.concat.bind(\"\");\n\nconst isobject = function(o) {\n\treturn typeof o === \"object\" ? o !== null : typeof o === \"function\";\n};\n\nconst js_tname = to_luastring(\"js object\");\nconst js_library_not_loaded = \"js library not loaded into lua_State\";\n\nconst testjs = function(L, idx) {\n\tlet u = luaL_testudata(L, idx, js_tname);\n\tif (u)\n\t\treturn u.data;\n\telse\n\t\treturn void 0;\n};\n\nconst checkjs = function(L, idx) {\n\treturn luaL_checkudata(L, idx, js_tname).data;\n};\n\nconst pushjs = function(L, v) {\n\tlet b = lua_newuserdata(L);\n\tb.data = v;\n\tluaL_setmetatable(L, js_tname);\n};\n\nconst getmainthread = function(L) {\n\tlua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);\n\tlet mainL = lua_tothread(L, -1);\n\tlua_pop(L, 1);\n\treturn mainL;\n};\n\n/* weak map from states to proxy objects (for each object) in that state */\nconst states = new WeakMap();\n\nconst push = function(L, v) {\n\tswitch (typeof v) {\n\t\tcase \"undefined\":\n\t\t\tlua_pushnil(L);\n\t\t\tbreak;\n\t\tcase \"number\":\n\t\t\tlua_pushnumber(L, v);\n\t\t\tbreak;\n\t\tcase \"string\":\n\t\t\tlua_pushstring(L, to_luastring(v));\n\t\t\tbreak;\n\t\tcase \"boolean\":\n\t\t\tlua_pushboolean(L, v);\n\t\t\tbreak;\n\t\tcase \"symbol\":\n\t\t\tlua_pushlightuserdata(L, v);\n\t\t\tbreak;\n\t\tcase \"function\":\n\t\t\tif (lua_isproxy(v, L)) {\n\t\t\t\tv(L);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t/* fall through */\n\t\tcase \"object\":\n\t\t\tif (v === null) {\n\t\t\t\t/* can't use null in a WeakMap; grab from registry */\n\t\t\t\tif (lua_rawgetp(L, LUA_REGISTRYINDEX, null) !== LUA_TUSERDATA)\n\t\t\t\t\tthrow Error(js_library_not_loaded);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t/* fall through */\n\t\tdefault: {\n\t\t\t/* Try and push same object again */\n\t\t\tlet objects_seen = states.get(getmainthread(L));\n\t\t\tif (!objects_seen) throw Error(js_library_not_loaded);\n\t\t\tlet p = objects_seen.get(v);\n\t\t\tif (p) {\n\t\t\t\tp(L);\n\t\t\t} else {\n\t\t\t\tpushjs(L, v);\n\t\t\t\tp = lua_toproxy(L, -1);\n\t\t\t\tobjects_seen.set(v, p);\n\t\t\t}\n\t\t}\n\t}\n};\n\nconst atnativeerror = function(L) {\n\tlet u = lua_touserdata(L, 1);\n\tpush(L, u);\n\treturn 1;\n};\n\nconst tojs = function(L, idx) {\n\tswitch(lua_type(L, idx)) {\n\t\tcase LUA_TNONE:\n\t\tcase LUA_TNIL:\n\t\t\treturn void 0;\n\t\tcase LUA_TBOOLEAN:\n\t\t\treturn lua_toboolean(L, idx);\n\t\tcase LUA_TLIGHTUSERDATA:\n\t\t\treturn lua_touserdata(L, idx);\n\t\tcase LUA_TNUMBER:\n\t\t\treturn lua_tonumber(L, idx);\n\t\tcase LUA_TSTRING:\n\t\t\treturn lua_tojsstring(L, idx);\n\t\tcase LUA_TUSERDATA: {\n\t\t\tlet u = testjs(L, idx);\n\t\t\tif (u !== void 0)\n\t\t\t\treturn u;\n\t\t}\n\t\t/* fall through */\n\t\tcase LUA_TTABLE:\n\t\tcase LUA_TFUNCTION:\n\t\tcase LUA_TTHREAD:\n\t\t/* fall through */\n\t\tdefault:\n\t\t\treturn wrap(L, lua_toproxy(L, idx));\n\t}\n};\n\n/* Calls function on the stack with `nargs` from the stack.\n   On lua error, re-throws as javascript error\n   On success, returns single return value */\nconst jscall = function(L, nargs) {\n\tlet status = lua_pcall(L, nargs, 1, 0);\n\tlet r = tojs(L, -1);\n\tlua_pop(L, 1);\n\tswitch(status) {\n\t\tcase LUA_OK:\n\t\t\treturn r;\n\t\tdefault:\n\t\t\tthrow r;\n\t}\n};\n\nconst invoke = function(L, p, thisarg, args, n_results) {\n\tif (!isobject(args)) throw new TypeError(\"`args` argument must be an object\");\n\tlet length = +args.length;\n\tif (!(length >= 0)) length = 0; /* Keep NaN in mind */\n\tluaL_checkstack(L, 2+length, null);\n\tlet base = lua_gettop(L);\n\tp(L);\n\tpush(L, thisarg);\n\tfor (let i=0; i<length; i++) {\n\t\tpush(L, args[i]);\n\t}\n\tswitch(lua_pcall(L, 1+length, n_results, 0)) {\n\t\tcase LUA_OK: {\n\t\t\tlet nres = lua_gettop(L)-base;\n\t\t\tlet res = new Array(nres);\n\t\t\tfor (let i=0; i<nres; i++) {\n\t\t\t\tres[i] = tojs(L, base+i+1);\n\t\t\t}\n\t\t\tlua_settop(L, base);\n\t\t\treturn res;\n\t\t}\n\t\tdefault: {\n\t\t\tlet r = tojs(L, -1);\n\t\t\tlua_settop(L, base);\n\t\t\tthrow r;\n\t\t}\n\t}\n};\n\nconst gettable = function(L) {\n\tlua_gettable(L, 1);\n\treturn 1;\n};\n\nconst get = function(L, p, prop) {\n\tluaL_checkstack(L, 3, null);\n\tlua_pushcfunction(L, gettable);\n\tp(L);\n\tpush(L, prop);\n\treturn jscall(L, 2);\n};\n\nconst has = function(L, p, prop) {\n\tluaL_checkstack(L, 3, null);\n\tlua_pushcfunction(L, gettable);\n\tp(L);\n\tpush(L, prop);\n\tlet status = lua_pcall(L, 2, 1, 0);\n\tswitch(status) {\n\t\tcase LUA_OK: {\n\t\t\tlet r = lua_isnil(L, -1);\n\t\t\tlua_pop(L, 1);\n\t\t\treturn !r;\n\t\t}\n\t\tdefault: {\n\t\t\tlet r = tojs(L, -1);\n\t\t\tlua_pop(L, 1);\n\t\t\tthrow r;\n\t\t}\n\t}\n};\n\nconst set = function(L, p, prop, value) {\n\tluaL_checkstack(L, 4, null);\n\tlua_pushcfunction(L, function(L) {\n\t\tlua_settable(L, 1);\n\t\treturn 0;\n\t});\n\tp(L);\n\tpush(L, prop);\n\tpush(L, value);\n\tswitch(lua_pcall(L, 3, 0, 0)) {\n\t\tcase LUA_OK:\n\t\t\treturn;\n\t\tdefault: {\n\t\t\tlet r = tojs(L, -1);\n\t\t\tlua_pop(L, 1);\n\t\t\tthrow r;\n\t\t}\n\t}\n};\n\nconst deleteProperty = function(L, p, prop) {\n\tluaL_checkstack(L, 4, null);\n\tlua_pushcfunction(L, function(L) {\n\t\tlua_settable(L, 1);\n\t\treturn 0;\n\t});\n\tp(L);\n\tpush(L, prop);\n\tlua_pushnil(L);\n\tswitch(lua_pcall(L, 3, 0, 0)) {\n\t\tcase LUA_OK:\n\t\t\treturn;\n\t\tdefault: {\n\t\t\tlet r = tojs(L, -1);\n\t\t\tlua_pop(L, 1);\n\t\t\tthrow r;\n\t\t}\n\t}\n};\n\nconst tostring = function(L, p) {\n\tluaL_checkstack(L, 2, null);\n\tlua_pushcfunction(L, function(L) {\n\t\tluaL_tolstring(L, 1);\n\t\treturn 1;\n\t});\n\tp(L);\n\treturn jscall(L, 1);\n};\n\n/* implements lua's \"Generic For\" protocol */\nconst iter_next = function() {\n\tlet L = this.L;\n\tluaL_checkstack(L, 3, null);\n\tlet top = lua_gettop(L);\n\tthis.iter(L);\n\tthis.state(L);\n\tthis.last(L);\n\tswitch(lua_pcall(L, 2, LUA_MULTRET, 0)) {\n\t\tcase LUA_OK: {\n\t\t\tthis.last = lua_toproxy(L, top+1);\n\t\t\tlet r;\n\t\t\tif (lua_isnil(L, -1)) {\n\t\t\t\tr = {\n\t\t\t\t\tdone: true,\n\t\t\t\t\tvalue: void 0\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\tlet n_results = lua_gettop(L) - top;\n\t\t\t\tlet result = new Array(n_results);\n\t\t\t\tfor (let i=0; i<n_results; i++) {\n\t\t\t\t\tresult[i] = tojs(L, top+i+1);\n\t\t\t\t}\n\t\t\t\tr = {\n\t\t\t\t\tdone: false,\n\t\t\t\t\tvalue: result\n\t\t\t\t};\n\t\t\t}\n\t\t\tlua_settop(L, top);\n\t\t\treturn r;\n\t\t}\n\t\tdefault: {\n\t\t\tlet e = tojs(L, -1);\n\t\t\tlua_pop(L, 1);\n\t\t\tthrow e;\n\t\t}\n\t}\n};\n\n/* make iteration use pairs() */\nconst jsiterator = function(L, p) {\n\tluaL_checkstack(L, 1, null);\n\tlua_pushcfunction(L, function(L) {\n\t\tluaL_requiref(L, to_luastring(\"_G\"), luaopen_base, 0);\n\t\tlua_getfield(L, -1, to_luastring(\"pairs\"));\n\t\tp(L);\n\t\tlua_call(L, 1, 3);\n\t\treturn 3;\n\t});\n\tswitch(lua_pcall(L, 0, 3, 0)) {\n\t\tcase LUA_OK: {\n\t\t\tlet iter = lua_toproxy(L, -3);\n\t\t\tlet state = lua_toproxy(L, -2);\n\t\t\tlet last = lua_toproxy(L, -1);\n\t\t\tlua_pop(L, 3);\n\t\t\treturn {\n\t\t\t\tL: L,\n\t\t\t\titer: iter,\n\t\t\t\tstate: state,\n\t\t\t\tlast: last,\n\t\t\t\tnext: iter_next\n\t\t\t};\n\t\t}\n\t\tdefault: {\n\t\t\tlet r = tojs(L, -1);\n\t\t\tlua_pop(L, 1);\n\t\t\tthrow r;\n\t\t}\n\t}\n};\n\nconst wrap = function(L1, p) {\n\tconst L = getmainthread(L1);\n\t/* we need `typeof js_proxy` to be \"function\" so that it's acceptable to native apis */\n\tlet js_proxy = function() {\n\t\t/* only get one result */\n\t\treturn invoke(L, p, this, arguments, 1)[0];\n\t};\n\tjs_proxy.apply = function(thisarg, args) {\n\t\t/* only get one result */\n\t\treturn invoke(L, p, thisarg, args, 1)[0];\n\t};\n\tjs_proxy.invoke = function(thisarg, args) {\n\t\treturn invoke(L, p, thisarg, args, LUA_MULTRET);\n\t};\n\tjs_proxy.get = function(k) {\n\t\treturn get(L, p, k);\n\t};\n\tjs_proxy.has = function(k) {\n\t\treturn has(L, p, k);\n\t};\n\tjs_proxy.set = function(k, v) {\n\t\treturn set(L, p, k, v);\n\t};\n\tjs_proxy.delete = function(k) {\n\t\treturn deleteProperty(L, p, k);\n\t};\n\tjs_proxy.toString = function() {\n\t\treturn tostring(L, p);\n\t};\n\tif (typeof Symbol === \"function\") {\n\t\tjs_proxy[Symbol.toStringTag] = \"Fengari object\";\n\t\tjs_proxy[Symbol.iterator] = function() {\n\t\t\treturn jsiterator(L, p);\n\t\t};\n\t\tif (Symbol.toPrimitive) {\n\t\t\tjs_proxy[Symbol.toPrimitive] = function(hint) {\n\t\t\t\tif (hint === \"string\") {\n\t\t\t\t\treturn tostring(L, p);\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t}\n\tif (custom_inspect_symbol) {\n\t\tjs_proxy[custom_inspect_symbol] = js_proxy.toString;\n\t}\n\tlet objects_seen = states.get(L);\n\tif (!objects_seen) throw Error(js_library_not_loaded);\n\tobjects_seen.set(js_proxy, p);\n\treturn js_proxy;\n};\n\nconst jslib = {\n\t\"new\": function(L) {\n\t\tlet u = tojs(L, 1);\n\t\tlet nargs = lua_gettop(L)-1;\n\t\tlet args = new Array(nargs);\n\t\tfor (let i = 0; i < nargs; i++) {\n\t\t\targs[i] = tojs(L, i+2);\n\t\t}\n\t\tpush(L, construct(u, args));\n\t\treturn 1;\n\t},\n\t\"tonumber\": function(L) {\n\t\tlet u = tojs(L, 1);\n\t\tlua_pushnumber(L, +u);\n\t\treturn 1;\n\t},\n\t\"tostring\": function(L) {\n\t\tlet u = tojs(L, 1);\n\t\tlua_pushliteral(L, toString(u));\n\t\treturn 1;\n\t},\n\t\"instanceof\": function(L) {\n\t\tlet u1 = tojs(L, 1);\n\t\tlet u2 = tojs(L, 2);\n\t\tlua_pushboolean(L, u1 instanceof u2);\n\t\treturn 1;\n\t},\n\t\"typeof\": function(L) {\n\t\tlet u = tojs(L, 1);\n\t\tlua_pushliteral(L, typeof u);\n\t\treturn 1;\n\t}\n};\n\nif (typeof Symbol === \"function\" && Symbol.iterator) {\n\tconst get_iterator = function(L, idx) {\n\t\tlet u = checkjs(L, idx);\n\t\tlet getiter = u[Symbol.iterator];\n\t\tif (!getiter)\n\t\t\tluaL_argerror(L, idx, to_luastring(\"object not iterable\"));\n\t\tlet iter = apply(getiter, u, []);\n\t\tif (!isobject(iter))\n\t\t\tluaL_argerror(L, idx, to_luastring(\"Result of the Symbol.iterator method is not an object\"));\n\t\treturn iter;\n\t};\n\n\tconst next = function(L) {\n\t\tlet iter = tojs(L, 1);\n\t\tlet r = iter.next();\n\t\tif (r.done) {\n\t\t\treturn 0;\n\t\t} else {\n\t\t\tpush(L, r.value);\n\t\t\treturn 1;\n\t\t}\n\t};\n\n\tjslib[\"of\"] = function(L) {\n\t\tlet iter = get_iterator(L, 1);\n\t\tlua_pushcfunction(L, next);\n\t\tpush(L, iter);\n\t\treturn 2;\n\t};\n}\n\nif (typeof Proxy === \"function\" && typeof Symbol === \"function\") {\n\tconst L_symbol = Symbol(\"lua_State\");\n\tconst p_symbol = Symbol(\"fengari-proxy\");\n\n\tconst proxy_handlers = {\n\t\t\"apply\": function(target, thisarg, args) {\n\t\t\treturn invoke(target[L_symbol], target[p_symbol], thisarg, args, 1)[0];\n\t\t},\n\t\t\"construct\": function(target, argumentsList) {\n\t\t\tlet L = target[L_symbol];\n\t\t\tlet p = target[p_symbol];\n\t\t\tlet arg_length = argumentsList.length;\n\t\t\tluaL_checkstack(L, 2+arg_length, null);\n\t\t\tp(L);\n\t\t\tlet idx = lua_gettop(L);\n\t\t\tif (luaL_getmetafield(L, idx, to_luastring(\"construct\")) === LUA_TNIL) {\n\t\t\t\tlua_pop(L, 1);\n\t\t\t\tthrow new TypeError(\"not a constructor\");\n\t\t\t}\n\t\t\tlua_rotate(L, idx, 1);\n\t\t\tfor (let i=0; i<arg_length; i++) {\n\t\t\t\tpush(L, argumentsList[i]);\n\t\t\t}\n\t\t\treturn jscall(L, 1+arg_length);\n\t\t},\n\t\t\"defineProperty\": function(target, prop, desc) {\n\t\t\tlet L = target[L_symbol];\n\t\t\tlet p = target[p_symbol];\n\t\t\tluaL_checkstack(L, 4, null);\n\t\t\tp(L);\n\t\t\tif (luaL_getmetafield(L, -1, to_luastring(\"defineProperty\")) === LUA_TNIL) {\n\t\t\t\tlua_pop(L, 1);\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tlua_rotate(L, -2, 1);\n\t\t\tpush(L, prop);\n\t\t\tpush(L, desc);\n\t\t\treturn jscall(L, 3);\n\t\t},\n\t\t\"deleteProperty\": function(target, k) {\n\t\t\treturn deleteProperty(target[L_symbol], target[p_symbol], k);\n\t\t},\n\t\t\"get\": function(target, k) {\n\t\t\treturn get(target[L_symbol], target[p_symbol], k);\n\t\t},\n\t\t\"getOwnPropertyDescriptor\": function(target, prop) {\n\t\t\tlet L = target[L_symbol];\n\t\t\tlet p = target[p_symbol];\n\t\t\tluaL_checkstack(L, 3, null);\n\t\t\tp(L);\n\t\t\tif (luaL_getmetafield(L, -1, to_luastring(\"getOwnPropertyDescriptor\")) === LUA_TNIL) {\n\t\t\t\tlua_pop(L, 1);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tlua_rotate(L, -2, 1);\n\t\t\tpush(L, prop);\n\t\t\treturn jscall(L, 2);\n\t\t},\n\t\t\"getPrototypeOf\": function(target) {\n\t\t\tlet L = target[L_symbol];\n\t\t\tlet p = target[p_symbol];\n\t\t\tluaL_checkstack(L, 2, null);\n\t\t\tp(L);\n\t\t\tif (luaL_getmetafield(L, -1, to_luastring(\"getPrototypeOf\")) === LUA_TNIL) {\n\t\t\t\tlua_pop(L, 1);\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\tlua_rotate(L, -2, 1);\n\t\t\treturn jscall(L, 1);\n\t\t},\n\t\t\"has\": function(target, k) {\n\t\t\treturn has(target[L_symbol], target[p_symbol], k);\n\t\t},\n\t\t\"ownKeys\": function(target) {\n\t\t\tlet L = target[L_symbol];\n\t\t\tlet p = target[p_symbol];\n\t\t\tluaL_checkstack(L, 2, null);\n\t\t\tp(L);\n\t\t\tif (luaL_getmetafield(L, -1, to_luastring(\"ownKeys\")) === LUA_TNIL) {\n\t\t\t\tlua_pop(L, 1);\n\t\t\t\tthrow Error(\"ownKeys unknown for fengari object\");\n\t\t\t}\n\t\t\tlua_rotate(L, -2, 1);\n\t\t\treturn jscall(L, 1);\n\t\t},\n\t\t\"set\": function(target, k, v) {\n\t\t\tset(target[L_symbol], target[p_symbol], k, v);\n\t\t\treturn true;\n\t\t},\n\t\t\"setPrototypeOf\": function(target, prototype) {\n\t\t\tlet L = target[L_symbol];\n\t\t\tlet p = target[p_symbol];\n\t\t\tluaL_checkstack(L, 3, null);\n\t\t\tp(L);\n\t\t\tif (luaL_getmetafield(L, -1, to_luastring(\"setPrototypeOf\")) === LUA_TNIL) {\n\t\t\t\tlua_pop(L, 1);\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tlua_rotate(L, -2, 1);\n\t\t\tpush(L, prototype);\n\t\t\treturn jscall(L, 2);\n\t\t}\n\t};\n\n\t/*\n\tFunctions created with `function(){}` have a non-configurable .prototype\n\tfield. This causes issues with the .ownKeys and .getOwnPropertyDescriptor\n\ttraps.\n\tHowever using `.bind()` returns a function without the .prototype property.\n\n\t```js\n\tReflect.ownKeys((function(){})) // Array [ \"prototype\", \"length\", \"name\" ]\n\tReflect.ownKeys((function(){}).bind()) // Array [ \"length\", \"name\" ]\n\t```\n\t*/\n\tconst raw_function = function() {\n\t\tlet f = (function(){}).bind();\n\t\tdelete f.length;\n\t\tdelete f.name;\n\t\treturn f;\n\t};\n\n\t/*\n\tWe use Function() here to get prevent transpilers from converting to a\n\tnon-arrow function.\n\tAdditionally, we avoid setting the internal name field by never giving the\n\tnew function a name in the block it was defined (and instead delete-ing\n\tthe configurable fields .length and .name in a wrapper function)\n\t*/\n\tconst make_arrow_function = Function(\"return ()=>void 0;\");\n\tconst raw_arrow_function = function() {\n\t\tlet f = make_arrow_function();\n\t\tdelete f.length;\n\t\tdelete f.name;\n\t\treturn f;\n\t};\n\n\t/*\n\tArrow functions do not have a .prototype field:\n\n\t```js\n\tReflect.ownKeys((() = >void 0)) // Array [ \"length\", \"name\" ]\n\t```\n\n\tHowever they cannot be used as a constructor:\n\n\t```js\n\tnew (new Proxy(() => void 0, { construct: function() { return {}; } })) // TypeError: (intermediate value) is not a constructor\n\tnew (new Proxy(function(){}, { construct: function() { return {}; } })) // {}\n\t```\n\t*/\n\tconst createproxy = function(L1, p, type) {\n\t\tconst L = getmainthread(L1);\n\t\tlet target;\n\t\tswitch (type) {\n\t\t\tcase \"function\":\n\t\t\t\ttarget = raw_function();\n\t\t\t\tbreak;\n\t\t\tcase \"arrow_function\":\n\t\t\t\ttarget = raw_arrow_function();\n\t\t\t\tbreak;\n\t\t\tcase \"object\":\n\t\t\t\ttarget = {};\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow TypeError(\"invalid type to createproxy\");\n\t\t}\n\t\ttarget[p_symbol] = p;\n\t\ttarget[L_symbol] = L;\n\t\treturn new Proxy(target, proxy_handlers);\n\t};\n\n\tconst valid_types = [\"function\", \"arrow_function\", \"object\"];\n\tconst valid_types_as_luastring = valid_types.map((v) => to_luastring(v));\n\tjslib[\"createproxy\"] = function(L) {\n\t\tluaL_checkany(L, 1);\n\t\tlet type = valid_types[luaL_checkoption(L, 2, valid_types_as_luastring[0], valid_types_as_luastring)];\n\t\tlet fengariProxy = createproxy(L, lua_toproxy(L, 1), type);\n\t\tpush(L, fengariProxy);\n\t\treturn 1;\n\t};\n}\n\nlet jsmt = {\n\t\"__index\": function(L) {\n\t\tlet u = checkjs(L, 1);\n\t\tlet k = tojs(L, 2);\n\t\tpush(L, u[k]);\n\t\treturn 1;\n\t},\n\t\"__newindex\": function(L) {\n\t\tlet u = checkjs(L, 1);\n\t\tlet k = tojs(L, 2);\n\t\tlet v = tojs(L, 3);\n\t\tif (v === void 0)\n\t\t\tReflect_deleteProperty(u, k);\n\t\telse\n\t\t\tu[k] = v;\n\t\treturn 0;\n\t},\n\t\"__tostring\": function(L) {\n\t\tlet u = checkjs(L, 1);\n\t\tlet s = toString(u);\n\t\tlua_pushstring(L, to_luastring(s));\n\t\treturn 1;\n\t},\n\t\"__call\": function(L) {\n\t\tlet u = checkjs(L, 1);\n\t\tlet nargs = lua_gettop(L)-1;\n\t\tlet thisarg;\n\t\tlet args = new Array(Math.max(0, nargs-1));\n\t\tif (nargs > 0) {\n\t\t\tthisarg = tojs(L, 2);\n\t\t\tif (nargs-- > 0) {\n\t\t\t\tfor (let i = 0; i < nargs; i++) {\n\t\t\t\t\targs[i] = tojs(L, i+3);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpush(L, apply(u, thisarg, args));\n\t\treturn 1;\n\t},\n\t\"__pairs\": function(L) {\n\t\tlet u = checkjs(L, 1);\n\t\tlet f;\n\t\tlet iter, state, first;\n\t\tif (typeof Symbol !== \"function\" || (f = u[Symbol.for(\"__pairs\")]) === void 0) {\n\t\t\t/* By default, iterate over Object.keys */\n\t\t\titer = function(last) {\n\t\t\t\tif (this.index >= this.keys.length)\n\t\t\t\t\treturn;\n\t\t\t\tlet key = this.keys[this.index++];\n\t\t\t\treturn [key, this.object[key]];\n\t\t\t};\n\t\t\tstate = {\n\t\t\t\tobject: u,\n\t\t\t\tkeys: Object.keys(u),\n\t\t\t\tindex: 0,\n\t\t\t};\n\t\t} else {\n\t\t\tlet r = apply(f, u, []);\n\t\t\tif (r === void 0)\n\t\t\t\tluaL_error(L, to_luastring(\"bad '__pairs' result (object with keys 'iter', 'state', 'first' expected)\"));\n\t\t\titer = r.iter;\n\t\t\tif (iter === void 0)\n\t\t\t\tluaL_error(L, to_luastring(\"bad '__pairs' result (object.iter is missing)\"));\n\t\t\tstate = r.state;\n\t\t\tfirst = r.first;\n\t\t}\n\t\tlua_pushcfunction(L, function() {\n\t\t\tlet state = tojs(L, 1);\n\t\t\tlet last = tojs(L, 2);\n\t\t\tlet r = apply(iter, state, [last]);\n\t\t\t/* returning undefined indicates end of iteration */\n\t\t\tif (r === void 0)\n\t\t\t\treturn 0;\n\t\t\t/* otherwise it should return an array of results */\n\t\t\tif (!Array.isArray(r))\n\t\t\t\tluaL_error(L, to_luastring(\"bad iterator result (Array or undefined expected)\"));\n\t\t\tluaL_checkstack(L, r.length, null);\n\t\t\tfor (let i=0; i<r.length; i++) {\n\t\t\t\tpush(L, r[i]);\n\t\t\t}\n\t\t\treturn r.length;\n\t\t});\n\t\tpush(L, state);\n\t\tpush(L, first);\n\t\treturn 3;\n\t},\n\t\"__len\": function(L) {\n\t\tlet u = checkjs(L, 1);\n\t\tlet f;\n\t\tlet r;\n\t\tif (typeof Symbol !== \"function\" || (f = u[Symbol.for(\"__len\")]) === void 0) {\n\t\t\t/* by default use .length field */\n\t\t\tr = u.length;\n\t\t} else {\n\t\t\tr = apply(f, u, []);\n\t\t}\n\t\tpush(L, r);\n\t\treturn 1;\n\t}\n};\n\nconst luaopen_js = function(L) {\n\t/* Add weak map to track objects seen */\n\tstates.set(getmainthread(L), new WeakMap());\n\n\tlua_atnativeerror(L, atnativeerror);\n\n\tluaL_newlib(L, jslib);\n\tlua_pushliteral(L, FENGARI_INTEROP_VERSION);\n\tlua_setfield(L, -2, to_luastring(\"_VERSION\"));\n\tlua_pushinteger(L, FENGARI_INTEROP_VERSION_NUM);\n\tlua_setfield(L, -2, to_luastring(\"_VERSION_NUM\"));\n\tlua_pushliteral(L, FENGARI_INTEROP_RELEASE);\n\tlua_setfield(L, -2, to_luastring(\"_RELEASE\"));\n\n\tluaL_newmetatable(L, js_tname);\n\tluaL_setfuncs(L, jsmt, 0);\n\tlua_pop(L, 1);\n\n\tpushjs(L, null);\n\t/* Store null object in registry under lightuserdata null */\n\tlua_pushvalue(L, -1);\n\tlua_rawsetp(L, LUA_REGISTRYINDEX, null);\n\tlua_setfield(L, -2, to_luastring(\"null\"));\n\n\tpush(L, global_env);\n\tlua_setfield(L, -2, to_luastring(\"global\"));\n\n\treturn 1;\n};\n\nmodule.exports.FENGARI_INTEROP_VERSION = FENGARI_INTEROP_VERSION;\nmodule.exports.FENGARI_INTEROP_VERSION_NUM = FENGARI_INTEROP_VERSION_NUM;\nmodule.exports.FENGARI_INTEROP_RELEASE = FENGARI_INTEROP_RELEASE;\nmodule.exports.checkjs = checkjs;\nmodule.exports.testjs = testjs;\nmodule.exports.pushjs = pushjs;\nmodule.exports.push = push;\nmodule.exports.tojs = tojs;\nmodule.exports.luaopen_js = luaopen_js;\n","\"use strict\";\n\nconst {\n    LUA_MULTRET,\n    LUA_OK,\n    LUA_TFUNCTION,\n    LUA_TNIL,\n    LUA_TNONE,\n    LUA_TNUMBER,\n    LUA_TSTRING,\n    LUA_TTABLE,\n    LUA_VERSION,\n    LUA_YIELD,\n    lua_call,\n    lua_callk,\n    lua_concat,\n    lua_error,\n    lua_getglobal,\n    lua_geti,\n    lua_getmetatable,\n    lua_gettop,\n    lua_insert,\n    lua_isnil,\n    lua_isnone,\n    lua_isstring,\n    lua_load,\n    lua_next,\n    lua_pcallk,\n    lua_pop,\n    lua_pushboolean,\n    lua_pushcfunction,\n    lua_pushglobaltable,\n    lua_pushinteger,\n    lua_pushliteral,\n    lua_pushnil,\n    lua_pushstring,\n    lua_pushvalue,\n    lua_rawequal,\n    lua_rawget,\n    lua_rawlen,\n    lua_rawset,\n    lua_remove,\n    lua_replace,\n    lua_rotate,\n    lua_setfield,\n    lua_setmetatable,\n    lua_settop,\n    lua_setupvalue,\n    lua_stringtonumber,\n    lua_toboolean,\n    lua_tolstring,\n    lua_tostring,\n    lua_type,\n    lua_typename\n} = require('./lua.js');\nconst {\n    luaL_argcheck,\n    luaL_checkany,\n    luaL_checkinteger,\n    luaL_checkoption,\n    luaL_checkstack,\n    luaL_checktype,\n    luaL_error,\n    luaL_getmetafield,\n    luaL_loadbufferx,\n    luaL_loadfile,\n    luaL_loadfilex,\n    luaL_optinteger,\n    luaL_optstring,\n    luaL_setfuncs,\n    luaL_tolstring,\n    luaL_where\n} = require('./lauxlib.js');\nconst {\n    to_jsstring,\n    to_luastring\n} = require(\"./fengaricore.js\");\n\nlet lua_writestring;\nlet lua_writeline;\nif (typeof process === \"undefined\") {\n    if (typeof TextDecoder === \"function\") { /* Older browsers don't have TextDecoder */\n        let buff = \"\";\n        let decoder = new TextDecoder(\"utf-8\");\n        lua_writestring = function(s) {\n            buff += decoder.decode(s, {stream: true});\n        };\n        let empty = new Uint8Array(0);\n        lua_writeline = function() {\n            buff += decoder.decode(empty);\n            console.log(buff);\n            buff = \"\";\n        };\n    } else {\n        let buff = [];\n        lua_writestring = function(s) {\n            try {\n                /* If the string is valid utf8, then we can use to_jsstring */\n                s = to_jsstring(s);\n            } catch(e) {\n                /* otherwise push copy of raw array */\n                let copy = new Uint8Array(s.length);\n                copy.set(s);\n                s = copy;\n            }\n            buff.push(s);\n        };\n        lua_writeline = function() {\n            console.log.apply(console.log, buff);\n            buff = [];\n        };\n    }\n} else {\n    lua_writestring = function(s) {\n        process.stdout.write(Buffer.from(s));\n    };\n    lua_writeline = function() {\n        process.stdout.write(\"\\n\");\n    };\n}\nconst luaB_print = function(L) {\n    let n = lua_gettop(L); /* number of arguments */\n    lua_getglobal(L, to_luastring(\"tostring\", true));\n    for (let i = 1; i <= n; i++) {\n        lua_pushvalue(L, -1);  /* function to be called */\n        lua_pushvalue(L, i);  /* value to print */\n        lua_call(L, 1, 1);\n        let s = lua_tolstring(L, -1);\n        if (s === null)\n            return luaL_error(L, to_luastring(\"'tostring' must return a string to 'print'\"));\n        if (i > 1) lua_writestring(to_luastring(\"\\t\"));\n        lua_writestring(s);\n        lua_pop(L, 1);\n    }\n    lua_writeline();\n    return 0;\n};\n\nconst luaB_tostring = function(L) {\n    luaL_checkany(L, 1);\n    luaL_tolstring(L, 1);\n\n    return 1;\n};\n\nconst luaB_getmetatable = function(L) {\n    luaL_checkany(L, 1);\n    if (!lua_getmetatable(L, 1)) {\n        lua_pushnil(L);\n        return 1;  /* no metatable */\n    }\n    luaL_getmetafield(L, 1, to_luastring(\"__metatable\", true));\n    return 1;  /* returns either __metatable field (if present) or metatable */\n};\n\nconst luaB_setmetatable = function(L) {\n    let t = lua_type(L, 2);\n    luaL_checktype(L, 1, LUA_TTABLE);\n    luaL_argcheck(L, t === LUA_TNIL || t === LUA_TTABLE, 2, \"nil or table expected\");\n    if (luaL_getmetafield(L, 1, to_luastring(\"__metatable\", true)) !== LUA_TNIL)\n        return luaL_error(L, to_luastring(\"cannot change a protected metatable\"));\n    lua_settop(L, 2);\n    lua_setmetatable(L, 1);\n    return 1;\n};\n\nconst luaB_rawequal = function(L) {\n    luaL_checkany(L, 1);\n    luaL_checkany(L, 2);\n    lua_pushboolean(L, lua_rawequal(L, 1, 2));\n    return 1;\n};\n\nconst luaB_rawlen = function(L) {\n    let t = lua_type(L, 1);\n    luaL_argcheck(L, t === LUA_TTABLE || t === LUA_TSTRING, 1, \"table or string expected\");\n    lua_pushinteger(L, lua_rawlen(L, 1));\n    return 1;\n};\n\nconst luaB_rawget = function(L) {\n    luaL_checktype(L, 1, LUA_TTABLE);\n    luaL_checkany(L, 2);\n    lua_settop(L, 2);\n    lua_rawget(L, 1);\n    return 1;\n};\n\nconst luaB_rawset = function(L) {\n    luaL_checktype(L, 1, LUA_TTABLE);\n    luaL_checkany(L, 2);\n    luaL_checkany(L, 3);\n    lua_settop(L, 3);\n    lua_rawset(L, 1);\n    return 1;\n};\n\nconst opts = [\n    \"stop\", \"restart\", \"collect\",\n    \"count\", \"step\", \"setpause\", \"setstepmul\",\n    \"isrunning\"\n].map((e) => to_luastring(e));\nconst luaB_collectgarbage = function(L) {\n    luaL_checkoption(L, 1, \"collect\", opts);\n    luaL_optinteger(L, 2, 0);\n    luaL_error(L, to_luastring(\"lua_gc not implemented\"));\n};\n\nconst luaB_type = function(L) {\n    let t = lua_type(L, 1);\n    luaL_argcheck(L, t !== LUA_TNONE, 1, \"value expected\");\n    lua_pushstring(L, lua_typename(L, t));\n    return 1;\n};\n\nconst pairsmeta = function(L, method, iszero, iter) {\n    luaL_checkany(L, 1);\n    if (luaL_getmetafield(L, 1, method) === LUA_TNIL) {  /* no metamethod? */\n        lua_pushcfunction(L, iter);  /* will return generator, */\n        lua_pushvalue(L, 1);  /* state, */\n        if (iszero) lua_pushinteger(L, 0);  /* and initial value */\n        else lua_pushnil(L);\n    } else {\n        lua_pushvalue(L, 1);  /* argument 'self' to metamethod */\n        lua_call(L, 1, 3);  /* get 3 values from metamethod */\n    }\n    return 3;\n};\n\nconst luaB_next = function(L) {\n    luaL_checktype(L, 1, LUA_TTABLE);\n    lua_settop(L, 2);  /* create a 2nd argument if there isn't one */\n    if (lua_next(L, 1))\n        return 2;\n    else {\n        lua_pushnil(L);\n        return 1;\n    }\n};\n\nconst luaB_pairs = function(L) {\n    return pairsmeta(L, to_luastring(\"__pairs\", true), 0, luaB_next);\n};\n\n/*\n** Traversal function for 'ipairs'\n*/\nconst ipairsaux = function(L) {\n    let i = luaL_checkinteger(L, 2) + 1;\n    lua_pushinteger(L, i);\n    return lua_geti(L, 1, i) === LUA_TNIL ? 1 : 2;\n};\n\n/*\n** 'ipairs' function. Returns 'ipairsaux', given \"table\", 0.\n** (The given \"table\" may not be a table.)\n*/\nconst luaB_ipairs = function(L) {\n    // Lua 5.2\n    // return pairsmeta(L, \"__ipairs\", 1, ipairsaux);\n\n    luaL_checkany(L, 1);\n    lua_pushcfunction(L, ipairsaux);  /* iteration function */\n    lua_pushvalue(L, 1);  /* state */\n    lua_pushinteger(L, 0);  /* initial value */\n    return 3;\n};\n\nconst b_str2int = function(s, base) {\n    try {\n        s = to_jsstring(s);\n    } catch (e) {\n        return null;\n    }\n    let r = /^[\\t\\v\\f \\n\\r]*([+-]?)0*([0-9A-Za-z]+)[\\t\\v\\f \\n\\r]*$/.exec(s);\n    if (!r) return null;\n    let v = parseInt(r[1]+r[2], base);\n    if (isNaN(v)) return null;\n    return v|0;\n};\n\nconst luaB_tonumber = function(L) {\n    if (lua_type(L, 2) <= 0) {  /* standard conversion? */\n        luaL_checkany(L, 1);\n        if (lua_type(L, 1) === LUA_TNUMBER) {  /* already a number? */\n            lua_settop(L, 1);\n            return 1;\n        } else {\n            let s = lua_tostring(L, 1);\n            if (s !== null && lua_stringtonumber(L, s) === s.length+1)\n                return 1;  /* successful conversion to number */\n        }\n    } else {\n        let base = luaL_checkinteger(L, 2);\n        luaL_checktype(L, 1, LUA_TSTRING);  /* no numbers as strings */\n        let s = lua_tostring(L, 1);\n        luaL_argcheck(L, 2 <= base && base <= 36, 2, \"base out of range\");\n        let n = b_str2int(s, base);\n        if (n !== null) {\n            lua_pushinteger(L, n);\n            return 1;\n        }\n    }\n\n    lua_pushnil(L);\n    return 1;\n};\n\nconst luaB_error = function(L) {\n    let level = luaL_optinteger(L, 2, 1);\n    lua_settop(L, 1);\n    if (lua_type(L, 1) === LUA_TSTRING && level > 0) {\n        luaL_where(L, level);  /* add extra information */\n        lua_pushvalue(L, 1);\n        lua_concat(L, 2);\n    }\n    return lua_error(L);\n};\n\nconst luaB_assert = function(L) {\n    if (lua_toboolean(L, 1))  /* condition is true? */\n        return lua_gettop(L);  /* return all arguments */\n    else {\n        luaL_checkany(L, 1);  /* there must be a condition */\n        lua_remove(L, 1);  /* remove it */\n        lua_pushliteral(L, \"assertion failed!\");  /* default message */\n        lua_settop(L, 1);  /* leave only message (default if no other one) */\n        return luaB_error(L);  /* call 'error' */\n    }\n};\n\nconst luaB_select = function(L) {\n    let n = lua_gettop(L);\n    if (lua_type(L, 1) === LUA_TSTRING && lua_tostring(L, 1)[0] === 35 /* '#'.charCodeAt(0) */) {\n        lua_pushinteger(L, n - 1);\n        return 1;\n    } else {\n        let i = luaL_checkinteger(L, 1);\n        if (i < 0) i = n + i;\n        else if (i > n) i = n;\n        luaL_argcheck(L, 1 <= i, 1, \"index out of range\");\n        return n - i;\n    }\n};\n\n/*\n** Continuation function for 'pcall' and 'xpcall'. Both functions\n** already pushed a 'true' before doing the call, so in case of success\n** 'finishpcall' only has to return everything in the stack minus\n** 'extra' values (where 'extra' is exactly the number of items to be\n** ignored).\n*/\nconst finishpcall = function(L, status, extra) {\n    if (status !== LUA_OK && status !== LUA_YIELD) {  /* error? */\n        lua_pushboolean(L, 0);  /* first result (false) */\n        lua_pushvalue(L, -2);  /* error message */\n        return 2;  /* return false, msg */\n    } else\n        return lua_gettop(L) - extra;\n};\n\nconst luaB_pcall = function(L) {\n    luaL_checkany(L, 1);\n    lua_pushboolean(L, 1);  /* first result if no errors */\n    lua_insert(L, 1);  /* put it in place */\n    let status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);\n    return finishpcall(L, status, 0);\n};\n\n/*\n** Do a protected call with error handling. After 'lua_rotate', the\n** stack will have <f, err, true, f, [args...]>; so, the function passes\n** 2 to 'finishpcall' to skip the 2 first values when returning results.\n*/\nconst luaB_xpcall = function(L) {\n    let n = lua_gettop(L);\n    luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */\n    lua_pushboolean(L, 1);  /* first result */\n    lua_pushvalue(L, 1);  /* function */\n    lua_rotate(L, 3, 2);  /* move them below function's arguments */\n    let status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);\n    return finishpcall(L, status, 2);\n};\n\nconst load_aux = function(L, status, envidx) {\n    if (status === LUA_OK) {\n        if (envidx !== 0) {  /* 'env' parameter? */\n            lua_pushvalue(L, envidx);  /* environment for loaded function */\n            if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */\n                lua_pop(L, 1);  /* remove 'env' if not used by previous call */\n        }\n        return 1;\n    } else {  /* error (message is on top of the stack) */\n        lua_pushnil(L);\n        lua_insert(L, -2);  /* put before error message */\n        return 2;  /* return nil plus error message */\n    }\n};\n\n/*\n** reserved slot, above all arguments, to hold a copy of the returned\n** string to avoid it being collected while parsed. 'load' has four\n** optional arguments (chunk, source name, mode, and environment).\n*/\nconst RESERVEDSLOT = 5;\n\n/*\n** Reader for generic 'load' function: 'lua_load' uses the\n** stack for internal stuff, so the reader cannot change the\n** stack top. Instead, it keeps its resulting string in a\n** reserved slot inside the stack.\n*/\nconst generic_reader = function(L, ud) {\n    luaL_checkstack(L, 2, \"too many nested functions\");\n    lua_pushvalue(L, 1);  /* get function */\n    lua_call(L, 0, 1);  /* call it */\n    if (lua_isnil(L, -1)) {\n        lua_pop(L, 1);  /* pop result */\n        return null;\n    } else if (!lua_isstring(L, -1))\n        luaL_error(L, to_luastring(\"reader function must return a string\"));\n    lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */\n    return lua_tostring(L, RESERVEDSLOT);\n};\n\nconst luaB_load = function(L) {\n    let s = lua_tostring(L, 1);\n    let mode = luaL_optstring(L, 3, \"bt\");\n    let env = !lua_isnone(L, 4) ? 4 : 0;  /* 'env' index or 0 if no 'env' */\n    let status;\n    if (s !== null) {  /* loading a string? */\n        let chunkname = luaL_optstring(L, 2, s);\n        status = luaL_loadbufferx(L, s, s.length, chunkname, mode);\n    } else {  /* loading from a reader function */\n        let chunkname = luaL_optstring(L, 2, \"=(load)\");\n        luaL_checktype(L, 1, LUA_TFUNCTION);\n        lua_settop(L, RESERVEDSLOT);  /* create reserved slot */\n        status = lua_load(L, generic_reader, null, chunkname, mode);\n    }\n    return load_aux(L, status, env);\n};\n\nconst luaB_loadfile = function(L) {\n    let fname = luaL_optstring(L, 1, null);\n    let mode = luaL_optstring(L, 2, null);\n    let env = !lua_isnone(L, 3) ? 3 : 0;  /* 'env' index or 0 if no 'env' */\n    let status = luaL_loadfilex(L, fname, mode);\n    return load_aux(L, status, env);\n};\n\nconst dofilecont = function(L, d1, d2) {\n    return lua_gettop(L) - 1;\n};\n\nconst luaB_dofile = function(L) {\n    let fname = luaL_optstring(L, 1, null);\n    lua_settop(L, 1);\n    if (luaL_loadfile(L, fname) !== LUA_OK)\n        return lua_error(L);\n    lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);\n    return dofilecont(L, 0, 0);\n};\n\nconst base_funcs = {\n    \"assert\":         luaB_assert,\n    \"collectgarbage\": luaB_collectgarbage,\n    \"dofile\":         luaB_dofile,\n    \"error\":          luaB_error,\n    \"getmetatable\":   luaB_getmetatable,\n    \"ipairs\":         luaB_ipairs,\n    \"load\":           luaB_load,\n    \"loadfile\":       luaB_loadfile,\n    \"next\":           luaB_next,\n    \"pairs\":          luaB_pairs,\n    \"pcall\":          luaB_pcall,\n    \"print\":          luaB_print,\n    \"rawequal\":       luaB_rawequal,\n    \"rawget\":         luaB_rawget,\n    \"rawlen\":         luaB_rawlen,\n    \"rawset\":         luaB_rawset,\n    \"select\":         luaB_select,\n    \"setmetatable\":   luaB_setmetatable,\n    \"tonumber\":       luaB_tonumber,\n    \"tostring\":       luaB_tostring,\n    \"type\":           luaB_type,\n    \"xpcall\":         luaB_xpcall\n};\n\nconst luaopen_base = function(L) {\n    /* open lib into global table */\n    lua_pushglobaltable(L);\n    luaL_setfuncs(L, base_funcs, 0);\n    /* set global _G */\n    lua_pushvalue(L, -1);\n    lua_setfield(L, -2, to_luastring(\"_G\"));\n    /* set global _VERSION */\n    lua_pushliteral(L, LUA_VERSION);\n    lua_setfield(L, -2, to_luastring(\"_VERSION\"));\n    return 1;\n};\n\nmodule.exports.luaopen_base = luaopen_base;\n","\"use strict\";\n\nconst { lua_pop } = require('./lua.js');\nconst { luaL_requiref } = require('./lauxlib.js');\nconst { to_luastring } = require(\"./fengaricore.js\");\n\nconst loadedlibs = {};\n\n/* export before requiring lualib.js */\nconst luaL_openlibs = function(L) {\n    /* \"require\" functions from 'loadedlibs' and set results to global table */\n    for (let lib in loadedlibs) {\n        luaL_requiref(L, to_luastring(lib), loadedlibs[lib], 1);\n        lua_pop(L, 1); /* remove lib */\n    }\n};\nmodule.exports.luaL_openlibs = luaL_openlibs;\n\nconst lualib = require('./lualib.js');\nconst { luaopen_base }      = require('./lbaselib.js');\nconst { luaopen_coroutine } = require('./lcorolib.js');\nconst { luaopen_debug }     = require('./ldblib.js');\nconst { luaopen_math }      = require('./lmathlib.js');\nconst { luaopen_package }   = require('./loadlib.js');\nconst { luaopen_os }        = require('./loslib.js');\nconst { luaopen_string }    = require('./lstrlib.js');\nconst { luaopen_table }     = require('./ltablib.js');\nconst { luaopen_utf8 }      = require('./lutf8lib.js');\n\nloadedlibs[\"_G\"] = luaopen_base,\nloadedlibs[lualib.LUA_LOADLIBNAME] = luaopen_package;\nloadedlibs[lualib.LUA_COLIBNAME] = luaopen_coroutine;\nloadedlibs[lualib.LUA_TABLIBNAME] = luaopen_table;\nloadedlibs[lualib.LUA_OSLIBNAME] = luaopen_os;\nloadedlibs[lualib.LUA_STRLIBNAME] = luaopen_string;\nloadedlibs[lualib.LUA_MATHLIBNAME] = luaopen_math;\nloadedlibs[lualib.LUA_UTF8LIBNAME] = luaopen_utf8;\nloadedlibs[lualib.LUA_DBLIBNAME] = luaopen_debug;\nif (typeof process !== \"undefined\")\n    loadedlibs[lualib.LUA_IOLIBNAME] = require('./liolib.js').luaopen_io;\n\n/* Extension: fengari library */\nconst { luaopen_fengari } = require('./fengarilib.js');\nloadedlibs[lualib.LUA_FENGARILIBNAME] = luaopen_fengari;\n","/* global window, exports, define */\n\n!function() {\n    'use strict'\n\n    var re = {\n        not_string: /[^s]/,\n        not_bool: /[^t]/,\n        not_type: /[^T]/,\n        not_primitive: /[^v]/,\n        number: /[diefg]/,\n        numeric_arg: /[bcdiefguxX]/,\n        json: /[j]/,\n        not_json: /[^j]/,\n        text: /^[^\\x25]+/,\n        modulo: /^\\x25{2}/,\n        placeholder: /^\\x25(?:([1-9]\\d*)\\$|\\(([^\\)]+)\\))?(\\+)?(0|'[^$])?(-)?(\\d+)?(?:\\.(\\d+))?([b-gijostTuvxX])/,\n        key: /^([a-z_][a-z_\\d]*)/i,\n        key_access: /^\\.([a-z_][a-z_\\d]*)/i,\n        index_access: /^\\[(\\d+)\\]/,\n        sign: /^[\\+\\-]/\n    }\n\n    function sprintf(key) {\n        // `arguments` is not an array, but should be fine for this call\n        return sprintf_format(sprintf_parse(key), arguments)\n    }\n\n    function vsprintf(fmt, argv) {\n        return sprintf.apply(null, [fmt].concat(argv || []))\n    }\n\n    function sprintf_format(parse_tree, argv) {\n        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, match, pad, pad_character, pad_length, is_positive, sign\n        for (i = 0; i < tree_length; i++) {\n            if (typeof parse_tree[i] === 'string') {\n                output += parse_tree[i]\n            }\n            else if (Array.isArray(parse_tree[i])) {\n                match = parse_tree[i] // convenience purposes only\n                if (match[2]) { // keyword argument\n                    arg = argv[cursor]\n                    for (k = 0; k < match[2].length; k++) {\n                        if (!arg.hasOwnProperty(match[2][k])) {\n                            throw new Error(sprintf('[sprintf] property \"%s\" does not exist', match[2][k]))\n                        }\n                        arg = arg[match[2][k]]\n                    }\n                }\n                else if (match[1]) { // positional argument (explicit)\n                    arg = argv[match[1]]\n                }\n                else { // positional argument (implicit)\n                    arg = argv[cursor++]\n                }\n\n                if (re.not_type.test(match[8]) && re.not_primitive.test(match[8]) && arg instanceof Function) {\n                    arg = arg()\n                }\n\n                if (re.numeric_arg.test(match[8]) && (typeof arg !== 'number' && isNaN(arg))) {\n                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))\n                }\n\n                if (re.number.test(match[8])) {\n                    is_positive = arg >= 0\n                }\n\n                switch (match[8]) {\n                    case 'b':\n                        arg = parseInt(arg, 10).toString(2)\n                        break\n                    case 'c':\n                        arg = String.fromCharCode(parseInt(arg, 10))\n                        break\n                    case 'd':\n                    case 'i':\n                        arg = parseInt(arg, 10)\n                        break\n                    case 'j':\n                        arg = JSON.stringify(arg, null, match[6] ? parseInt(match[6]) : 0)\n                        break\n                    case 'e':\n                        arg = match[7] ? parseFloat(arg).toExponential(match[7]) : parseFloat(arg).toExponential()\n                        break\n                    case 'f':\n                        arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg)\n                        break\n                    case 'g':\n                        arg = match[7] ? String(Number(arg.toPrecision(match[7]))) : parseFloat(arg)\n                        break\n                    case 'o':\n                        arg = (parseInt(arg, 10) >>> 0).toString(8)\n                        break\n                    case 's':\n                        arg = String(arg)\n                        arg = (match[7] ? arg.substring(0, match[7]) : arg)\n                        break\n                    case 't':\n                        arg = String(!!arg)\n                        arg = (match[7] ? arg.substring(0, match[7]) : arg)\n                        break\n                    case 'T':\n                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()\n                        arg = (match[7] ? arg.substring(0, match[7]) : arg)\n                        break\n                    case 'u':\n                        arg = parseInt(arg, 10) >>> 0\n                        break\n                    case 'v':\n                        arg = arg.valueOf()\n                        arg = (match[7] ? arg.substring(0, match[7]) : arg)\n                        break\n                    case 'x':\n                        arg = (parseInt(arg, 10) >>> 0).toString(16)\n                        break\n                    case 'X':\n                        arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()\n                        break\n                }\n                if (re.json.test(match[8])) {\n                    output += arg\n                }\n                else {\n                    if (re.number.test(match[8]) && (!is_positive || match[3])) {\n                        sign = is_positive ? '+' : '-'\n                        arg = arg.toString().replace(re.sign, '')\n                    }\n                    else {\n                        sign = ''\n                    }\n                    pad_character = match[4] ? match[4] === '0' ? '0' : match[4].charAt(1) : ' '\n                    pad_length = match[6] - (sign + arg).length\n                    pad = match[6] ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''\n                    output += match[5] ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)\n                }\n            }\n        }\n        return output\n    }\n\n    var sprintf_cache = Object.create(null)\n\n    function sprintf_parse(fmt) {\n        if (sprintf_cache[fmt]) {\n            return sprintf_cache[fmt]\n        }\n\n        var _fmt = fmt, match, parse_tree = [], arg_names = 0\n        while (_fmt) {\n            if ((match = re.text.exec(_fmt)) !== null) {\n                parse_tree.push(match[0])\n            }\n            else if ((match = re.modulo.exec(_fmt)) !== null) {\n                parse_tree.push('%')\n            }\n            else if ((match = re.placeholder.exec(_fmt)) !== null) {\n                if (match[2]) {\n                    arg_names |= 1\n                    var field_list = [], replacement_field = match[2], field_match = []\n                    if ((field_match = re.key.exec(replacement_field)) !== null) {\n                        field_list.push(field_match[1])\n                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {\n                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {\n                                field_list.push(field_match[1])\n                            }\n                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {\n                                field_list.push(field_match[1])\n                            }\n                            else {\n                                throw new SyntaxError('[sprintf] failed to parse named argument key')\n                            }\n                        }\n                    }\n                    else {\n                        throw new SyntaxError('[sprintf] failed to parse named argument key')\n                    }\n                    match[2] = field_list\n                }\n                else {\n                    arg_names |= 2\n                }\n                if (arg_names === 3) {\n                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')\n                }\n                parse_tree.push(match)\n            }\n            else {\n                throw new SyntaxError('[sprintf] unexpected placeholder')\n            }\n            _fmt = _fmt.substring(match[0].length)\n        }\n        return sprintf_cache[fmt] = parse_tree\n    }\n\n    /**\n     * export to either browser or node.js\n     */\n    /* eslint-disable quote-props */\n    if (typeof exports !== 'undefined') {\n        exports['sprintf'] = sprintf\n        exports['vsprintf'] = vsprintf\n    }\n    if (typeof window !== 'undefined') {\n        window['sprintf'] = sprintf\n        window['vsprintf'] = vsprintf\n\n        if (typeof define === 'function' && define['amd']) {\n            define(function() {\n                return {\n                    'sprintf': sprintf,\n                    'vsprintf': vsprintf\n                }\n            })\n        }\n    }\n    /* eslint-enable quote-props */\n}()\n","\"use strict\";\n\nconst {\n    LUA_SIGNATURE,\n    LUA_VERSION_MAJOR,\n    LUA_VERSION_MINOR,\n    constant_types: {\n        LUA_TBOOLEAN,\n        LUA_TLNGSTR,\n        LUA_TNIL,\n        LUA_TNUMFLT,\n        LUA_TNUMINT,\n        LUA_TSHRSTR\n    },\n    luastring_of\n} = require('./defs.js');\n\nconst LUAC_DATA    = luastring_of(25, 147, 13, 10, 26, 10);\nconst LUAC_INT     = 0x5678;\nconst LUAC_NUM     = 370.5;\nconst LUAC_VERSION = Number(LUA_VERSION_MAJOR) * 16 + Number(LUA_VERSION_MINOR);\nconst LUAC_FORMAT  = 0;   /* this is the official format */\n\nclass DumpState {\n    constructor() {\n        this.L = null;\n        this.write = null;\n        this.data = null;\n        this.strip = NaN;\n        this.status = NaN;\n    }\n}\n\nconst DumpBlock = function(b, size, D) {\n    if (D.status === 0 && size > 0)\n        D.status = D.writer(D.L, b, size, D.data);\n};\n\nconst DumpByte = function(y, D) {\n    DumpBlock(luastring_of(y), 1, D);\n};\n\nconst DumpInt = function(x, D) {\n    let ab = new ArrayBuffer(4);\n    let dv = new DataView(ab);\n    dv.setInt32(0, x, true);\n    let t = new Uint8Array(ab);\n    DumpBlock(t, 4, D);\n};\n\nconst DumpInteger = function(x, D) {\n    let ab = new ArrayBuffer(4);\n    let dv = new DataView(ab);\n    dv.setInt32(0, x, true);\n    let t = new Uint8Array(ab);\n    DumpBlock(t, 4, D);\n};\n\nconst DumpNumber = function(x, D) {\n    let ab = new ArrayBuffer(8);\n    let dv = new DataView(ab);\n    dv.setFloat64(0, x, true);\n    let t = new Uint8Array(ab);\n    DumpBlock(t, 8, D);\n};\n\nconst DumpString = function(s, D) {\n    if (s === null)\n        DumpByte(0, D);\n    else {\n        let size = s.tsslen() + 1;\n        let str = s.getstr();\n        if (size < 0xFF)\n            DumpByte(size, D);\n        else {\n            DumpByte(0xFF, D);\n            DumpInteger(size, D);\n        }\n        DumpBlock(str, size - 1, D);  /* no need to save '\\0' */\n    }\n};\n\nconst DumpCode = function(f, D) {\n    let s = f.code.map(e => e.code);\n    DumpInt(s.length, D);\n\n    for (let i = 0; i < s.length; i++)\n        DumpInt(s[i], D);\n};\n\nconst DumpConstants = function(f, D) {\n    let n = f.k.length;\n    DumpInt(n, D);\n    for (let i = 0; i < n; i++) {\n        let o = f.k[i];\n        DumpByte(o.ttype(), D);\n        switch (o.ttype()) {\n            case LUA_TNIL:\n                break;\n            case LUA_TBOOLEAN:\n                DumpByte(o.value ? 1 : 0, D);\n                break;\n            case LUA_TNUMFLT:\n                DumpNumber(o.value, D);\n                break;\n            case LUA_TNUMINT:\n                DumpInteger(o.value, D);\n                break;\n            case LUA_TSHRSTR:\n            case LUA_TLNGSTR:\n                DumpString(o.tsvalue(), D);\n                break;\n        }\n    }\n};\n\nconst DumpProtos = function(f, D) {\n    let n = f.p.length;\n    DumpInt(n, D);\n    for (let i = 0; i < n; i++)\n        DumpFunction(f.p[i], f.source, D);\n};\n\nconst DumpUpvalues = function(f, D) {\n    let n = f.upvalues.length;\n    DumpInt(n, D);\n    for (let i = 0; i < n; i++) {\n        DumpByte(f.upvalues[i].instack ? 1 : 0, D);\n        DumpByte(f.upvalues[i].idx, D);\n    }\n};\n\nconst DumpDebug = function(f, D) {\n    let n = D.strip ? 0 : f.lineinfo.length;\n    DumpInt(n, D);\n    for (let i = 0; i < n; i++)\n        DumpInt(f.lineinfo[i], D);\n    n = D.strip ? 0 : f.locvars.length;\n    DumpInt(n, D);\n    for (let i = 0; i < n; i++) {\n        DumpString(f.locvars[i].varname, D);\n        DumpInt(f.locvars[i].startpc, D);\n        DumpInt(f.locvars[i].endpc, D);\n    }\n    n = D.strip ? 0 : f.upvalues.length;\n    DumpInt(n, D);\n    for (let i = 0; i < n; i++)\n        DumpString(f.upvalues[i].name, D);\n};\n\nconst DumpFunction = function(f, psource, D) {\n    if (D.strip || f.source === psource)\n        DumpString(null, D);  /* no debug info or same source as its parent */\n    else\n        DumpString(f.source, D);\n    DumpInt(f.linedefined, D);\n    DumpInt(f.lastlinedefined, D);\n    DumpByte(f.numparams, D);\n    DumpByte(f.is_vararg?1:0, D);\n    DumpByte(f.maxstacksize, D);\n    DumpCode(f, D);\n    DumpConstants(f, D);\n    DumpUpvalues(f, D);\n    DumpProtos(f, D);\n    DumpDebug(f, D);\n};\n\nconst DumpHeader = function(D) {\n    DumpBlock(LUA_SIGNATURE, LUA_SIGNATURE.length, D);\n    DumpByte(LUAC_VERSION, D);\n    DumpByte(LUAC_FORMAT, D);\n    DumpBlock(LUAC_DATA, LUAC_DATA.length, D);\n    DumpByte(4, D); // intSize\n    DumpByte(4, D); // size_tSize\n    DumpByte(4, D); // instructionSize\n    DumpByte(4, D); // integerSize\n    DumpByte(8, D); // numberSize\n    DumpInteger(LUAC_INT, D);\n    DumpNumber(LUAC_NUM, D);\n};\n\n/*\n** dump Lua function as precompiled chunk\n*/\nconst luaU_dump = function(L, f, w, data, strip) {\n    let D = new DumpState();\n    D.L = L;\n    D.writer = w;\n    D.data = data;\n    D.strip = strip;\n    D.status = 0;\n    DumpHeader(D);\n    DumpByte(f.upvalues.length, D);\n    DumpFunction(f, null, D);\n    return D.status;\n};\n\nmodule.exports.luaU_dump = luaU_dump;\n","\"use strict\";\n\nconst {\n    LUA_SIGNATURE,\n    constant_types: {\n        LUA_TBOOLEAN,\n        LUA_TLNGSTR,\n        LUA_TNIL,\n        LUA_TNUMFLT,\n        LUA_TNUMINT,\n        LUA_TSHRSTR\n    },\n    thread_status: { LUA_ERRSYNTAX },\n    is_luastring,\n    luastring_eq,\n    to_luastring\n} = require('./defs.js');\nconst ldo      = require('./ldo.js');\nconst lfunc    = require('./lfunc.js');\nconst lobject  = require('./lobject.js');\nconst {\n    MAXARG_sBx,\n    POS_A,\n    POS_Ax,\n    POS_B,\n    POS_Bx,\n    POS_C,\n    POS_OP,\n    SIZE_A,\n    SIZE_Ax,\n    SIZE_B,\n    SIZE_Bx,\n    SIZE_C,\n    SIZE_OP\n} = require('./lopcodes.js');\nconst { lua_assert } = require(\"./llimits.js\");\nconst { luaS_bless } = require('./lstring.js');\nconst {\n    luaZ_read,\n    ZIO\n} = require('./lzio.js');\n\nlet LUAC_DATA = [0x19, 0x93, 13, 10, 0x1a, 10];\n\nclass BytecodeParser {\n\n    constructor(L, Z, name) {\n        this.intSize = 4;\n        this.size_tSize = 4;\n        this.instructionSize = 4;\n        this.integerSize = 4;\n        this.numberSize = 8;\n\n        lua_assert(Z instanceof ZIO, \"BytecodeParser only operates on a ZIO\");\n        lua_assert(is_luastring(name));\n\n        if (name[0] === 64 /* ('@').charCodeAt(0) */ || name[0] === 61 /* ('=').charCodeAt(0) */)\n            this.name = name.subarray(1);\n        else if (name[0] == LUA_SIGNATURE[0])\n            this.name = to_luastring(\"binary string\", true);\n        else\n            this.name = name;\n\n        this.L = L;\n        this.Z = Z;\n\n        // Used to do buffer to number conversions\n        this.arraybuffer = new ArrayBuffer(\n            Math.max(this.intSize, this.size_tSize, this.instructionSize, this.integerSize, this.numberSize)\n        );\n        this.dv = new DataView(this.arraybuffer);\n        this.u8 = new Uint8Array(this.arraybuffer);\n    }\n\n    read(size) {\n        let u8 = new Uint8Array(size);\n        if(luaZ_read(this.Z, u8, 0, size) !== 0)\n            this.error(\"truncated\");\n        return u8;\n    }\n\n    readByte() {\n        if (luaZ_read(this.Z, this.u8, 0, 1) !== 0)\n            this.error(\"truncated\");\n        return this.u8[0];\n    }\n\n    readInteger() {\n        if (luaZ_read(this.Z, this.u8, 0, this.integerSize) !== 0)\n            this.error(\"truncated\");\n        return this.dv.getInt32(0, true);\n    }\n\n    readSize_t() {\n        return this.readInteger();\n    }\n\n    readInt() {\n        if (luaZ_read(this.Z, this.u8, 0, this.intSize) !== 0)\n            this.error(\"truncated\");\n        return this.dv.getInt32(0, true);\n    }\n\n    readNumber() {\n        if (luaZ_read(this.Z, this.u8, 0, this.numberSize) !== 0)\n            this.error(\"truncated\");\n        return this.dv.getFloat64(0, true);\n    }\n\n    readString() {\n        let size = Math.max(this.readByte() - 1, 0);\n\n        if (size + 1 === 0xFF)\n            size = this.readSize_t() - 1;\n\n        if (size === 0) {\n            return null;\n        }\n\n        return luaS_bless(this.L, this.read(size));\n    }\n\n    /* creates a mask with 'n' 1 bits at position 'p' */\n    static MASK1(n, p) {\n        return ((~((~0)<<(n)))<<(p));\n    }\n\n    /* creates a mask with 'n' 0 bits at position 'p' */\n    static MASK0(n, p) {\n        return (~BytecodeParser.MASK1(n,p));\n    }\n\n    readInstruction() {\n        if (luaZ_read(this.Z, this.u8, 0, this.instructionSize) !== 0)\n            this.error(\"truncated\");\n        return this.dv.getUint32(0, true);\n    }\n\n    readCode(f) {\n        let n = this.readInt();\n        let p = BytecodeParser;\n\n        for (let i = 0; i < n; i++) {\n            let ins = this.readInstruction();\n            f.code[i] = {\n                code:   ins,\n                opcode: (ins >> POS_OP) & p.MASK1(SIZE_OP, 0),\n                A:      (ins >> POS_A)  & p.MASK1(SIZE_A,  0),\n                B:      (ins >> POS_B)  & p.MASK1(SIZE_B,  0),\n                C:      (ins >> POS_C)  & p.MASK1(SIZE_C,  0),\n                Bx:     (ins >> POS_Bx) & p.MASK1(SIZE_Bx, 0),\n                Ax:     (ins >> POS_Ax) & p.MASK1(SIZE_Ax, 0),\n                sBx:    ((ins >> POS_Bx) & p.MASK1(SIZE_Bx, 0)) - MAXARG_sBx\n            };\n        }\n    }\n\n    readUpvalues(f) {\n        let n = this.readInt();\n\n        for (let i = 0; i < n; i++) {\n            f.upvalues[i] = {\n                name:    null,\n                instack: this.readByte(),\n                idx:     this.readByte()\n            };\n        }\n    }\n\n    readConstants(f) {\n        let n = this.readInt();\n\n        for (let i = 0; i < n; i++) {\n            let t = this.readByte();\n\n            switch (t) {\n                case LUA_TNIL:\n                    f.k.push(new lobject.TValue(LUA_TNIL, null));\n                    break;\n                case LUA_TBOOLEAN:\n                    f.k.push(new lobject.TValue(LUA_TBOOLEAN, this.readByte() !== 0));\n                    break;\n                case LUA_TNUMFLT:\n                    f.k.push(new lobject.TValue(LUA_TNUMFLT, this.readNumber()));\n                    break;\n                case LUA_TNUMINT:\n                    f.k.push(new lobject.TValue(LUA_TNUMINT, this.readInteger()));\n                    break;\n                case LUA_TSHRSTR:\n                case LUA_TLNGSTR:\n                    f.k.push(new lobject.TValue(LUA_TLNGSTR, this.readString()));\n                    break;\n                default:\n                    this.error(`unrecognized constant '${t}'`);\n            }\n        }\n    }\n\n    readProtos(f) {\n        let n = this.readInt();\n\n        for (let i = 0; i < n; i++) {\n            f.p[i] = new lfunc.Proto(this.L);\n            this.readFunction(f.p[i], f.source);\n        }\n    }\n\n    readDebug(f) {\n        let n = this.readInt();\n        for (let i = 0; i < n; i++)\n            f.lineinfo[i] = this.readInt();\n\n        n = this.readInt();\n        for (let i = 0; i < n; i++) {\n            f.locvars[i] = {\n                varname: this.readString(),\n                startpc: this.readInt(),\n                endpc:   this.readInt()\n            };\n        }\n\n        n = this.readInt();\n        for (let i = 0; i < n; i++) {\n            f.upvalues[i].name = this.readString();\n        }\n    }\n\n    readFunction(f, psource) {\n        f.source = this.readString();\n        if (f.source === null)  /* no source in dump? */\n            f.source = psource;  /* reuse parent's source */\n        f.linedefined = this.readInt();\n        f.lastlinedefined = this.readInt();\n        f.numparams = this.readByte();\n        f.is_vararg = this.readByte() !== 0;\n        f.maxstacksize = this.readByte();\n        this.readCode(f);\n        this.readConstants(f);\n        this.readUpvalues(f);\n        this.readProtos(f);\n        this.readDebug(f);\n    }\n\n    checkliteral(s, msg) {\n        let buff = this.read(s.length);\n        if (!luastring_eq(buff, s))\n            this.error(msg);\n    }\n\n    checkHeader() {\n        this.checkliteral(LUA_SIGNATURE.subarray(1), \"not a\"); /* 1st char already checked */\n\n        if (this.readByte() !== 0x53)\n            this.error(\"version mismatch in\");\n\n        if (this.readByte() !== 0)\n            this.error(\"format mismatch in\");\n\n        this.checkliteral(LUAC_DATA, \"corrupted\");\n\n        this.intSize         = this.readByte();\n        this.size_tSize      = this.readByte();\n        this.instructionSize = this.readByte();\n        this.integerSize     = this.readByte();\n        this.numberSize      = this.readByte();\n\n        this.checksize(this.intSize, 4, \"int\");\n        this.checksize(this.size_tSize, 4, \"size_t\");\n        this.checksize(this.instructionSize, 4, \"instruction\");\n        this.checksize(this.integerSize, 4, \"integer\");\n        this.checksize(this.numberSize, 8, \"number\");\n\n        if (this.readInteger() !== 0x5678)\n            this.error(\"endianness mismatch in\");\n\n        if (this.readNumber() !== 370.5)\n            this.error(\"float format mismatch in\");\n\n    }\n\n    error(why) {\n        lobject.luaO_pushfstring(this.L, to_luastring(\"%s: %s precompiled chunk\"), this.name, to_luastring(why));\n        ldo.luaD_throw(this.L, LUA_ERRSYNTAX);\n    }\n\n    checksize(byte, size, tname) {\n        if (byte !== size)\n            this.error(`${tname} size mismatch in`);\n    }\n}\n\nconst luaU_undump = function(L, Z, name) {\n    let S = new BytecodeParser(L, Z, name);\n    S.checkHeader();\n    let cl = lfunc.luaF_newLclosure(L, S.readByte());\n    ldo.luaD_inctop(L);\n    L.stack[L.top-1].setclLvalue(cl);\n    cl.p = new lfunc.Proto(L);\n    S.readFunction(cl.p, null);\n    lua_assert(cl.nupvalues === cl.p.upvalues.length);\n    /* luai_verifycode */\n    return cl;\n};\n\nmodule.exports.luaU_undump = luaU_undump;\n","\"use strict\";\n\nconst {\n    LUA_MULTRET,\n    LUA_OPADD,\n    LUA_OPBAND,\n    LUA_OPBNOT,\n    LUA_OPBOR,\n    LUA_OPBXOR,\n    LUA_OPDIV,\n    LUA_OPIDIV,\n    LUA_OPMOD,\n    LUA_OPSHL,\n    LUA_OPSHR,\n    LUA_OPUNM,\n    constant_types: {\n        LUA_TBOOLEAN,\n        LUA_TLIGHTUSERDATA,\n        LUA_TLNGSTR,\n        LUA_TNIL,\n        LUA_TNUMFLT,\n        LUA_TNUMINT,\n        LUA_TTABLE\n    },\n    to_luastring\n} = require('./defs.js');\nconst { lua_assert } = require(\"./llimits.js\");\nconst llex     = require('./llex.js');\nconst lobject  = require('./lobject.js');\nconst lopcodes = require('./lopcodes.js');\nconst lparser  = require('./lparser.js');\nconst ltable   = require('./ltable.js');\nconst lvm      = require('./lvm.js');\n\nconst OpCodesI = lopcodes.OpCodesI;\nconst TValue   = lobject.TValue;\n\n/* Maximum number of registers in a Lua function (must fit in 8 bits) */\nconst MAXREGS = 255;\n\n/*\n** Marks the end of a patch list. It is an invalid value both as an absolute\n** address, and as a list link (would link an element to itself).\n*/\nconst NO_JUMP = -1;\n\nconst BinOpr = {\n    OPR_ADD:      0,\n    OPR_SUB:      1,\n    OPR_MUL:      2,\n    OPR_MOD:      3,\n    OPR_POW:      4,\n    OPR_DIV:      5,\n    OPR_IDIV:     6,\n    OPR_BAND:     7,\n    OPR_BOR:      8,\n    OPR_BXOR:     9,\n    OPR_SHL:      10,\n    OPR_SHR:      11,\n    OPR_CONCAT:   12,\n    OPR_EQ:       13,\n    OPR_LT:       14,\n    OPR_LE:       15,\n    OPR_NE:       16,\n    OPR_GT:       17,\n    OPR_GE:       18,\n    OPR_AND:      19,\n    OPR_OR:       20,\n    OPR_NOBINOPR: 21\n};\n\nconst UnOpr = {\n    OPR_MINUS:    0,\n    OPR_BNOT:     1,\n    OPR_NOT:      2,\n    OPR_LEN:      3,\n    OPR_NOUNOPR:  4\n};\n\nconst hasjumps = function(e) {\n    return e.t !== e.f;\n};\n\n/*\n** If expression is a numeric constant returns either true or a new TValue\n** (depending on 'make_tvalue'). Otherwise, returns false.\n*/\nconst tonumeral = function(e, make_tvalue) {\n    let ek = lparser.expkind;\n    if (hasjumps(e))\n        return false;  /* not a numeral */\n    switch (e.k) {\n        case ek.VKINT:\n            if (make_tvalue) {\n                return new TValue(LUA_TNUMINT, e.u.ival);\n            }\n            return true;\n        case ek.VKFLT:\n            if (make_tvalue) {\n                return new TValue(LUA_TNUMFLT, e.u.nval);\n            }\n            return true;\n        default: return false;\n    }\n};\n\n/*\n** Create a OP_LOADNIL instruction, but try to optimize: if the previous\n** instruction is also OP_LOADNIL and ranges are compatible, adjust\n** range of previous instruction instead of emitting a new one. (For\n** instance, 'local a; local b' will generate a single opcode.)\n*/\nconst luaK_nil = function(fs, from, n) {\n    let previous;\n    let l = from + n - 1;  /* last register to set nil */\n    if (fs.pc > fs.lasttarget) {  /* no jumps to current position? */\n        previous = fs.f.code[fs.pc-1];\n        if (previous.opcode === OpCodesI.OP_LOADNIL) {  /* previous is LOADNIL? */\n            let pfrom = previous.A;  /* get previous range */\n            let pl = pfrom + previous.B;\n            if ((pfrom <= from && from <= pl + 1) ||\n                    (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */\n                if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */\n                if (pl > l) l = pl;  /* l = max(l, pl) */\n                lopcodes.SETARG_A(previous, from);\n                lopcodes.SETARG_B(previous, l - from);\n                return;\n            }\n        }  /* else go through */\n    }\n    luaK_codeABC(fs, OpCodesI.OP_LOADNIL, from, n - 1, 0);  /* else no optimization */\n};\n\nconst getinstruction = function(fs, e) {\n    return fs.f.code[e.u.info];\n};\n\n/*\n** Gets the destination address of a jump instruction. Used to traverse\n** a list of jumps.\n*/\nconst getjump = function(fs, pc) {\n    let offset = fs.f.code[pc].sBx;\n    if (offset === NO_JUMP)  /* point to itself represents end of list */\n        return NO_JUMP;  /* end of list */\n    else\n        return pc + 1 + offset;  /* turn offset into absolute position */\n};\n\n/*\n** Fix jump instruction at position 'pc' to jump to 'dest'.\n** (Jump addresses are relative in Lua)\n*/\nconst fixjump = function(fs, pc, dest) {\n    let jmp = fs.f.code[pc];\n    let offset = dest - (pc + 1);\n    lua_assert(dest !== NO_JUMP);\n    if (Math.abs(offset) > lopcodes.MAXARG_sBx)\n        llex.luaX_syntaxerror(fs.ls, to_luastring(\"control structure too long\", true));\n    lopcodes.SETARG_sBx(jmp, offset);\n};\n\n/*\n** Concatenate jump-list 'l2' into jump-list 'l1'\n*/\nconst luaK_concat = function(fs, l1, l2) {\n    if (l2 === NO_JUMP) return l1;  /* nothing to concatenate? */\n    else if (l1 === NO_JUMP)  /* no original list? */\n        l1 = l2;\n    else {\n        let list = l1;\n        let next = getjump(fs, list);\n        while (next !== NO_JUMP) {  /* find last element */\n            list = next;\n            next = getjump(fs, list);\n        }\n        fixjump(fs, list, l2);\n    }\n\n    return l1;\n};\n\n/*\n** Create a jump instruction and return its position, so its destination\n** can be fixed later (with 'fixjump'). If there are jumps to\n** this position (kept in 'jpc'), link them all together so that\n** 'patchlistaux' will fix all them directly to the final destination.\n*/\nconst luaK_jump = function (fs) {\n    let jpc = fs.jpc;  /* save list of jumps to here */\n    fs.jpc = NO_JUMP;  /* no more jumps to here */\n    let j = luaK_codeAsBx(fs, OpCodesI.OP_JMP, 0, NO_JUMP);\n    j = luaK_concat(fs, j, jpc);  /* keep them on hold */\n    return j;\n};\n\nconst luaK_jumpto = function(fs, t) {\n    return luaK_patchlist(fs, luaK_jump(fs), t);\n};\n\n/*\n** Code a 'return' instruction\n*/\nconst luaK_ret = function(fs, first, nret) {\n    luaK_codeABC(fs, OpCodesI.OP_RETURN, first, nret + 1, 0);\n};\n\n/*\n** Code a \"conditional jump\", that is, a test or comparison opcode\n** followed by a jump. Return jump position.\n*/\nconst condjump = function(fs, op, A, B, C) {\n    luaK_codeABC(fs, op, A, B, C);\n    return luaK_jump(fs);\n};\n\n/*\n** returns current 'pc' and marks it as a jump target (to avoid wrong\n** optimizations with consecutive instructions not in the same basic block).\n*/\nconst luaK_getlabel = function(fs) {\n    fs.lasttarget = fs.pc;\n    return fs.pc;\n};\n\n/*\n** Returns the position of the instruction \"controlling\" a given\n** jump (that is, its condition), or the jump itself if it is\n** unconditional.\n*/\nconst getjumpcontroloffset = function(fs, pc) {\n    if (pc >= 1 && lopcodes.testTMode(fs.f.code[pc - 1].opcode))\n        return pc - 1;\n    else\n        return pc;\n};\nconst getjumpcontrol = function(fs, pc) {\n    return fs.f.code[getjumpcontroloffset(fs, pc)];\n};\n\n/*\n** Patch destination register for a TESTSET instruction.\n** If instruction in position 'node' is not a TESTSET, return 0 (\"fails\").\n** Otherwise, if 'reg' is not 'NO_REG', set it as the destination\n** register. Otherwise, change instruction to a simple 'TEST' (produces\n** no register value)\n*/\nconst patchtestreg = function(fs, node, reg) {\n    let pc = getjumpcontroloffset(fs, node);\n    let i = fs.f.code[pc];\n    if (i.opcode !== OpCodesI.OP_TESTSET)\n        return false;  /* cannot patch other instructions */\n    if (reg !== lopcodes.NO_REG && reg !== i.B)\n        lopcodes.SETARG_A(i, reg);\n    else {\n        /* no register to put value or register already has the value;\n           change instruction to simple test */\n        fs.f.code[pc] = lopcodes.CREATE_ABC(OpCodesI.OP_TEST, i.B, 0, i.C);\n    }\n    return true;\n};\n\n/*\n** Traverse a list of tests ensuring no one produces a value\n*/\nconst removevalues = function(fs, list) {\n    for (; list !== NO_JUMP; list = getjump(fs, list))\n        patchtestreg(fs, list, lopcodes.NO_REG);\n};\n\n/*\n** Traverse a list of tests, patching their destination address and\n** registers: tests producing values jump to 'vtarget' (and put their\n** values in 'reg'), other tests jump to 'dtarget'.\n*/\nconst patchlistaux = function(fs, list, vtarget, reg, dtarget) {\n    while (list !== NO_JUMP) {\n        let next = getjump(fs, list);\n        if (patchtestreg(fs, list, reg))\n            fixjump(fs, list, vtarget);\n        else\n            fixjump(fs, list, dtarget);  /* jump to default target */\n        list = next;\n    }\n};\n\n/*\n** Ensure all pending jumps to current position are fixed (jumping\n** to current position with no values) and reset list of pending\n** jumps\n*/\nconst dischargejpc = function(fs) {\n    patchlistaux(fs, fs.jpc, fs.pc, lopcodes.NO_REG, fs.pc);\n    fs.jpc = NO_JUMP;\n};\n\n/*\n** Add elements in 'list' to list of pending jumps to \"here\"\n** (current position)\n*/\nconst luaK_patchtohere = function(fs, list) {\n    luaK_getlabel(fs);  /* mark \"here\" as a jump target */\n    fs.jpc = luaK_concat(fs, fs.jpc, list);\n};\n\n/*\n** Path all jumps in 'list' to jump to 'target'.\n** (The assert means that we cannot fix a jump to a forward address\n** because we only know addresses once code is generated.)\n*/\nconst luaK_patchlist = function(fs, list, target) {\n    if (target === fs.pc)  /* 'target' is current position? */\n        luaK_patchtohere(fs, list);  /* add list to pending jumps */\n    else {\n        lua_assert(target < fs.pc);\n        patchlistaux(fs, list, target, lopcodes.NO_REG, target);\n    }\n};\n\n/*\n** Path all jumps in 'list' to close upvalues up to given 'level'\n** (The assertion checks that jumps either were closing nothing\n** or were closing higher levels, from inner blocks.)\n*/\nconst luaK_patchclose = function(fs, list, level) {\n    level++;  /* argument is +1 to reserve 0 as non-op */\n    for (; list !== NO_JUMP; list = getjump(fs, list)) {\n        let ins = fs.f.code[list];\n        lua_assert(ins.opcode === OpCodesI.OP_JMP && (ins.A === 0 || ins.A >= level));\n        lopcodes.SETARG_A(ins, level);\n    }\n};\n\n/*\n** Emit instruction 'i', checking for array sizes and saving also its\n** line information. Return 'i' position.\n*/\nconst luaK_code = function(fs, i) {\n    let f = fs.f;\n    dischargejpc(fs);  /* 'pc' will change */\n    /* put new instruction in code array */\n    f.code[fs.pc] = i;\n    f.lineinfo[fs.pc] = fs.ls.lastline;\n    return fs.pc++;\n};\n\n/*\n** Format and emit an 'iABC' instruction. (Assertions check consistency\n** of parameters versus opcode.)\n*/\nconst luaK_codeABC = function(fs, o, a, b, c) {\n    lua_assert(lopcodes.getOpMode(o) === lopcodes.iABC);\n    lua_assert(lopcodes.getBMode(o) !== lopcodes.OpArgN || b === 0);\n    lua_assert(lopcodes.getCMode(o) !== lopcodes.OpArgN || c === 0);\n    lua_assert(a <= lopcodes.MAXARG_A && b <= lopcodes.MAXARG_B && c <= lopcodes.MAXARG_C);\n    return luaK_code(fs, lopcodes.CREATE_ABC(o, a, b, c));\n};\n\n/*\n** Format and emit an 'iABx' instruction.\n*/\nconst luaK_codeABx = function(fs, o, a, bc) {\n    lua_assert(lopcodes.getOpMode(o) === lopcodes.iABx || lopcodes.getOpMode(o) === lopcodes.iAsBx);\n    lua_assert(lopcodes.getCMode(o) === lopcodes.OpArgN);\n    lua_assert(a <= lopcodes.MAXARG_A && bc <= lopcodes.MAXARG_Bx);\n    return luaK_code(fs, lopcodes.CREATE_ABx(o, a, bc));\n};\n\nconst luaK_codeAsBx = function(fs,o,A,sBx) {\n    return luaK_codeABx(fs, o, A, (sBx) + lopcodes.MAXARG_sBx);\n};\n\n/*\n** Emit an \"extra argument\" instruction (format 'iAx')\n*/\nconst codeextraarg = function(fs, a) {\n    lua_assert(a <= lopcodes.MAXARG_Ax);\n    return luaK_code(fs, lopcodes.CREATE_Ax(OpCodesI.OP_EXTRAARG, a));\n};\n\n/*\n** Emit a \"load constant\" instruction, using either 'OP_LOADK'\n** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX'\n** instruction with \"extra argument\".\n*/\nconst luaK_codek = function(fs, reg, k) {\n    if (k <= lopcodes.MAXARG_Bx)\n        return luaK_codeABx(fs, OpCodesI.OP_LOADK, reg, k);\n    else {\n        let p = luaK_codeABx(fs, OpCodesI.OP_LOADKX, reg, 0);\n        codeextraarg(fs, k);\n        return p;\n    }\n};\n\n/*\n** Check register-stack level, keeping track of its maximum size\n** in field 'maxstacksize'\n*/\nconst luaK_checkstack = function(fs, n) {\n    let newstack = fs.freereg + n;\n    if (newstack > fs.f.maxstacksize) {\n        if (newstack >= MAXREGS)\n            llex.luaX_syntaxerror(fs.ls, to_luastring(\"function or expression needs too many registers\", true));\n        fs.f.maxstacksize = newstack;\n    }\n};\n\n/*\n** Reserve 'n' registers in register stack\n*/\nconst luaK_reserveregs = function(fs, n) {\n    luaK_checkstack(fs, n);\n    fs.freereg += n;\n};\n\n/*\n** Free register 'reg', if it is neither a constant index nor\n** a local variable.\n*/\nconst freereg = function(fs, reg) {\n    if (!lopcodes.ISK(reg) && reg >= fs.nactvar) {\n        fs.freereg--;\n        lua_assert(reg === fs.freereg);\n    }\n};\n\n/*\n** Free register used by expression 'e' (if any)\n*/\nconst freeexp = function(fs, e) {\n    if (e.k === lparser.expkind.VNONRELOC)\n        freereg(fs, e.u.info);\n};\n\n/*\n** Free registers used by expressions 'e1' and 'e2' (if any) in proper\n** order.\n*/\nconst freeexps = function(fs, e1, e2) {\n    let r1 = (e1.k === lparser.expkind.VNONRELOC) ? e1.u.info : -1;\n    let r2 = (e2.k === lparser.expkind.VNONRELOC) ? e2.u.info : -1;\n    if (r1 > r2) {\n        freereg(fs, r1);\n        freereg(fs, r2);\n    }\n    else {\n        freereg(fs, r2);\n        freereg(fs, r1);\n    }\n};\n\n\n/*\n** Add constant 'v' to prototype's list of constants (field 'k').\n** Use scanner's table to cache position of constants in constant list\n** and try to reuse constants. Because some values should not be used\n** as keys (nil cannot be a key, integer keys can collapse with float\n** keys), the caller must provide a useful 'key' for indexing the cache.\n*/\nconst addk = function(fs, key, v) {\n    let f = fs.f;\n    let idx = ltable.luaH_set(fs.L, fs.ls.h, key);  /* index scanner table */\n    if (idx.ttisinteger()) {  /* is there an index there? */\n        let k = idx.value;\n        /* correct value? (warning: must distinguish floats from integers!) */\n        if (k < fs.nk && f.k[k].ttype() === v.ttype() && f.k[k].value === v.value)\n            return k;  /* reuse index */\n    }\n    /* constant not found; create a new entry */\n    let k = fs.nk;\n    idx.setivalue(k);\n    f.k[k] = v;\n    fs.nk++;\n    return k;\n};\n\n/*\n** Add a string to list of constants and return its index.\n*/\nconst luaK_stringK = function(fs, s) {\n    let o = new TValue(LUA_TLNGSTR, s);\n    return addk(fs, o, o);  /* use string itself as key */\n};\n\n\n/*\n** Add an integer to list of constants and return its index.\n** Integers use userdata as keys to avoid collision with floats with\n** same value.\n*/\nconst luaK_intK = function(fs, n) {\n    let k = new TValue(LUA_TLIGHTUSERDATA, n);\n    let o = new TValue(LUA_TNUMINT, n);\n    return addk(fs, k, o);\n};\n\n/*\n** Add a float to list of constants and return its index.\n*/\nconst luaK_numberK = function(fs, r) {\n    let o = new TValue(LUA_TNUMFLT, r);\n    return addk(fs, o, o);  /* use number itself as key */\n};\n\n\n/*\n** Add a boolean to list of constants and return its index.\n*/\nconst boolK = function(fs, b) {\n    let o = new TValue(LUA_TBOOLEAN, b);\n    return addk(fs, o, o);  /* use boolean itself as key */\n};\n\n\n/*\n** Add nil to list of constants and return its index.\n*/\nconst nilK = function(fs) {\n    let v = new TValue(LUA_TNIL, null);\n    let k = new TValue(LUA_TTABLE, fs.ls.h);\n    /* cannot use nil as key; instead use table itself to represent nil */\n    return addk(fs, k, v);\n};\n\n/*\n** Fix an expression to return the number of results 'nresults'.\n** Either 'e' is a multi-ret expression (function call or vararg)\n** or 'nresults' is LUA_MULTRET (as any expression can satisfy that).\n*/\nconst luaK_setreturns = function(fs, e, nresults) {\n    let ek = lparser.expkind;\n    if (e.k === ek.VCALL) {  /* expression is an open function call? */\n        lopcodes.SETARG_C(getinstruction(fs, e), nresults + 1);\n    }\n    else if (e.k === ek.VVARARG) {\n        let pc = getinstruction(fs, e);\n        lopcodes.SETARG_B(pc, nresults + 1);\n        lopcodes.SETARG_A(pc, fs.freereg);\n        luaK_reserveregs(fs, 1);\n    }\n    else lua_assert(nresults === LUA_MULTRET);\n};\n\nconst luaK_setmultret = function(fs, e) {\n    luaK_setreturns(fs, e, LUA_MULTRET);\n};\n\n/*\n** Fix an expression to return one result.\n** If expression is not a multi-ret expression (function call or\n** vararg), it already returns one result, so nothing needs to be done.\n** Function calls become VNONRELOC expressions (as its result comes\n** fixed in the base register of the call), while vararg expressions\n** become VRELOCABLE (as OP_VARARG puts its results where it wants).\n** (Calls are created returning one result, so that does not need\n** to be fixed.)\n*/\nconst luaK_setoneret = function(fs, e) {\n    let ek = lparser.expkind;\n    if (e.k === ek.VCALL) {  /* expression is an open function call? */\n        /* already returns 1 value */\n        lua_assert(getinstruction(fs, e).C === 2);\n        e.k = ek.VNONRELOC;  /* result has fixed position */\n        e.u.info = getinstruction(fs, e).A;\n    } else if (e.k === ek.VVARARG) {\n        lopcodes.SETARG_B(getinstruction(fs, e), 2);\n        e.k = ek.VRELOCABLE;  /* can relocate its simple result */\n    }\n};\n\n/*\n** Ensure that expression 'e' is not a variable.\n*/\nconst luaK_dischargevars = function(fs, e) {\n    let ek = lparser.expkind;\n\n    switch (e.k) {\n        case ek.VLOCAL: {  /* already in a register */\n            e.k =  ek.VNONRELOC;  /* becomes a non-relocatable value */\n            break;\n        }\n        case ek.VUPVAL: {  /* move value to some (pending) register */\n            e.u.info = luaK_codeABC(fs, OpCodesI.OP_GETUPVAL, 0, e.u.info, 0);\n            e.k = ek.VRELOCABLE;\n            break;\n        }\n        case ek.VINDEXED: {\n            let op;\n            freereg(fs, e.u.ind.idx);\n            if (e.u.ind.vt === ek.VLOCAL) {  /* is 't' in a register? */\n                freereg(fs, e.u.ind.t);\n                op = OpCodesI.OP_GETTABLE;\n            } else {\n                lua_assert(e.u.ind.vt === ek.VUPVAL);\n                op = OpCodesI.OP_GETTABUP;  /* 't' is in an upvalue */\n            }\n            e.u.info = luaK_codeABC(fs, op, 0, e.u.ind.t, e.u.ind.idx);\n            e.k = ek.VRELOCABLE;\n            break;\n        }\n        case ek.VVARARG: case ek.VCALL: {\n            luaK_setoneret(fs, e);\n            break;\n        }\n        default: break;  /* there is one value available (somewhere) */\n    }\n};\n\nconst code_loadbool = function(fs, A, b, jump) {\n    luaK_getlabel(fs);  /* those instructions may be jump targets */\n    return luaK_codeABC(fs, OpCodesI.OP_LOADBOOL, A, b, jump);\n};\n\n/*\n** Ensures expression value is in register 'reg' (and therefore\n** 'e' will become a non-relocatable expression).\n*/\nconst discharge2reg = function(fs, e, reg) {\n    let ek = lparser.expkind;\n    luaK_dischargevars(fs, e);\n    switch (e.k) {\n        case ek.VNIL: {\n            luaK_nil(fs, reg, 1);\n            break;\n        }\n        case ek.VFALSE: case ek.VTRUE: {\n            luaK_codeABC(fs, OpCodesI.OP_LOADBOOL, reg, e.k === ek.VTRUE, 0);\n            break;\n        }\n        case ek.VK: {\n            luaK_codek(fs, reg, e.u.info);\n            break;\n        }\n        case ek.VKFLT: {\n            luaK_codek(fs, reg, luaK_numberK(fs, e.u.nval));\n            break;\n        }\n        case ek.VKINT: {\n            luaK_codek(fs, reg, luaK_intK(fs, e.u.ival));\n            break;\n        }\n        case ek.VRELOCABLE: {\n            let pc = getinstruction(fs, e);\n            lopcodes.SETARG_A(pc, reg);  /* instruction will put result in 'reg' */\n            break;\n        }\n        case ek.VNONRELOC: {\n            if (reg !== e.u.info)\n                luaK_codeABC(fs, OpCodesI.OP_MOVE, reg, e.u.info, 0);\n            break;\n        }\n        default: {\n            lua_assert(e.k === ek.VJMP);\n            return;  /* nothing to do... */\n        }\n    }\n    e.u.info = reg;\n    e.k = ek.VNONRELOC;\n};\n\n/*\n** Ensures expression value is in any register.\n*/\nconst discharge2anyreg = function(fs, e) {\n    if (e.k !== lparser.expkind.VNONRELOC) {  /* no fixed register yet? */\n        luaK_reserveregs(fs, 1);  /* get a register */\n        discharge2reg(fs, e, fs.freereg-1);  /* put value there */\n    }\n};\n\n/*\n** check whether list has any jump that do not produce a value\n** or produce an inverted value\n*/\nconst need_value = function(fs, list) {\n    for (; list !== NO_JUMP; list = getjump(fs, list)) {\n        let i = getjumpcontrol(fs, list);\n        if (i.opcode !== OpCodesI.OP_TESTSET) return true;\n    }\n    return false;  /* not found */\n};\n\n/*\n** Ensures final expression result (including results from its jump\n** lists) is in register 'reg'.\n** If expression has jumps, need to patch these jumps either to\n** its final position or to \"load\" instructions (for those tests\n** that do not produce values).\n*/\nconst exp2reg = function(fs, e, reg) {\n    let ek = lparser.expkind;\n    discharge2reg(fs, e, reg);\n    if (e.k === ek.VJMP)  /* expression itself is a test? */\n        e.t = luaK_concat(fs, e.t, e.u.info);  /* put this jump in 't' list */\n    if (hasjumps(e)) {\n        let final;  /* position after whole expression */\n        let p_f = NO_JUMP;  /* position of an eventual LOAD false */\n        let p_t = NO_JUMP;  /* position of an eventual LOAD true */\n        if (need_value(fs, e.t) || need_value(fs, e.f)) {\n            let fj = (e.k === ek.VJMP) ? NO_JUMP : luaK_jump(fs);\n            p_f = code_loadbool(fs, reg, 0, 1);\n            p_t = code_loadbool(fs, reg, 1, 0);\n            luaK_patchtohere(fs, fj);\n        }\n        final = luaK_getlabel(fs);\n        patchlistaux(fs, e.f, final, reg, p_f);\n        patchlistaux(fs, e.t, final, reg, p_t);\n    }\n    e.f = e.t = NO_JUMP;\n    e.u.info = reg;\n    e.k = ek.VNONRELOC;\n};\n\n/*\n** Ensures final expression result (including results from its jump\n** lists) is in next available register.\n*/\nconst luaK_exp2nextreg = function(fs, e) {\n    luaK_dischargevars(fs, e);\n    freeexp(fs, e);\n    luaK_reserveregs(fs, 1);\n    exp2reg(fs, e, fs.freereg - 1);\n};\n\n\n/*\n** Ensures final expression result (including results from its jump\n** lists) is in some (any) register and return that register.\n*/\nconst luaK_exp2anyreg = function(fs, e) {\n    luaK_dischargevars(fs, e);\n    if (e.k === lparser.expkind.VNONRELOC) {  /* expression already has a register? */\n        if (!hasjumps(e))  /* no jumps? */\n            return e.u.info;  /* result is already in a register */\n        if (e.u.info >= fs.nactvar) {  /* reg. is not a local? */\n            exp2reg(fs, e, e.u.info);  /* put final result in it */\n            return e.u.info;\n        }\n    }\n    luaK_exp2nextreg(fs, e);  /* otherwise, use next available register */\n    return e.u.info;\n};\n\n/*\n** Ensures final expression result is either in a register or in an\n** upvalue.\n*/\nconst luaK_exp2anyregup = function(fs, e) {\n    if (e.k !== lparser.expkind.VUPVAL || hasjumps(e))\n        luaK_exp2anyreg(fs, e);\n};\n\n/*\n** Ensures final expression result is either in a register or it is\n** a constant.\n*/\nconst luaK_exp2val = function(fs, e) {\n    if (hasjumps(e))\n        luaK_exp2anyreg(fs, e);\n    else\n        luaK_dischargevars(fs, e);\n};\n\n/*\n** Ensures final expression result is in a valid R/K index\n** (that is, it is either in a register or in 'k' with an index\n** in the range of R/K indices).\n** Returns R/K index.\n*/\nconst luaK_exp2RK = function(fs, e) {\n    let ek = lparser.expkind;\n    let vk = false;\n    luaK_exp2val(fs, e);\n    switch (e.k) {  /* move constants to 'k' */\n        case ek.VTRUE: e.u.info = boolK(fs, true); vk = true; break;\n        case ek.VFALSE: e.u.info = boolK(fs, false); vk = true; break;\n        case ek.VNIL: e.u.info = nilK(fs); vk = true; break;\n        case ek.VKINT: e.u.info = luaK_intK(fs, e.u.ival); vk = true; break;\n        case ek.VKFLT: e.u.info = luaK_numberK(fs, e.u.nval); vk = true; break;\n        case ek.VK: vk = true; break;\n        default: break;\n    }\n\n    if (vk) {\n        e.k = ek.VK;\n        if (e.u.info <= lopcodes.MAXINDEXRK)  /* constant fits in 'argC'? */\n            return lopcodes.RKASK(e.u.info);\n    }\n\n    /* not a constant in the right range: put it in a register */\n    return luaK_exp2anyreg(fs, e);\n};\n\n/*\n** Generate code to store result of expression 'ex' into variable 'var'.\n*/\nconst luaK_storevar = function(fs, vr, ex) {\n    let ek = lparser.expkind;\n    switch (vr.k) {\n        case ek.VLOCAL: {\n            freeexp(fs, ex);\n            exp2reg(fs, ex, vr.u.info);  /* compute 'ex' into proper place */\n            return;\n        }\n        case ek.VUPVAL: {\n            let e = luaK_exp2anyreg(fs, ex);\n            luaK_codeABC(fs, OpCodesI.OP_SETUPVAL, e, vr.u.info, 0);\n            break;\n        }\n        case ek.VINDEXED: {\n            let op = (vr.u.ind.vt === ek.VLOCAL) ? OpCodesI.OP_SETTABLE : OpCodesI.OP_SETTABUP;\n            let e = luaK_exp2RK(fs, ex);\n            luaK_codeABC(fs, op, vr.u.ind.t, vr.u.ind.idx, e);\n            break;\n        }\n    }\n    freeexp(fs, ex);\n};\n\n\n/*\n** Emit SELF instruction (convert expression 'e' into 'e:key(e,').\n*/\nconst luaK_self = function(fs, e, key) {\n    luaK_exp2anyreg(fs, e);\n    let ereg = e.u.info;  /* register where 'e' was placed */\n    freeexp(fs, e);\n    e.u.info = fs.freereg;  /* base register for op_self */\n    e.k = lparser.expkind.VNONRELOC;  /* self expression has a fixed register */\n    luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */\n    luaK_codeABC(fs, OpCodesI.OP_SELF, e.u.info, ereg, luaK_exp2RK(fs, key));\n    freeexp(fs, key);\n};\n\n/*\n** Negate condition 'e' (where 'e' is a comparison).\n*/\nconst negatecondition = function(fs, e) {\n    let pc = getjumpcontrol(fs, e.u.info);\n    lua_assert(lopcodes.testTMode(pc.opcode) && pc.opcode !== OpCodesI.OP_TESTSET && pc.opcode !== OpCodesI.OP_TEST);\n    lopcodes.SETARG_A(pc, !(pc.A));\n};\n\n/*\n** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond'\n** is true, code will jump if 'e' is true.) Return jump position.\n** Optimize when 'e' is 'not' something, inverting the condition\n** and removing the 'not'.\n*/\nconst jumponcond = function(fs, e, cond) {\n    if (e.k === lparser.expkind.VRELOCABLE) {\n        let ie = getinstruction(fs, e);\n        if (ie.opcode === OpCodesI.OP_NOT) {\n            fs.pc--;  /* remove previous OP_NOT */\n            return condjump(fs, OpCodesI.OP_TEST, ie.B, 0, !cond);\n        }\n        /* else go through */\n    }\n    discharge2anyreg(fs, e);\n    freeexp(fs, e);\n    return condjump(fs, OpCodesI.OP_TESTSET, lopcodes.NO_REG, e.u.info, cond);\n};\n\n/*\n** Emit code to go through if 'e' is true, jump otherwise.\n*/\nconst luaK_goiftrue = function(fs, e) {\n    let ek = lparser.expkind;\n    let pc;  /* pc of new jump */\n    luaK_dischargevars(fs, e);\n    switch (e.k) {\n        case ek.VJMP: {  /* condition? */\n            negatecondition(fs, e);  /* jump when it is false */\n            pc = e.u.info;  /* save jump position */\n            break;\n        }\n        case ek.VK: case ek.VKFLT: case ek.VKINT: case ek.VTRUE: {\n            pc = NO_JUMP;  /* always true; do nothing */\n            break;\n        }\n        default: {\n            pc = jumponcond(fs, e, 0);  /* jump when false */\n            break;\n        }\n    }\n    e.f = luaK_concat(fs, e.f, pc);  /* insert new jump in false list */\n    luaK_patchtohere(fs, e.t);  /* true list jumps to here (to go through) */\n    e.t = NO_JUMP;\n};\n\n/*\n** Emit code to go through if 'e' is false, jump otherwise.\n*/\nconst luaK_goiffalse = function(fs, e) {\n    let ek = lparser.expkind;\n    let pc;  /* pc of new jump */\n    luaK_dischargevars(fs, e);\n    switch (e.k) {\n        case ek.VJMP: {\n            pc = e.u.info;  /* already jump if true */\n            break;\n        }\n        case ek.VNIL: case ek.VFALSE: {\n            pc = NO_JUMP;  /* always false; do nothing */\n            break;\n        }\n        default: {\n            pc = jumponcond(fs, e, 1);  /* jump if true */\n            break;\n        }\n    }\n    e.t = luaK_concat(fs, e.t, pc);  /* insert new jump in 't' list */\n    luaK_patchtohere(fs, e.f);  /* false list jumps to here (to go through) */\n    e.f = NO_JUMP;\n};\n\n/*\n** Code 'not e', doing constant folding.\n*/\nconst codenot = function(fs, e) {\n    let ek = lparser.expkind;\n    luaK_dischargevars(fs, e);\n    switch (e.k) {\n        case ek.VNIL: case ek.VFALSE: {\n            e.k = ek.VTRUE;  /* true === not nil === not false */\n            break;\n        }\n        case ek.VK: case ek.VKFLT: case ek.VKINT: case ek.VTRUE: {\n            e.k = ek.VFALSE;  /* false === not \"x\" === not 0.5 === not 1 === not true */\n            break;\n        }\n        case ek.VJMP: {\n            negatecondition(fs, e);\n            break;\n        }\n        case ek.VRELOCABLE:\n        case ek.VNONRELOC: {\n            discharge2anyreg(fs, e);\n            freeexp(fs, e);\n            e.u.info = luaK_codeABC(fs, OpCodesI.OP_NOT, 0, e.u.info, 0);\n            e.k = ek.VRELOCABLE;\n            break;\n        }\n    }\n    /* interchange true and false lists */\n    { let temp = e.f; e.f = e.t; e.t = temp; }\n    removevalues(fs, e.f);  /* values are useless when negated */\n    removevalues(fs, e.t);\n};\n\n/*\n** Create expression 't[k]'. 't' must have its final result already in a\n** register or upvalue.\n*/\nconst luaK_indexed = function(fs, t, k) {\n    let ek = lparser.expkind;\n    lua_assert(!hasjumps(t) && (lparser.vkisinreg(t.k) || t.k === ek.VUPVAL));\n    t.u.ind.t = t.u.info;  /* register or upvalue index */\n    t.u.ind.idx = luaK_exp2RK(fs, k);  /* R/K index for key */\n    t.u.ind.vt = (t.k === ek.VUPVAL) ? ek.VUPVAL : ek.VLOCAL;\n    t.k = ek.VINDEXED;\n};\n\n/*\n** Return false if folding can raise an error.\n** Bitwise operations need operands convertible to integers; division\n** operations cannot have 0 as divisor.\n*/\nconst validop = function(op, v1, v2) {\n    switch (op) {\n        case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:\n        case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */\n            return (lvm.tointeger(v1) !== false && lvm.tointeger(v2) !== false);\n        }\n        case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD:  /* division by 0 */\n            return (v2.value !== 0);\n        default: return 1;  /* everything else is valid */\n    }\n};\n\n/*\n** Try to \"constant-fold\" an operation; return 1 iff successful.\n** (In this case, 'e1' has the final result.)\n*/\nconst constfolding = function(op, e1, e2) {\n    let ek = lparser.expkind;\n    let v1, v2;\n    if (!(v1 = tonumeral(e1, true)) || !(v2 = tonumeral(e2, true)) || !validop(op, v1, v2))\n        return 0;  /* non-numeric operands or not safe to fold */\n    let res = new TValue(); /* FIXME */\n    lobject.luaO_arith(null, op, v1, v2, res);  /* does operation */\n    if (res.ttisinteger()) {\n        e1.k = ek.VKINT;\n        e1.u.ival = res.value;\n    }\n    else {  /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */\n        let n = res.value;\n        if (isNaN(n) || n === 0)\n            return false;\n        e1.k = ek.VKFLT;\n        e1.u.nval = n;\n    }\n    return true;\n};\n\n/*\n** Emit code for unary expressions that \"produce values\"\n** (everything but 'not').\n** Expression to produce final result will be encoded in 'e'.\n*/\nconst codeunexpval = function(fs, op, e, line) {\n    let r = luaK_exp2anyreg(fs, e);  /* opcodes operate only on registers */\n    freeexp(fs, e);\n    e.u.info = luaK_codeABC(fs, op, 0, r, 0);  /* generate opcode */\n    e.k = lparser.expkind.VRELOCABLE;  /* all those operations are relocatable */\n    luaK_fixline(fs, line);\n};\n\n/*\n** Emit code for binary expressions that \"produce values\"\n** (everything but logical operators 'and'/'or' and comparison\n** operators).\n** Expression to produce final result will be encoded in 'e1'.\n** Because 'luaK_exp2RK' can free registers, its calls must be\n** in \"stack order\" (that is, first on 'e2', which may have more\n** recent registers to be released).\n*/\nconst codebinexpval = function(fs, op, e1, e2, line) {\n    let rk2 = luaK_exp2RK(fs, e2);  /* both operands are \"RK\" */\n    let rk1 = luaK_exp2RK(fs, e1);\n    freeexps(fs, e1, e2);\n    e1.u.info = luaK_codeABC(fs, op, 0, rk1, rk2);  /* generate opcode */\n    e1.k = lparser.expkind.VRELOCABLE;  /* all those operations are relocatable */\n    luaK_fixline(fs, line);\n};\n\n\n/*\n** Emit code for comparisons.\n** 'e1' was already put in R/K form by 'luaK_infix'.\n*/\nconst codecomp = function(fs, opr, e1, e2) {\n    let ek = lparser.expkind;\n\n    let rk1;\n    if (e1.k === ek.VK)\n        rk1 = lopcodes.RKASK(e1.u.info);\n    else {\n        lua_assert(e1.k === ek.VNONRELOC);\n        rk1 = e1.u.info;\n    }\n\n    let rk2 = luaK_exp2RK(fs, e2);\n    freeexps(fs, e1, e2);\n    switch (opr) {\n        case BinOpr.OPR_NE: {  /* '(a ~= b)' ==> 'not (a === b)' */\n            e1.u.info = condjump(fs, OpCodesI.OP_EQ, 0, rk1, rk2);\n            break;\n        }\n        case BinOpr.OPR_GT: case BinOpr.OPR_GE: {\n            /* '(a > b)' ==> '(b < a)';  '(a >= b)' ==> '(b <= a)' */\n            let op = (opr - BinOpr.OPR_NE) + OpCodesI.OP_EQ;\n            e1.u.info = condjump(fs, op, 1, rk2, rk1);  /* invert operands */\n            break;\n        }\n        default: {  /* '==', '<', '<=' use their own opcodes */\n            let op = (opr - BinOpr.OPR_EQ) + OpCodesI.OP_EQ;\n            e1.u.info = condjump(fs, op, 1, rk1, rk2);\n            break;\n        }\n    }\n    e1.k = ek.VJMP;\n};\n\n/*\n** Apply prefix operation 'op' to expression 'e'.\n*/\nconst luaK_prefix = function(fs, op, e, line) {\n    let ef = new lparser.expdesc();\n    ef.k = lparser.expkind.VKINT;\n    ef.u.ival = ef.u.nval = ef.u.info = 0;\n    ef.t = NO_JUMP;\n    ef.f = NO_JUMP;\n    switch (op) {\n        case UnOpr.OPR_MINUS: case UnOpr.OPR_BNOT:  /* use 'ef' as fake 2nd operand */\n            if (constfolding(op + LUA_OPUNM, e, ef))\n                break;\n            /* FALLTHROUGH */\n        case UnOpr.OPR_LEN:\n            codeunexpval(fs, op + OpCodesI.OP_UNM, e, line);\n            break;\n        case UnOpr.OPR_NOT: codenot(fs, e); break;\n    }\n};\n\n/*\n** Process 1st operand 'v' of binary operation 'op' before reading\n** 2nd operand.\n*/\nconst luaK_infix = function(fs, op, v) {\n    switch (op) {\n        case BinOpr.OPR_AND: {\n            luaK_goiftrue(fs, v);  /* go ahead only if 'v' is true */\n            break;\n        }\n        case BinOpr.OPR_OR: {\n            luaK_goiffalse(fs, v);  /* go ahead only if 'v' is false */\n            break;\n        }\n        case BinOpr.OPR_CONCAT: {\n            luaK_exp2nextreg(fs, v);  /* operand must be on the 'stack' */\n            break;\n        }\n        case BinOpr.OPR_ADD: case BinOpr.OPR_SUB:\n        case BinOpr.OPR_MUL: case BinOpr.OPR_DIV: case BinOpr.OPR_IDIV:\n        case BinOpr.OPR_MOD: case BinOpr.OPR_POW:\n        case BinOpr.OPR_BAND: case BinOpr.OPR_BOR: case BinOpr.OPR_BXOR:\n        case BinOpr.OPR_SHL: case BinOpr.OPR_SHR: {\n            if (!tonumeral(v, false))\n                luaK_exp2RK(fs, v);\n            /* else keep numeral, which may be folded with 2nd operand */\n            break;\n        }\n        default: {\n            luaK_exp2RK(fs, v);\n            break;\n        }\n    }\n};\n\n/*\n** Finalize code for binary operation, after reading 2nd operand.\n** For '(a .. b .. c)' (which is '(a .. (b .. c))', because\n** concatenation is right associative), merge second CONCAT into first\n** one.\n*/\nconst luaK_posfix = function(fs, op, e1, e2, line) {\n    let ek = lparser.expkind;\n    switch (op) {\n        case BinOpr.OPR_AND: {\n            lua_assert(e1.t === NO_JUMP);  /* list closed by 'luK_infix' */\n            luaK_dischargevars(fs, e2);\n            e2.f = luaK_concat(fs, e2.f, e1.f);\n            e1.to(e2);\n            break;\n        }\n        case BinOpr.OPR_OR: {\n            lua_assert(e1.f === NO_JUMP);  /* list closed by 'luK_infix' */\n            luaK_dischargevars(fs, e2);\n            e2.t = luaK_concat(fs, e2.t, e1.t);\n            e1.to(e2);\n            break;\n        }\n        case BinOpr.OPR_CONCAT: {\n            luaK_exp2val(fs, e2);\n            let ins = getinstruction(fs, e2);\n            if (e2.k === ek.VRELOCABLE && ins.opcode === OpCodesI.OP_CONCAT) {\n                lua_assert(e1.u.info === ins.B - 1);\n                freeexp(fs, e1);\n                lopcodes.SETARG_B(ins, e1.u.info);\n                e1.k = ek.VRELOCABLE; e1.u.info = e2.u.info;\n            }\n            else {\n                luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */\n                codebinexpval(fs, OpCodesI.OP_CONCAT, e1, e2, line);\n            }\n            break;\n        }\n        case BinOpr.OPR_ADD: case BinOpr.OPR_SUB: case BinOpr.OPR_MUL: case BinOpr.OPR_DIV:\n        case BinOpr.OPR_IDIV: case BinOpr.OPR_MOD: case BinOpr.OPR_POW:\n        case BinOpr.OPR_BAND: case BinOpr.OPR_BOR: case BinOpr.OPR_BXOR:\n        case BinOpr.OPR_SHL: case BinOpr.OPR_SHR: {\n            if (!constfolding(op + LUA_OPADD, e1, e2))\n                codebinexpval(fs, op + OpCodesI.OP_ADD, e1, e2, line);\n            break;\n        }\n        case BinOpr.OPR_EQ: case BinOpr.OPR_LT: case BinOpr.OPR_LE:\n        case BinOpr.OPR_NE: case BinOpr.OPR_GT: case BinOpr.OPR_GE: {\n            codecomp(fs, op, e1, e2);\n            break;\n        }\n    }\n\n    return e1;\n};\n\n/*\n** Change line information associated with current position.\n*/\nconst luaK_fixline = function(fs, line) {\n    fs.f.lineinfo[fs.pc - 1] = line;\n};\n\n/*\n** Emit a SETLIST instruction.\n** 'base' is register that keeps table;\n** 'nelems' is #table plus those to be stored now;\n** 'tostore' is number of values (in registers 'base + 1',...) to add to\n** table (or LUA_MULTRET to add up to stack top).\n*/\nconst luaK_setlist = function(fs, base, nelems, tostore) {\n    let c =  (nelems - 1)/lopcodes.LFIELDS_PER_FLUSH + 1;\n    let b = (tostore === LUA_MULTRET) ? 0 : tostore;\n    lua_assert(tostore !== 0 && tostore <= lopcodes.LFIELDS_PER_FLUSH);\n    if (c <= lopcodes.MAXARG_C)\n        luaK_codeABC(fs, OpCodesI.OP_SETLIST, base, b, c);\n    else if (c <= lopcodes.MAXARG_Ax) {\n        luaK_codeABC(fs, OpCodesI.OP_SETLIST, base, b, 0);\n        codeextraarg(fs, c);\n    }\n    else\n        llex.luaX_syntaxerror(fs.ls, to_luastring(\"constructor too long\", true));\n    fs.freereg = base + 1;  /* free registers with list values */\n};\n\n\nmodule.exports.BinOpr             = BinOpr;\nmodule.exports.NO_JUMP            = NO_JUMP;\nmodule.exports.UnOpr              = UnOpr;\nmodule.exports.getinstruction     = getinstruction;\nmodule.exports.luaK_checkstack    = luaK_checkstack;\nmodule.exports.luaK_code          = luaK_code;\nmodule.exports.luaK_codeABC       = luaK_codeABC;\nmodule.exports.luaK_codeABx       = luaK_codeABx;\nmodule.exports.luaK_codeAsBx      = luaK_codeAsBx;\nmodule.exports.luaK_codek         = luaK_codek;\nmodule.exports.luaK_concat        = luaK_concat;\nmodule.exports.luaK_dischargevars = luaK_dischargevars;\nmodule.exports.luaK_exp2RK        = luaK_exp2RK;\nmodule.exports.luaK_exp2anyreg    = luaK_exp2anyreg;\nmodule.exports.luaK_exp2anyregup  = luaK_exp2anyregup;\nmodule.exports.luaK_exp2nextreg   = luaK_exp2nextreg;\nmodule.exports.luaK_exp2val       = luaK_exp2val;\nmodule.exports.luaK_fixline       = luaK_fixline;\nmodule.exports.luaK_getlabel      = luaK_getlabel;\nmodule.exports.luaK_goiffalse     = luaK_goiffalse;\nmodule.exports.luaK_goiftrue      = luaK_goiftrue;\nmodule.exports.luaK_indexed       = luaK_indexed;\nmodule.exports.luaK_infix         = luaK_infix;\nmodule.exports.luaK_intK          = luaK_intK;\nmodule.exports.luaK_jump          = luaK_jump;\nmodule.exports.luaK_jumpto        = luaK_jumpto;\nmodule.exports.luaK_nil           = luaK_nil;\nmodule.exports.luaK_numberK       = luaK_numberK;\nmodule.exports.luaK_patchclose    = luaK_patchclose;\nmodule.exports.luaK_patchlist     = luaK_patchlist;\nmodule.exports.luaK_patchtohere   = luaK_patchtohere;\nmodule.exports.luaK_posfix        = luaK_posfix;\nmodule.exports.luaK_prefix        = luaK_prefix;\nmodule.exports.luaK_reserveregs   = luaK_reserveregs;\nmodule.exports.luaK_ret           = luaK_ret;\nmodule.exports.luaK_self          = luaK_self;\nmodule.exports.luaK_setlist       = luaK_setlist;\nmodule.exports.luaK_setmultret    = luaK_setmultret;\nmodule.exports.luaK_setoneret     = luaK_setoneret;\nmodule.exports.luaK_setreturns    = luaK_setreturns;\nmodule.exports.luaK_storevar      = luaK_storevar;\nmodule.exports.luaK_stringK       = luaK_stringK;\n","\"use strict\";\n\nimport {\n\tFENGARI_AUTHORS,\n\tFENGARI_COPYRIGHT,\n\tFENGARI_RELEASE,\n\tFENGARI_VERSION,\n\tFENGARI_VERSION_MAJOR,\n\tFENGARI_VERSION_MINOR,\n\tFENGARI_VERSION_NUM,\n\tFENGARI_VERSION_RELEASE,\n\n\tluastring_eq,\n\tluastring_indexOf,\n\tluastring_of,\n\tto_jsstring,\n\tto_luastring,\n\tto_uristring,\n\n\tlua,\n\tlauxlib,\n\tlualib\n} from 'fengari';\nimport * as interop from 'fengari-interop';\n\nconst {\n\tLUA_ERRRUN,\n\tLUA_ERRSYNTAX,\n\tLUA_OK,\n\tLUA_VERSION_MAJOR,\n\tLUA_VERSION_MINOR,\n\tlua_Debug,\n\tlua_getinfo,\n\tlua_getstack,\n\tlua_gettop,\n\tlua_insert,\n\tlua_pcall,\n\tlua_pop,\n\tlua_pushcfunction,\n\tlua_pushstring,\n\tlua_remove,\n\tlua_setglobal,\n\tlua_tojsstring\n} = lua;\nconst {\n\tluaL_loadbuffer,\n\tluaL_newstate,\n\tluaL_requiref\n} = lauxlib;\nconst {\n\tcheckjs,\n\tluaopen_js,\n\tpush,\n\ttojs\n} = interop;\n\nexport {\n\tFENGARI_AUTHORS,\n\tFENGARI_COPYRIGHT,\n\tFENGARI_RELEASE,\n\tFENGARI_VERSION,\n\tFENGARI_VERSION_MAJOR,\n\tFENGARI_VERSION_MINOR,\n\tFENGARI_VERSION_NUM,\n\tFENGARI_VERSION_RELEASE,\n\n\tluastring_eq,\n\tluastring_indexOf,\n\tluastring_of,\n\tto_jsstring,\n\tto_luastring,\n\tto_uristring,\n\n\tlua,\n\tlauxlib,\n\tlualib,\n\tinterop\n};\n\nexport const L = luaL_newstate();\n\n/* open standard libraries */\nlualib.luaL_openlibs(L);\nluaL_requiref(L, to_luastring(\"js\"), luaopen_js, 1);\nlua_pop(L, 1); /* remove lib */\n\nlua_pushstring(L, to_luastring(FENGARI_COPYRIGHT));\nlua_setglobal(L, to_luastring(\"_COPYRIGHT\"));\n\n/* Helper function to load a JS string of Lua source */\nexport function load(source, chunkname) {\n\tif (typeof source == \"string\")\n\t\tsource = to_luastring(source);\n\telse if (!(source instanceof Uint8Array))\n\t\tthrow new TypeError(\"expects an array of bytes or javascript string\");\n\n\tchunkname = chunkname?to_luastring(chunkname):null;\n\tlet ok = luaL_loadbuffer(L, source, null, chunkname);\n\tlet res;\n\tif (ok === LUA_ERRSYNTAX) {\n\t\tres = new SyntaxError(lua_tojsstring(L, -1));\n\t} else {\n\t\tres = tojs(L, -1);\n\t}\n\tlua_pop(L, 1);\n\tif (ok !== LUA_OK) {\n\t\tthrow res;\n\t}\n\treturn res;\n}\n\nif (typeof document !== 'undefined' && document instanceof HTMLDocument) {\n\t/* Have a document, e.g. we are in main browser window */\n\n\tconst crossorigin_to_credentials = function(crossorigin) {\n\t\tswitch(crossorigin) {\n\t\t\tcase \"anonymous\": return \"omit\";\n\t\t\tcase \"use-credentials\": return \"include\";\n\t\t\tdefault: return \"same-origin\";\n\t\t}\n\t};\n\n\tconst msghandler = function(L) {\n\t\tlet ar = new lua_Debug();\n\t\tif (lua_getstack(L, 2, ar))\n\t\t\tlua_getinfo(L, to_luastring(\"Sl\"), ar);\n\t\tpush(L, new ErrorEvent(\"error\", {\n\t\t\tbubbles: true,\n\t\t\tcancelable: true,\n\t\t\tmessage: lua_tojsstring(L, 1),\n\t\t\terror: tojs(L, 1),\n\t\t\tfilename: ar.short_src ? to_jsstring(ar.short_src) : void 0,\n\t\t\tlineno: ar.currentline > 0 ? ar.currentline : void 0\n\t\t}));\n\t\treturn 1;\n\t};\n\n\tconst run_lua_script = function(tag, code, chunkname) {\n\t\tlet ok = luaL_loadbuffer(L, code, null, chunkname);\n\t\tlet e;\n\t\tif (ok === LUA_ERRSYNTAX) {\n\t\t\tlet msg = lua_tojsstring(L, -1);\n\t\t\tlet filename = tag.src?tag.src:document.location;\n\t\t\tlet lineno = void 0; /* TODO: extract out of msg */\n\t\t\tlet syntaxerror = new SyntaxError(msg, filename, lineno);\n\t\t\te = new ErrorEvent(\"error\", {\n\t\t\t\tmessage: msg,\n\t\t\t\terror: syntaxerror,\n\t\t\t\tfilename: filename,\n\t\t\t\tlineno: lineno\n\t\t\t});\n\t\t} else if (ok === LUA_OK) {\n\t\t\t/* insert message handler below function */\n\t\t\tlet base = lua_gettop(L);\n\t\t\tlua_pushcfunction(L, msghandler);\n\t\t\tlua_insert(L, base);\n\t\t\t/* set document.currentScript.\n\t\t\t   We can't set it normally; but we can create a getter for it, then remove the getter */\n\t\t\tObject.defineProperty(document, 'currentScript', {\n\t\t\t\tvalue: tag,\n\t\t\t\tconfigurable: true\n\t\t\t});\n\t\t\tok = lua_pcall(L, 0, 0, base);\n\t\t\t/* Remove the currentScript getter installed above; this restores normal behaviour */\n\t\t\tdelete document.currentScript;\n\t\t\t/* Remove message handler */\n\t\t\tlua_remove(L, base);\n\t\t\t/* Check if normal error that msghandler would have handled */\n\t\t\tif (ok === LUA_ERRRUN) {\n\t\t\t\te = checkjs(L, -1);\n\t\t\t}\n\t\t}\n\t\tif (ok !== LUA_OK) {\n\t\t\tif (e === void 0) {\n\t\t\t\te = new ErrorEvent(\"error\", {\n\t\t\t\t\tmessage: lua_tojsstring(L, -1),\n\t\t\t\t\terror: tojs(L, -1)\n\t\t\t\t});\n\t\t\t}\n\t\t\tlua_pop(L, 1);\n\t\t\tif (window.dispatchEvent(e)) {\n\t\t\t\tconsole.error(\"uncaught exception\", e.error);\n\t\t\t}\n\t\t}\n\t};\n\n\tconst process_xhr_response = function(xhr, tag, chunkname) {\n\t\tif (xhr.status >= 200 && xhr.status < 300) {\n\t\t\tlet code = xhr.response;\n\t\t\tif (typeof code === \"string\") {\n\t\t\t\tcode = to_luastring(xhr.response);\n\t\t\t} else { /* is an array buffer */\n\t\t\t\tcode = new Uint8Array(code);\n\t\t\t}\n\t\t\t/* TODO: subresource integrity check? */\n\t\t\trun_lua_script(tag, code, chunkname);\n\t\t} else {\n\t\t\ttag.dispatchEvent(new Event(\"error\"));\n\t\t}\n\t};\n\n\tconst run_lua_script_tag = function(tag) {\n\t\tif (tag.src) {\n\t\t\tlet chunkname = to_luastring(\"@\"+tag.src);\n\t\t\t/* JS script tags are async after document has loaded */\n\t\t\tif (document.readyState === \"complete\" || tag.async) {\n\t\t\t\tif (typeof fetch === \"function\") {\n\t\t\t\t\tfetch(tag.src, {\n\t\t\t\t\t\tmethod: \"GET\",\n\t\t\t\t\t\tcredentials: crossorigin_to_credentials(tag.crossorigin),\n\t\t\t\t\t\tredirect: \"follow\",\n\t\t\t\t\t\tintegrity: tag.integrity\n\t\t\t\t\t}).then(function(resp) {\n\t\t\t\t\t\tif (resp.ok) {\n\t\t\t\t\t\t\treturn resp.arrayBuffer();\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthrow new Error(\"unable to fetch\");\n\t\t\t\t\t\t}\n\t\t\t\t\t}).then(function(buffer) {\n\t\t\t\t\t\tlet code = new Uint8Array(buffer);\n\t\t\t\t\t\trun_lua_script(tag, code, chunkname);\n\t\t\t\t\t}).catch(function(reason) {\n\t\t\t\t\t\ttag.dispatchEvent(new Event(\"error\"));\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tlet xhr = new XMLHttpRequest();\n\t\t\t\t\txhr.open(\"GET\", tag.src, true);\n\t\t\t\t\txhr.responseType = \"arraybuffer\";\n\t\t\t\t\txhr.onreadystatechange = function() {\n\t\t\t\t\t\tif (xhr.readyState === 4)\n\t\t\t\t\t\t\tprocess_xhr_response(xhr, tag, chunkname);\n\t\t\t\t\t};\n\t\t\t\t\txhr.send();\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t/* Needs to be synchronous: use an XHR */\n\t\t\t\tlet xhr = new XMLHttpRequest();\n\t\t\t\txhr.open(\"GET\", tag.src, false);\n\t\t\t\txhr.send();\n\t\t\t\tprocess_xhr_response(xhr, tag, chunkname);\n\t\t\t}\n\t\t} else {\n\t\t\tlet code = to_luastring(tag.innerHTML);\n\t\t\tlet chunkname = tag.id ? to_luastring(\"=\"+tag.id) : code;\n\t\t\trun_lua_script(tag, code, chunkname);\n\t\t}\n\t};\n\n\tconst contentTypeRegexp = /^(.*?\\/.*?)([\\t ]*;.*)?$/;\n\tconst luaVersionRegex = /^(\\d+)\\.(\\d+)$/;\n\tconst try_tag = function(tag) {\n\t\tif (tag.tagName !== \"SCRIPT\")\n\t\t\treturn;\n\n\t\t/* strip off mime type parameters */\n\t\tlet contentTypeMatch = contentTypeRegexp.exec(tag.type);\n\t\tif (!contentTypeMatch)\n\t\t\treturn;\n\t\tlet mimetype = contentTypeMatch[1];\n\t\tif (mimetype !== \"application/lua\" && mimetype !== \"text/lua\")\n\t\t\treturn;\n\n\t\tif (tag.hasAttribute(\"lua-version\")) {\n\t\t\tlet lua_version = luaVersionRegex.exec(tag.getAttribute(\"lua-version\"));\n\t\t\tif (!lua_version || lua_version[1] !== LUA_VERSION_MAJOR || lua_version[2] !== LUA_VERSION_MINOR)\n\t\t\t\treturn;\n\t\t}\n\n\t\trun_lua_script_tag(tag);\n\t};\n\n\tif (typeof MutationObserver !== 'undefined') {\n\t\t/* watch for new script tags added to document */\n\t\t(new MutationObserver(function(records, observer) {\n\t\t\tfor (let i=0; i<records.length; i++) {\n\t\t\t\tlet record = records[i];\n\t\t\t\tfor (let j=0; j<record.addedNodes.length; j++) {\n\t\t\t\t\ttry_tag(record.addedNodes[j]);\n\t\t\t\t}\n\t\t\t}\n\t\t})).observe(document, {\n\t\t\tchildList: true,\n\t\t\tsubtree: true\n\t\t});\n\t} else if (console.warn) {\n\t\tconsole.warn(\"fengari-web: MutationObserver not found; lua script tags will not be run when inserted\");\n\t}\n\n\t/* the query selector here is slightly liberal,\n\t   more checks occur in try_tag */\n\tconst selector = 'script[type^=\"application/lua\"], script[type^=\"text/lua\"]';\n\n\t/* try to run existing script tags */\n\tArray.prototype.forEach.call(document.querySelectorAll(selector), try_tag);\n}\n"],"sourceRoot":""}