{"version":3,"sources":["webpack:///./node_modules/moo/moo.js"],"names":["this","hasOwnProperty","Object","prototype","toString","hasSticky","RegExp","sticky","isRegExp","o","call","isObject","Array","isArray","reEscape","s","replace","reGroups","re","exec","length","reCapture","reUnion","regexps","source","map","join","regexpOrLiteral","obj","ignoreCase","Error","global","multiline","objectToRules","object","keys","getOwnPropertyNames","result","i","key","thing","rules","concat","match","forEach","rule","push","ruleOptions","j","include","arrayToRules","array","type","JSON","stringify","options","defaultType","lineBreaks","error","fallback","pop","next","value","shouldThrow","sort","a","b","toRules","spec","defaultErrorRule","compileRules","hasStates","errorRule","fast","create","fastAllowed","unicodeFlag","groups","parts","slice","word","shift","charCodeAt","unicode","pat","regexp","test","groupCount","fallbackRule","flags","suffix","combined","compile","Lexer","start","checkStateGroup","g","name","state","compileStates","states","all","$all","ruleMap","included","splice","newRules","k","newRule","indexOf","apply","fastKeys","keywordTransform","reverseMap","byLength","types","tokenType","item","keywordList","keyword","str","x","keywords","Function","startState","buffer","stack","reset","data","info","index","line","col","queuedToken","queuedThrow","setState","save","popState","pushState","eat","tokenToString","_getGroup","undefined","queuedGroup","token","_token","queuedText","group","charAt","lastIndex","text","offset","matchNL","nl","size","formatError","Symbol","iterator","LexerIterator","lexer","done","message","Math","max","eol","firstLine","substring","clone","has","freeze"],"mappings":"8FAAA,yBAEI,EAAO,GAAI,EAAF,EAAS,kEAFtB,CAQEA,GAAM,WACN,aAEA,IAAIC,EAAiBC,OAAOC,UAAUF,eAClCG,EAAWF,OAAOC,UAAUC,SAC5BC,EAA2C,mBAAxB,IAAIC,QAASC,OAIpC,SAASC,EAASC,GAAK,OAAOA,GAA0B,oBAArBL,EAASM,KAAKD,GACjD,SAASE,EAASF,GAAK,OAAOA,GAAkB,kBAANA,IAAmBD,EAASC,KAAOG,MAAMC,QAAQJ,GAE3F,SAASK,EAASC,GAChB,OAAOA,EAAEC,QAAQ,yBAA0B,QAE7C,SAASC,EAASF,GAChB,IAAIG,EAAK,IAAIZ,OAAO,IAAMS,GAC1B,OAAOG,EAAGC,KAAK,IAAIC,OAAS,EAE9B,SAASC,EAAUN,GACjB,MAAO,IAAMA,EAAI,IAEnB,SAASO,EAAQC,GACf,IAAKA,EAAQH,OAAQ,MAAO,OAC5B,IAAII,EAAUD,EAAQE,KAAI,SAASV,GACjC,MAAO,MAAQA,EAAI,OAClBW,KAAK,KACR,MAAO,MAAQF,EAAS,IAG1B,SAASG,EAAgBC,GACvB,GAAmB,kBAARA,EACT,MAAO,MAAQd,EAASc,GAAO,IAE1B,GAAIpB,EAASoB,GAAM,CAExB,GAAIA,EAAIC,WAAY,MAAM,IAAIC,MAAM,8BACpC,GAAIF,EAAIG,OAAQ,MAAM,IAAID,MAAM,6BAChC,GAAIF,EAAIrB,OAAQ,MAAM,IAAIuB,MAAM,6BAChC,GAAIF,EAAII,UAAW,MAAM,IAAIF,MAAM,6BACnC,OAAOF,EAAIJ,OAGX,MAAM,IAAIM,MAAM,kBAAoBF,GAIxC,SAASK,EAAcC,GAGrB,IAFA,IAAIC,EAAOjC,OAAOkC,oBAAoBF,GAClCG,EAAS,GACJC,EAAI,EAAGA,EAAIH,EAAKf,OAAQkB,IAAK,CACpC,IAAIC,EAAMJ,EAAKG,GACXE,EAAQN,EAAOK,GACfE,EAAQ,GAAGC,OAAOF,GACtB,GAAY,YAARD,EAAJ,CAMA,IAAII,EAAQ,GACZF,EAAMG,SAAQ,SAASC,GACjBlC,EAASkC,IACPF,EAAMvB,QAAQiB,EAAOS,KAAKC,EAAYR,EAAKI,IAC/CN,EAAOS,KAAKC,EAAYR,EAAKM,IAC7BF,EAAQ,IAERA,EAAMG,KAAKD,MAGXF,EAAMvB,QAAQiB,EAAOS,KAAKC,EAAYR,EAAKI,SAf7C,IAAK,IAAIK,EAAI,EAAGA,EAAIP,EAAMrB,OAAQ4B,IAChCX,EAAOS,KAAK,CAACG,QAASR,EAAMO,KAgBlC,OAAOX,EAGT,SAASa,EAAaC,GAEpB,IADA,IAAId,EAAS,GACJC,EAAI,EAAGA,EAAIa,EAAM/B,OAAQkB,IAAK,CACrC,IAAIV,EAAMuB,EAAMb,GAChB,GAAIV,EAAIqB,QAEN,IADA,IAAIA,EAAU,GAAGP,OAAOd,EAAIqB,SACnBD,EAAI,EAAGA,EAAIC,EAAQ7B,OAAQ4B,IAClCX,EAAOS,KAAK,CAACG,QAASA,EAAQD,SAHlC,CAOA,IAAKpB,EAAIwB,KACP,MAAM,IAAItB,MAAM,qBAAuBuB,KAAKC,UAAU1B,IAExDS,EAAOS,KAAKC,EAAYnB,EAAIwB,KAAMxB,KAEpC,OAAOS,EAGT,SAASU,EAAYK,EAAMxB,GAIzB,GAHKjB,EAASiB,KACZA,EAAM,CAAEe,MAAOf,IAEbA,EAAIqB,QACN,MAAM,IAAInB,MAAM,6CAIlB,IAAIyB,EAAU,CACZC,YAAaJ,EACbK,aAAc7B,EAAI8B,SAAW9B,EAAI+B,SACjCC,KAAK,EACLC,KAAM,KACNf,KAAM,KACNY,OAAO,EACPC,UAAU,EACVG,MAAO,KACPV,KAAM,KACNW,aAAa,GAIf,IAAK,IAAIxB,KAAOX,EACV3B,EAAeS,KAAKkB,EAAKW,KAC3BgB,EAAQhB,GAAOX,EAAIW,IAKvB,GAA4B,kBAAjBgB,EAAQH,MAAqBA,IAASG,EAAQH,KACvD,MAAM,IAAItB,MAAM,4CAA8CyB,EAAQH,KAAO,gBAAkBA,EAAO,MAIxG,IAAIT,EAAQY,EAAQZ,MAMpB,OALAY,EAAQZ,MAAQ/B,MAAMC,QAAQ8B,GAASA,EAAQA,EAAQ,CAACA,GAAS,GACjEY,EAAQZ,MAAMqB,MAAK,SAASC,EAAGC,GAC7B,OAAO1D,EAASyD,IAAMzD,EAAS0D,GAAK,EAC7B1D,EAAS0D,IAAM,EAAI1D,EAASyD,GAAK,EAAKC,EAAE9C,OAAS6C,EAAE7C,UAErDmC,EAGT,SAASY,EAAQC,GACf,OAAOxD,MAAMC,QAAQuD,GAAQlB,EAAakB,GAAQnC,EAAcmC,GAGlE,IAAIC,EAAmBtB,EAAY,QAAS,CAACU,YAAY,EAAMM,aAAa,IAC5E,SAASO,EAAa7B,EAAO8B,GAS3B,IARA,IAAIC,EAAY,KACZC,EAAOvE,OAAOwE,OAAO,MACrBC,GAAc,EACdC,EAAc,KACdC,EAAS,GACTC,EAAQ,GAGHxC,EAAI,EAAGA,EAAIG,EAAMrB,OAAQkB,IAC5BG,EAAMH,GAAGqB,WACXgB,GAAc,GAIlB,IAASrC,EAAI,EAAGA,EAAIG,EAAMrB,OAAQkB,IAAK,CACrC,IAAIiB,EAAUd,EAAMH,GAEpB,GAAIiB,EAAQN,QAEV,MAAM,IAAInB,MAAM,kDAGlB,GAAIyB,EAAQG,OAASH,EAAQI,SAAU,CAErC,GAAIa,EACF,MAAKjB,EAAQI,YAAca,EAAUb,SAC7B,IAAI7B,MAAM,aAAeyB,EAAQI,SAAW,WAAa,SAAW,kCAAoCJ,EAAQC,YAAc,MAE9H,IAAI1B,MAAM,yDAA2DyB,EAAQC,YAAc,MAGrGgB,EAAYjB,EAGd,IAAIZ,EAAQY,EAAQZ,MAAMoC,QAC1B,GAAIJ,EACF,MAAOhC,EAAMvB,QAA8B,kBAAbuB,EAAM,IAAuC,IAApBA,EAAM,GAAGvB,OAAc,CAC5E,IAAI4D,EAAOrC,EAAMsC,QACjBR,EAAKO,EAAKE,WAAW,IAAM3B,EAK/B,GAAIA,EAAQK,KAAOL,EAAQT,MAAQS,EAAQM,KAAM,CAC/C,IAAKU,EACH,MAAM,IAAIzC,MAAM,2EAA6EyB,EAAQC,YAAc,MAErH,GAAID,EAAQI,SACV,MAAM,IAAI7B,MAAM,0EAA4EyB,EAAQC,YAAc,MAKtH,GAAqB,IAAjBb,EAAMvB,OAAV,CAGAuD,GAAc,EAEdE,EAAO/B,KAAKS,GAGZ,IAAK,IAAIP,EAAI,EAAGA,EAAIL,EAAMvB,OAAQ4B,IAAK,CACrC,IAAIpB,EAAMe,EAAMK,GAChB,GAAKxC,EAASoB,GAId,GAAoB,OAAhBgD,EACFA,EAAchD,EAAIuD,aACb,GAAIP,IAAgBhD,EAAIuD,UAAgC,IAArB5B,EAAQI,SAChD,MAAM,IAAI7B,MAAM,sCAKpB,IAAIsD,EAAM9D,EAAQqB,EAAMlB,IAAIE,IAGxB0D,EAAS,IAAI/E,OAAO8E,GACxB,GAAIC,EAAOC,KAAK,IACd,MAAM,IAAIxD,MAAM,gCAAkCuD,GAEpD,IAAIE,EAAatE,EAASmE,GAC1B,GAAIG,EAAa,EACf,MAAM,IAAIzD,MAAM,8BAAgCuD,EAAS,yBAI3D,IAAK9B,EAAQE,YAAc4B,EAAOC,KAAK,MACrC,MAAM,IAAIxD,MAAM,mCAAqCuD,GAIvDP,EAAMhC,KAAKzB,EAAU+D,KASvB,IAAII,EAAehB,GAAaA,EAAUb,SACtC8B,EAAQpF,IAAcmF,EAAe,KAAO,KAC5CE,EAASrF,GAAamF,EAAe,GAAK,KAE1B,IAAhBZ,IAAsBa,GAAS,KACnC,IAAIE,EAAW,IAAIrF,OAAOgB,EAAQwD,GAASY,EAAQD,GACnD,MAAO,CAACJ,OAAQM,EAAUd,OAAQA,EAAQJ,KAAMA,EAAMf,MAAOc,GAAaH,GAG5E,SAASuB,EAAQnD,GACf,IAAIJ,EAASiC,EAAaH,EAAQ1B,IAClC,OAAO,IAAIoD,EAAM,CAACC,MAAOzD,GAAS,SAGpC,SAAS0D,EAAgBC,EAAGC,EAAMxE,GAChC,IAAIyE,EAAQF,IAAMA,EAAElD,MAAQkD,EAAEnC,MAC9B,GAAIqC,IAAUzE,EAAIyE,GAChB,MAAM,IAAIpE,MAAM,kBAAoBoE,EAAQ,gBAAkBF,EAAExC,YAAc,eAAiByC,EAAO,MAExG,GAAID,GAAKA,EAAEpC,KAAkB,KAAVoC,EAAEpC,IACnB,MAAM,IAAI9B,MAAM,4BAA8BkE,EAAExC,YAAc,eAAiByC,EAAO,MAG1F,SAASE,EAAcC,EAAQN,GAC7B,IAAIO,EAAMD,EAAOE,KAAOnC,EAAQiC,EAAOE,MAAQ,UACxCF,EAAOE,KAEd,IAAInE,EAAOjC,OAAOkC,oBAAoBgE,GACjCN,IAAOA,EAAQ3D,EAAK,IAGzB,IADA,IAAIoE,EAAUrG,OAAOwE,OAAO,MACnBpC,EAAI,EAAGA,EAAIH,EAAKf,OAAQkB,IAAK,CACpC,IAAIC,EAAMJ,EAAKG,GACfiE,EAAQhE,GAAO4B,EAAQiC,EAAO7D,IAAMG,OAAO2D,GAE7C,IAAS/D,EAAI,EAAGA,EAAIH,EAAKf,OAAQkB,IAC/B,CAAIC,EAAMJ,EAAKG,GAGf,IAHA,IACIG,EAAQ8D,EAAQhE,GAChBiE,EAAWtG,OAAOwE,OAAO,MACpB1B,EAAI,EAAGA,EAAIP,EAAMrB,OAAQ4B,IAAK,CACrC,IAAIH,EAAOJ,EAAMO,GACjB,GAAKH,EAAKI,QAAV,CACA,IAAIwD,EAAS,CAACzD,EAAG,GACjB,GAAIH,EAAKI,UAAYV,IAAQiE,EAAS3D,EAAKI,SAAU,CACnDuD,EAAS3D,EAAKI,UAAW,EACzB,IAAIyD,EAAWH,EAAQ1D,EAAKI,SAC5B,IAAKyD,EACH,MAAM,IAAI5E,MAAM,qCAAuCe,EAAKI,QAAU,gBAAkBV,EAAM,MAEhG,IAAK,IAAIoE,EAAI,EAAGA,EAAID,EAAStF,OAAQuF,IAAK,CACxC,IAAIC,EAAUF,EAASC,IACS,IAA5BlE,EAAMoE,QAAQD,IAClBH,EAAO3D,KAAK8D,IAGhBnE,EAAMgE,OAAOK,MAAMrE,EAAOgE,GAC1BzD,MAIJ,IAAIvB,EAAMvB,OAAOwE,OAAO,MACxB,IAASpC,EAAI,EAAGA,EAAIH,EAAKf,OAAQkB,IAAK,CAChCC,EAAMJ,EAAKG,GACfb,EAAIc,GAAO+B,EAAaiC,EAAQhE,IAAM,GAGxC,IAASD,EAAI,EAAGA,EAAIH,EAAKf,OAAQkB,IAAK,CACpC,IAAI2D,EAAO9D,EAAKG,GACZ4D,EAAQzE,EAAIwE,GACZpB,EAASqB,EAAMrB,OACnB,IAAS7B,EAAI,EAAGA,EAAI6B,EAAOzD,OAAQ4B,IACjC+C,EAAgBlB,EAAO7B,GAAIiD,EAAMxE,GAEnC,IAAIsF,EAAW7G,OAAOkC,oBAAoB8D,EAAMzB,MAChD,IAASzB,EAAI,EAAGA,EAAI+D,EAAS3F,OAAQ4B,IACnC+C,EAAgBG,EAAMzB,KAAKsC,EAAS/D,IAAKiD,EAAMxE,GAInD,OAAO,IAAIoE,EAAMpE,EAAKqE,GAGxB,SAASkB,EAAiBvF,GAIxB,IAHA,IAAIwF,EAAa/G,OAAOwE,OAAO,MAC3BwC,EAAWhH,OAAOwE,OAAO,MACzByC,EAAQjH,OAAOkC,oBAAoBX,GAC9Ba,EAAI,EAAGA,EAAI6E,EAAM/F,OAAQkB,IAAK,CACrC,IAAI8E,EAAYD,EAAM7E,GAClB+E,EAAO5F,EAAI2F,GACXE,EAAc1G,MAAMC,QAAQwG,GAAQA,EAAO,CAACA,GAChDC,EAAY1E,SAAQ,SAAS2E,GAE3B,IADCL,EAASK,EAAQnG,QAAU8F,EAASK,EAAQnG,SAAW,IAAI0B,KAAKyE,GAC1C,kBAAZA,EACT,MAAM,IAAIzF,MAAM,uCAAyCsF,EAAY,MAEvEH,EAAWM,GAAWH,KAM1B,SAASI,EAAIC,GAAK,OAAOpE,KAAKC,UAAUmE,GACxC,IAAIjG,EAAS,GAEb,IAAK,IAAIJ,KADTI,GAAU,4BACS0F,EAAU,CAC3B,IAAIQ,EAAWR,EAAS9F,GACxBI,GAAU,QAAUJ,EAAS,MAC7BI,GAAU,qBACVkG,EAAS9E,SAAQ,SAAS2E,GACxB,IAAIH,EAAYH,EAAWM,GAC3B/F,GAAU,QAAUgG,EAAID,GAAW,YAAcC,EAAIJ,GAAa,QAEpE5F,GAAU,MAGZ,OADAA,GAAU,MACHmG,SAAS,QAASnG,GAK3B,IAAIqE,EAAQ,SAASO,EAAQF,GAC3BlG,KAAK4H,WAAa1B,EAClBlG,KAAKoG,OAASA,EACdpG,KAAK6H,OAAS,GACd7H,KAAK8H,MAAQ,GACb9H,KAAK+H,SAGPlC,EAAM1F,UAAU4H,MAAQ,SAASC,EAAMC,GASrC,OARAjI,KAAK6H,OAASG,GAAQ,GACtBhI,KAAKkI,MAAQ,EACblI,KAAKmI,KAAOF,EAAOA,EAAKE,KAAO,EAC/BnI,KAAKoI,IAAMH,EAAOA,EAAKG,IAAM,EAC7BpI,KAAKqI,YAAcJ,EAAOA,EAAKI,YAAc,KAC7CrI,KAAKsI,YAAcL,EAAOA,EAAKK,YAAc,KAC7CtI,KAAKuI,SAASN,EAAOA,EAAK/B,MAAQlG,KAAK4H,YACvC5H,KAAK8H,MAAQG,GAAQA,EAAKH,MAAQG,EAAKH,MAAM/C,QAAU,GAChD/E,MAGT6F,EAAM1F,UAAUqI,KAAO,WACrB,MAAO,CACLL,KAAMnI,KAAKmI,KACXC,IAAKpI,KAAKoI,IACVlC,MAAOlG,KAAKkG,MACZ4B,MAAO9H,KAAK8H,MAAM/C,QAClBsD,YAAarI,KAAKqI,YAClBC,YAAatI,KAAKsI,cAItBzC,EAAM1F,UAAUoI,SAAW,SAASrC,GAClC,GAAKA,GAASlG,KAAKkG,QAAUA,EAA7B,CACAlG,KAAKkG,MAAQA,EACb,IAAI+B,EAAOjI,KAAKoG,OAAOF,GACvBlG,KAAK6E,OAASoD,EAAKpD,OACnB7E,KAAK0D,MAAQuE,EAAKvE,MAClB1D,KAAKkB,GAAK+G,EAAK5C,OACfrF,KAAKyE,KAAOwD,EAAKxD,OAGnBoB,EAAM1F,UAAUsI,SAAW,WACzBzI,KAAKuI,SAASvI,KAAK8H,MAAMlE,QAG3BiC,EAAM1F,UAAUuI,UAAY,SAASxC,GACnClG,KAAK8H,MAAMhF,KAAK9C,KAAKkG,OACrBlG,KAAKuI,SAASrC,IAGhB,IAAIyC,EAAMtI,EAAY,SAASa,EAAI2G,GACjC,OAAO3G,EAAGC,KAAK0G,IACb,SAAS3G,EAAI2G,GACf,IAAIlF,EAAQzB,EAAGC,KAAK0G,GAEpB,OAAwB,IAApBlF,EAAM,GAAGvB,OACJ,KAEFuB,GAaT,SAASiG,IACP,OAAO5I,KAAK8D,MAgGd,GA3GA+B,EAAM1F,UAAU0I,UAAY,SAASlG,GAEnC,IADA,IAAI4C,EAAavF,KAAK6E,OAAOzD,OACpBkB,EAAI,EAAGA,EAAIiD,EAAYjD,IAC9B,QAAqBwG,IAAjBnG,EAAML,EAAI,GACZ,OAAOtC,KAAK6E,OAAOvC,GAGvB,MAAM,IAAIR,MAAM,4CAOlB+D,EAAM1F,UAAU0D,KAAO,WACrB,IAAIqE,EAAQlI,KAAKkI,MAGjB,GAAIlI,KAAK+I,YAAa,CACpB,IAAIC,EAAQhJ,KAAKiJ,OAAOjJ,KAAK+I,YAAa/I,KAAKkJ,WAAYhB,GAG3D,OAFAlI,KAAK+I,YAAc,KACnB/I,KAAKkJ,WAAa,GACXF,EAGT,IAAInB,EAAS7H,KAAK6H,OAClB,GAAIK,IAAUL,EAAOzG,OAArB,CAKA,IAAI+H,EAAQnJ,KAAKyE,KAAKoD,EAAO3C,WAAWgD,IACxC,GAAIiB,EACF,OAAOnJ,KAAKiJ,OAAOE,EAAOtB,EAAOuB,OAAOlB,GAAQA,GAIlD,IAAIhH,EAAKlB,KAAKkB,GACdA,EAAGmI,UAAYnB,EACf,IAAIvF,EAAQgG,EAAIzH,EAAI2G,GAGhBnE,EAAQ1D,KAAK0D,MACjB,GAAa,MAATf,EACF,OAAO3C,KAAKiJ,OAAOvF,EAAOmE,EAAO9C,MAAMmD,EAAOL,EAAOzG,QAAS8G,GAG5DiB,EAAQnJ,KAAK6I,UAAUlG,GAA3B,IACI2G,EAAO3G,EAAM,GAEjB,OAAIe,EAAMC,UAAYhB,EAAMuF,QAAUA,GACpClI,KAAK+I,YAAcI,EACnBnJ,KAAKkJ,WAAaI,EAGXtJ,KAAKiJ,OAAOvF,EAAOmE,EAAO9C,MAAMmD,EAAOvF,EAAMuF,OAAQA,IAGvDlI,KAAKiJ,OAAOE,EAAOG,EAAMpB,KAGlCrC,EAAM1F,UAAU8I,OAAS,SAASE,EAAOG,EAAMC,GAE7C,IAAI9F,EAAa,EACjB,GAAI0F,EAAM1F,WAAY,CACpB,IAAI+F,EAAU,MACVC,EAAK,EACT,GAAa,OAATH,EACF7F,EAAa,OAEb,MAAO+F,EAAQrI,KAAKmI,GAAS7F,IAAcgG,EAAKD,EAAQH,UAI5D,IAAIL,EAAQ,CACV5F,KAA6B,oBAAf+F,EAAM/F,MAAuB+F,EAAM/F,KAAKkG,IAAUH,EAAM3F,YACtEM,MAA8B,oBAAhBqF,EAAMrF,MAAuBqF,EAAMrF,MAAMwF,GAAQA,EAC/DA,KAAMA,EACNlJ,SAAUwI,EACVW,OAAQA,EACR9F,WAAYA,EACZ0E,KAAMnI,KAAKmI,KACXC,IAAKpI,KAAKoI,KAIRsB,EAAOJ,EAAKlI,OAUhB,GATApB,KAAKkI,OAASwB,EACd1J,KAAKmI,MAAQ1E,EACM,IAAfA,EACFzD,KAAKoI,IAAMsB,EAAOD,EAAK,EAEvBzJ,KAAKoI,KAAOsB,EAIVP,EAAMpF,YACR,MAAM,IAAIjC,MAAM9B,KAAK2J,YAAYX,EAAO,mBAO1C,OAJIG,EAAMvF,IAAK5D,KAAKyI,WACXU,EAAMrG,KAAM9C,KAAK0I,UAAUS,EAAMrG,MACjCqG,EAAMtF,MAAM7D,KAAKuI,SAASY,EAAMtF,MAElCmF,GAGa,qBAAXY,QAA0BA,OAAOC,SAAU,CACpD,IAAIC,EAAgB,SAASC,GAC3B/J,KAAK+J,MAAQA,GAGfD,EAAc3J,UAAU0D,KAAO,WAC7B,IAAImF,EAAQhJ,KAAK+J,MAAMlG,OACvB,MAAO,CAACC,MAAOkF,EAAOgB,MAAOhB,IAG/Bc,EAAc3J,UAAUyJ,OAAOC,UAAY,WACzC,OAAO7J,MAGT6F,EAAM1F,UAAUyJ,OAAOC,UAAY,WACjC,OAAO,IAAIC,EAAc9J,OAkC7B,OA9BA6F,EAAM1F,UAAUwJ,YAAc,SAASX,EAAOiB,GAC5C,GAAa,MAATjB,EAEF,KAAIM,EAAOtJ,KAAK6H,OAAO9C,MAAM/E,KAAKkI,OAC9Bc,EAAQ,CACVM,KAAMA,EACNC,OAAQvJ,KAAKkI,MACbzE,YAAoC,IAAxB6F,EAAKzC,QAAQ,MAAe,EAAI,EAC5CsB,KAAMnI,KAAKmI,KACXC,IAAKpI,KAAKoI,KAGd,IAAItC,EAAQoE,KAAKC,IAAI,EAAGnB,EAAMO,OAASP,EAAMZ,IAAM,GAC/CgC,EAAMpB,EAAMvF,WAAauF,EAAMM,KAAKzC,QAAQ,MAAQmC,EAAMM,KAAKlI,OAC/DiJ,EAAYrK,KAAK6H,OAAOyC,UAAUxE,EAAOkD,EAAMO,OAASa,GAI5D,OAHAH,GAAW,YAAcjB,EAAMb,KAAO,QAAUa,EAAMZ,IAAM,QAC5D6B,GAAW,KAAOI,EAAY,KAC9BJ,GAAW,KAAOrJ,MAAMoI,EAAMZ,KAAK1G,KAAK,KAAO,IACxCuI,GAGTpE,EAAM1F,UAAUoK,MAAQ,WACtB,OAAO,IAAI1E,EAAM7F,KAAKoG,OAAQpG,KAAKkG,QAGrCL,EAAM1F,UAAUqK,IAAM,SAASpD,GAC7B,OAAO,GAIF,CACLxB,QAASA,EACTQ,OAAQD,EACRzC,MAAOxD,OAAOuK,OAAO,CAAC/G,OAAO,IAC7BC,SAAUzD,OAAOuK,OAAO,CAAC9G,UAAU,IACnC+D,SAAUV","file":"js/npm.moo.d5d6fc07.js","sourcesContent":["(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define([], factory) /* global define */\n  } else if (typeof module === 'object' && module.exports) {\n    module.exports = factory()\n  } else {\n    root.moo = factory()\n  }\n}(this, function() {\n  'use strict';\n\n  var hasOwnProperty = Object.prototype.hasOwnProperty\n  var toString = Object.prototype.toString\n  var hasSticky = typeof new RegExp().sticky === 'boolean'\n\n  /***************************************************************************/\n\n  function isRegExp(o) { return o && toString.call(o) === '[object RegExp]' }\n  function isObject(o) { return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o) }\n\n  function reEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')\n  }\n  function reGroups(s) {\n    var re = new RegExp('|' + s)\n    return re.exec('').length - 1\n  }\n  function reCapture(s) {\n    return '(' + s + ')'\n  }\n  function reUnion(regexps) {\n    if (!regexps.length) return '(?!)'\n    var source =  regexps.map(function(s) {\n      return \"(?:\" + s + \")\"\n    }).join('|')\n    return \"(?:\" + source + \")\"\n  }\n\n  function regexpOrLiteral(obj) {\n    if (typeof obj === 'string') {\n      return '(?:' + reEscape(obj) + ')'\n\n    } else if (isRegExp(obj)) {\n      // TODO: consider /u support\n      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')\n      if (obj.global) throw new Error('RegExp /g flag is implied')\n      if (obj.sticky) throw new Error('RegExp /y flag is implied')\n      if (obj.multiline) throw new Error('RegExp /m flag is implied')\n      return obj.source\n\n    } else {\n      throw new Error('Not a pattern: ' + obj)\n    }\n  }\n\n  function objectToRules(object) {\n    var keys = Object.getOwnPropertyNames(object)\n    var result = []\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      var thing = object[key]\n      var rules = [].concat(thing)\n      if (key === 'include') {\n        for (var j = 0; j < rules.length; j++) {\n          result.push({include: rules[j]})\n        }\n        continue\n      }\n      var match = []\n      rules.forEach(function(rule) {\n        if (isObject(rule)) {\n          if (match.length) result.push(ruleOptions(key, match))\n          result.push(ruleOptions(key, rule))\n          match = []\n        } else {\n          match.push(rule)\n        }\n      })\n      if (match.length) result.push(ruleOptions(key, match))\n    }\n    return result\n  }\n\n  function arrayToRules(array) {\n    var result = []\n    for (var i = 0; i < array.length; i++) {\n      var obj = array[i]\n      if (obj.include) {\n        var include = [].concat(obj.include)\n        for (var j = 0; j < include.length; j++) {\n          result.push({include: include[j]})\n        }\n        continue\n      }\n      if (!obj.type) {\n        throw new Error('Rule has no type: ' + JSON.stringify(obj))\n      }\n      result.push(ruleOptions(obj.type, obj))\n    }\n    return result\n  }\n\n  function ruleOptions(type, obj) {\n    if (!isObject(obj)) {\n      obj = { match: obj }\n    }\n    if (obj.include) {\n      throw new Error('Matching rules cannot also include states')\n    }\n\n    // nb. error and fallback imply lineBreaks\n    var options = {\n      defaultType: type,\n      lineBreaks: !!obj.error || !!obj.fallback,\n      pop: false,\n      next: null,\n      push: null,\n      error: false,\n      fallback: false,\n      value: null,\n      type: null,\n      shouldThrow: false,\n    }\n\n    // Avoid Object.assign(), so we support IE9+\n    for (var key in obj) {\n      if (hasOwnProperty.call(obj, key)) {\n        options[key] = obj[key]\n      }\n    }\n\n    // type transform cannot be a string\n    if (typeof options.type === 'string' && type !== options.type) {\n      throw new Error(\"Type transform cannot be a string (type '\" + options.type + \"' for token '\" + type + \"')\")\n    }\n\n    // convert to array\n    var match = options.match\n    options.match = Array.isArray(match) ? match : match ? [match] : []\n    options.match.sort(function(a, b) {\n      return isRegExp(a) && isRegExp(b) ? 0\n           : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length\n    })\n    return options\n  }\n\n  function toRules(spec) {\n    return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec)\n  }\n\n  var defaultErrorRule = ruleOptions('error', {lineBreaks: true, shouldThrow: true})\n  function compileRules(rules, hasStates) {\n    var errorRule = null\n    var fast = Object.create(null)\n    var fastAllowed = true\n    var unicodeFlag = null\n    var groups = []\n    var parts = []\n\n    // If there is a fallback rule, then disable fast matching\n    for (var i = 0; i < rules.length; i++) {\n      if (rules[i].fallback) {\n        fastAllowed = false\n      }\n    }\n\n    for (var i = 0; i < rules.length; i++) {\n      var options = rules[i]\n\n      if (options.include) {\n        // all valid inclusions are removed by states() preprocessor\n        throw new Error('Inheritance is not allowed in stateless lexers')\n      }\n\n      if (options.error || options.fallback) {\n        // errorRule can only be set once\n        if (errorRule) {\n          if (!options.fallback === !errorRule.fallback) {\n            throw new Error(\"Multiple \" + (options.fallback ? \"fallback\" : \"error\") + \" rules not allowed (for token '\" + options.defaultType + \"')\")\n          } else {\n            throw new Error(\"fallback and error are mutually exclusive (for token '\" + options.defaultType + \"')\")\n          }\n        }\n        errorRule = options\n      }\n\n      var match = options.match.slice()\n      if (fastAllowed) {\n        while (match.length && typeof match[0] === 'string' && match[0].length === 1) {\n          var word = match.shift()\n          fast[word.charCodeAt(0)] = options\n        }\n      }\n\n      // Warn about inappropriate state-switching options\n      if (options.pop || options.push || options.next) {\n        if (!hasStates) {\n          throw new Error(\"State-switching options are not allowed in stateless lexers (for token '\" + options.defaultType + \"')\")\n        }\n        if (options.fallback) {\n          throw new Error(\"State-switching options are not allowed on fallback tokens (for token '\" + options.defaultType + \"')\")\n        }\n      }\n\n      // Only rules with a .match are included in the RegExp\n      if (match.length === 0) {\n        continue\n      }\n      fastAllowed = false\n\n      groups.push(options)\n\n      // Check unicode flag is used everywhere or nowhere\n      for (var j = 0; j < match.length; j++) {\n        var obj = match[j]\n        if (!isRegExp(obj)) {\n          continue\n        }\n\n        if (unicodeFlag === null) {\n          unicodeFlag = obj.unicode\n        } else if (unicodeFlag !== obj.unicode && options.fallback === false) {\n          throw new Error('If one rule is /u then all must be')\n        }\n      }\n\n      // convert to RegExp\n      var pat = reUnion(match.map(regexpOrLiteral))\n\n      // validate\n      var regexp = new RegExp(pat)\n      if (regexp.test(\"\")) {\n        throw new Error(\"RegExp matches empty string: \" + regexp)\n      }\n      var groupCount = reGroups(pat)\n      if (groupCount > 0) {\n        throw new Error(\"RegExp has capture groups: \" + regexp + \"\\nUse (?: … ) instead\")\n      }\n\n      // try and detect rules matching newlines\n      if (!options.lineBreaks && regexp.test('\\n')) {\n        throw new Error('Rule should declare lineBreaks: ' + regexp)\n      }\n\n      // store regex\n      parts.push(reCapture(pat))\n    }\n\n\n    // If there's no fallback rule, use the sticky flag so we only look for\n    // matches at the current index.\n    //\n    // If we don't support the sticky flag, then fake it using an irrefutable\n    // match (i.e. an empty pattern).\n    var fallbackRule = errorRule && errorRule.fallback\n    var flags = hasSticky && !fallbackRule ? 'ym' : 'gm'\n    var suffix = hasSticky || fallbackRule ? '' : '|'\n\n    if (unicodeFlag === true) flags += \"u\"\n    var combined = new RegExp(reUnion(parts) + suffix, flags)\n    return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}\n  }\n\n  function compile(rules) {\n    var result = compileRules(toRules(rules))\n    return new Lexer({start: result}, 'start')\n  }\n\n  function checkStateGroup(g, name, map) {\n    var state = g && (g.push || g.next)\n    if (state && !map[state]) {\n      throw new Error(\"Missing state '\" + state + \"' (in token '\" + g.defaultType + \"' of state '\" + name + \"')\")\n    }\n    if (g && g.pop && +g.pop !== 1) {\n      throw new Error(\"pop must be 1 (in token '\" + g.defaultType + \"' of state '\" + name + \"')\")\n    }\n  }\n  function compileStates(states, start) {\n    var all = states.$all ? toRules(states.$all) : []\n    delete states.$all\n\n    var keys = Object.getOwnPropertyNames(states)\n    if (!start) start = keys[0]\n\n    var ruleMap = Object.create(null)\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      ruleMap[key] = toRules(states[key]).concat(all)\n    }\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      var rules = ruleMap[key]\n      var included = Object.create(null)\n      for (var j = 0; j < rules.length; j++) {\n        var rule = rules[j]\n        if (!rule.include) continue\n        var splice = [j, 1]\n        if (rule.include !== key && !included[rule.include]) {\n          included[rule.include] = true\n          var newRules = ruleMap[rule.include]\n          if (!newRules) {\n            throw new Error(\"Cannot include nonexistent state '\" + rule.include + \"' (in state '\" + key + \"')\")\n          }\n          for (var k = 0; k < newRules.length; k++) {\n            var newRule = newRules[k]\n            if (rules.indexOf(newRule) !== -1) continue\n            splice.push(newRule)\n          }\n        }\n        rules.splice.apply(rules, splice)\n        j--\n      }\n    }\n\n    var map = Object.create(null)\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      map[key] = compileRules(ruleMap[key], true)\n    }\n\n    for (var i = 0; i < keys.length; i++) {\n      var name = keys[i]\n      var state = map[name]\n      var groups = state.groups\n      for (var j = 0; j < groups.length; j++) {\n        checkStateGroup(groups[j], name, map)\n      }\n      var fastKeys = Object.getOwnPropertyNames(state.fast)\n      for (var j = 0; j < fastKeys.length; j++) {\n        checkStateGroup(state.fast[fastKeys[j]], name, map)\n      }\n    }\n\n    return new Lexer(map, start)\n  }\n\n  function keywordTransform(map) {\n    var reverseMap = Object.create(null)\n    var byLength = Object.create(null)\n    var types = Object.getOwnPropertyNames(map)\n    for (var i = 0; i < types.length; i++) {\n      var tokenType = types[i]\n      var item = map[tokenType]\n      var keywordList = Array.isArray(item) ? item : [item]\n      keywordList.forEach(function(keyword) {\n        (byLength[keyword.length] = byLength[keyword.length] || []).push(keyword)\n        if (typeof keyword !== 'string') {\n          throw new Error(\"keyword must be string (in keyword '\" + tokenType + \"')\")\n        }\n        reverseMap[keyword] = tokenType\n      })\n    }\n\n    // fast string lookup\n    // https://jsperf.com/string-lookups\n    function str(x) { return JSON.stringify(x) }\n    var source = ''\n    source += 'switch (value.length) {\\n'\n    for (var length in byLength) {\n      var keywords = byLength[length]\n      source += 'case ' + length + ':\\n'\n      source += 'switch (value) {\\n'\n      keywords.forEach(function(keyword) {\n        var tokenType = reverseMap[keyword]\n        source += 'case ' + str(keyword) + ': return ' + str(tokenType) + '\\n'\n      })\n      source += '}\\n'\n    }\n    source += '}\\n'\n    return Function('value', source) // type\n  }\n\n  /***************************************************************************/\n\n  var Lexer = function(states, state) {\n    this.startState = state\n    this.states = states\n    this.buffer = ''\n    this.stack = []\n    this.reset()\n  }\n\n  Lexer.prototype.reset = function(data, info) {\n    this.buffer = data || ''\n    this.index = 0\n    this.line = info ? info.line : 1\n    this.col = info ? info.col : 1\n    this.queuedToken = info ? info.queuedToken : null\n    this.queuedThrow = info ? info.queuedThrow : null\n    this.setState(info ? info.state : this.startState)\n    this.stack = info && info.stack ? info.stack.slice() : []\n    return this\n  }\n\n  Lexer.prototype.save = function() {\n    return {\n      line: this.line,\n      col: this.col,\n      state: this.state,\n      stack: this.stack.slice(),\n      queuedToken: this.queuedToken,\n      queuedThrow: this.queuedThrow,\n    }\n  }\n\n  Lexer.prototype.setState = function(state) {\n    if (!state || this.state === state) return\n    this.state = state\n    var info = this.states[state]\n    this.groups = info.groups\n    this.error = info.error\n    this.re = info.regexp\n    this.fast = info.fast\n  }\n\n  Lexer.prototype.popState = function() {\n    this.setState(this.stack.pop())\n  }\n\n  Lexer.prototype.pushState = function(state) {\n    this.stack.push(this.state)\n    this.setState(state)\n  }\n\n  var eat = hasSticky ? function(re, buffer) { // assume re is /y\n    return re.exec(buffer)\n  } : function(re, buffer) { // assume re is /g\n    var match = re.exec(buffer)\n    // will always match, since we used the |(?:) trick\n    if (match[0].length === 0) {\n      return null\n    }\n    return match\n  }\n\n  Lexer.prototype._getGroup = function(match) {\n    var groupCount = this.groups.length\n    for (var i = 0; i < groupCount; i++) {\n      if (match[i + 1] !== undefined) {\n        return this.groups[i]\n      }\n    }\n    throw new Error('Cannot find token type for matched text')\n  }\n\n  function tokenToString() {\n    return this.value\n  }\n\n  Lexer.prototype.next = function() {\n    var index = this.index\n\n    // If a fallback token matched, we don't need to re-run the RegExp\n    if (this.queuedGroup) {\n      var token = this._token(this.queuedGroup, this.queuedText, index)\n      this.queuedGroup = null\n      this.queuedText = \"\"\n      return token\n    }\n\n    var buffer = this.buffer\n    if (index === buffer.length) {\n      return // EOF\n    }\n\n    // Fast matching for single characters\n    var group = this.fast[buffer.charCodeAt(index)]\n    if (group) {\n      return this._token(group, buffer.charAt(index), index)\n    }\n\n    // Execute RegExp\n    var re = this.re\n    re.lastIndex = index\n    var match = eat(re, buffer)\n\n    // Error tokens match the remaining buffer\n    var error = this.error\n    if (match == null) {\n      return this._token(error, buffer.slice(index, buffer.length), index)\n    }\n\n    var group = this._getGroup(match)\n    var text = match[0]\n\n    if (error.fallback && match.index !== index) {\n      this.queuedGroup = group\n      this.queuedText = text\n\n      // Fallback tokens contain the unmatched portion of the buffer\n      return this._token(error, buffer.slice(index, match.index), index)\n    }\n\n    return this._token(group, text, index)\n  }\n\n  Lexer.prototype._token = function(group, text, offset) {\n    // count line breaks\n    var lineBreaks = 0\n    if (group.lineBreaks) {\n      var matchNL = /\\n/g\n      var nl = 1\n      if (text === '\\n') {\n        lineBreaks = 1\n      } else {\n        while (matchNL.exec(text)) { lineBreaks++; nl = matchNL.lastIndex }\n      }\n    }\n\n    var token = {\n      type: (typeof group.type === 'function' && group.type(text)) || group.defaultType,\n      value: typeof group.value === 'function' ? group.value(text) : text,\n      text: text,\n      toString: tokenToString,\n      offset: offset,\n      lineBreaks: lineBreaks,\n      line: this.line,\n      col: this.col,\n    }\n    // nb. adding more props to token object will make V8 sad!\n\n    var size = text.length\n    this.index += size\n    this.line += lineBreaks\n    if (lineBreaks !== 0) {\n      this.col = size - nl + 1\n    } else {\n      this.col += size\n    }\n\n    // throw, if no rule with {error: true}\n    if (group.shouldThrow) {\n      throw new Error(this.formatError(token, \"invalid syntax\"))\n    }\n\n    if (group.pop) this.popState()\n    else if (group.push) this.pushState(group.push)\n    else if (group.next) this.setState(group.next)\n\n    return token\n  }\n\n  if (typeof Symbol !== 'undefined' && Symbol.iterator) {\n    var LexerIterator = function(lexer) {\n      this.lexer = lexer\n    }\n\n    LexerIterator.prototype.next = function() {\n      var token = this.lexer.next()\n      return {value: token, done: !token}\n    }\n\n    LexerIterator.prototype[Symbol.iterator] = function() {\n      return this\n    }\n\n    Lexer.prototype[Symbol.iterator] = function() {\n      return new LexerIterator(this)\n    }\n  }\n\n  Lexer.prototype.formatError = function(token, message) {\n    if (token == null) {\n      // An undefined token indicates EOF\n      var text = this.buffer.slice(this.index)\n      var token = {\n        text: text,\n        offset: this.index,\n        lineBreaks: text.indexOf('\\n') === -1 ? 0 : 1,\n        line: this.line,\n        col: this.col,\n      }\n    }\n    var start = Math.max(0, token.offset - token.col + 1)\n    var eol = token.lineBreaks ? token.text.indexOf('\\n') : token.text.length\n    var firstLine = this.buffer.substring(start, token.offset + eol)\n    message += \" at line \" + token.line + \" col \" + token.col + \":\\n\\n\"\n    message += \"  \" + firstLine + \"\\n\"\n    message += \"  \" + Array(token.col).join(\" \") + \"^\"\n    return message\n  }\n\n  Lexer.prototype.clone = function() {\n    return new Lexer(this.states, this.state)\n  }\n\n  Lexer.prototype.has = function(tokenType) {\n    return true\n  }\n\n\n  return {\n    compile: compile,\n    states: compileStates,\n    error: Object.freeze({error: true}),\n    fallback: Object.freeze({fallback: true}),\n    keywords: keywordTransform,\n  }\n\n}));\n"],"sourceRoot":""}