{"version":3,"sources":["webpack:///./node_modules/markdown-it/lib/presets/zero.js","webpack:///./node_modules/markdown-it/lib/presets/commonmark.js","webpack:///./node_modules/markdown-it/lib/ruler.js","webpack:///./node_modules/markdown-it/lib/parser_inline.js","webpack:///./node_modules/markdown-it/lib/parser_block.js","webpack:///./node_modules/markdown-it/lib/renderer.js","webpack:///./node_modules/markdown-it/lib/presets/default.js","webpack:///./node_modules/markdown-it/lib/parser_core.js"],"names":["module","exports","options","html","xhtmlOut","breaks","langPrefix","linkify","typographer","quotes","highlight","maxNesting","components","core","rules","block","inline","rules2","Ruler","this","__rules__","__cache__","prototype","__find__","name","i","length","__compile__","self","chains","forEach","rule","enabled","alt","altName","indexOf","push","chain","fn","at","index","opt","Error","before","beforeName","ruleName","splice","after","afterName","enable","list","ignoreInvalid","Array","isArray","result","idx","enableOnly","disable","getRules","chainName","_rules","tokenize","_rules2","postProcess","ParserInline","ruler","ruler2","skipToken","state","ok","pos","len","md","cache","level","posMax","end","pending","src","pushPending","parse","str","env","outTokens","State","ParserBlock","slice","startLine","endLine","line","hasEmptyLines","skipEmptyLines","sCount","blkIndent","tight","isEmpty","parentType","lineMax","assign","unescapeAll","escapeHtml","default_rules","Renderer","code_inline","tokens","slf","token","attrs","renderAttrs","content","code_block","fence","highlighted","tmpAttrs","tmpToken","info","trim","langName","split","attrIndex","image","renderInlineAsText","children","renderToken","hardbreak","softbreak","text","html_block","html_inline","l","nextToken","needLf","hidden","nesting","tag","type","renderInline","render","Core","process"],"mappings":"kHAMAA,EAAOC,QAAU,CACfC,QAAS,CACPC,MAAc,EACdC,UAAc,EACdC,QAAc,EACdC,WAAc,YACdC,SAAc,EAGdC,aAAc,EAOdC,OAAQ,OAQRC,UAAW,KAEXC,WAAc,IAGhBC,WAAY,CAEVC,KAAM,CACJC,MAAO,CACL,YACA,QACA,WAIJC,MAAO,CACLD,MAAO,CACL,cAIJE,OAAQ,CACNF,MAAO,CACL,QAEFG,OAAQ,CACN,gBACA,qB,oCCpDRjB,EAAOC,QAAU,CACfC,QAAS,CACPC,MAAc,EACdC,UAAc,EACdC,QAAc,EACdC,WAAc,YACdC,SAAc,EAGdC,aAAc,EAOdC,OAAQ,OAQRC,UAAW,KAEXC,WAAc,IAGhBC,WAAY,CAEVC,KAAM,CACJC,MAAO,CACL,YACA,QACA,WAIJC,MAAO,CACLD,MAAO,CACL,aACA,OACA,QACA,UACA,KACA,aACA,WACA,OACA,YACA,cAIJE,OAAQ,CACNF,MAAO,CACL,WACA,YACA,WACA,SACA,SACA,cACA,QACA,OACA,UACA,QAEFG,OAAQ,CACN,gBACA,WACA,qB,kCCpDR,SAASC,IAUPC,KAAKC,UAAY,GAOjBD,KAAKE,UAAY,KASnBH,EAAMI,UAAUC,SAAW,SAAUC,GACnC,IAAK,IAAIC,EAAI,EAAGA,EAAIN,KAAKC,UAAUM,OAAQD,IACzC,GAAIN,KAAKC,UAAUK,GAAGD,OAASA,EAC7B,OAAOC,EAGX,OAAQ,GAMVP,EAAMI,UAAUK,YAAc,WAC5B,IAAIC,EAAOT,KACPU,EAAS,CAAE,IAGfD,EAAKR,UAAUU,SAAQ,SAAUC,GAC1BA,EAAKC,SAEVD,EAAKE,IAAIH,SAAQ,SAAUI,GACrBL,EAAOM,QAAQD,GAAW,GAC5BL,EAAOO,KAAKF,SAKlBN,EAAKP,UAAY,GAEjBQ,EAAOC,SAAQ,SAAUO,GACvBT,EAAKP,UAAUgB,GAAS,GACxBT,EAAKR,UAAUU,SAAQ,SAAUC,GAC1BA,EAAKC,UAENK,GAASN,EAAKE,IAAIE,QAAQE,GAAS,GAEvCT,EAAKP,UAAUgB,GAAOD,KAAKL,EAAKO,YA+BtCpB,EAAMI,UAAUiB,GAAK,SAAUf,EAAMc,EAAIpC,GACvC,IAAIsC,EAAQrB,KAAKI,SAASC,GACtBiB,EAAMvC,GAAW,GAErB,IAAe,IAAXsC,EAAgB,MAAM,IAAIE,MAAM,0BAA4BlB,GAEhEL,KAAKC,UAAUoB,GAAOF,GAAKA,EAC3BnB,KAAKC,UAAUoB,GAAOP,IAAMQ,EAAIR,KAAO,GACvCd,KAAKE,UAAY,MA4BnBH,EAAMI,UAAUqB,OAAS,SAAUC,EAAYC,EAAUP,EAAIpC,GAC3D,IAAIsC,EAAQrB,KAAKI,SAASqB,GACtBH,EAAMvC,GAAW,GAErB,IAAe,IAAXsC,EAAgB,MAAM,IAAIE,MAAM,0BAA4BE,GAEhEzB,KAAKC,UAAU0B,OAAON,EAAO,EAAG,CAC9BhB,KAAMqB,EACNb,SAAS,EACTM,GAAIA,EACJL,IAAKQ,EAAIR,KAAO,KAGlBd,KAAKE,UAAY,MA4BnBH,EAAMI,UAAUyB,MAAQ,SAAUC,EAAWH,EAAUP,EAAIpC,GACzD,IAAIsC,EAAQrB,KAAKI,SAASyB,GACtBP,EAAMvC,GAAW,GAErB,IAAe,IAAXsC,EAAgB,MAAM,IAAIE,MAAM,0BAA4BM,GAEhE7B,KAAKC,UAAU0B,OAAON,EAAQ,EAAG,EAAG,CAClChB,KAAMqB,EACNb,SAAS,EACTM,GAAIA,EACJL,IAAKQ,EAAIR,KAAO,KAGlBd,KAAKE,UAAY,MA0BnBH,EAAMI,UAAUc,KAAO,SAAUS,EAAUP,EAAIpC,GAC7C,IAAIuC,EAAMvC,GAAW,GAErBiB,KAAKC,UAAUgB,KAAK,CAClBZ,KAAMqB,EACNb,SAAS,EACTM,GAAIA,EACJL,IAAKQ,EAAIR,KAAO,KAGlBd,KAAKE,UAAY,MAgBnBH,EAAMI,UAAU2B,OAAS,SAAUC,EAAMC,GAClCC,MAAMC,QAAQH,KAASA,EAAO,CAAEA,IAErC,IAAII,EAAS,GAeb,OAZAJ,EAAKpB,SAAQ,SAAUN,GACrB,IAAI+B,EAAMpC,KAAKI,SAASC,GAExB,GAAI+B,EAAM,EAAG,CACX,GAAIJ,EAAiB,OACrB,MAAM,IAAIT,MAAM,oCAAsClB,GAExDL,KAAKC,UAAUmC,GAAKvB,SAAU,EAC9BsB,EAAOlB,KAAKZ,KACXL,MAEHA,KAAKE,UAAY,KACViC,GAcTpC,EAAMI,UAAUkC,WAAa,SAAUN,EAAMC,GACtCC,MAAMC,QAAQH,KAASA,EAAO,CAAEA,IAErC/B,KAAKC,UAAUU,SAAQ,SAAUC,GAAQA,EAAKC,SAAU,KAExDb,KAAK8B,OAAOC,EAAMC,IAgBpBjC,EAAMI,UAAUmC,QAAU,SAAUP,EAAMC,GACnCC,MAAMC,QAAQH,KAASA,EAAO,CAAEA,IAErC,IAAII,EAAS,GAeb,OAZAJ,EAAKpB,SAAQ,SAAUN,GACrB,IAAI+B,EAAMpC,KAAKI,SAASC,GAExB,GAAI+B,EAAM,EAAG,CACX,GAAIJ,EAAiB,OACrB,MAAM,IAAIT,MAAM,oCAAsClB,GAExDL,KAAKC,UAAUmC,GAAKvB,SAAU,EAC9BsB,EAAOlB,KAAKZ,KACXL,MAEHA,KAAKE,UAAY,KACViC,GAaTpC,EAAMI,UAAUoC,SAAW,SAAUC,GAMnC,OALuB,OAAnBxC,KAAKE,WACPF,KAAKQ,cAIAR,KAAKE,UAAUsC,IAAc,IAGtC3D,EAAOC,QAAUiB,G,oCCvVjB,IAAIA,EAAkB,EAAQ,QAM1B0C,EAAS,CACX,CAAE,OAAmB,EAAQ,SAC7B,CAAE,UAAmB,EAAQ,SAC7B,CAAE,SAAmB,EAAQ,SAC7B,CAAE,YAAmB,EAAQ,SAC7B,CAAE,gBAAmB,EAAQ,QAAgCC,UAC7D,CAAE,WAAmB,EAAQ,QAA2BA,UACxD,CAAE,OAAmB,EAAQ,SAC7B,CAAE,QAAmB,EAAQ,SAC7B,CAAE,WAAmB,EAAQ,SAC7B,CAAE,cAAmB,EAAQ,SAC7B,CAAE,SAAmB,EAAQ,UAG3BC,EAAU,CACZ,CAAE,gBAAmB,EAAQ,SAC7B,CAAE,gBAAmB,EAAQ,QAAgCC,aAC7D,CAAE,WAAmB,EAAQ,QAA2BA,aACxD,CAAE,gBAAmB,EAAQ,UAO/B,SAASC,IACP,IAAIvC,EASJ,IAFAN,KAAK8C,MAAQ,IAAI/C,EAEZO,EAAI,EAAGA,EAAImC,EAAOlC,OAAQD,IAC7BN,KAAK8C,MAAM7B,KAAKwB,EAAOnC,GAAG,GAAImC,EAAOnC,GAAG,IAW1C,IAFAN,KAAK+C,OAAS,IAAIhD,EAEbO,EAAI,EAAGA,EAAIqC,EAAQpC,OAAQD,IAC9BN,KAAK+C,OAAO9B,KAAK0B,EAAQrC,GAAG,GAAIqC,EAAQrC,GAAG,IAQ/CuC,EAAa1C,UAAU6C,UAAY,SAAUC,GAC3C,IAAIC,EAAI5C,EAAG6C,EAAMF,EAAME,IACnBxD,EAAQK,KAAK8C,MAAMP,SAAS,IAC5Ba,EAAMzD,EAAMY,OACZf,EAAayD,EAAMI,GAAGtE,QAAQS,WAC9B8D,EAAQL,EAAMK,MAGlB,GAA0B,qBAAfA,EAAMH,GAAjB,CAKA,GAAIF,EAAMM,MAAQ/D,GAChB,IAAKc,EAAI,EAAGA,EAAI8C,EAAK9C,IASnB,GAJA2C,EAAMM,QACNL,EAAKvD,EAAMW,GAAG2C,GAAO,GACrBA,EAAMM,QAEFL,EAAM,WAcZD,EAAME,IAAMF,EAAMO,OAGfN,GAAMD,EAAME,MACjBG,EAAMH,GAAOF,EAAME,SAhCjBF,EAAME,IAAMG,EAAMH,IAsCtBN,EAAa1C,UAAUuC,SAAW,SAAUO,GAC1C,IAAIC,EAAI5C,EACJX,EAAQK,KAAK8C,MAAMP,SAAS,IAC5Ba,EAAMzD,EAAMY,OACZkD,EAAMR,EAAMO,OACZhE,EAAayD,EAAMI,GAAGtE,QAAQS,WAElC,MAAOyD,EAAME,IAAMM,EAAK,CAQtB,GAAIR,EAAMM,MAAQ/D,EAChB,IAAKc,EAAI,EAAGA,EAAI8C,EAAK9C,IAEnB,GADA4C,EAAKvD,EAAMW,GAAG2C,GAAO,GACjBC,EAAM,MAId,GAAIA,GACF,GAAID,EAAME,KAAOM,EAAO,WAI1BR,EAAMS,SAAWT,EAAMU,IAAIV,EAAME,OAG/BF,EAAMS,SACRT,EAAMW,eAUVf,EAAa1C,UAAU0D,MAAQ,SAAUC,EAAKT,EAAIU,EAAKC,GACrD,IAAI1D,EAAGX,EAAOyD,EACVH,EAAQ,IAAIjD,KAAKiE,MAAMH,EAAKT,EAAIU,EAAKC,GAOzC,IALAhE,KAAK0C,SAASO,GAEdtD,EAAQK,KAAK+C,OAAOR,SAAS,IAC7Ba,EAAMzD,EAAMY,OAEPD,EAAI,EAAGA,EAAI8C,EAAK9C,IACnBX,EAAMW,GAAG2C,IAKbJ,EAAa1C,UAAU8D,MAAQ,EAAQ,QAGvCpF,EAAOC,QAAU+D,G,kCCxKjB,IAAI9C,EAAkB,EAAQ,QAG1B0C,EAAS,CAGX,CAAE,QAAc,EAAQ,QAA6B,CAAE,YAAa,cACpE,CAAE,OAAc,EAAQ,SACxB,CAAE,QAAc,EAAQ,QAA6B,CAAE,YAAa,YAAa,aAAc,SAC/F,CAAE,aAAc,EAAQ,QAA6B,CAAE,YAAa,YAAa,SACjF,CAAE,KAAc,EAAQ,QAA6B,CAAE,YAAa,YAAa,aAAc,SAC/F,CAAE,OAAc,EAAQ,QAA6B,CAAE,YAAa,YAAa,eACjF,CAAE,YAAc,EAAQ,SACxB,CAAE,UAAc,EAAQ,QAA6B,CAAE,YAAa,YAAa,eACjF,CAAE,WAAc,EAAQ,SACxB,CAAE,aAAc,EAAQ,QAA6B,CAAE,YAAa,YAAa,eACjF,CAAE,YAAc,EAAQ,UAO1B,SAASyB,IAMPlE,KAAK8C,MAAQ,IAAI/C,EAEjB,IAAK,IAAIO,EAAI,EAAGA,EAAImC,EAAOlC,OAAQD,IACjCN,KAAK8C,MAAM7B,KAAKwB,EAAOnC,GAAG,GAAImC,EAAOnC,GAAG,GAAI,CAAEQ,KAAM2B,EAAOnC,GAAG,IAAM,IAAI6D,UAO5ED,EAAY/D,UAAUuC,SAAW,SAAUO,EAAOmB,EAAWC,GAC3D,IAAInB,EAAI5C,EACJX,EAAQK,KAAK8C,MAAMP,SAAS,IAC5Ba,EAAMzD,EAAMY,OACZ+D,EAAOF,EACPG,GAAgB,EAChB/E,EAAayD,EAAMI,GAAGtE,QAAQS,WAElC,MAAO8E,EAAOD,EAAS,CAErB,GADApB,EAAMqB,KAAOA,EAAOrB,EAAMuB,eAAeF,GACrCA,GAAQD,EAAW,MAIvB,GAAIpB,EAAMwB,OAAOH,GAAQrB,EAAMyB,UAAa,MAI5C,GAAIzB,EAAMM,OAAS/D,EAAY,CAC7ByD,EAAMqB,KAAOD,EACb,MAUF,IAAK/D,EAAI,EAAGA,EAAI8C,EAAK9C,IAEnB,GADA4C,EAAKvD,EAAMW,GAAG2C,EAAOqB,EAAMD,GAAS,GAChCnB,EAAM,MAcZ,GATAD,EAAM0B,OAASJ,EAGXtB,EAAM2B,QAAQ3B,EAAMqB,KAAO,KAC7BC,GAAgB,GAGlBD,EAAOrB,EAAMqB,KAETA,EAAOD,GAAWpB,EAAM2B,QAAQN,GAAO,CAKzC,GAJAC,GAAgB,EAChBD,IAGIA,EAAOD,GAAgC,SAArBpB,EAAM4B,YAAyB5B,EAAM2B,QAAQN,GAAS,MAC5ErB,EAAMqB,KAAOA,KAWnBJ,EAAY/D,UAAU0D,MAAQ,SAAUF,EAAKN,EAAIU,EAAKC,GACpD,IAAIf,EAECU,IAELV,EAAQ,IAAIjD,KAAKiE,MAAMN,EAAKN,EAAIU,EAAKC,GAErChE,KAAK0C,SAASO,EAAOA,EAAMqB,KAAMrB,EAAM6B,WAIzCZ,EAAY/D,UAAU8D,MAAQ,EAAQ,QAGtCpF,EAAOC,QAAUoF,G,oCClHjB,IAAIa,EAAkB,EAAQ,QAAkBA,OAC5CC,EAAkB,EAAQ,QAAkBA,YAC5CC,EAAkB,EAAQ,QAAkBA,WAK5CC,EAAgB,GAkHpB,SAASC,IA8BPnF,KAAKL,MAAQoF,EAAO,GAAIG,GA7I1BA,EAAcE,YAAc,SAAUC,EAAQjD,EAAKrD,EAASgF,EAAKuB,GAC/D,IAAIC,EAAQF,EAAOjD,GACfoD,EAAQF,EAAIG,YAAYF,GAE5B,MAAQ,SAAWC,EAAQ,IAAMA,EAAQ,IAAM,IACvCP,EAAWI,EAAOjD,GAAKsD,SACvB,WAIVR,EAAcS,WAAa,SAAUN,EAAQjD,EAAKrD,EAASgF,EAAKuB,GAC9D,IAAIC,EAAQF,EAAOjD,GACfoD,EAAQF,EAAIG,YAAYF,GAE5B,MAAQ,QAAUC,EAAQ,IAAMA,EAAQ,IAAM,UACtCP,EAAWI,EAAOjD,GAAKsD,SACvB,mBAIVR,EAAcU,MAAQ,SAAUP,EAAQjD,EAAKrD,EAASgF,EAAKuB,GACzD,IAGIO,EAAavF,EAAGwF,EAAUC,EAH1BR,EAAQF,EAAOjD,GACf4D,EAAOT,EAAMS,KAAOhB,EAAYO,EAAMS,MAAMC,OAAS,GACrDC,EAAW,GAaf,OAVIF,IACFE,EAAWF,EAAKG,MAAM,QAAQ,IAI9BN,EADE9G,EAAQQ,WACIR,EAAQQ,UAAUgG,EAAMG,QAASQ,IAEjCjB,EAAWM,EAAMG,SAGG,IAAhCG,EAAY7E,QAAQ,QACf6E,EAAc,KAMnBG,GACF1F,EAAWiF,EAAMa,UAAU,SAC3BN,EAAWP,EAAMC,MAAQD,EAAMC,MAAMrB,QAAU,GAE3C7D,EAAI,EACNwF,EAAS7E,KAAK,CAAE,QAASlC,EAAQI,WAAa+G,IAE9CJ,EAASxF,IAAM,IAAMvB,EAAQI,WAAa+G,EAI5CH,EAAW,CACTP,MAAOM,GAGD,aAAeR,EAAIG,YAAYM,GAAY,IAC3CF,EACA,mBAIF,aAAeP,EAAIG,YAAYF,GAAS,IACxCM,EACA,mBAIVX,EAAcmB,MAAQ,SAAUhB,EAAQjD,EAAKrD,EAASgF,EAAKuB,GACzD,IAAIC,EAAQF,EAAOjD,GAUnB,OAHAmD,EAAMC,MAAMD,EAAMa,UAAU,QAAQ,GAClCd,EAAIgB,mBAAmBf,EAAMgB,SAAUxH,EAASgF,GAE3CuB,EAAIkB,YAAYnB,EAAQjD,EAAKrD,IAItCmG,EAAcuB,UAAY,SAAUpB,EAAQjD,EAAKrD,GAC/C,OAAOA,EAAQE,SAAW,WAAa,UAEzCiG,EAAcwB,UAAY,SAAUrB,EAAQjD,EAAKrD,GAC/C,OAAOA,EAAQG,OAAUH,EAAQE,SAAW,WAAa,SAAY,MAIvEiG,EAAcyB,KAAO,SAAUtB,EAAQjD,GACrC,OAAO6C,EAAWI,EAAOjD,GAAKsD,UAIhCR,EAAc0B,WAAa,SAAUvB,EAAQjD,GAC3C,OAAOiD,EAAOjD,GAAKsD,SAErBR,EAAc2B,YAAc,SAAUxB,EAAQjD,GAC5C,OAAOiD,EAAOjD,GAAKsD,SAgDrBP,EAAShF,UAAUsF,YAAc,SAAqBF,GACpD,IAAIjF,EAAGwG,EAAG3E,EAEV,IAAKoD,EAAMC,MAAS,MAAO,GAI3B,IAFArD,EAAS,GAEJ7B,EAAI,EAAGwG,EAAIvB,EAAMC,MAAMjF,OAAQD,EAAIwG,EAAGxG,IACzC6B,GAAU,IAAM8C,EAAWM,EAAMC,MAAMlF,GAAG,IAAM,KAAO2E,EAAWM,EAAMC,MAAMlF,GAAG,IAAM,IAGzF,OAAO6B,GAaTgD,EAAShF,UAAUqG,YAAc,SAAqBnB,EAAQjD,EAAKrD,GACjE,IAAIgI,EACA5E,EAAS,GACT6E,GAAS,EACTzB,EAAQF,EAAOjD,GAGnB,OAAImD,EAAM0B,OACD,IAUL1B,EAAM3F,QAA4B,IAAnB2F,EAAM2B,SAAkB9E,GAAOiD,EAAOjD,EAAM,GAAG6E,SAChE9E,GAAU,MAIZA,KAA8B,IAAnBoD,EAAM2B,QAAiB,KAAO,KAAO3B,EAAM4B,IAGtDhF,GAAUnC,KAAKyF,YAAYF,GAGL,IAAlBA,EAAM2B,SAAiBnI,EAAQE,WACjCkD,GAAU,MAIRoD,EAAM3F,QACRoH,GAAS,EAEa,IAAlBzB,EAAM2B,SACJ9E,EAAM,EAAIiD,EAAO9E,SACnBwG,EAAY1B,EAAOjD,EAAM,IAEF,WAAnB2E,EAAUK,MAAqBL,EAAUE,SAKX,IAAvBF,EAAUG,SAAkBH,EAAUI,MAAQ5B,EAAM4B,OAF7DH,GAAS,KAWjB7E,GAAU6E,EAAS,MAAQ,IAEpB7E,IAYTgD,EAAShF,UAAUkH,aAAe,SAAUhC,EAAQtG,EAASgF,GAK3D,IAJA,IAAIqD,EACAjF,EAAS,GACTxC,EAAQK,KAAKL,MAERW,EAAI,EAAG8C,EAAMiC,EAAO9E,OAAQD,EAAI8C,EAAK9C,IAC5C8G,EAAO/B,EAAO/E,GAAG8G,KAEU,qBAAhBzH,EAAMyH,GACfjF,GAAUxC,EAAMyH,GAAM/B,EAAQ/E,EAAGvB,EAASgF,EAAK/D,MAE/CmC,GAAUnC,KAAKwG,YAAYnB,EAAQ/E,EAAGvB,GAI1C,OAAOoD,GAcTgD,EAAShF,UAAUmG,mBAAqB,SAAUjB,EAAQtG,EAASgF,GAGjE,IAFA,IAAI5B,EAAS,GAEJ7B,EAAI,EAAG8C,EAAMiC,EAAO9E,OAAQD,EAAI8C,EAAK9C,IACrB,SAAnB+E,EAAO/E,GAAG8G,KACZjF,GAAUkD,EAAO/E,GAAGoF,QACQ,UAAnBL,EAAO/E,GAAG8G,OACnBjF,GAAUnC,KAAKsG,mBAAmBjB,EAAO/E,GAAGiG,SAAUxH,EAASgF,IAInE,OAAO5B,GAaTgD,EAAShF,UAAUmH,OAAS,SAAUjC,EAAQtG,EAASgF,GACrD,IAAIzD,EAAG8C,EAAKgE,EACRjF,EAAS,GACTxC,EAAQK,KAAKL,MAEjB,IAAKW,EAAI,EAAG8C,EAAMiC,EAAO9E,OAAQD,EAAI8C,EAAK9C,IACxC8G,EAAO/B,EAAO/E,GAAG8G,KAEJ,WAATA,EACFjF,GAAUnC,KAAKqH,aAAahC,EAAO/E,GAAGiG,SAAUxH,EAASgF,GACzB,qBAAhBpE,EAAMyH,GACtBjF,GAAUxC,EAAM0F,EAAO/E,GAAG8G,MAAM/B,EAAQ/E,EAAGvB,EAASgF,EAAK/D,MAEzDmC,GAAUnC,KAAKwG,YAAYnB,EAAQ/E,EAAGvB,EAASgF,GAInD,OAAO5B,GAGTtD,EAAOC,QAAUqG,G,oCC3UjBtG,EAAOC,QAAU,CACfC,QAAS,CACPC,MAAc,EACdC,UAAc,EACdC,QAAc,EACdC,WAAc,YACdC,SAAc,EAGdC,aAAc,EAOdC,OAAQ,OAQRC,UAAW,KAEXC,WAAc,KAGhBC,WAAY,CAEVC,KAAM,GACNE,MAAO,GACPC,OAAQ,M,kCC7BZ,IAAIE,EAAS,EAAQ,QAGjB0C,EAAS,CACX,CAAE,YAAkB,EAAQ,SAC5B,CAAE,QAAkB,EAAQ,SAC5B,CAAE,SAAkB,EAAQ,SAC5B,CAAE,UAAkB,EAAQ,SAC5B,CAAE,eAAkB,EAAQ,SAC5B,CAAE,cAAkB,EAAQ,UAO9B,SAAS8E,IAMPvH,KAAK8C,MAAQ,IAAI/C,EAEjB,IAAK,IAAIO,EAAI,EAAGA,EAAImC,EAAOlC,OAAQD,IACjCN,KAAK8C,MAAM7B,KAAKwB,EAAOnC,GAAG,GAAImC,EAAOnC,GAAG,IAU5CiH,EAAKpH,UAAUqH,QAAU,SAAUvE,GACjC,IAAI3C,EAAGwG,EAAGnH,EAIV,IAFAA,EAAQK,KAAK8C,MAAMP,SAAS,IAEvBjC,EAAI,EAAGwG,EAAInH,EAAMY,OAAQD,EAAIwG,EAAGxG,IACnCX,EAAMW,GAAG2C,IAIbsE,EAAKpH,UAAU8D,MAAQ,EAAQ,QAG/BpF,EAAOC,QAAUyI","file":"js/chunk-3975e5be.13e11219.js","sourcesContent":["// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline'\n      ]\n    },\n\n    block: {\n      rules: [\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'text_collapse'\n      ]\n    }\n  }\n};\n","// Commonmark default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         true,         // Enable HTML tags in source\n    xhtmlOut:     true,         // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'text_collapse'\n      ]\n    }\n  }\n};\n","/**\n * class Ruler\n *\n * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and\n * [[MarkdownIt#inline]] to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and\n * [[MarkdownIt.use]].\n **/\n'use strict';\n\n\n/**\n * new Ruler()\n **/\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Helper methods, should not be used directly\n\n\n// Find rule index by name\n//\nRuler.prototype.__find__ = function (name) {\n  for (var i = 0; i < this.__rules__.length; i++) {\n    if (this.__rules__[i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n\n// Build rules lookup cache\n//\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = [ '' ];\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) { return; }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) { return; }\n\n      if (chain && rule.alt.indexOf(chain) < 0) { return; }\n\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function & options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing typorgapher replacement rule with new one:\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.at('replacements', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.at = function (name, fn, options) {\n  var index = this.__find__(name);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + name); }\n\n  this.__rules__[index].fn = fn;\n  this.__rules__[index].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.before(beforeName, ruleName, fn [, options])\n * - beforeName (String): new rule will be added before this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain before one with given name. See also\n * [[Ruler.after]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var index = this.__find__(beforeName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName); }\n\n  this.__rules__.splice(index, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.after(afterName, ruleName, fn [, options])\n * - afterName (String): new rule will be added after this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain after one with given name. See also\n * [[Ruler.before]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.inline.ruler.after('text', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var index = this.__find__(afterName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + afterName); }\n\n  this.__rules__.splice(index + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.push(ruleName, fn [, options])\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Push new rule to the end of chain. See also\n * [[Ruler.before]], [[Ruler.after]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.push('my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.push = function (ruleName, fn, options) {\n  var opt = options || {};\n\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.enable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to enable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.disable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.enableOnly(list [, ignoreInvalid])\n * - list (String|Array): list of rule names to enable (whitelist).\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names, and disable everything else. If any rule name\n * not found - throw Error. Errors can be disabled by second param.\n *\n * See also [[Ruler.disable]], [[Ruler.enable]].\n **/\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  this.__rules__.forEach(function (rule) { rule.enabled = false; });\n\n  this.enable(list, ignoreInvalid);\n};\n\n\n/**\n * Ruler.disable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Disable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.enable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.getRules(chainName) -> Array\n *\n * Return array of active functions (rules) for given chain name. It analyzes\n * rules configuration, compiles caches if not exists and returns result.\n *\n * Default chain name is `''` (empty string). It can't be skipped. That's\n * done intentionally, to keep signature monomorphic for high speed.\n **/\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n\n  // Chain can be empty, if rules disabled. But we still have to return Array.\n  return this.__cache__[chainName] || [];\n};\n\nmodule.exports = Ruler;\n","/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Parser rules\n\nvar _rules = [\n  [ 'text',            require('./rules_inline/text') ],\n  [ 'newline',         require('./rules_inline/newline') ],\n  [ 'escape',          require('./rules_inline/escape') ],\n  [ 'backticks',       require('./rules_inline/backticks') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').tokenize ],\n  [ 'emphasis',        require('./rules_inline/emphasis').tokenize ],\n  [ 'link',            require('./rules_inline/link') ],\n  [ 'image',           require('./rules_inline/image') ],\n  [ 'autolink',        require('./rules_inline/autolink') ],\n  [ 'html_inline',     require('./rules_inline/html_inline') ],\n  [ 'entity',          require('./rules_inline/entity') ]\n];\n\nvar _rules2 = [\n  [ 'balance_pairs',   require('./rules_inline/balance_pairs') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').postProcess ],\n  [ 'emphasis',        require('./rules_inline/emphasis').postProcess ],\n  [ 'text_collapse',   require('./rules_inline/text_collapse') ]\n];\n\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline() {\n  var i;\n\n  /**\n   * ParserInline#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n\n  /**\n   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler();\n\n  for (i = 0; i < _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1]);\n  }\n}\n\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  var ok, i, pos = state.pos,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      maxNesting = state.md.options.maxNesting,\n      cache = state.cache;\n\n\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos];\n    return;\n  }\n\n  if (state.level < maxNesting) {\n    for (i = 0; i < len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++;\n      ok = rules[i](state, true);\n      state.level--;\n\n      if (ok) { break; }\n    }\n  } else {\n    // Too much nesting, just skip until the end of the paragraph.\n    //\n    // NOTE: this will cause links to behave incorrectly in the following case,\n    //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n    //\n    //       [[[[[[[[[[[[[[[[[[[[[foo]()\n    //\n    // TODO: remove this workaround when CM standard will allow nested links\n    //       (we can replace it by preventing links from being parsed in\n    //       validation mode)\n    //\n    state.pos = state.posMax;\n  }\n\n  if (!ok) { state.pos++; }\n  cache[pos] = state.pos;\n};\n\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      end = state.posMax,\n      maxNesting = state.md.options.maxNesting;\n\n  while (state.pos < end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n\n    if (state.level < maxNesting) {\n      for (i = 0; i < len; i++) {\n        ok = rules[i](state, false);\n        if (ok) { break; }\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) { break; }\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  var i, rules, len;\n  var state = new this.State(str, md, env, outTokens);\n\n  this.tokenize(state);\n\n  rules = this.ruler2.getRules('');\n  len = rules.length;\n\n  for (i = 0; i < len; i++) {\n    rules[i](state);\n  }\n};\n\n\nParserInline.prototype.State = require('./rules_inline/state_inline');\n\n\nmodule.exports = ParserInline;\n","/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\nvar _rules = [\n  // First 2 params - rule name & source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  [ 'table',      require('./rules_block/table'),      [ 'paragraph', 'reference' ] ],\n  [ 'code',       require('./rules_block/code') ],\n  [ 'fence',      require('./rules_block/fence'),      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'blockquote', require('./rules_block/blockquote'), [ 'paragraph', 'reference', 'list' ] ],\n  [ 'hr',         require('./rules_block/hr'),         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'list',       require('./rules_block/list'),       [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'reference',  require('./rules_block/reference') ],\n  [ 'heading',    require('./rules_block/heading'),    [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'lheading',   require('./rules_block/lheading') ],\n  [ 'html_block', require('./rules_block/html_block'), [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'paragraph',  require('./rules_block/paragraph') ]\n];\n\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock() {\n  /**\n   * ParserBlock#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });\n  }\n}\n\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      line = startLine,\n      hasEmptyLines = false,\n      maxNesting = state.md.options.maxNesting;\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line >= endLine) { break; }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.sCount[line] < state.blkIndent) { break; }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level >= maxNesting) {\n      state.line = endLine;\n      break;\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n      if (ok) { break; }\n    }\n\n    // set state.tight iff we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines;\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n\n    line = state.line;\n\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++;\n\n      // two empty lines should stop the parser in list mode\n      if (line < endLine && state.parentType === 'list' && state.isEmpty(line)) { break; }\n      state.line = line;\n    }\n  }\n};\n\n\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  var state;\n\n  if (!src) { return; }\n\n  state = new this.State(src, md, env, outTokens);\n\n  this.tokenize(state, state.line, state.lineMax);\n};\n\n\nParserBlock.prototype.State = require('./rules_block/state_block');\n\n\nmodule.exports = ParserBlock;\n","/**\n * class Renderer\n *\n * Generates HTML from parsed token stream. Each instance has independent\n * copy of rules. Those can be rewritten with ease. Also, you can add new\n * rules if you create plugin and adds new token types.\n **/\n'use strict';\n\n\nvar assign          = require('./common/utils').assign;\nvar unescapeAll     = require('./common/utils').unescapeAll;\nvar escapeHtml      = require('./common/utils').escapeHtml;\n\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar default_rules = {};\n\n\ndefault_rules.code_inline = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx],\n      attrs = slf.renderAttrs(token);\n\n  return  '<code' + (attrs ? ' ' + attrs : '') + '>' +\n          escapeHtml(tokens[idx].content) +\n          '</code>';\n};\n\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx],\n      attrs = slf.renderAttrs(token);\n\n  return  '<pre' + (attrs ? ' ' + attrs : '') + '><code>' +\n          escapeHtml(tokens[idx].content) +\n          '</code></pre>\\n';\n};\n\n\ndefault_rules.fence = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx],\n      info = token.info ? unescapeAll(token.info).trim() : '',\n      langName = '',\n      highlighted, i, tmpAttrs, tmpToken;\n\n  if (info) {\n    langName = info.split(/\\s+/g)[0];\n  }\n\n  if (options.highlight) {\n    highlighted = options.highlight(token.content, langName) || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n\n  if (highlighted.indexOf('<pre') === 0) {\n    return highlighted + '\\n';\n  }\n\n  // If language exists, inject class gently, without mudofying original token.\n  // May be, one day we will add .clone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    i        = token.attrIndex('class');\n    tmpAttrs = token.attrs ? token.attrs.slice() : [];\n\n    if (i < 0) {\n      tmpAttrs.push([ 'class', options.langPrefix + langName ]);\n    } else {\n      tmpAttrs[i] += ' ' + options.langPrefix + langName;\n    }\n\n    // Fake token just to render attributes\n    tmpToken = {\n      attrs: tmpAttrs\n    };\n\n    return  '<pre><code' + slf.renderAttrs(tmpToken) + '>'\n          + highlighted\n          + '</code></pre>\\n';\n  }\n\n\n  return  '<pre><code' + slf.renderAttrs(token) + '>'\n        + highlighted\n        + '</code></pre>\\n';\n};\n\n\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs[token.attrIndex('alt')][1] =\n    slf.renderInlineAsText(token.children, options, env);\n\n  return slf.renderToken(tokens, idx, options);\n};\n\n\ndefault_rules.hardbreak = function (tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n';\n};\n\n\ndefault_rules.text = function (tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\n\n\ndefault_rules.html_block = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\ndefault_rules.html_inline = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\nfunction Renderer() {\n\n  /**\n   * Renderer#rules -> Object\n   *\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * md.renderer.rules.strong_open  = function () { return '<b>'; };\n   * md.renderer.rules.strong_close = function () { return '</b>'; };\n   *\n   * var result = md.renderInline(...);\n   * ```\n   *\n   * Each rule is called as independed static function with fixed signature:\n   *\n   * ```javascript\n   * function my_token_render(tokens, idx, options, env, renderer) {\n   *   // ...\n   *   return renderedHTML;\n   * }\n   * ```\n   *\n   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)\n   * for more details and examples.\n   **/\n  this.rules = assign({}, default_rules);\n}\n\n\n/**\n * Renderer.renderAttrs(token) -> String\n *\n * Render token attributes to string.\n **/\nRenderer.prototype.renderAttrs = function renderAttrs(token) {\n  var i, l, result;\n\n  if (!token.attrs) { return ''; }\n\n  result = '';\n\n  for (i = 0, l = token.attrs.length; i < l; i++) {\n    result += ' ' + escapeHtml(token.attrs[i][0]) + '=\"' + escapeHtml(token.attrs[i][1]) + '\"';\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.renderToken(tokens, idx, options) -> String\n * - tokens (Array): list of tokens\n * - idx (Numbed): token index to render\n * - options (Object): params of parser instance\n *\n * Default token renderer. Can be overriden by custom function\n * in [[Renderer#rules]].\n **/\nRenderer.prototype.renderToken = function renderToken(tokens, idx, options) {\n  var nextToken,\n      result = '',\n      needLf = false,\n      token = tokens[idx];\n\n  // Tight list paragraphs\n  if (token.hidden) {\n    return '';\n  }\n\n  // Insert a newline between hidden paragraph and subsequent opening\n  // block-level tag.\n  //\n  // For example, here we should insert a newline before blockquote:\n  //  - a\n  //    >\n  //\n  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {\n    result += '\\n';\n  }\n\n  // Add token name, e.g. `<img`\n  result += (token.nesting === -1 ? '</' : '<') + token.tag;\n\n  // Encode attributes, e.g. `<img src=\"foo\"`\n  result += this.renderAttrs(token);\n\n  // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n  if (token.nesting === 0 && options.xhtmlOut) {\n    result += ' /';\n  }\n\n  // Check if we need to add a newline after this tag\n  if (token.block) {\n    needLf = true;\n\n    if (token.nesting === 1) {\n      if (idx + 1 < tokens.length) {\n        nextToken = tokens[idx + 1];\n\n        if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n          needLf = false;\n\n        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `<li></li>`.\n          //\n          needLf = false;\n        }\n      }\n    }\n  }\n\n  result += needLf ? '>\\n' : '>';\n\n  return result;\n};\n\n\n/**\n * Renderer.renderInline(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * The same as [[Renderer.render]], but for single token of `inline` type.\n **/\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  var type,\n      result = '',\n      rules = this.rules;\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options);\n    }\n  }\n\n  return result;\n};\n\n\n/** internal\n * Renderer.renderInlineAsText(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Special kludge for image `alt` attributes to conform CommonMark spec.\n * Don't try to use it! Spec requires to show `alt` content with stripped markup,\n * instead of simple escaping.\n **/\nRenderer.prototype.renderInlineAsText = function (tokens, options, env) {\n  var result = '';\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    if (tokens[i].type === 'text') {\n      result += tokens[i].content;\n    } else if (tokens[i].type === 'image') {\n      result += this.renderInlineAsText(tokens[i].children, options, env);\n    }\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.render(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Takes token stream and generates HTML. Probably, you will never need to call\n * this method directly.\n **/\nRenderer.prototype.render = function (tokens, options, env) {\n  var i, len, type,\n      result = '',\n      rules = this.rules;\n\n  for (i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else if (typeof rules[type] !== 'undefined') {\n      result += rules[tokens[i].type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options, env);\n    }\n  }\n\n  return result;\n};\n\nmodule.exports = Renderer;\n","// markdown-it default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   100            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n","/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n'use strict';\n\n\nvar Ruler  = require('./ruler');\n\n\nvar _rules = [\n  [ 'normalize',      require('./rules_core/normalize')      ],\n  [ 'block',          require('./rules_core/block')          ],\n  [ 'inline',         require('./rules_core/inline')         ],\n  [ 'linkify',        require('./rules_core/linkify')        ],\n  [ 'replacements',   require('./rules_core/replacements')   ],\n  [ 'smartquotes',    require('./rules_core/smartquotes')    ]\n];\n\n\n/**\n * new Core()\n **/\nfunction Core() {\n  /**\n   * Core#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  var i, l, rules;\n\n  rules = this.ruler.getRules('');\n\n  for (i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\n\nCore.prototype.State = require('./rules_core/state_core');\n\n\nmodule.exports = Core;\n"],"sourceRoot":""}