{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/markdown-it/lib/common/utils.js","webpack:///(webpack)/buildin/module.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/uc.micro/categories/P/regex.js","webpack:///./node_modules/markdown-it/lib/ruler.js","webpack:///./node_modules/markdown-it/lib/token.js","webpack:///./node_modules/markdown-it/index.js","webpack:///./node_modules/markdown-it/lib/common/entities.js","webpack:///./node_modules/mdurl/index.js","webpack:///./node_modules/uc.micro/properties/Any/regex.js","webpack:///./node_modules/uc.micro/categories/Cc/regex.js","webpack:///./node_modules/uc.micro/categories/Z/regex.js","webpack:///./node_modules/markdown-it/lib/common/html_re.js","webpack:///./node_modules/markdown-it/lib/rules_inline/strikethrough.js","webpack:///./node_modules/markdown-it/lib/rules_inline/emphasis.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./node_modules/markdown-it-html5-embed/lib/index.js","webpack:///./node_modules/markdown-it/lib/index.js","webpack:///./node_modules/mdurl/encode.js","webpack:///./node_modules/mdurl/decode.js","webpack:///./node_modules/mdurl/format.js","webpack:///./node_modules/mdurl/parse.js","webpack:///./node_modules/uc.micro/index.js","webpack:///./node_modules/uc.micro/categories/Cf/regex.js","webpack:///./node_modules/markdown-it/lib/helpers/index.js","webpack:///./node_modules/markdown-it/lib/helpers/parse_link_label.js","webpack:///./node_modules/markdown-it/lib/helpers/parse_link_destination.js","webpack:///./node_modules/markdown-it/lib/helpers/parse_link_title.js","webpack:///./node_modules/markdown-it/lib/renderer.js","webpack:///./node_modules/markdown-it/lib/parser_core.js","webpack:///./node_modules/markdown-it/lib/rules_core/normalize.js","webpack:///./node_modules/markdown-it/lib/rules_core/block.js","webpack:///./node_modules/markdown-it/lib/rules_core/inline.js","webpack:///./node_modules/markdown-it/lib/rules_core/linkify.js","webpack:///./node_modules/markdown-it/lib/rules_core/replacements.js","webpack:///./node_modules/markdown-it/lib/rules_core/smartquotes.js","webpack:///./node_modules/markdown-it/lib/rules_core/state_core.js","webpack:///./node_modules/markdown-it/lib/parser_block.js","webpack:///./node_modules/markdown-it/lib/rules_block/table.js","webpack:///./node_modules/markdown-it/lib/rules_block/code.js","webpack:///./node_modules/markdown-it/lib/rules_block/fence.js","webpack:///./node_modules/markdown-it/lib/rules_block/blockquote.js","webpack:///./node_modules/markdown-it/lib/rules_block/hr.js","webpack:///./node_modules/markdown-it/lib/rules_block/list.js","webpack:///./node_modules/markdown-it/lib/rules_block/reference.js","webpack:///./node_modules/markdown-it/lib/rules_block/heading.js","webpack:///./node_modules/markdown-it/lib/rules_block/lheading.js","webpack:///./node_modules/markdown-it/lib/rules_block/html_block.js","webpack:///./node_modules/markdown-it/lib/common/html_blocks.js","webpack:///./node_modules/markdown-it/lib/rules_block/paragraph.js","webpack:///./node_modules/markdown-it/lib/rules_block/state_block.js","webpack:///./node_modules/markdown-it/lib/parser_inline.js","webpack:///./node_modules/markdown-it/lib/rules_inline/text.js","webpack:///./node_modules/markdown-it/lib/rules_inline/newline.js","webpack:///./node_modules/markdown-it/lib/rules_inline/escape.js","webpack:///./node_modules/markdown-it/lib/rules_inline/backticks.js","webpack:///./node_modules/markdown-it/lib/rules_inline/link.js","webpack:///./node_modules/markdown-it/lib/rules_inline/image.js","webpack:///./node_modules/markdown-it/lib/rules_inline/autolink.js","webpack:///./node_modules/markdown-it/lib/rules_inline/html_inline.js","webpack:///./node_modules/markdown-it/lib/rules_inline/entity.js","webpack:///./node_modules/markdown-it/lib/rules_inline/balance_pairs.js","webpack:///./node_modules/markdown-it/lib/rules_inline/text_collapse.js","webpack:///./node_modules/markdown-it/lib/rules_inline/state_inline.js","webpack:///./node_modules/linkify-it/index.js","webpack:///./node_modules/linkify-it/lib/re.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/markdown-it/lib/presets/default.js","webpack:///./node_modules/markdown-it/lib/presets/zero.js","webpack:///./node_modules/markdown-it/lib/presets/commonmark.js","webpack:///./node_modules/mimoza/index.js","webpack:///./node_modules/mimoza/node_modules/mime-db/index.js","webpack:///./app/javascript/packs/markdown_viewer.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","_typeof","obj","iterator","constructor","_hasOwnProperty","has","isValidEntityCode","fromCodePoint","surrogate1","surrogate2","String","fromCharCode","UNESCAPE_MD_RE","UNESCAPE_ALL_RE","RegExp","source","DIGITAL_ENTITY_TEST_RE","entities","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","ch","REGEXP_ESCAPE_RE","UNICODE_PUNCT_RE","lib","mdurl","ucmicro","assign","sources","Array","slice","arguments","forEach","TypeError","keys","isString","toString","_class","unescapeMd","str","indexOf","replace","unescapeAll","match","escaped","entity","code","charCodeAt","test","toLowerCase","parseInt","replaceEntityPattern","escapeHtml","arrayReplaceAt","src","pos","newElements","concat","isSpace","isWhiteSpace","isMdAsciiPunct","isPunctChar","escapeRE","normalizeReference","trim","toUpperCase","webpackPolyfill","deprecate","paths","children","g","this","Function","e","window","Ruler","__rules__","__cache__","__find__","length","__compile__","self","chains","rule","enabled","alt","altName","push","chain","fn","at","options","index","opt","Error","before","beforeName","ruleName","splice","after","afterName","enable","list","ignoreInvalid","isArray","result","idx","enableOnly","disable","getRules","chainName","Token","type","tag","nesting","attrs","map","level","content","markup","info","meta","block","hidden","attrIndex","len","attrPush","attrData","attrSet","attrGet","attrJoin","encode","decode","format","parse","open_tag","close_tag","HTML_TAG_RE","HTML_OPEN_CLOSE_TAG_RE","postProcess","state","delimiters","j","startDelim","endDelim","token","loneMarkers","max","marker","end","tokens","pop","tokenize","silent","scanned","start","scanDelims","jump","open","can_open","close","can_close","curr","tokens_meta","isStrong","__webpack_amd_options__","Mimoza","messages","en","parseToken","env","parsed","description","aIndex","isLink","url","mimeType","getMimeType","mimetype_matches","exec","mediaType","fallback","translate","messageKey","messageParam","language","title","isAllowedToEmbed","isAllowedMimeType","isAllowedHttp","isAllowedSchema","renderMediaEmbed","mediaAttributes","attributes","join","html5EmbedRenderer","renderer","defaultRender","html5embed","clearTokens","messageObj","rv","md","gstate","defaults","audio","video","useImageSyntax","inline","autoAppend","embedPlaceDirectiveRegexp","utils","ruler","startLine","endLine","_endLine","regexp","build_token","bMarks","tShift","eMarks","currentLine","substring","line","findDirective","rules","html5media","_","action","_idx","_tokens","core","is_allowed_mime_type","image","useLinkSyntax","link_open","renderToken","translateFn","renderFn","helpers","Renderer","ParserCore","ParserBlock","ParserInline","LinkifyIt","punycode","config","zero","commonmark","BAD_PROTO_RE","GOOD_DATA_RE","validateLink","RECODE_HOSTNAME_FOR","normalizeLink","hostname","protocol","toASCII","er","normalizeLinkText","toUnicode","MarkdownIt","presetName","linkify","configure","set","presets","components","rules2","ruler2","missed","filter","use","plugin","args","apply","State","process","render","parseInline","inlineMode","renderInline","encodeCache","string","exclude","keepEscaped","nextCode","cache","defaultChars","getEncodeCache","encodeURIComponent","componentChars","decodeCache","getDecodeCache","seq","b1","b2","b3","b4","chr","slashes","auth","port","pathname","search","hash","Url","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","hostlessProtocol","slashedProtocol","slashesDenoteHost","lowerProto","hec","rest","split","simplePath","proto","substr","atSign","hostEnd","lastIndexOf","host","parseHost","ipv6Hostname","hostparts","part","newpart","k","validParts","notHost","bit","unshift","qm","u","Any","Cc","Cf","P","Z","parseLinkLabel","parseLinkDestination","parseLinkTitle","disableNested","found","prevPos","labelEnd","posMax","oldPos","skipToken","ok","lines","default_rules","code_inline","slf","renderAttrs","code_block","fence","highlighted","tmpAttrs","tmpToken","langName","highlight","langPrefix","renderInlineAsText","hardbreak","xhtmlOut","softbreak","breaks","text","html_block","html_inline","nextToken","needLf","_rules","Core","NEWLINES_RE","NULL_RE","tok","isLinkClose","currentToken","nodes","ln","lastPos","htmlLinkLevel","fullUrl","urlText","links","blockTokens","pretest","schema","lastIndex","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","tm","replaceFn","replace_scoped","inlineTokens","inside_autolink","replace_rare","blkIdx","typographer","QUOTE_TEST_RE","QUOTE_RE","replaceAt","process_inlines","thisLevel","item","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","canOpen","canClose","isSingle","stack","openQuote","closeQuote","OUTER","single","quotes","StateCore","hasEmptyLines","maxNesting","skipEmptyLines","sCount","blkIndent","tight","isEmpty","outTokens","lineMax","getLine","escapedSplit","escapes","backTicked","lastBackTick","lineText","nextLine","columns","columnCount","aligns","tableLines","tbodyLines","last","getLines","params","mem","haveEndMarker","skipChars","skipSpaces","adjustTab","initial","lastLineEmpty","offset","oldBMarks","oldBSCount","oldIndent","oldParentType","oldSCount","oldTShift","spaceAfterMarker","terminate","terminatorRules","wasOutdented","oldLineMax","bsCount","parentType","cnt","skipBulletListMarker","skipOrderedListMarker","contentStart","indent","indentAfterMarker","isOrdered","itemLines","listLines","listTokIdx","markerCharCode","markerValue","oldListIndent","oldTight","posAfterMarker","prevEmptyEnd","isTerminatingParagraph","listIndent","Number","Math","min","markTightParagraphs","destEndPos","destEndLineNo","href","label","res","references","tmp","skipSpacesBack","skipCharsBack","block_names","HTML_SEQUENCES","html","StateBlock","indent_found","ddIndent","from","begin","keepLastLF","lineIndent","first","queue","lineStart","_rules2","pending","pushPending","isTerminatorChar","pmax","ESCAPED","matchStart","matchEnd","labelStart","ref","parseReference","EMAIL_RE","AUTOLINK_RE","tail","linkMatch","emailMatch","lc","isLetter","DIGITAL_RE","NAMED_RE","processDelimiters","closerIdx","openerIdx","closer","opener","minOpenerIdx","newMinOpenerIdx","isOddMatch","lastJump","openersBottom","StateInline","pendingLevel","_prev_delimiters","token_meta","canSplitWord","count","left_flanking","right_flanking","isFunction","defaultOptions","fuzzyLink","fuzzyEmail","fuzzyIP","defaultSchemas","validate","re","http","src_auth","src_host_port_strict","src_path","no_http","src_domain","src_domain_root","src_port","src_host_terminator","mailto","src_email_name","src_host_strict","tlds_default","compile","__opts__","tlds","__tlds__","untpl","tpl","src_tlds","onCompile","__tlds_replaced__","src_xn","email_fuzzy","tpl_email_fuzzy","link_fuzzy","tpl_link_fuzzy","link_no_ip_fuzzy","tpl_link_no_ip_fuzzy","host_fuzzy_test","tpl_host_fuzzy_test","aliases","schemaError","val","__compiled__","__schemas__","compiled","link","isRegExp","createValidator","normalize","alias","slist","schema_test","src_ZPCc","schema_search","__index__","__text_cache__","resetScanCache","Match","shift","__last_index__","__schema__","raw","createMatch","schemas","reduce","acc","add","definition","ml","me","next","tld_pos","testSchemaAt","keepOld","sort","el","arr","reverse","opts","src_Any","src_Cc","src_Z","src_P","src_ZCc","src_pseudo_letter","src_ip4","src_host","tpl_host_fuzzy","tpl_host_no_ip_fuzzy","tpl_host_fuzzy_strict","tpl_host_port_fuzzy_strict","tpl_host_port_no_ip_fuzzy_strict","root","freeExports","nodeType","freeModule","freeGlobal","global","maxInt","base","regexPunycode","regexNonASCII","regexSeparators","errors","floor","stringFromCharCode","error","RangeError","array","mapDomain","parts","ucs2decode","extra","output","counter","ucs2encode","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","baseMinusTMin","input","out","basic","oldi","w","baseMinusT","codePoint","inputLength","bias","handledCPCount","basicLength","q","currentValue","handledCPCountPlusOne","qMinusT","db","path","clearMime","defaultType","preloaded","mime","extensions","register","clone","types","overrideDefault","ext","getExtension","TEXT_MIME_RE","isText","builtin","addEventListener","require","document","getElementById","innerHTML"],"mappings":";aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,qBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,kBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,UAIjBlC,EAAoBA,EAAoBmC,EAAI,K,+BC9ErD,SAASC,EAAQC,GAAkC,OAAOD,EAAU,mBAAqBjB,QAAU,iBAAmBA,OAAOmB,SAAW,SAAUD,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAO,mBAAqBlB,QAAUkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,GAAQD,EAAQC,GAUzU,IAAIG,EAAkB1B,OAAOkB,UAAUC,eAEvC,SAASQ,EAAIX,EAAQH,GACnB,OAAOa,EAAgBjC,KAAKuB,EAAQH,GAgCtC,SAASe,EAAkBjC,GAGzB,QAAIA,GAAK,OAAUA,GAAK,WAKpBA,GAAK,OAAUA,GAAK,SAIH,SAAZ,MAAJA,IAA2C,SAAZ,MAAJA,OAK5BA,GAAK,GAAQA,GAAK,KAIZ,KAANA,MAIAA,GAAK,IAAQA,GAAK,QAIlBA,GAAK,KAAQA,GAAK,QAKlBA,EAAI,eAOV,SAASkC,EAAclC,GAErB,GAAIA,EAAI,MAAQ,CAEd,IAAImC,EAAa,QADjBnC,GAAK,QAC2B,IAC5BoC,EAAa,OAAc,KAAJpC,GAC3B,OAAOqC,OAAOC,aAAaH,EAAYC,GAGzC,OAAOC,OAAOC,aAAatC,GAG7B,IAAIuC,EAAiB,8CAEjBC,EAAkB,IAAIC,OAAOF,EAAeG,OAAS,IADzC,6BACyDA,OAAQ,MAC7EC,EAAyB,qCAEzBC,EAAW,EAAQ,IAmDvB,IAAIC,EAAsB,SACtBC,EAAyB,UACzBC,EAAoB,CACtB,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,UAGP,SAASC,EAAkBC,GACzB,OAAOF,EAAkBE,GAY3B,IAAIC,EAAmB,uBAiDvB,IAAIC,EAAmB,EAAQ,GA+K/B1D,EAAQ2D,IAAM,GACd3D,EAAQ2D,IAAIC,MAAQ,EAAQ,IAC5B5D,EAAQ2D,IAAIE,QAAU,EAAQ,IAC9B7D,EAAQ8D,OAjYR,SAAgB3B,GAGd,IAAI4B,EAAUC,MAAMlC,UAAUmC,MAAM5D,KAAK6D,UAAW,GAcpD,OAbAH,EAAQI,SAAQ,SAAUlB,GACxB,GAAKA,EAAL,CAIA,GAAwB,WAApBf,EAAQe,GACV,MAAM,IAAImB,UAAUnB,EAAS,kBAG/BrC,OAAOyD,KAAKpB,GAAQkB,SAAQ,SAAU1C,GACpCU,EAAIV,GAAOwB,EAAOxB,UAGfU,GAiXTnC,EAAQsE,SA9YR,SAAkBnC,GAChB,MAAuB,oBALzB,SAAgBA,GACd,OAAOvB,OAAOkB,UAAUyC,SAASlE,KAAK8B,GAI/BqC,CAAOrC,IA8YhBnC,EAAQuC,IAAMA,EACdvC,EAAQyE,WAnRR,SAAoBC,GAClB,OAAIA,EAAIC,QAAQ,MAAQ,EACfD,EAGFA,EAAIE,QAAQ9B,EAAgB,OA+QrC9C,EAAQ6E,YA5QR,SAAqBH,GACnB,OAAIA,EAAIC,QAAQ,MAAQ,GAAKD,EAAIC,QAAQ,KAAO,EACvCD,EAGFA,EAAIE,QAAQ7B,GAAiB,SAAU+B,EAAOC,EAASC,GAC5D,OAAID,GAxCR,SAA8BD,EAAOrE,GACnC,IAAIwE,EAAO,EAEX,OAAI1C,EAAIY,EAAU1C,GACT0C,EAAS1C,GAGS,KAAvBA,EAAKyE,WAAW,IAEjBhC,EAAuBiC,KAAK1E,IAGzB+B,EAFJyC,EAAiC,MAA1BxE,EAAK,GAAG2E,cAAwBC,SAAS5E,EAAKwD,MAAM,GAAI,IAAMoB,SAAS5E,EAAKwD,MAAM,GAAI,KAGpFxB,EAAcwC,GAIlBH,EA2BEQ,CAAqBR,EAAOE,OAmQvChF,EAAQwC,kBAAoBA,EAC5BxC,EAAQyC,cAAgBA,EAExBzC,EAAQuF,WApPR,SAAoBb,GAClB,OAAItB,EAAoB+B,KAAKT,GACpBA,EAAIE,QAAQvB,EAAwBE,GAGtCmB,GAgPT1E,EAAQwF,eApXR,SAAwBC,EAAKC,EAAKC,GAChC,MAAO,GAAGC,OAAOH,EAAIxB,MAAM,EAAGyB,GAAMC,EAAaF,EAAIxB,MAAMyB,EAAM,KAoXnE1F,EAAQ6F,QAtOR,SAAiBZ,GACf,OAAQA,GACN,KAAK,EACL,KAAK,GACH,OAAO,EAGX,OAAO,GAgOTjF,EAAQ8F,aA5NR,SAAsBb,GACpB,GAAIA,GAAQ,MAAUA,GAAQ,KAC5B,OAAO,EAGT,OAAQA,GACN,KAAK,EAEL,KAAK,GAEL,KAAK,GAEL,KAAK,GAEL,KAAK,GAEL,KAAK,GACL,KAAK,IACL,KAAK,KACL,KAAK,KACL,KAAK,KACL,KAAK,MACH,OAAO,EAGX,OAAO,GAoMTjF,EAAQ+F,eAhLR,SAAwBvC,GACtB,OAAQA,GACN,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,IAGL,KAAK,IAGL,KAAK,IAGL,KAAK,IAGH,OAAO,EAET,QACE,OAAO,IA4EbxD,EAAQgG,YA5LR,SAAqBxC,GACnB,OAAOE,EAAiByB,KAAK3B,IA4L/BxD,EAAQiG,SA/OR,SAAkBvB,GAChB,OAAOA,EAAIE,QAAQnB,EAAkB,SA+OvCzD,EAAQkG,mBAxER,SAA4BxB,GA8C1B,OA3CAA,EAAMA,EAAIyB,OAAOvB,QAAQ,OAAQ,KAOP,WAAtB,SAAIQ,gBACNV,EAAMA,EAAIE,QAAQ,UAAM,SAmCnBF,EAAIU,cAAcgB,gB,iBC5Y3BnG,EAAOD,QAAU,SAAUC,GAsBzB,OArBKA,EAAOoG,kBACVpG,EAAOqG,UAAY,aAEnBrG,EAAOsG,MAAQ,GAEVtG,EAAOuG,WAAUvG,EAAOuG,SAAW,IACxC5F,OAAOC,eAAeZ,EAAQ,SAAU,CACtCa,YAAY,EACZC,IAAK,WACH,OAAOd,EAAOE,KAGlBS,OAAOC,eAAeZ,EAAQ,KAAM,CAClCa,YAAY,EACZC,IAAK,WACH,OAAOd,EAAOC,KAGlBD,EAAOoG,gBAAkB,GAGpBpG,I,eCtBT,SAASiC,EAAQC,GAAkC,OAAOD,EAAU,mBAAqBjB,QAAU,iBAAmBA,OAAOmB,SAAW,SAAUD,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAO,mBAAqBlB,QAAUkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,GAAQD,EAAQC,GAEzU,IAAIsE,EAEJA,EAAI,WACF,OAAOC,KADL,GAIJ,IAEED,EAAIA,GAAK,IAAIE,SAAS,cAAb,GACT,MAAOC,GAEiE,YAAjD,qBAAXC,OAAyB,YAAc3E,EAAQ2E,WAAuBJ,EAAII,QAMxF5G,EAAOD,QAAUyG,G,cCnBjBxG,EAAOD,QAAU,s2D,6BCsBjB,SAAS8G,IAUPJ,KAAKK,UAAY,GAMjBL,KAAKM,UAAY,KAOnBF,EAAMhF,UAAUmF,SAAW,SAAUxG,GACnC,IAAK,IAAIP,EAAI,EAAGA,EAAIwG,KAAKK,UAAUG,OAAQhH,IACzC,GAAIwG,KAAKK,UAAU7G,GAAGO,OAASA,EAC7B,OAAOP,EAIX,OAAQ,GAKV4G,EAAMhF,UAAUqF,YAAc,WAC5B,IAAIC,EAAOV,KACPW,EAAS,CAAC,IAEdD,EAAKL,UAAU5C,SAAQ,SAAUmD,GAC1BA,EAAKC,SAIVD,EAAKE,IAAIrD,SAAQ,SAAUsD,GACrBJ,EAAO1C,QAAQ8C,GAAW,GAC5BJ,EAAOK,KAAKD,SAKlBL,EAAKJ,UAAY,GACjBK,EAAOlD,SAAQ,SAAUwD,GACvBP,EAAKJ,UAAUW,GAAS,GAExBP,EAAKL,UAAU5C,SAAQ,SAAUmD,GAC1BA,EAAKC,UAINI,GAASL,EAAKE,IAAI7C,QAAQgD,GAAS,GAIvCP,EAAKJ,UAAUW,GAAOD,KAAKJ,EAAKM,YA+BtCd,EAAMhF,UAAU+F,GAAK,SAAUpH,EAAMmH,EAAIE,GACvC,IAAIC,EAAQrB,KAAKO,SAASxG,GAEtBuH,EAAMF,GAAW,GAErB,IAAe,IAAXC,EACF,MAAM,IAAIE,MAAM,0BAA4BxH,GAG9CiG,KAAKK,UAAUgB,GAAOH,GAAKA,EAC3BlB,KAAKK,UAAUgB,GAAOP,IAAMQ,EAAIR,KAAO,GACvCd,KAAKM,UAAY,MA4BnBF,EAAMhF,UAAUoG,OAAS,SAAUC,EAAYC,EAAUR,EAAIE,GAC3D,IAAIC,EAAQrB,KAAKO,SAASkB,GAEtBH,EAAMF,GAAW,GAErB,IAAe,IAAXC,EACF,MAAM,IAAIE,MAAM,0BAA4BE,GAG9CzB,KAAKK,UAAUsB,OAAON,EAAO,EAAG,CAC9BtH,KAAM2H,EACNb,SAAS,EACTK,GAAIA,EACJJ,IAAKQ,EAAIR,KAAO,KAGlBd,KAAKM,UAAY,MA4BnBF,EAAMhF,UAAUwG,MAAQ,SAAUC,EAAWH,EAAUR,EAAIE,GACzD,IAAIC,EAAQrB,KAAKO,SAASsB,GAEtBP,EAAMF,GAAW,GAErB,IAAe,IAAXC,EACF,MAAM,IAAIE,MAAM,0BAA4BM,GAG9C7B,KAAKK,UAAUsB,OAAON,EAAQ,EAAG,EAAG,CAClCtH,KAAM2H,EACNb,SAAS,EACTK,GAAIA,EACJJ,IAAKQ,EAAIR,KAAO,KAGlBd,KAAKM,UAAY,MA2BnBF,EAAMhF,UAAU4F,KAAO,SAAUU,EAAUR,EAAIE,GAC7C,IAAIE,EAAMF,GAAW,GAErBpB,KAAKK,UAAUW,KAAK,CAClBjH,KAAM2H,EACNb,SAAS,EACTK,GAAIA,EACJJ,IAAKQ,EAAIR,KAAO,KAGlBd,KAAKM,UAAY,MAgBnBF,EAAMhF,UAAU0G,OAAS,SAAUC,EAAMC,GAClC1E,MAAM2E,QAAQF,KACjBA,EAAO,CAACA,IAGV,IAAIG,EAAS,GAiBb,OAfAH,EAAKtE,SAAQ,SAAU1D,GACrB,IAAIoI,EAAMnC,KAAKO,SAASxG,GAExB,GAAIoI,EAAM,EAAG,CACX,GAAIH,EACF,OAGF,MAAM,IAAIT,MAAM,oCAAsCxH,GAGxDiG,KAAKK,UAAU8B,GAAKtB,SAAU,EAC9BqB,EAAOlB,KAAKjH,KACXiG,MACHA,KAAKM,UAAY,KACV4B,GAcT9B,EAAMhF,UAAUgH,WAAa,SAAUL,EAAMC,GACtC1E,MAAM2E,QAAQF,KACjBA,EAAO,CAACA,IAGV/B,KAAKK,UAAU5C,SAAQ,SAAUmD,GAC/BA,EAAKC,SAAU,KAGjBb,KAAK8B,OAAOC,EAAMC,IAgBpB5B,EAAMhF,UAAUiH,QAAU,SAAUN,EAAMC,GACnC1E,MAAM2E,QAAQF,KACjBA,EAAO,CAACA,IAGV,IAAIG,EAAS,GAiBb,OAfAH,EAAKtE,SAAQ,SAAU1D,GACrB,IAAIoI,EAAMnC,KAAKO,SAASxG,GAExB,GAAIoI,EAAM,EAAG,CACX,GAAIH,EACF,OAGF,MAAM,IAAIT,MAAM,oCAAsCxH,GAGxDiG,KAAKK,UAAU8B,GAAKtB,SAAU,EAC9BqB,EAAOlB,KAAKjH,KACXiG,MACHA,KAAKM,UAAY,KACV4B,GAaT9B,EAAMhF,UAAUkH,SAAW,SAAUC,GAMnC,OALuB,OAAnBvC,KAAKM,WACPN,KAAKS,cAIAT,KAAKM,UAAUiC,IAAc,IAGtChJ,EAAOD,QAAU8G,G,6BC1WjB,SAASoC,EAAMC,EAAMC,EAAKC,GAMxB3C,KAAKyC,KAAOA,EAOZzC,KAAK0C,IAAMA,EAOX1C,KAAK4C,MAAQ,KAOb5C,KAAK6C,IAAM,KAWX7C,KAAK2C,QAAUA,EAOf3C,KAAK8C,MAAQ,EAOb9C,KAAKF,SAAW,KAQhBE,KAAK+C,QAAU,GAOf/C,KAAKgD,OAAS,GAOdhD,KAAKiD,KAAO,GAOZjD,KAAKkD,KAAO,KAQZlD,KAAKmD,OAAQ,EAQbnD,KAAKoD,QAAS,EAShBZ,EAAMpH,UAAUiI,UAAY,SAAmBtJ,GAC7C,IAAI6I,EAAOpJ,EAAG8J,EAEd,IAAKtD,KAAK4C,MACR,OAAQ,EAKV,IAAKpJ,EAAI,EAAG8J,GAFZV,EAAQ5C,KAAK4C,OAEWpC,OAAQhH,EAAI8J,EAAK9J,IACvC,GAAIoJ,EAAMpJ,GAAG,KAAOO,EAClB,OAAOP,EAIX,OAAQ,GASVgJ,EAAMpH,UAAUmI,SAAW,SAAkBC,GACvCxD,KAAK4C,MACP5C,KAAK4C,MAAM5B,KAAKwC,GAEhBxD,KAAK4C,MAAQ,CAACY,IAUlBhB,EAAMpH,UAAUqI,QAAU,SAAiB1J,EAAMU,GAC/C,IAAI0H,EAAMnC,KAAKqD,UAAUtJ,GACrByJ,EAAW,CAACzJ,EAAMU,GAElB0H,EAAM,EACRnC,KAAKuD,SAASC,GAEdxD,KAAK4C,MAAMT,GAAOqB,GAUtBhB,EAAMpH,UAAUsI,QAAU,SAAiB3J,GACzC,IAAIoI,EAAMnC,KAAKqD,UAAUtJ,GACrBU,EAAQ,KAMZ,OAJI0H,GAAO,IACT1H,EAAQuF,KAAK4C,MAAMT,GAAK,IAGnB1H,GAUT+H,EAAMpH,UAAUuI,SAAW,SAAkB5J,EAAMU,GACjD,IAAI0H,EAAMnC,KAAKqD,UAAUtJ,GAErBoI,EAAM,EACRnC,KAAKuD,SAAS,CAACxJ,EAAMU,IAErBuF,KAAK4C,MAAMT,GAAK,GAAKnC,KAAK4C,MAAMT,GAAK,GAAK,IAAM1H,GAIpDlB,EAAOD,QAAUkJ,G,+BCvMjBjJ,EAAOD,QAAU,EAAQ,K,6BCGzBC,EAAOD,QAAU,EAAQ,K,6BCHzBC,EAAOD,QAAQsK,OAAS,EAAQ,IAChCrK,EAAOD,QAAQuK,OAAS,EAAQ,IAChCtK,EAAOD,QAAQwK,OAAS,EAAQ,IAChCvK,EAAOD,QAAQyK,MAAQ,EAAQ,K,cCL/BxK,EAAOD,QAAU,oI,cCAjBC,EAAOD,QAAU,sB,cCAjBC,EAAOD,QAAU,4D,6BCGjB,IAMI0K,EAAW,kIACXC,EAAY,mCAKZC,EAAc,IAAI5H,OAAO,OAAS0H,EAAW,IAAMC,EAA1B,qHACzBE,EAAyB,IAAI7H,OAAO,OAAS0H,EAAW,IAAMC,EAAY,KAC9E1K,EAAOD,QAAQ4K,YAAcA,EAC7B3K,EAAOD,QAAQ6K,uBAAyBA,G,6BCuCxC,SAASC,EAAYC,EAAOC,GAC1B,IAAI9K,EACA+K,EACAC,EACAC,EACAC,EACAC,EAAc,GACdC,EAAMN,EAAW9D,OAErB,IAAKhH,EAAI,EAAGA,EAAIoL,EAAKpL,IAGO,OAF1BgL,EAAaF,EAAW9K,IAETqL,SAMS,IAApBL,EAAWM,MAIfL,EAAWH,EAAWE,EAAWM,MACjCJ,EAAQL,EAAMU,OAAOP,EAAWE,QAC1BjC,KAAO,SACbiC,EAAMhC,IAAM,IACZgC,EAAM/B,QAAU,EAChB+B,EAAM1B,OAAS,KACf0B,EAAM3B,QAAU,IAChB2B,EAAQL,EAAMU,OAAON,EAASC,QACxBjC,KAAO,UACbiC,EAAMhC,IAAM,IACZgC,EAAM/B,SAAW,EACjB+B,EAAM1B,OAAS,KACf0B,EAAM3B,QAAU,GAE8B,SAA1CsB,EAAMU,OAAON,EAASC,MAAQ,GAAGjC,MAAgE,MAA7C4B,EAAMU,OAAON,EAASC,MAAQ,GAAG3B,SACvF4B,EAAY3D,KAAKyD,EAASC,MAAQ,IAUtC,KAAOC,EAAYnE,QAAQ,CAIzB,IAFA+D,GADA/K,EAAImL,EAAYK,OACR,EAEDT,EAAIF,EAAMU,OAAOvE,QAAmC,YAAzB6D,EAAMU,OAAOR,GAAG9B,MAChD8B,IAKE/K,MAFJ+K,IAGEG,EAAQL,EAAMU,OAAOR,GACrBF,EAAMU,OAAOR,GAAKF,EAAMU,OAAOvL,GAC/B6K,EAAMU,OAAOvL,GAAKkL,IAhHxBnL,EAAOD,QAAQ2L,SAAW,SAAuBZ,EAAOa,GACtD,IAAI1L,EACA2L,EAEA7B,EACAxG,EACAsI,EAAQf,EAAMrF,IACd6F,EAASR,EAAMtF,IAAIP,WAAW4G,GAElC,GAAIF,EACF,OAAO,EAGT,GAAe,MAAXL,EAGF,OAAO,EAOT,GAHAvB,GADA6B,EAAUd,EAAMgB,WAAWhB,EAAMrF,KAAK,IACxBwB,OACd1D,EAAKZ,OAAOC,aAAa0I,GAErBvB,EAAM,EACR,OAAO,EAST,IANIA,EAAM,IACAe,EAAMrD,KAAK,OAAQ,GAAI,GACzB+B,QAAUjG,EAChBwG,KAGG9J,EAAI,EAAGA,EAAI8J,EAAK9J,GAAK,EAChB6K,EAAMrD,KAAK,OAAQ,GAAI,GACzB+B,QAAUjG,EAAKA,EACrBuH,EAAMC,WAAWtD,KAAK,CACpB6D,OAAQA,EACRrE,OAAQ,EAER8E,KAAM9L,EACNkL,MAAOL,EAAMU,OAAOvE,OAAS,EAC7BsE,KAAM,EACNS,KAAMJ,EAAQK,SACdC,MAAON,EAAQO,YAKnB,OADArB,EAAMrF,KAAOmG,EAAQ3E,QACd,GAsETjH,EAAOD,QAAQ8K,YAAc,SAAuBC,GAClD,IAAIsB,EACAC,EAAcvB,EAAMuB,YACpBhB,EAAMP,EAAMuB,YAAYpF,OAG5B,IAFA4D,EAAYC,EAAOA,EAAMC,YAEpBqB,EAAO,EAAGA,EAAOf,EAAKe,IACrBC,EAAYD,IAASC,EAAYD,GAAMrB,YACzCF,EAAYC,EAAOuB,EAAYD,GAAMrB,c,6BCrE3C,SAASF,EAAYC,EAAOC,GAC1B,IAAI9K,EACAgL,EACAC,EACAC,EACA5H,EACA+I,EAGJ,IAAKrM,EAFK8K,EAAW9D,OAEN,EAAGhH,GAAK,EAAGA,IAGE,MAF1BgL,EAAaF,EAAW9K,IAETqL,QAEU,KAAtBL,EAAWK,SAOU,IAApBL,EAAWM,MAIfL,EAAWH,EAAWE,EAAWM,KAMjCe,EAAWrM,EAAI,GAAK8K,EAAW9K,EAAI,GAAGsL,MAAQN,EAAWM,IAAM,GAAKR,EAAW9K,EAAI,GAAGkL,QAAUF,EAAWE,MAAQ,GAAKJ,EAAWE,EAAWM,IAAM,GAAGJ,QAAUD,EAASC,MAAQ,GAAKJ,EAAW9K,EAAI,GAAGqL,SAAWL,EAAWK,OAC/N/H,EAAKZ,OAAOC,aAAaqI,EAAWK,SACpCH,EAAQL,EAAMU,OAAOP,EAAWE,QAC1BjC,KAAOoD,EAAW,cAAgB,UACxCnB,EAAMhC,IAAMmD,EAAW,SAAW,KAClCnB,EAAM/B,QAAU,EAChB+B,EAAM1B,OAAS6C,EAAW/I,EAAKA,EAAKA,EACpC4H,EAAM3B,QAAU,IAChB2B,EAAQL,EAAMU,OAAON,EAASC,QACxBjC,KAAOoD,EAAW,eAAiB,WACzCnB,EAAMhC,IAAMmD,EAAW,SAAW,KAClCnB,EAAM/B,SAAW,EACjB+B,EAAM1B,OAAS6C,EAAW/I,EAAKA,EAAKA,EACpC4H,EAAM3B,QAAU,GAEZ8C,IACFxB,EAAMU,OAAOT,EAAW9K,EAAI,GAAGkL,OAAO3B,QAAU,GAChDsB,EAAMU,OAAOT,EAAWE,EAAWM,IAAM,GAAGJ,OAAO3B,QAAU,GAC7DvJ,MA3GND,EAAOD,QAAQ2L,SAAW,SAAkBZ,EAAOa,GACjD,IAAI1L,EACA2L,EAEAC,EAAQf,EAAMrF,IACd6F,EAASR,EAAMtF,IAAIP,WAAW4G,GAElC,GAAIF,EACF,OAAO,EAGT,GAAe,KAAXL,GAEU,KAAXA,EAGD,OAAO,EAKT,IAFAM,EAAUd,EAAMgB,WAAWhB,EAAMrF,IAAgB,KAAX6F,GAEjCrL,EAAI,EAAGA,EAAI2L,EAAQ3E,OAAQhH,IACtB6K,EAAMrD,KAAK,OAAQ,GAAI,GACzB+B,QAAU7G,OAAOC,aAAa0I,GACpCR,EAAMC,WAAWtD,KAAK,CAGpB6D,OAAQA,EAGRrE,OAAQ2E,EAAQ3E,OAQhB8E,KAAM9L,EAGNkL,MAAOL,EAAMU,OAAOvE,OAAS,EAI7BsE,KAAM,EAINS,KAAMJ,EAAQK,SACdC,MAAON,EAAQO,YAKnB,OADArB,EAAMrF,KAAOmG,EAAQ3E,QACd,GA2DTjH,EAAOD,QAAQ8K,YAAc,SAAkBC,GAC7C,IAAIsB,EACAC,EAAcvB,EAAMuB,YACpBhB,EAAMP,EAAMuB,YAAYpF,OAG5B,IAFA4D,EAAYC,EAAOA,EAAMC,YAEpBqB,EAAO,EAAGA,EAAOf,EAAKe,IACrBC,EAAYD,IAASC,EAAYD,GAAMrB,YACzCF,EAAYC,EAAOuB,EAAYD,GAAMrB,c,eC/H3C,YACA/K,EAAOD,QAAUwM,I,4CCGjB,IAAIC,EAAS,EAAQ,IAcjBC,EAAW,CACbC,GAAI,CACF,sBAAuB,kIACvB,sBAAuB,kIACvB,sBAAuB,2CACvB,iBAAkB,iBAClB,iBAAkB,mBAqBtB,SAASC,EAAWnB,EAAQ5C,EAAKgE,GAC/B,IAAIC,EAAS,GACT1B,EAAQK,EAAO5C,GACfkE,EAAc,GACdC,EAAS5B,EAAMrB,UAAU,OAC7B+C,EAAOG,OAASD,EAAS,EAErBF,EAAOG,QACTD,EAAS5B,EAAMrB,UAAU,QACzBgD,EAActB,EAAO5C,EAAM,GAAGY,SAE9BsD,EAAc3B,EAAM3B,QAGtBqD,EAAOI,IAAM9B,EAAM9B,MAAM0D,GAAQ,GACjCF,EAAOK,SAAWV,EAAOW,YAAYN,EAAOI,KAC5C,IACIG,EADK,uBACiBC,KAAKR,EAAOK,UAiCtC,OA9BEL,EAAOS,UADgB,OAArBF,EACiB,KAEAA,EAAiB,GAGb,OAArBP,EAAOS,YAITT,EAAOU,SAAWC,EAAU,CAC1BC,WAAYZ,EAAOS,UAAY,iBAC/BI,aAAcb,EAAOI,IACrBU,SAAUf,EAAIe,WAGZb,EAAY5G,OAAOe,QACrB4F,EAAOU,UAAY,KAAOC,EAAU,CAClCC,WAAY,sBACZC,aAAcZ,EACda,SAAUf,EAAIe,WAEhBd,EAAOe,MAAQd,GAEfD,EAAOe,MAAQJ,EAAU,CACvBC,WAAY,YAAcZ,EAAOS,UACjCK,SAAUf,EAAIe,YAKbd,EAeT,SAASgB,EAAiBhB,EAAQhF,GAChC,OAbF,SAA2BgF,EAAQhF,GACjC,OAA4B,OAArBgF,EAAOS,aAAwBzF,EAAQiG,mBAAqBjG,EAAQiG,kBAAkB,CAACjB,EAAOK,SAAUL,EAAOS,aAY/GQ,CAAkBjB,EAAQhF,IATnC,SAAyBgF,EAAQhF,GAC/B,SAAKA,EAAQkG,eAAiBlB,EAAOI,IAAIpI,MAAM,aAQFmJ,CAAgBnB,EAAQhF,GAGvE,SAASoG,EAAiBpB,EAAQqB,GAChC,IAAIC,EAAaD,EAAgBrB,EAAOS,WACxC,MAAO,CAAC,IAAMT,EAAOS,UAAY,IAAMa,EAAa,IAAK,iBAAmBtB,EAAOK,SAAW,UAAYL,EAAOI,IAAM,cAAeJ,EAAOU,SAAU,KAAOV,EAAOS,UAAY,KAAKc,KAAK,MAG7L,SAASC,EAAmB7C,EAAQ5C,EAAKf,EAAS+E,EAAK0B,EAAUC,GAC/D,IAAI1B,EAASF,EAAWnB,EAAQ5C,EAAKgE,GAErC,OAAKiB,EAAiBhB,EAAQhF,EAAQ2G,aAIlC3B,EAAOG,QAlGb,SAAqBxB,EAAQ5C,GAC3B,IAAK,IAAI3I,EAAI2I,EAAK3I,EAAIuL,EAAOvE,OAAQhH,IACnC,OAAQuL,EAAOvL,GAAGiJ,MAChB,IAAK,aACHsC,EAAOvL,GAAG4J,QAAS,EACnB,MAEF,IAAK,OACH2B,EAAOvL,GAAGuJ,QAAU,GACpB,MAEF,QACE,KAAM,qBAAuBgC,EAAOvL,GAAGiJ,MAuF3CuF,CAAYjD,EAAQ5C,EAAM,GAGrBqF,EAAiBpB,EAAQhF,EAAQ2G,WAAWL,aAP1CI,EAAc/C,EAAQ5C,EAAKf,EAAS+E,EAAK0B,GA+DpD,SAASd,EAAUkB,GAGjB,IACIC,EAAKlI,KADMiI,EAAWf,UAAYlH,KAAKiI,EAAWf,WAAalH,KAAKiI,EAAWf,UAAUe,EAAWjB,YAAciB,EAAWf,SAAW,MACpHe,EAAWjB,YAMnC,OAJIiB,EAAWhB,eACbiB,EAAKA,EAAGhK,QAAQ,KAAM+J,EAAWhB,eAG5BiB,EAGT3O,EAAOD,QAAU,SAA4B6O,EAAI/G,GAC/C,IAAIgH,EACAC,EAAW,CACbX,WAAY,CACVY,MAAO,8BACPC,MAAO,+BAETC,gBAAgB,EAChBC,QAAQ,EACRC,YAAY,EACZC,0BAA2B,wBAC3B3C,SAAUA,GA6CZ,IA3CI5E,EAAU+G,EAAGS,MAAMxL,OAAO,GAAIiL,EAAUjH,EAAQ2G,aAEvCU,SACXN,EAAGhF,MAAM0F,MAAMrH,OAAO,YAAa,cAAc,SAAU6C,EAAOyE,EAAWC,EAAS7D,GACpF,OAvEN,SAAuBb,EAAOyE,EAAWE,EAAU9D,EAAQ+D,EAAQC,GACjE,IAAIlK,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GAEnBQ,EAAcjF,EAAMtF,IAAIwK,UAAUvK,EAAK4F,GACvCxG,EAAQ6K,EAAOrC,KAAK0C,GAExB,GAAc,OAAVlL,GAAkBA,EAAMoC,OAAS,EACnC,OAAO,EAGT,GAAI0E,EACF,OAAO,EAGTb,EAAMmF,KAAOV,EAAY,EAEzB,IAAIpE,EAAQwE,IAGZ,OAFAxE,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,MAC9B9E,EAAM1B,OAASsG,GACR,EAmDIG,CAAcpF,EAAOyE,EAAWC,EAAS7D,EAAQ9D,EAAQuH,2BAA2B,WACzF,OAAOtE,EAAMrD,KAAK,aAAc,aAAc,SAIlDmH,EAAGN,SAAS6B,MAAMC,WAAa,SAAU5E,EAAQ1D,EAAOuI,EAAGzD,GACzD,IAzF0B0D,EAyFtB3H,EAAS,GAeb,OAxG0B2H,EA0FF,SAAU9E,EAAQ5C,GACxC,IAAIiE,EAASF,EAAWnB,EAAQ5C,EAAKgE,GAEhCiB,EAAiBhB,EAAQhF,KAI9Bc,GAAUsF,EAAiBpB,EAAQhF,EAAQsG,cAP7BU,EAzFdrD,OAAOtH,SAAQ,SAAUiH,EAAOoF,EAAMC,GACvB,WAAfrF,EAAMjC,MACRiC,EAAM5E,SAASrC,SAAQ,SAAUiH,EAAOvC,EAAK4C,GACxB,cAAfL,EAAMjC,MACRoH,EAAO9E,EAAQ5C,SA+FfD,EAAO1B,SACT0B,GAAU,MAGLA,GAITiG,EAAG6B,KAAKnB,MAAM7H,KAAK,cAAc,SAAUqD,GAGzC,GAFA+D,EAAS/D,EAELjD,EAAQsH,WAAY,CACtB,IAAIhE,EAAQ,IAAIL,EAAM7B,MAAM,aAAc,GAAI,GAC9C6B,EAAMU,OAAO/D,KAAK0D,QAKiB,qBAA9BtD,EAAQiG,oBACjBjG,EAAQiG,kBAAoBjG,EAAQ6I,sBAGlC7I,EAAQqH,QAAUrH,EAAQoH,eAAgB,CAC5C,IAAIV,EAAgBK,EAAGN,SAAS6B,MAAMQ,MAEtC/B,EAAGN,SAAS6B,MAAMQ,MAAQ,SAAUnF,EAAQ5C,EAAKb,EAAK6E,EAAKzF,GAEzD,OADAY,EAAIyG,WAAa3G,EACVwG,EAAmB7C,EAAQ5C,EAAKb,EAAK6E,EAAKzF,EAAMoH,IAI3D,GAAI1G,EAAQqH,QAAUrH,EAAQ+I,cAAe,CACvCrC,EAAgBK,EAAGN,SAAS6B,MAAMU,WAAa,SAAUrF,EAAQ5C,EAAKf,EAAS+E,EAAKzF,GACtF,OAAOA,EAAK2J,YAAYtF,EAAQ5C,EAAKf,IAGvC+G,EAAGN,SAAS6B,MAAMU,UAAY,SAAUrF,EAAQ5C,EAAKb,EAAK6E,EAAKzF,GAE7D,OADAY,EAAIyG,WAAa3G,EACVwG,EAAmB7C,EAAQ5C,EAAKb,EAAK6E,EAAKzF,EAAMoH,IAM3Df,EAA0C,mBAAvB3F,EAAQkJ,YAA4BlJ,EAAQkJ,YAAYtP,KAAKoG,EAAQ4E,UAAYe,EAAU/L,KAAKoG,EAAQ4E,UAE5F,mBAApB5E,EAAQmJ,WACjB/C,EAAmBpG,EAAQmJ,Y,4CCrR/B,IAAI3B,EAAQ,EAAQ,GAEhB4B,EAAU,EAAQ,IAElBC,EAAW,EAAQ,IAEnBC,EAAa,EAAQ,IAErBC,EAAc,EAAQ,IAEtBC,EAAe,EAAQ,IAEvBC,EAAY,EAAQ,IAEpB3N,EAAQ,EAAQ,IAEhB4N,EAAW,EAAQ,IAEnBC,EAAS,CACX,QAAW,EAAQ,IACnBC,KAAM,EAAQ,IACdC,WAAY,EAAQ,KAUlBC,EAAe,oCACfC,EAAe,oCAEnB,SAASC,EAAa5E,GAEpB,IAAIxI,EAAMwI,EAAI/G,OAAOf,cACrB,OAAOwM,EAAazM,KAAKT,MAAOmN,EAAa1M,KAAKT,GAIpD,IAAIqN,EAAsB,CAAC,QAAS,SAAU,WAE9C,SAASC,EAAc9E,GACrB,IAAIJ,EAASlJ,EAAM6G,MAAMyC,GAAK,GAE9B,GAAIJ,EAAOmF,YAOJnF,EAAOoF,UAAYH,EAAoBpN,QAAQmI,EAAOoF,WAAa,GACtE,IACEpF,EAAOmF,SAAWT,EAASW,QAAQrF,EAAOmF,UAC1C,MAAOG,IAMb,OAAOxO,EAAM0G,OAAO1G,EAAM4G,OAAOsC,IAGnC,SAASuF,EAAkBnF,GACzB,IAAIJ,EAASlJ,EAAM6G,MAAMyC,GAAK,GAE9B,GAAIJ,EAAOmF,YAOJnF,EAAOoF,UAAYH,EAAoBpN,QAAQmI,EAAOoF,WAAa,GACtE,IACEpF,EAAOmF,SAAWT,EAASc,UAAUxF,EAAOmF,UAC5C,MAAOG,IAMb,OAAOxO,EAAM2G,OAAO3G,EAAM4G,OAAOsC,IAyInC,SAASyF,EAAWC,EAAY1K,GAC9B,KAAMpB,gBAAgB6L,GACpB,OAAO,IAAIA,EAAWC,EAAY1K,GAG/BA,GACEwH,EAAMhL,SAASkO,KAClB1K,EAAU0K,GAAc,GACxBA,EAAa,WAYjB9L,KAAKyI,OAAS,IAAImC,EASlB5K,KAAKmD,MAAQ,IAAIwH,EASjB3K,KAAKgK,KAAO,IAAIU,EAuBhB1K,KAAK6H,SAAW,IAAI4C,EASpBzK,KAAK+L,QAAU,IAAIlB,EAiBnB7K,KAAKoL,aAAeA,EAQpBpL,KAAKsL,cAAgBA,EAOrBtL,KAAK2L,kBAAoBA,EASzB3L,KAAK4I,MAAQA,EAQb5I,KAAKwK,QAAU5B,EAAMxL,OAAO,GAAIoN,GAChCxK,KAAKoB,QAAU,GACfpB,KAAKgM,UAAUF,GAEX1K,GACFpB,KAAKiM,IAAI7K,GAwBbyK,EAAWzQ,UAAU6Q,IAAM,SAAU7K,GAEnC,OADAwH,EAAMxL,OAAO4C,KAAKoB,QAASA,GACpBpB,MAcT6L,EAAWzQ,UAAU4Q,UAAY,SAAUE,GACzC,IACIJ,EADApL,EAAOV,KAGX,GAAI4I,EAAMhL,SAASsO,MAEjBA,EAAUnB,EADVe,EAAaI,IAIX,MAAM,IAAI3K,MAAM,+BAAiCuK,EAAa,iBAIlE,IAAKI,EACH,MAAM,IAAI3K,MAAM,8CAmBlB,OAhBI2K,EAAQ9K,SACVV,EAAKuL,IAAIC,EAAQ9K,SAGf8K,EAAQC,YACVjS,OAAOyD,KAAKuO,EAAQC,YAAY1O,SAAQ,SAAU1D,GAC5CmS,EAAQC,WAAWpS,GAAM2P,OAC3BhJ,EAAK3G,GAAM8O,MAAMzG,WAAW8J,EAAQC,WAAWpS,GAAM2P,OAGnDwC,EAAQC,WAAWpS,GAAMqS,QAC3B1L,EAAK3G,GAAMsS,OAAOjK,WAAW8J,EAAQC,WAAWpS,GAAMqS,WAKrDpM,MAqBT6L,EAAWzQ,UAAU0G,OAAS,SAAUC,EAAMC,GAC5C,IAAIE,EAAS,GAER5E,MAAM2E,QAAQF,KACjBA,EAAO,CAACA,IAGV,CAAC,OAAQ,QAAS,UAAUtE,SAAQ,SAAUwD,GAC5CiB,EAASA,EAAOhD,OAAOc,KAAKiB,GAAO4H,MAAM/G,OAAOC,GAAM,MACrD/B,MACHkC,EAASA,EAAOhD,OAAOc,KAAKyI,OAAO4D,OAAOvK,OAAOC,GAAM,IACvD,IAAIuK,EAASvK,EAAKwK,QAAO,SAAUxS,GACjC,OAAOmI,EAAOjE,QAAQlE,GAAQ,KAGhC,GAAIuS,EAAO9L,SAAWwB,EACpB,MAAM,IAAIT,MAAM,iDAAmD+K,GAGrE,OAAOtM,MAWT6L,EAAWzQ,UAAUiH,QAAU,SAAUN,EAAMC,GAC7C,IAAIE,EAAS,GAER5E,MAAM2E,QAAQF,KACjBA,EAAO,CAACA,IAGV,CAAC,OAAQ,QAAS,UAAUtE,SAAQ,SAAUwD,GAC5CiB,EAASA,EAAOhD,OAAOc,KAAKiB,GAAO4H,MAAMxG,QAAQN,GAAM,MACtD/B,MACHkC,EAASA,EAAOhD,OAAOc,KAAKyI,OAAO4D,OAAOhK,QAAQN,GAAM,IACxD,IAAIuK,EAASvK,EAAKwK,QAAO,SAAUxS,GACjC,OAAOmI,EAAOjE,QAAQlE,GAAQ,KAGhC,GAAIuS,EAAO9L,SAAWwB,EACpB,MAAM,IAAIT,MAAM,kDAAoD+K,GAGtE,OAAOtM,MAoBT6L,EAAWzQ,UAAUoR,IAAM,SAAUC,GAGnC,IAAIC,EAAO,CAAC1M,MAAMd,OAAO5B,MAAMlC,UAAUmC,MAAM5D,KAAK6D,UAAW,IAE/D,OADAiP,EAAOE,MAAMF,EAAQC,GACd1M,MAmBT6L,EAAWzQ,UAAU2I,MAAQ,SAAUhF,EAAKoH,GAC1C,GAAmB,kBAARpH,EACT,MAAM,IAAIwC,MAAM,iCAGlB,IAAI8C,EAAQ,IAAIrE,KAAKgK,KAAK4C,MAAM7N,EAAKiB,KAAMmG,GAE3C,OADAnG,KAAKgK,KAAK6C,QAAQxI,GACXA,EAAMU,QAef8G,EAAWzQ,UAAU0R,OAAS,SAAU/N,EAAKoH,GAE3C,OADAA,EAAMA,GAAO,GACNnG,KAAK6H,SAASiF,OAAO9M,KAAK+D,MAAMhF,EAAKoH,GAAMnG,KAAKoB,QAAS+E,IAalE0F,EAAWzQ,UAAU2R,YAAc,SAAUhO,EAAKoH,GAChD,IAAI9B,EAAQ,IAAIrE,KAAKgK,KAAK4C,MAAM7N,EAAKiB,KAAMmG,GAG3C,OAFA9B,EAAM2I,YAAa,EACnBhN,KAAKgK,KAAK6C,QAAQxI,GACXA,EAAMU,QAYf8G,EAAWzQ,UAAU6R,aAAe,SAAUlO,EAAKoH,GAEjD,OADAA,EAAMA,GAAO,GACNnG,KAAK6H,SAASiF,OAAO9M,KAAK+M,YAAYhO,EAAKoH,GAAMnG,KAAKoB,QAAS+E,IAGxE5M,EAAOD,QAAUuS,G,ghvCC/kBjB,IAAIqB,EAAc,GAwClB,SAAStJ,EAAOuJ,EAAQC,EAASC,GAC/B,IAAI7T,EACAC,EACA8E,EACA+O,EACAC,EACArL,EAAS,GAcb,IAZuB,kBAAZkL,IAETC,EAAcD,EACdA,EAAUxJ,EAAO4J,cAGQ,qBAAhBH,IACTA,GAAc,GAGhBE,EAtDF,SAAwBH,GACtB,IAAI5T,EACAsD,EACAyQ,EAAQL,EAAYE,GAExB,GAAIG,EACF,OAAOA,EAKT,IAFAA,EAAQL,EAAYE,GAAW,GAE1B5T,EAAI,EAAGA,EAAI,IAAKA,IACnBsD,EAAKZ,OAAOC,aAAa3C,GAErB,cAAciF,KAAK3B,GAErByQ,EAAMvM,KAAKlE,GAEXyQ,EAAMvM,KAAK,KAAO,IAAMxH,EAAEqE,SAAS,IAAI6B,eAAenC,OAAO,IAIjE,IAAK/D,EAAI,EAAGA,EAAI4T,EAAQ5M,OAAQhH,IAC9B+T,EAAMH,EAAQ5O,WAAWhF,IAAM4T,EAAQ5T,GAGzC,OAAO+T,EA4BCE,CAAeL,GAElB5T,EAAI,EAAGC,EAAI0T,EAAO3M,OAAQhH,EAAIC,EAAGD,IAGpC,GAFA+E,EAAO4O,EAAO3O,WAAWhF,GAErB6T,GAAwB,KAAT9O,GAEhB/E,EAAI,EAAIC,GACL,iBAAiBgF,KAAK0O,EAAO5P,MAAM/D,EAAI,EAAGA,EAAI,IAChD0I,GAAUiL,EAAO5P,MAAM/D,EAAGA,EAAI,GAC9BA,GAAK,OAKT,GAAI+E,EAAO,IACT2D,GAAUqL,EAAMhP,QAIlB,GAAIA,GAAQ,OAAUA,GAAQ,MAA9B,CACE,GAAIA,GAAQ,OAAUA,GAAQ,OAAU/E,EAAI,EAAIC,IAC9C6T,EAAWH,EAAO3O,WAAWhF,EAAI,KAEjB,OAAU8T,GAAY,MAAQ,CAC5CpL,GAAUwL,mBAAmBP,EAAO3T,GAAK2T,EAAO3T,EAAI,IACpDA,IACA,SAIJ0I,GAAU,iBAIZA,GAAUwL,mBAAmBP,EAAO3T,IAGtC,OAAO0I,EAGT0B,EAAO4J,aAAe,uBACtB5J,EAAO+J,eAAiB,YACxBpU,EAAOD,QAAUsK,G,6BCpGjB,IAAIgK,EAAc,GA4BlB,SAAS/J,EAAOsJ,EAAQC,GACtB,IAAIG,EAOJ,MALuB,kBAAZH,IACTA,EAAUvJ,EAAO2J,cAGnBD,EAjCF,SAAwBH,GACtB,IAAI5T,EACAsD,EACAyQ,EAAQK,EAAYR,GAExB,GAAIG,EACF,OAAOA,EAKT,IAFAA,EAAQK,EAAYR,GAAW,GAE1B5T,EAAI,EAAGA,EAAI,IAAKA,IACnBsD,EAAKZ,OAAOC,aAAa3C,GACzB+T,EAAMvM,KAAKlE,GAGb,IAAKtD,EAAI,EAAGA,EAAI4T,EAAQ5M,OAAQhH,IAE9B+T,EADAzQ,EAAKsQ,EAAQ5O,WAAWhF,IACZ,KAAO,IAAMsD,EAAGe,SAAS,IAAI6B,eAAenC,OAAO,GAGjE,OAAOgQ,EAYCM,CAAeT,GAChBD,EAAOjP,QAAQ,qBAAqB,SAAU4P,GACnD,IAAItU,EACAC,EACAsU,EACAC,EACAC,EACAC,EACAC,EACAjM,EAAS,GAEb,IAAK1I,EAAI,EAAGC,EAAIqU,EAAItN,OAAQhH,EAAIC,EAAGD,GAAK,GACtCuU,EAAKpP,SAASmP,EAAIvQ,MAAM/D,EAAI,EAAGA,EAAI,GAAI,KAE9B,IACP0I,GAAUqL,EAAMQ,GAIE,OAAV,IAALA,IAAuBvU,EAAI,EAAIC,GAId,OAAV,KAFVuU,EAAKrP,SAASmP,EAAIvQ,MAAM/D,EAAI,EAAGA,EAAI,GAAI,OAMnC0I,IAHFiM,EAAMJ,GAAM,EAAI,KAAa,GAALC,GAEd,IACE,eAEA9R,OAAOC,aAAagS,GAGhC3U,GAAK,GAKW,OAAV,IAALuU,IAAuBvU,EAAI,EAAIC,IAElCuU,EAAKrP,SAASmP,EAAIvQ,MAAM/D,EAAI,EAAGA,EAAI,GAAI,IACvCyU,EAAKtP,SAASmP,EAAIvQ,MAAM/D,EAAI,EAAGA,EAAI,GAAI,IAEnB,OAAV,IAALwU,IAAuC,OAAV,IAALC,KAIzB/L,IAHFiM,EAAMJ,GAAM,GAAK,MAASC,GAAM,EAAI,KAAa,GAALC,GAElC,MAASE,GAAO,OAAUA,GAAO,MAC/B,qBAEAjS,OAAOC,aAAagS,GAGhC3U,GAAK,GAKW,OAAV,IAALuU,IAAuBvU,EAAI,EAAIC,IAElCuU,EAAKrP,SAASmP,EAAIvQ,MAAM/D,EAAI,EAAGA,EAAI,GAAI,IACvCyU,EAAKtP,SAASmP,EAAIvQ,MAAM/D,EAAI,EAAGA,EAAI,GAAI,IACvC0U,EAAKvP,SAASmP,EAAIvQ,MAAM/D,EAAI,GAAIA,EAAI,IAAK,IAErB,OAAV,IAALwU,IAAuC,OAAV,IAALC,IAAuC,OAAV,IAALC,MACnDC,EAAMJ,GAAM,GAAK,QAAWC,GAAM,GAAK,OAAUC,GAAM,EAAI,KAAa,GAALC,GAEzD,OAAWC,EAAM,QACzBjM,GAAU,4BAEViM,GAAO,MACPjM,GAAUhG,OAAOC,aAAa,OAAUgS,GAAO,IAAK,OAAgB,KAANA,KAGhE3U,GAAK,GAKT0I,GAAU,SAGZ,OAAOA,KAIX2B,EAAO2J,aAAe,cACtB3J,EAAO8J,eAAiB,GACxBpU,EAAOD,QAAUuK,G,6BC1HjBtK,EAAOD,QAAU,SAAgBkN,GAC/B,IAAItE,EAAS,GAgBb,OAfAA,GAAUsE,EAAIgF,UAAY,GAC1BtJ,GAAUsE,EAAI4H,QAAU,KAAO,GAC/BlM,GAAUsE,EAAI6H,KAAO7H,EAAI6H,KAAO,IAAM,GAElC7H,EAAI+E,WAA2C,IAA/B/E,EAAI+E,SAAStN,QAAQ,KAEvCiE,GAAU,IAAMsE,EAAI+E,SAAW,IAE/BrJ,GAAUsE,EAAI+E,UAAY,GAG5BrJ,GAAUsE,EAAI8H,KAAO,IAAM9H,EAAI8H,KAAO,GACtCpM,GAAUsE,EAAI+H,UAAY,GAC1BrM,GAAUsE,EAAIgI,QAAU,GACxBtM,GAAUsE,EAAIiI,MAAQ,K,6BCuBxB,SAASC,IACP1O,KAAKwL,SAAW,KAChBxL,KAAKoO,QAAU,KACfpO,KAAKqO,KAAO,KACZrO,KAAKsO,KAAO,KACZtO,KAAKuL,SAAW,KAChBvL,KAAKyO,KAAO,KACZzO,KAAKwO,OAAS,KACdxO,KAAKuO,SAAW,KAMlB,IAAII,EAAkB,oBAClBC,EAAc,WAElBC,EAAoB,qCAKpBC,EAAS,CAAC,IAAK,IAAK,IAAK,KAAM,IAAK,KAAK5P,OAFhC,CAAC,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,OAI/C6P,EAAa,CAAC,KAAM7P,OAAO4P,GAK3BE,EAAe,CAAC,IAAK,IAAK,IAAK,IAAK,KAAK9P,OAAO6P,GAC5CE,EAAkB,CAAC,IAAK,IAAK,KAE7BC,EAAsB,yBACtBC,EAAoB,+BAKxBC,EAAmB,CACjB,YAAc,EACd,eAAe,GAGjBC,EAAkB,CAChB,MAAQ,EACR,OAAS,EACT,KAAO,EACP,QAAU,EACV,MAAQ,EACR,SAAS,EACT,UAAU,EACV,QAAQ,EACR,WAAW,EACX,SAAS,GAcXX,EAAItT,UAAU2I,MAAQ,SAAUyC,EAAK8I,GACnC,IAAI9V,EACAC,EACA8V,EACAC,EACApB,EACAqB,EAAOjJ,EAKX,GAFAiJ,EAAOA,EAAKhQ,QAEP6P,GAA+C,IAA1B9I,EAAIkJ,MAAM,KAAKlP,OAAc,CAErD,IAAImP,EAAad,EAAkBjI,KAAK6I,GAExC,GAAIE,EAOF,OANA3P,KAAKuO,SAAWoB,EAAW,GAEvBA,EAAW,KACb3P,KAAKwO,OAASmB,EAAW,IAGpB3P,KAIX,IAAI4P,EAAQjB,EAAgB/H,KAAK6I,GAsBjC,GApBIG,IAEFL,GADAK,EAAQA,EAAM,IACKlR,cACnBsB,KAAKwL,SAAWoE,EAChBH,EAAOA,EAAKI,OAAOD,EAAMpP,UAOvB8O,GAAqBM,GAASH,EAAKrR,MAAM,6BAC3CgQ,EAAgC,OAAtBqB,EAAKI,OAAO,EAAG,KAERD,GAASR,EAAiBQ,KACzCH,EAAOA,EAAKI,OAAO,GACnB7P,KAAKoO,SAAU,KAIdgB,EAAiBQ,KAAWxB,GAAWwB,IAAUP,EAAgBO,IAAS,CAe7E,IAYIvB,EAAMyB,EAZNC,GAAW,EAEf,IAAKvW,EAAI,EAAGA,EAAIyV,EAAgBzO,OAAQhH,KAGzB,KAFbgW,EAAMC,EAAKxR,QAAQgR,EAAgBzV,QAEH,IAAbuW,GAAkBP,EAAMO,KACzCA,EAAUP,GA4Bd,KATgB,KATdM,GAFe,IAAbC,EAEON,EAAKO,YAAY,KAIjBP,EAAKO,YAAY,IAAKD,MAM/B1B,EAAOoB,EAAKlS,MAAM,EAAGuS,GACrBL,EAAOA,EAAKlS,MAAMuS,EAAS,GAC3B9P,KAAKqO,KAAOA,GAId0B,GAAW,EAENvW,EAAI,EAAGA,EAAIwV,EAAaxO,OAAQhH,KAGtB,KAFbgW,EAAMC,EAAKxR,QAAQ+Q,EAAaxV,QAEA,IAAbuW,GAAkBP,EAAMO,KACzCA,EAAUP,IAKG,IAAbO,IACFA,EAAUN,EAAKjP,QAGS,MAAtBiP,EAAKM,EAAU,IACjBA,IAGF,IAAIE,EAAOR,EAAKlS,MAAM,EAAGwS,GACzBN,EAAOA,EAAKlS,MAAMwS,GAElB/P,KAAKkQ,UAAUD,GAGfjQ,KAAKuL,SAAWvL,KAAKuL,UAAY,GAGjC,IAAI4E,EAAoC,MAArBnQ,KAAKuL,SAAS,IAA0D,MAA5CvL,KAAKuL,SAASvL,KAAKuL,SAAS/K,OAAS,GAEpF,IAAK2P,EAAc,CACjB,IAAIC,EAAYpQ,KAAKuL,SAASmE,MAAM,MAEpC,IAAKlW,EAAI,EAAGC,EAAI2W,EAAU5P,OAAQhH,EAAIC,EAAGD,IAAK,CAC5C,IAAI6W,EAAOD,EAAU5W,GAErB,GAAK6W,IAIAA,EAAKjS,MAAM8Q,GAAsB,CAGpC,IAFA,IAAIoB,EAAU,GAEL/L,EAAI,EAAGgM,EAAIF,EAAK7P,OAAQ+D,EAAIgM,EAAGhM,IAClC8L,EAAK7R,WAAW+F,GAAK,IAIvB+L,GAAW,IAEXA,GAAWD,EAAK9L,GAKpB,IAAK+L,EAAQlS,MAAM8Q,GAAsB,CACvC,IAAIsB,EAAaJ,EAAU7S,MAAM,EAAG/D,GAChCiX,EAAUL,EAAU7S,MAAM/D,EAAI,GAC9BkX,EAAML,EAAKjS,MAAM+Q,GAEjBuB,IACFF,EAAWxP,KAAK0P,EAAI,IACpBD,EAAQE,QAAQD,EAAI,KAGlBD,EAAQjQ,SACViP,EAAOgB,EAAQ9I,KAAK,KAAO8H,GAG7BzP,KAAKuL,SAAWiF,EAAW7I,KAAK,KAChC,SAMJ3H,KAAKuL,SAAS/K,OA/MD,MAgNfR,KAAKuL,SAAW,IAKd4E,IACFnQ,KAAKuL,SAAWvL,KAAKuL,SAASsE,OAAO,EAAG7P,KAAKuL,SAAS/K,OAAS,IAKnE,IAAIiO,EAAOgB,EAAKxR,QAAQ,MAEV,IAAVwQ,IAEFzO,KAAKyO,KAAOgB,EAAKI,OAAOpB,GACxBgB,EAAOA,EAAKlS,MAAM,EAAGkR,IAGvB,IAAImC,EAAKnB,EAAKxR,QAAQ,KAetB,OAbY,IAAR2S,IACF5Q,KAAKwO,OAASiB,EAAKI,OAAOe,GAC1BnB,EAAOA,EAAKlS,MAAM,EAAGqT,IAGnBnB,IACFzP,KAAKuO,SAAWkB,GAGdJ,EAAgBE,IAAevP,KAAKuL,WAAavL,KAAKuO,WACxDvO,KAAKuO,SAAW,IAGXvO,MAGT0O,EAAItT,UAAU8U,UAAY,SAAUD,GAClC,IAAI3B,EAAOM,EAAYhI,KAAKqJ,GAExB3B,IAGW,OAFbA,EAAOA,EAAK,MAGVtO,KAAKsO,KAAOA,EAAKuB,OAAO,IAG1BI,EAAOA,EAAKJ,OAAO,EAAGI,EAAKzP,OAAS8N,EAAK9N,SAGvCyP,IACFjQ,KAAKuL,SAAW0E,IAIpB1W,EAAOD,QA7OP,SAAkBkN,EAAK8I,GACrB,GAAI9I,GAAOA,aAAekI,EACxB,OAAOlI,EAGT,IAAIqK,EAAI,IAAInC,EAEZ,OADAmC,EAAE9M,MAAMyC,EAAK8I,GACNuB,I,6BCvGTvX,EAAQwX,IAAM,EAAQ,IACtBxX,EAAQyX,GAAK,EAAQ,IACrBzX,EAAQ0X,GAAK,EAAQ,IACrB1X,EAAQ2X,EAAI,EAAQ,GACpB3X,EAAQ4X,EAAI,EAAQ,K,cCNpB3X,EAAOD,QAAU,yN,6BCGjBA,EAAQ6X,eAAiB,EAAQ,IACjC7X,EAAQ8X,qBAAuB,EAAQ,IACvC9X,EAAQ+X,eAAiB,EAAQ,K,6BCEjC9X,EAAOD,QAAU,SAAwB+K,EAAOe,EAAOkM,GACrD,IAAIxO,EACAyO,EACA1M,EACA2M,EACAC,GAAY,EACZ7M,EAAMP,EAAMqN,OACZC,EAAStN,EAAMrF,IAInB,IAHAqF,EAAMrF,IAAMoG,EAAQ,EACpBtC,EAAQ,EAEDuB,EAAMrF,IAAM4F,GAAK,CAGtB,GAAe,MAFfC,EAASR,EAAMtF,IAAIP,WAAW6F,EAAMrF,OAOpB,MAFd8D,EAEiB,CACfyO,GAAQ,EACR,MAOJ,GAHAC,EAAUnN,EAAMrF,IAChBqF,EAAM8D,GAAGM,OAAOmJ,UAAUvN,GAEX,KAAXQ,EAGF,GAAI2M,IAAYnN,EAAMrF,IAAM,EAE1B8D,SACK,GAAIwO,EAET,OADAjN,EAAMrF,IAAM2S,GACJ,EAWd,OANIJ,IACFE,EAAWpN,EAAMrF,KAInBqF,EAAMrF,IAAM2S,EACLF,I,6BClDT,IAAItT,EAAc,EAAQ,GAAmBA,YAE7C5E,EAAOD,QAAU,SAA8B0E,EAAKgB,EAAK4F,GACvD,IAAIrG,EACAuE,EAEAsC,EAAQpG,EACRkD,EAAS,CACX2P,IAAI,EACJ7S,IAAK,EACL8S,MAAO,EACP9T,IAAK,IAGP,GAA4B,KAAxBA,EAAIQ,WAAWQ,GAEjB,CAGA,IAFAA,IAEOA,EAAM4F,GAAK,CAGhB,GAAa,MAFbrG,EAAOP,EAAIQ,WAAWQ,IAKpB,OAAOkD,EAGT,GAAa,KAAT3D,EAMF,OAHA2D,EAAOlD,IAAMA,EAAM,EACnBkD,EAAOlE,IAAMG,EAAYH,EAAIT,MAAM6H,EAAQ,EAAGpG,IAC9CkD,EAAO2P,IAAK,EACL3P,EAGI,KAAT3D,GAEDS,EAAM,EAAI4F,EACX5F,GAAO,EAITA,IAIF,OAAOkD,EAMT,IAFAY,EAAQ,EAED9D,EAAM4F,GAGE,MAFbrG,EAAOP,EAAIQ,WAAWQ,OAOlBT,EAAO,IAAiB,MAATA,IAInB,GAAa,KAATA,GAEDS,EAAM,EAAI4F,EACX5F,GAAO,MAHT,CAaA,GANa,KAATT,GAGFuE,IAGW,KAATvE,EAEF,CACA,GAAc,IAAVuE,EACF,MAGFA,IAGF9D,IAGF,OAAIoG,IAAUpG,GAIA,IAAV8D,IAIJZ,EAAOlE,IAAMG,EAAYH,EAAIT,MAAM6H,EAAOpG,IAC1CkD,EAAO4P,MAhGK,EAiGZ5P,EAAOlD,IAAMA,EACbkD,EAAO2P,IAAK,GAVH3P,I,6BC7FX,IAAI/D,EAAc,EAAQ,GAAmBA,YAE7C5E,EAAOD,QAAU,SAAwB0E,EAAKgB,EAAK4F,GACjD,IAAIrG,EACAsG,EACAiN,EAAQ,EACR1M,EAAQpG,EACRkD,EAAS,CACX2P,IAAI,EACJ7S,IAAK,EACL8S,MAAO,EACP9T,IAAK,IAGP,GAAIgB,GAAO4F,EACT,OAAO1C,EAKT,GAAe,MAFf2C,EAAS7G,EAAIQ,WAAWQ,KAIV,KAAX6F,GAEW,KAAXA,EAGD,OAAO3C,EAST,IANAlD,IAEe,KAAX6F,IACFA,EAAS,IAGJ7F,EAAM4F,GAAK,CAGhB,IAFArG,EAAOP,EAAIQ,WAAWQ,MAET6F,EAKX,OAJA3C,EAAOlD,IAAMA,EAAM,EACnBkD,EAAO4P,MAAQA,EACf5P,EAAOlE,IAAMG,EAAYH,EAAIT,MAAM6H,EAAQ,EAAGpG,IAC9CkD,EAAO2P,IAAK,EACL3P,EACW,KAAT3D,EACTuT,IACkB,KAATvT,GAERS,EAAM,EAAI4F,IACX5F,IAE4B,KAAxBhB,EAAIQ,WAAWQ,IACjB8S,KAIJ9S,IAGF,OAAOkD,I,6BCvDT,IAAI9E,EAAS,EAAQ,GAAkBA,OAEnCe,EAAc,EAAQ,GAAkBA,YAExCU,EAAa,EAAQ,GAAkBA,WAGvCkT,EAAgB,GAwGpB,SAAStH,IA6BPzK,KAAK0J,MAAQtM,EAAO,GAAI2U,GAnI1BA,EAAcC,YAAc,SAAUjN,EAAQ5C,EAAKf,EAAS+E,EAAK8L,GAC/D,IAAIvN,EAAQK,EAAO5C,GACnB,MAAO,QAAU8P,EAAIC,YAAYxN,GAAS,IAAM7F,EAAWkG,EAAO5C,GAAKY,SAAW,WAGpFgP,EAAcI,WAAa,SAAUpN,EAAQ5C,EAAKf,EAAS+E,EAAK8L,GAC9D,IAAIvN,EAAQK,EAAO5C,GACnB,MAAO,OAAS8P,EAAIC,YAAYxN,GAAS,UAAY7F,EAAWkG,EAAO5C,GAAKY,SAAW,mBAGzFgP,EAAcK,MAAQ,SAAUrN,EAAQ5C,EAAKf,EAAS+E,EAAK8L,GACzD,IAGII,EACA7Y,EACA8Y,EACAC,EANA7N,EAAQK,EAAO5C,GACfc,EAAOyB,EAAMzB,KAAO9E,EAAYuG,EAAMzB,MAAMxD,OAAS,GACrD+S,EAAW,GAgBf,OAVIvP,IACFuP,EAAWvP,EAAKyM,MAAM,QAAQ,IASI,KALlC2C,EADEjR,EAAQqR,WACIrR,EAAQqR,UAAU/N,EAAM3B,QAASyP,IAEjC3T,EAAW6F,EAAM3B,UAGjB9E,QAAQ,QACfoU,EAAc,KAMnBpP,GACFzJ,EAAIkL,EAAMrB,UAAU,SACpBiP,EAAW5N,EAAM9B,MAAQ8B,EAAM9B,MAAMrF,QAAU,GAE3C/D,EAAI,EACN8Y,EAAStR,KAAK,CAAC,QAASI,EAAQsR,WAAaF,IAE7CF,EAAS9Y,GAAG,IAAM,IAAM4H,EAAQsR,WAAaF,EAI/CD,EAAW,CACT3P,MAAO0P,GAEF,aAAeL,EAAIC,YAAYK,GAAY,IAAMF,EAAc,mBAGjE,aAAeJ,EAAIC,YAAYxN,GAAS,IAAM2N,EAAc,mBAGrEN,EAAc7H,MAAQ,SAAUnF,EAAQ5C,EAAKf,EAAS+E,EAAK8L,GACzD,IAAIvN,EAAQK,EAAO5C,GAMnB,OADAuC,EAAM9B,MAAM8B,EAAMrB,UAAU,QAAQ,GAAK4O,EAAIU,mBAAmBjO,EAAM5E,SAAUsB,EAAS+E,GAClF8L,EAAI5H,YAAYtF,EAAQ5C,EAAKf,IAGtC2Q,EAAca,UAAY,SAAU7N,EAAQ5C,EAAKf,GAG/C,OAAOA,EAAQyR,SAAW,WAAa,UAGzCd,EAAce,UAAY,SAAU/N,EAAQ5C,EAAKf,GAG/C,OAAOA,EAAQ2R,OAAS3R,EAAQyR,SAAW,WAAa,SAAW,MAGrEd,EAAciB,KAAO,SAAUjO,EAAQ5C,GAGrC,OAAOtD,EAAWkG,EAAO5C,GAAKY,UAGhCgP,EAAckB,WAAa,SAAUlO,EAAQ5C,GAG3C,OAAO4C,EAAO5C,GAAKY,SAGrBgP,EAAcmB,YAAc,SAAUnO,EAAQ5C,GAG5C,OAAO4C,EAAO5C,GAAKY,SA+CrB0H,EAASrP,UAAU8W,YAAc,SAAqBxN,GACpD,IAAIlL,EAAGC,EAAGyI,EAEV,IAAKwC,EAAM9B,MACT,MAAO,GAKT,IAFAV,EAAS,GAEJ1I,EAAI,EAAGC,EAAIiL,EAAM9B,MAAMpC,OAAQhH,EAAIC,EAAGD,IACzC0I,GAAU,IAAMrD,EAAW6F,EAAM9B,MAAMpJ,GAAG,IAAM,KAAOqF,EAAW6F,EAAM9B,MAAMpJ,GAAG,IAAM,IAGzF,OAAO0I,GAaTuI,EAASrP,UAAUiP,YAAc,SAAqBtF,EAAQ5C,EAAKf,GACjE,IAAI+R,EACAjR,EAAS,GACTkR,GAAS,EACT1O,EAAQK,EAAO5C,GAEnB,OAAIuC,EAAMtB,OACD,IAULsB,EAAMvB,QAA4B,IAAnBuB,EAAM/B,SAAkBR,GAAO4C,EAAO5C,EAAM,GAAGiB,SAChElB,GAAU,MAIZA,KAA8B,IAAnBwC,EAAM/B,QAAiB,KAAO,KAAO+B,EAAMhC,IAEtDR,GAAUlC,KAAKkS,YAAYxN,GAEL,IAAlBA,EAAM/B,SAAiBvB,EAAQyR,WACjC3Q,GAAU,MAIRwC,EAAMvB,QACRiQ,GAAS,EAEa,IAAlB1O,EAAM/B,SACJR,EAAM,EAAI4C,EAAOvE,SAGI,YAFvB2S,EAAYpO,EAAO5C,EAAM,IAEXM,MAAqB0Q,EAAU/P,SAIX,IAAvB+P,EAAUxQ,SAAkBwQ,EAAUzQ,MAAQgC,EAAMhC,OAD7D0Q,GAAS,IAUjBlR,GAAUkR,EAAS,MAAQ,MAa7B3I,EAASrP,UAAU6R,aAAe,SAAUlI,EAAQ3D,EAAS+E,GAK3D,IAJA,IAAI1D,EACAP,EAAS,GACTwH,EAAQ1J,KAAK0J,MAERlQ,EAAI,EAAG8J,EAAMyB,EAAOvE,OAAQhH,EAAI8J,EAAK9J,IAGjB,qBAAhBkQ,EAFXjH,EAAOsC,EAAOvL,GAAGiJ,MAGfP,GAAUwH,EAAMjH,GAAMsC,EAAQvL,EAAG4H,EAAS+E,EAAKnG,MAE/CkC,GAAUlC,KAAKqK,YAAYtF,EAAQvL,EAAG4H,GAI1C,OAAOc,GAcTuI,EAASrP,UAAUuX,mBAAqB,SAAU5N,EAAQ3D,EAAS+E,GAGjE,IAFA,IAAIjE,EAAS,GAEJ1I,EAAI,EAAG8J,EAAMyB,EAAOvE,OAAQhH,EAAI8J,EAAK9J,IACrB,SAAnBuL,EAAOvL,GAAGiJ,KACZP,GAAU6C,EAAOvL,GAAGuJ,QACQ,UAAnBgC,EAAOvL,GAAGiJ,OACnBP,GAAUlC,KAAK2S,mBAAmB5N,EAAOvL,GAAGsG,SAAUsB,EAAS+E,IAInE,OAAOjE,GAaTuI,EAASrP,UAAU0R,OAAS,SAAU/H,EAAQ3D,EAAS+E,GACrD,IAAI3M,EACA8J,EACAb,EACAP,EAAS,GACTwH,EAAQ1J,KAAK0J,MAEjB,IAAKlQ,EAAI,EAAG8J,EAAMyB,EAAOvE,OAAQhH,EAAI8J,EAAK9J,IAG3B,YAFbiJ,EAAOsC,EAAOvL,GAAGiJ,MAGfP,GAAUlC,KAAKiN,aAAalI,EAAOvL,GAAGsG,SAAUsB,EAAS+E,GACzB,qBAAhBuD,EAAMjH,GACtBP,GAAUwH,EAAM3E,EAAOvL,GAAGiJ,MAAMsC,EAAQvL,EAAG4H,EAAS+E,EAAKnG,MAEzDkC,GAAUlC,KAAKqK,YAAYtF,EAAQvL,EAAG4H,EAAS+E,GAInD,OAAOjE,GAGT3I,EAAOD,QAAUmR,G,6BC3TjB,IAAIrK,EAAQ,EAAQ,GAEhBiT,EAAS,CAAC,CAAC,YAAa,EAAQ,KAA4B,CAAC,QAAS,EAAQ,KAAwB,CAAC,SAAU,EAAQ,KAAyB,CAAC,UAAW,EAAQ,KAA0B,CAAC,eAAgB,EAAQ,KAA+B,CAAC,cAAe,EAAQ,MAKpR,SAASC,IAMPtT,KAAK6I,MAAQ,IAAIzI,EAEjB,IAAK,IAAI5G,EAAI,EAAGA,EAAI6Z,EAAO7S,OAAQhH,IACjCwG,KAAK6I,MAAM7H,KAAKqS,EAAO7Z,GAAG,GAAI6Z,EAAO7Z,GAAG,IAU5C8Z,EAAKlY,UAAUyR,QAAU,SAAUxI,GACjC,IAAI7K,EAAGC,EAAGiQ,EAGV,IAAKlQ,EAAI,EAAGC,GAFZiQ,EAAQ1J,KAAK6I,MAAMvG,SAAS,KAEN9B,OAAQhH,EAAIC,EAAGD,IACnCkQ,EAAMlQ,GAAG6K,IAIbiP,EAAKlY,UAAUwR,MAAQ,EAAQ,IAC/BrT,EAAOD,QAAUga,G,6BCzCjB,IAAIC,EAAc,YACdC,EAAU,MAEdja,EAAOD,QAAU,SAAmB+K,GAClC,IAAIrG,EAIJA,GAFAA,EAAMqG,EAAMtF,IAAIb,QAAQqV,EAAa,OAE3BrV,QAAQsV,EAAS,UAC3BnP,EAAMtF,IAAMf,I,6BCVdzE,EAAOD,QAAU,SAAe+K,GAC9B,IAAIK,EAEAL,EAAM2I,aACRtI,EAAQ,IAAIL,EAAM7B,MAAM,SAAU,GAAI,IAChCO,QAAUsB,EAAMtF,IACtB2F,EAAM7B,IAAM,CAAC,EAAG,GAChB6B,EAAM5E,SAAW,GACjBuE,EAAMU,OAAO/D,KAAK0D,IAElBL,EAAM8D,GAAGhF,MAAMY,MAAMM,EAAMtF,IAAKsF,EAAM8D,GAAI9D,EAAM8B,IAAK9B,EAAMU,U,6BCV/DxL,EAAOD,QAAU,SAAgB+K,GAC/B,IACIoP,EACAja,EACAC,EAHAsL,EAASV,EAAMU,OAKnB,IAAKvL,EAAI,EAAGC,EAAIsL,EAAOvE,OAAQhH,EAAIC,EAAGD,IAGnB,YAFjBia,EAAM1O,EAAOvL,IAELiJ,MACN4B,EAAM8D,GAAGM,OAAO1E,MAAM0P,EAAI1Q,QAASsB,EAAM8D,GAAI9D,EAAM8B,IAAKsN,EAAI3T,Y,6BCNlE,IAAIhB,EAAiB,EAAQ,GAAmBA,eAMhD,SAAS4U,EAAY1V,GACnB,MAAO,aAAaS,KAAKT,GAG3BzE,EAAOD,QAAU,SAAiB+K,GAChC,IAAI7K,EACA+K,EACA9K,EACAsL,EACAL,EACAiP,EACAC,EACAC,EACAb,EACAhU,EACA8U,EACAhR,EACAiR,EACAvN,EACAwN,EACAC,EAEAC,EA1BclW,EAyBdmW,EAAc9P,EAAMU,OAGxB,GAAKV,EAAM8D,GAAG/G,QAAQ2K,QAItB,IAAKxH,EAAI,EAAG9K,EAAI0a,EAAY3T,OAAQ+D,EAAI9K,EAAG8K,IACzC,GAA4B,WAAxB4P,EAAY5P,GAAG9B,MAAsB4B,EAAM8D,GAAG4D,QAAQqI,QAAQD,EAAY5P,GAAGxB,SAQjF,IAHAgR,EAAgB,EAGXva,GAJLuL,EAASoP,EAAY5P,GAAGzE,UAIRU,OAAS,EAAGhH,GAAK,EAAGA,IAGlC,GAA0B,gBAF1Bma,EAAe5O,EAAOvL,IAELiJ,MAqBjB,GAV0B,gBAAtBkR,EAAalR,OAvDHzE,EAwDG2V,EAAa5Q,QAvD3B,YAAYtE,KAAKT,IAuDsB+V,EAAgB,GACtDA,IAGEL,EAAYC,EAAa5Q,UAC3BgR,OAIAA,EAAgB,IAIM,SAAtBJ,EAAalR,MAAmB4B,EAAM8D,GAAG4D,QAAQtN,KAAKkV,EAAa5Q,SAAU,CAQ/E,IAPAiQ,EAAOW,EAAa5Q,QACpBmR,EAAQ7P,EAAM8D,GAAG4D,QAAQ3N,MAAM4U,GAE/BY,EAAQ,GACR9Q,EAAQ6Q,EAAa7Q,MACrBgR,EAAU,EAELD,EAAK,EAAGA,EAAKK,EAAM1T,OAAQqT,IAC9BrN,EAAM0N,EAAML,GAAIrN,IAChBwN,EAAU3P,EAAM8D,GAAGmD,cAAc9E,GAE5BnC,EAAM8D,GAAGiD,aAAa4I,KAI3BC,EAAUC,EAAML,GAAIb,KAUlBiB,EALGC,EAAML,GAAIQ,OAEiB,YAArBH,EAAML,GAAIQ,QAAyB,YAAY5V,KAAKwV,GAGnD5P,EAAM8D,GAAGwD,kBAAkBsI,GAF3B5P,EAAM8D,GAAGwD,kBAAkB,UAAYsI,GAAS/V,QAAQ,WAAY,IAFpEmG,EAAM8D,GAAGwD,kBAAkB,UAAYsI,GAAS/V,QAAQ,aAAc,KAOlFc,EAAMkV,EAAML,GAAIxS,OAENyS,KACRpP,EAAQ,IAAIL,EAAM7B,MAAM,OAAQ,GAAI,IAC9BO,QAAUiQ,EAAKzV,MAAMuW,EAAS9U,GACpC0F,EAAM5B,MAAQA,EACd8Q,EAAM5S,KAAK0D,KAGbA,EAAQ,IAAIL,EAAM7B,MAAM,YAAa,IAAK,IACpCI,MAAQ,CAAC,CAAC,OAAQoR,IACxBtP,EAAM5B,MAAQA,IACd4B,EAAM1B,OAAS,UACf0B,EAAMzB,KAAO,OACb2Q,EAAM5S,KAAK0D,IACXA,EAAQ,IAAIL,EAAM7B,MAAM,OAAQ,GAAI,IAC9BO,QAAUkR,EAChBvP,EAAM5B,MAAQA,EACd8Q,EAAM5S,KAAK0D,IACXA,EAAQ,IAAIL,EAAM7B,MAAM,aAAc,KAAM,IACtCM,QAAUA,EAChB4B,EAAM1B,OAAS,UACf0B,EAAMzB,KAAO,OACb2Q,EAAM5S,KAAK0D,GACXoP,EAAUI,EAAML,GAAIS,WAGlBR,EAAUd,EAAKxS,UACjBkE,EAAQ,IAAIL,EAAM7B,MAAM,OAAQ,GAAI,IAC9BO,QAAUiQ,EAAKzV,MAAMuW,GAC3BpP,EAAM5B,MAAQA,EACd8Q,EAAM5S,KAAK0D,IAIbyP,EAAY5P,GAAGzE,SAAWiF,EAASjG,EAAeiG,EAAQvL,EAAGoa,SAtF7D,IAFApa,IAEOuL,EAAOvL,GAAGsJ,QAAU6Q,EAAa7Q,OAA4B,cAAnBiC,EAAOvL,GAAGiJ,MACzDjJ,M,6BCzCV,IAAI+a,EAAU,+BAGVC,EAAsB,kBACtBC,EAAiB,mBACjBC,EAAc,CAChB7a,EAAG,OACHS,EAAG,OACHgB,EAAG,OACHqZ,GAAI,UAGN,SAASC,EAAUxW,EAAOrE,GACxB,OAAO2a,EAAY3a,EAAK2E,eAG1B,SAASmW,EAAeC,GACtB,IAAItb,EACAkL,EACAqQ,EAAkB,EAEtB,IAAKvb,EAAIsb,EAAatU,OAAS,EAAGhH,GAAK,EAAGA,IAGrB,UAFnBkL,EAAQoQ,EAAatb,IAEXiJ,MAAoBsS,IAC5BrQ,EAAM3B,QAAU2B,EAAM3B,QAAQ7E,QAAQuW,EAAgBG,IAGrC,cAAflQ,EAAMjC,MAAuC,SAAfiC,EAAMzB,MACtC8R,IAGiB,eAAfrQ,EAAMjC,MAAwC,SAAfiC,EAAMzB,MACvC8R,IAKN,SAASC,EAAaF,GACpB,IAAItb,EACAkL,EACAqQ,EAAkB,EAEtB,IAAKvb,EAAIsb,EAAatU,OAAS,EAAGhH,GAAK,EAAGA,IAGrB,UAFnBkL,EAAQoQ,EAAatb,IAEXiJ,MAAoBsS,GACxBR,EAAQ9V,KAAKiG,EAAM3B,WACrB2B,EAAM3B,QAAU2B,EAAM3B,QAAQ7E,QAAQ,OAAQ,QAE7CA,QAAQ,UAAW,UAAKA,QAAQ,gBAAY,QAAQA,QAAQ,cAAe,UAAUA,QAAQ,SAAU,KACvGA,QAAQ,wBAAyB,cACjCA,QAAQ,mBAAoB,cAAcA,QAAQ,2BAA4B,eAIhE,cAAfwG,EAAMjC,MAAuC,SAAfiC,EAAMzB,MACtC8R,IAGiB,eAAfrQ,EAAMjC,MAAwC,SAAfiC,EAAMzB,MACvC8R,IAKNxb,EAAOD,QAAU,SAAiB+K,GAChC,IAAI4Q,EAEJ,GAAK5Q,EAAM8D,GAAG/G,QAAQ8T,YAItB,IAAKD,EAAS5Q,EAAMU,OAAOvE,OAAS,EAAGyU,GAAU,EAAGA,IAChB,WAA9B5Q,EAAMU,OAAOkQ,GAAQxS,OAIrB+R,EAAoB/V,KAAK4F,EAAMU,OAAOkQ,GAAQlS,UAChD8R,EAAexQ,EAAMU,OAAOkQ,GAAQnV,UAGlCyU,EAAQ9V,KAAK4F,EAAMU,OAAOkQ,GAAQlS,UACpCiS,EAAa3Q,EAAMU,OAAOkQ,GAAQnV,a,6BC9FxC,IAAIV,EAAe,EAAQ,GAAmBA,aAE1CE,EAAc,EAAQ,GAAmBA,YAEzCD,EAAiB,EAAQ,GAAmBA,eAE5C8V,EAAgB,OAChBC,EAAW,QAIf,SAASC,EAAUrX,EAAKqD,EAAOvE,GAC7B,OAAOkB,EAAI6R,OAAO,EAAGxO,GAASvE,EAAKkB,EAAI6R,OAAOxO,EAAQ,GAGxD,SAASiU,EAAgBvQ,EAAQV,GAC/B,IAAI7K,EAAGkL,EAAOsO,EAAMtY,EAAGsE,EAAK4F,EAAK2Q,EAAWC,EAAMC,EAAUC,EAAUC,EAAiBC,EAAiBC,EAAkBC,EAAkBC,EAASC,EAAUzR,EAAG0R,EAAUC,EAAOC,EAAWC,EAG9L,IAFAF,EAAQ,GAEH1c,EAAI,EAAGA,EAAIuL,EAAOvE,OAAQhH,IAAK,CAIlC,IAHAkL,EAAQK,EAAOvL,GACf+b,EAAYxQ,EAAOvL,GAAGsJ,MAEjByB,EAAI2R,EAAM1V,OAAS,EAAG+D,GAAK,KAC1B2R,EAAM3R,GAAGzB,OAASyS,GADWhR,KAQnC,GAFA2R,EAAM1V,OAAS+D,EAAI,EAEA,SAAfG,EAAMjC,KAAV,CAKAzD,EAAM,EACN4F,GAFAoO,EAAOtO,EAAM3B,SAEFvC,OAGX6V,EAAO,KAAOrX,EAAM4F,IAClBwQ,EAASd,UAAYtV,EACrBtE,EAAI0a,EAASxO,KAAKoM,KAFK,CAgBvB,GARA+C,EAAUC,GAAW,EACrBhX,EAAMtE,EAAE2G,MAAQ,EAChB4U,EAAoB,MAATvb,EAAE,GAIb+a,EAAW,GAEP/a,EAAE2G,MAAQ,GAAK,EACjBoU,EAAWzC,EAAKxU,WAAW9D,EAAE2G,MAAQ,QAErC,IAAKkD,EAAI/K,EAAI,EAAG+K,GAAK,IACI,cAAnBQ,EAAOR,GAAG9B,MAA2C,cAAnBsC,EAAOR,GAAG9B,MAD1B8B,IAGtB,GAAuB,SAAnBQ,EAAOR,GAAG9B,KAAd,CACAgT,EAAW1Q,EAAOR,GAAGxB,QAAQvE,WAAWuG,EAAOR,GAAGxB,QAAQvC,OAAS,GACnE,MASJ,GAFAkV,EAAW,GAEP1W,EAAM4F,EACR8Q,EAAW1C,EAAKxU,WAAWQ,QAE3B,IAAKuF,EAAI/K,EAAI,EAAG+K,EAAIQ,EAAOvE,SACF,cAAnBuE,EAAOR,GAAG9B,MAA2C,cAAnBsC,EAAOR,GAAG9B,MADf8B,IAGjC,GAAuB,SAAnBQ,EAAOR,GAAG9B,KAAd,CACAiT,EAAW3Q,EAAOR,GAAGxB,QAAQvE,WAAW,GACxC,MA4CJ,GAxCAmX,EAAkBtW,EAAeoW,IAAanW,EAAYpD,OAAOC,aAAasZ,IAC9EG,EAAkBvW,EAAeqW,IAAapW,EAAYpD,OAAOC,aAAauZ,IAC9EG,EAAmBzW,EAAaqW,IAChCK,EAAmB1W,EAAasW,IAG9BK,GAAU,EACDH,IACHC,GAAoBF,IACxBI,GAAU,IAIVF,EACFG,GAAW,EACFL,IACHG,GAAoBF,IACxBI,GAAW,IAIE,KAAbN,GAEQ,MAAThb,EAAE,IACC+a,GAAY,IAEbA,GAAY,KAIbO,EAAWD,GAAU,GAIrBA,GAAWC,IAEbD,GAAU,EACVC,EAAWJ,GAGRG,GAAYC,EAAjB,CASA,GAAIA,EAEF,IAAKzR,EAAI2R,EAAM1V,OAAS,EAAG+D,GAAK,IAC9BiR,EAAOU,EAAM3R,KAET2R,EAAM3R,GAAGzB,MAAQyS,IAHYhR,IAOjC,GAAIiR,EAAKc,SAAWL,GAAYC,EAAM3R,GAAGzB,QAAUyS,EAAW,CAC5DC,EAAOU,EAAM3R,GAET0R,GACFE,EAAY9R,EAAM8D,GAAG/G,QAAQmV,OAAO,GACpCH,EAAa/R,EAAM8D,GAAG/G,QAAQmV,OAAO,KAErCJ,EAAY9R,EAAM8D,GAAG/G,QAAQmV,OAAO,GACpCH,EAAa/R,EAAM8D,GAAG/G,QAAQmV,OAAO,IAMvC7R,EAAM3B,QAAUsS,EAAU3Q,EAAM3B,QAASrI,EAAE2G,MAAO+U,GAClDrR,EAAOyQ,EAAK9Q,OAAO3B,QAAUsS,EAAUtQ,EAAOyQ,EAAK9Q,OAAO3B,QAASyS,EAAKxW,IAAKmX,GAC7EnX,GAAOoX,EAAW5V,OAAS,EAEvBgV,EAAK9Q,QAAUlL,IACjBwF,GAAOmX,EAAU3V,OAAS,GAI5BoE,GADAoO,EAAOtO,EAAM3B,SACFvC,OACX0V,EAAM1V,OAAS+D,EACf,SAAS8R,EAKXN,EACFG,EAAMlV,KAAK,CACT0D,MAAOlL,EACPwF,IAAKtE,EAAE2G,MACPiV,OAAQL,EACRnT,MAAOyS,IAEAS,GAAYC,IACrBvR,EAAM3B,QAAUsS,EAAU3Q,EAAM3B,QAASrI,EAAE2G,MA7KlC,gBAuHL4U,IACFvR,EAAM3B,QAAUsS,EAAU3Q,EAAM3B,QAASrI,EAAE2G,MAxHpC,cAmLjB9H,EAAOD,QAAU,SAAqB+K,GAEpC,IAAI4Q,EAEJ,GAAK5Q,EAAM8D,GAAG/G,QAAQ8T,YAItB,IAAKD,EAAS5Q,EAAMU,OAAOvE,OAAS,EAAGyU,GAAU,EAAGA,IAChB,WAA9B5Q,EAAMU,OAAOkQ,GAAQxS,MAAsB0S,EAAc1W,KAAK4F,EAAMU,OAAOkQ,GAAQlS,UAIvFuS,EAAgBjR,EAAMU,OAAOkQ,GAAQnV,SAAUuE,K,6BCxMnD,IAAI7B,EAAQ,EAAQ,GAEpB,SAASgU,EAAUzX,EAAKoJ,EAAIhC,GAC1BnG,KAAKjB,IAAMA,EACXiB,KAAKmG,IAAMA,EACXnG,KAAK+E,OAAS,GACd/E,KAAKgN,YAAa,EAClBhN,KAAKmI,GAAKA,EAIZqO,EAAUpb,UAAUoH,MAAQA,EAC5BjJ,EAAOD,QAAUkd,G,6BCTjB,IAAIpW,EAAQ,EAAQ,GAEhBiT,EAAS,CAEb,CAAC,QAAS,EAAQ,IAAwB,CAAC,YAAa,cAAe,CAAC,OAAQ,EAAQ,KAAwB,CAAC,QAAS,EAAQ,IAAwB,CAAC,YAAa,YAAa,aAAc,SAAU,CAAC,aAAc,EAAQ,IAA6B,CAAC,YAAa,YAAa,aAAc,SAAU,CAAC,KAAM,EAAQ,IAAqB,CAAC,YAAa,YAAa,aAAc,SAAU,CAAC,OAAQ,EAAQ,IAAuB,CAAC,YAAa,YAAa,eAAgB,CAAC,YAAa,EAAQ,KAA6B,CAAC,UAAW,EAAQ,IAA0B,CAAC,YAAa,YAAa,eAAgB,CAAC,WAAY,EAAQ,KAA4B,CAAC,aAAc,EAAQ,IAA6B,CAAC,YAAa,YAAa,eAAgB,CAAC,YAAa,EAAQ,MAKhxB,SAAS1I,IAMP3K,KAAK6I,MAAQ,IAAIzI,EAEjB,IAAK,IAAI5G,EAAI,EAAGA,EAAI6Z,EAAO7S,OAAQhH,IACjCwG,KAAK6I,MAAM7H,KAAKqS,EAAO7Z,GAAG,GAAI6Z,EAAO7Z,GAAG,GAAI,CAC1CsH,KAAMuS,EAAO7Z,GAAG,IAAM,IAAI+D,UAOhCoN,EAAYvP,UAAU6J,SAAW,SAAUZ,EAAOyE,EAAWC,GAS3D,IARA,IACIvP,EACAkQ,EAAQ1J,KAAK6I,MAAMvG,SAAS,IAC5BgB,EAAMoG,EAAMlJ,OACZgJ,EAAOV,EACP2N,GAAgB,EAChBC,EAAarS,EAAM8D,GAAG/G,QAAQsV,WAE3BlN,EAAOT,IACZ1E,EAAMmF,KAAOA,EAAOnF,EAAMsS,eAAenN,KAErCA,GAAQT,OAMR1E,EAAMuS,OAAOpN,GAAQnF,EAAMwS,YATV,CAerB,GAAIxS,EAAMvB,OAAS4T,EAAY,CAC7BrS,EAAMmF,KAAOT,EACb,MASF,IAAKvP,EAAI,EAAGA,EAAI8J,IACToG,EAAMlQ,GAAG6K,EAAOmF,EAAMT,GAAS,GADjBvP,KAUrB6K,EAAMyS,OAASL,EAEXpS,EAAM0S,QAAQ1S,EAAMmF,KAAO,KAC7BiN,GAAgB,IAGlBjN,EAAOnF,EAAMmF,MAEFT,GAAW1E,EAAM0S,QAAQvN,KAClCiN,GAAgB,EAChBjN,IACAnF,EAAMmF,KAAOA,KAWnBmB,EAAYvP,UAAU2I,MAAQ,SAAUhF,EAAKoJ,EAAIhC,EAAK6Q,GACpD,IAAI3S,EAECtF,IAILsF,EAAQ,IAAIrE,KAAK4M,MAAM7N,EAAKoJ,EAAIhC,EAAK6Q,GACrChX,KAAKiF,SAASZ,EAAOA,EAAMmF,KAAMnF,EAAM4S,WAGzCtM,EAAYvP,UAAUwR,MAAQ,EAAQ,IACtCrT,EAAOD,QAAUqR,G,6BC7GjB,IAAIxL,EAAU,EAAQ,GAAmBA,QAEzC,SAAS+X,EAAQ7S,EAAOmF,GACtB,IAAIxK,EAAMqF,EAAM8E,OAAOK,GAAQnF,EAAMwS,UACjCjS,EAAMP,EAAMgF,OAAOG,GACvB,OAAOnF,EAAMtF,IAAI8Q,OAAO7Q,EAAK4F,EAAM5F,GAGrC,SAASmY,EAAanZ,GACpB,IAGIlB,EAHAoF,EAAS,GACTlD,EAAM,EACN4F,EAAM5G,EAAIwC,OAEV4W,EAAU,EACVtD,EAAU,EACVuD,GAAa,EACbC,EAAe,EAGnB,IAFAxa,EAAKkB,EAAIQ,WAAWQ,GAEbA,EAAM4F,GACA,KAAP9H,EAGEua,GAGFA,GAAa,EACbC,EAAetY,GACNoY,EAAU,IAAM,IACzBC,GAAa,EACbC,EAAetY,GAED,MAAPlC,GAERsa,EAAU,IAAM,GAAMC,IACvBnV,EAAOlB,KAAKhD,EAAIuL,UAAUuK,EAAS9U,IACnC8U,EAAU9U,EAAM,GAGP,KAAPlC,EAGFsa,IAEAA,EAAU,IAGZpY,IAGY4F,GAAOyS,IACjBA,GAAa,EACbrY,EAAMsY,EAAe,GAGvBxa,EAAKkB,EAAIQ,WAAWQ,GAItB,OADAkD,EAAOlB,KAAKhD,EAAIuL,UAAUuK,IACnB5R,EAGT3I,EAAOD,QAAU,SAAe+K,EAAOyE,EAAWC,EAAS7D,GACzD,IAAIpI,EAAIya,EAAUvY,EAAKxF,EAAGge,EAAUC,EAASC,EAAahT,EAAOiT,EAAQjd,EAAGkd,EAAYC,EAExF,GAAI/O,EAAY,EAAIC,EAClB,OAAO,EAKT,GAFAyO,EAAW1O,EAAY,EAEnBzE,EAAMuS,OAAOY,GAAYnT,EAAMwS,UACjC,OAAO,EAIT,GAAIxS,EAAMuS,OAAOY,GAAYnT,EAAMwS,WAAa,EAC9C,OAAO,EAQT,IAFA7X,EAAMqF,EAAM8E,OAAOqO,GAAYnT,EAAM+E,OAAOoO,KAEjCnT,EAAMgF,OAAOmO,GACtB,OAAO,EAKT,GAAW,OAFX1a,EAAKuH,EAAMtF,IAAIP,WAAWQ,OAIhB,KAAPlC,GAEO,KAAPA,EAGD,OAAO,EAGT,KAAOkC,EAAMqF,EAAMgF,OAAOmO,IAAW,CAGnC,GAAW,OAFX1a,EAAKuH,EAAMtF,IAAIP,WAAWQ,KAIhB,KAAPlC,GAEO,KAAPA,IAECqC,EAAQrC,GACV,OAAO,EAGTkC,IAOF,IAHAyY,GADAF,EAAWL,EAAQ7S,EAAOyE,EAAY,IACnB4G,MAAM,KACzBiI,EAAS,GAEJne,EAAI,EAAGA,EAAIie,EAAQjX,OAAQhH,IAAK,CAGnC,KAFAkB,EAAI+c,EAAQje,GAAGiG,QAEP,CAGN,GAAU,IAANjG,GAAWA,IAAMie,EAAQjX,OAAS,EACpC,SAEA,OAAO,EAIX,IAAK,WAAW/B,KAAK/D,GACnB,OAAO,EAG0B,KAA/BA,EAAE8D,WAAW9D,EAAE8F,OAAS,GAG1BmX,EAAO3W,KAAyB,KAApBtG,EAAE8D,WAAW,GAEvB,SAAW,SACgB,KAApB9D,EAAE8D,WAAW,GAGtBmZ,EAAO3W,KAAK,QAEZ2W,EAAO3W,KAAK,IAMhB,IAA+B,KAF/BuW,EAAWL,EAAQ7S,EAAOyE,GAAWrJ,QAExBxB,QAAQ,KACnB,OAAO,EAGT,GAAIoG,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAQT,IAFAa,GAHAD,EAAUN,EAAaI,EAASrZ,QAAQ,WAAY,MAG9BsC,QAEJmX,EAAOnX,OACvB,OAAO,EAGT,GAAI0E,EACF,OAAO,EAUT,KAPAR,EAAQL,EAAMrD,KAAK,aAAc,QAAS,IACpC6B,IAAM+U,EAAa,CAAC9O,EAAW,IACrCpE,EAAQL,EAAMrD,KAAK,aAAc,QAAS,IACpC6B,IAAM,CAACiG,EAAWA,EAAY,IACpCpE,EAAQL,EAAMrD,KAAK,UAAW,KAAM,IAC9B6B,IAAM,CAACiG,EAAWA,EAAY,GAE/BtP,EAAI,EAAGA,EAAIie,EAAQjX,OAAQhH,KAC9BkL,EAAQL,EAAMrD,KAAK,UAAW,KAAM,IAC9B6B,IAAM,CAACiG,EAAWA,EAAY,GAEhC6O,EAAOne,KACTkL,EAAM9B,MAAQ,CAAC,CAAC,QAAS,cAAgB+U,EAAOne,OAGlDkL,EAAQL,EAAMrD,KAAK,SAAU,GAAI,IAC3B+B,QAAU0U,EAAQje,GAAGiG,OAC3BiF,EAAM7B,IAAM,CAACiG,EAAWA,EAAY,GACpCpE,EAAM5E,SAAW,GACjB4E,EAAQL,EAAMrD,KAAK,WAAY,MAAO,GAQxC,IALA0D,EAAQL,EAAMrD,KAAK,WAAY,MAAO,GACtC0D,EAAQL,EAAMrD,KAAK,cAAe,SAAU,IAC5C0D,EAAQL,EAAMrD,KAAK,aAAc,QAAS,IACpC6B,IAAMgV,EAAa,CAAC/O,EAAY,EAAG,GAEpC0O,EAAW1O,EAAY,EAAG0O,EAAWzO,KACpC1E,EAAMuS,OAAOY,GAAYnT,EAAMwS,aAMJ,KAF/BU,EAAWL,EAAQ7S,EAAOmT,GAAU/X,QAEvBxB,QAAQ,QAIjBoG,EAAMuS,OAAOY,GAAYnT,EAAMwS,WAAa,GAXCW,IAAY,CAkB7D,IAHAC,EAAUN,EAAaI,EAASrZ,QAAQ,WAAY,KACpDwG,EAAQL,EAAMrD,KAAK,UAAW,KAAM,GAE/BxH,EAAI,EAAGA,EAAIke,EAAale,IAC3BkL,EAAQL,EAAMrD,KAAK,UAAW,KAAM,GAEhC2W,EAAOne,KACTkL,EAAM9B,MAAQ,CAAC,CAAC,QAAS,cAAgB+U,EAAOne,OAGlDkL,EAAQL,EAAMrD,KAAK,SAAU,GAAI,IAC3B+B,QAAU0U,EAAQje,GAAKie,EAAQje,GAAGiG,OAAS,GACjDiF,EAAM5E,SAAW,GACjB4E,EAAQL,EAAMrD,KAAK,WAAY,MAAO,GAGxC0D,EAAQL,EAAMrD,KAAK,WAAY,MAAO,GAOxC,OAJA0D,EAAQL,EAAMrD,KAAK,cAAe,SAAU,GAC5C0D,EAAQL,EAAMrD,KAAK,cAAe,SAAU,GAC5C4W,EAAW,GAAKC,EAAW,GAAKL,EAChCnT,EAAMmF,KAAOgO,GACN,I,6BCjPTje,EAAOD,QAAU,SAAc+K,EAAOyE,EAAWC,GAG/C,IAAIyO,EAAUM,EAAMpT,EAEpB,GAAIL,EAAMuS,OAAO9N,GAAazE,EAAMwS,UAAY,EAC9C,OAAO,EAKT,IAFAiB,EAAON,EAAW1O,EAAY,EAEvB0O,EAAWzO,GAChB,GAAI1E,EAAM0S,QAAQS,GAChBA,QADF,CAKA,KAAInT,EAAMuS,OAAOY,GAAYnT,EAAMwS,WAAa,GAMhD,MAJEiB,IADAN,EAYJ,OAJAnT,EAAMmF,KAAOsO,GACbpT,EAAQL,EAAMrD,KAAK,aAAc,OAAQ,IACnC+B,QAAUsB,EAAM0T,SAASjP,EAAWgP,EAAM,EAAIzT,EAAMwS,WAAW,GACrEnS,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,OACvB,I,6BC9BTjQ,EAAOD,QAAU,SAAe+K,EAAOyE,EAAWC,EAAS7D,GACzD,IAAIL,EACAvB,EACA0U,EACAR,EACAS,EACAvT,EACA1B,EACAkV,GAAgB,EAChBlZ,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GAEvB,GAAIzE,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAGT,GAAI7X,EAAM,EAAI4F,EACZ,OAAO,EAKT,GAAe,OAFfC,EAASR,EAAMtF,IAAIP,WAAWQ,KAIhB,KAAX6F,EAGD,OAAO,EAQT,GAJAoT,EAAMjZ,GAENsE,GADAtE,EAAMqF,EAAM8T,UAAUnZ,EAAK6F,IACfoT,GAEF,EACR,OAAO,EAMT,GAHAjV,EAASqB,EAAMtF,IAAIxB,MAAM0a,EAAKjZ,GAC9BgZ,EAAS3T,EAAMtF,IAAIxB,MAAMyB,EAAK4F,GAEf,KAAXC,GAGEmT,EAAO/Z,QAAQ/B,OAAOC,aAAa0I,KAAY,EACjD,OAAO,EAKX,GAAIK,EACF,OAAO,EAMT,IAFAsS,EAAW1O,MAGT0O,GAEgBzO,OAMhB/J,EAAMiZ,EAAM5T,EAAM8E,OAAOqO,GAAYnT,EAAM+E,OAAOoO,KAClD5S,EAAMP,EAAMgF,OAAOmO,KAEFnT,EAAMuS,OAAOY,GAAYnT,EAAMwS,YAOhD,GAAIxS,EAAMtF,IAAIP,WAAWQ,KAAS6F,KAI9BR,EAAMuS,OAAOY,GAAYnT,EAAMwS,WAAa,OAKhD7X,EAAMqF,EAAM8T,UAAUnZ,EAAK6F,IAEjBoT,EAAM3U,OAKhBtE,EAAMqF,EAAM+T,WAAWpZ,IAEb4F,GAAV,CAIAsT,GAAgB,EAEhB,MAWF,OAPA5U,EAAMe,EAAMuS,OAAO9N,GACnBzE,EAAMmF,KAAOgO,GAAYU,EAAgB,EAAI,IAC7CxT,EAAQL,EAAMrD,KAAK,QAAS,OAAQ,IAC9BiC,KAAO+U,EACbtT,EAAM3B,QAAUsB,EAAM0T,SAASjP,EAAY,EAAG0O,EAAUlU,GAAK,GAC7DoB,EAAM1B,OAASA,EACf0B,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,OACvB,I,6BChHT,IAAIrK,EAAU,EAAQ,GAAmBA,QAEzC5F,EAAOD,QAAU,SAAoB+K,EAAOyE,EAAWC,EAAS7D,GAC9D,IAAImT,EACAvb,EACAtD,EACA8e,EACA7e,EACA8e,EACAzG,EACA0F,EACAgB,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAvU,EACAwU,EACAC,EAAa9U,EAAM4S,QACnBjY,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GAEvB,GAAIzE,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAIT,GAAoC,KAAhCxS,EAAMtF,IAAIP,WAAWQ,KAGvB,OAAO,EAKT,GAAIkG,EACF,OAAO,EAyCT,IArCAoT,EAAUE,EAASnU,EAAMuS,OAAO9N,GAAa9J,GAAOqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,IAEzD,KAA9BzE,EAAMtF,IAAIP,WAAWQ,IAKvBA,IACAsZ,IACAE,IACAH,GAAY,EACZU,GAAmB,GACoB,IAA9B1U,EAAMtF,IAAIP,WAAWQ,IAG9B+Z,GAAmB,GAEd1U,EAAM+U,QAAQtQ,GAAa0P,GAAU,IAAM,GAG9CxZ,IACAsZ,IACAE,IACAH,GAAY,GAKZA,GAAY,GAGdU,GAAmB,EAGrBN,EAAY,CAACpU,EAAM8E,OAAOL,IAC1BzE,EAAM8E,OAAOL,GAAa9J,EAEnBA,EAAM4F,IACX9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,GAEtBG,EAAQrC,KACC,IAAPA,EACF0b,GAAU,GAAKA,EAASnU,EAAM+U,QAAQtQ,IAAcuP,EAAY,EAAI,IAAM,EAE1EG,IAMJxZ,IAgCF,IA7BA0Z,EAAa,CAACrU,EAAM+U,QAAQtQ,IAC5BzE,EAAM+U,QAAQtQ,GAAazE,EAAMuS,OAAO9N,GAAa,GAAKiQ,EAAmB,EAAI,GACjFR,EAAgBvZ,GAAO4F,EACvBiU,EAAY,CAACxU,EAAMuS,OAAO9N,IAC1BzE,EAAMuS,OAAO9N,GAAa0P,EAASF,EACnCQ,EAAY,CAACzU,EAAM+E,OAAON,IAC1BzE,EAAM+E,OAAON,GAAa9J,EAAMqF,EAAM8E,OAAOL,GAC7CmQ,EAAkB5U,EAAM8D,GAAGhF,MAAM0F,MAAMvG,SAAS,cAChDsW,EAAgBvU,EAAMgV,WACtBhV,EAAMgV,WAAa,aACnBH,GAAe,EAmBV1B,EAAW1O,EAAY,EAAG0O,EAAWzO,IASpC1E,EAAMuS,OAAOY,GAAYnT,EAAMwS,YAAWqC,GAAe,MAC7Dla,EAAMqF,EAAM8E,OAAOqO,GAAYnT,EAAM+E,OAAOoO,MAC5C5S,EAAMP,EAAMgF,OAAOmO,MAX8BA,IAkBjD,GAAoC,KAAhCnT,EAAMtF,IAAIP,WAAWQ,MAErBka,EAFJ,CAqEA,GAAIX,EACF,MAMF,IAFAS,GAAY,EAEPxf,EAAI,EAAGC,EAAIwf,EAAgBzY,OAAQhH,EAAIC,EAAGD,IAC7C,GAAIyf,EAAgBzf,GAAG6K,EAAOmT,EAAUzO,GAAS,GAAO,CACtDiQ,GAAY,EACZ,MAIJ,GAAIA,EAAW,CAKb3U,EAAM4S,QAAUO,EAEQ,IAApBnT,EAAMwS,YAIR4B,EAAUzX,KAAKqD,EAAM8E,OAAOqO,IAC5BkB,EAAW1X,KAAKqD,EAAM+U,QAAQ5B,IAC9BsB,EAAU9X,KAAKqD,EAAM+E,OAAOoO,IAC5BqB,EAAU7X,KAAKqD,EAAMuS,OAAOY,IAC5BnT,EAAMuS,OAAOY,IAAanT,EAAMwS,WAGlC,MAGF4B,EAAUzX,KAAKqD,EAAM8E,OAAOqO,IAC5BkB,EAAW1X,KAAKqD,EAAM+U,QAAQ5B,IAC9BsB,EAAU9X,KAAKqD,EAAM+E,OAAOoO,IAC5BqB,EAAU7X,KAAKqD,EAAMuS,OAAOY,IAG5BnT,EAAMuS,OAAOY,IAAa,MA9G1B,CA0CE,IArCAc,EAAUE,EAASnU,EAAMuS,OAAOY,GAAYxY,GAAOqF,EAAM8E,OAAOqO,GAAYnT,EAAM+E,OAAOoO,IAEvD,KAA9BnT,EAAMtF,IAAIP,WAAWQ,IAKvBA,IACAsZ,IACAE,IACAH,GAAY,EACZU,GAAmB,GACoB,IAA9B1U,EAAMtF,IAAIP,WAAWQ,IAG9B+Z,GAAmB,GAEd1U,EAAM+U,QAAQ5B,GAAYgB,GAAU,IAAM,GAG7CxZ,IACAsZ,IACAE,IACAH,GAAY,GAKZA,GAAY,GAGdU,GAAmB,EAGrBN,EAAUzX,KAAKqD,EAAM8E,OAAOqO,IAC5BnT,EAAM8E,OAAOqO,GAAYxY,EAElBA,EAAM4F,IACX9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,GAEtBG,EAAQrC,KACC,IAAPA,EACF0b,GAAU,GAAKA,EAASnU,EAAM+U,QAAQ5B,IAAaa,EAAY,EAAI,IAAM,EAEzEG,IAMJxZ,IAGFuZ,EAAgBvZ,GAAO4F,EACvB8T,EAAW1X,KAAKqD,EAAM+U,QAAQ5B,IAC9BnT,EAAM+U,QAAQ5B,GAAYnT,EAAMuS,OAAOY,GAAY,GAAKuB,EAAmB,EAAI,GAC/EF,EAAU7X,KAAKqD,EAAMuS,OAAOY,IAC5BnT,EAAMuS,OAAOY,GAAYgB,EAASF,EAClCQ,EAAU9X,KAAKqD,EAAM+E,OAAOoO,IAC5BnT,EAAM+E,OAAOoO,GAAYxY,EAAMqF,EAAM8E,OAAOqO,GA8DhD,IAbAmB,EAAYtU,EAAMwS,UAClBxS,EAAMwS,UAAY,GAClBnS,EAAQL,EAAMrD,KAAK,kBAAmB,aAAc,IAC9CgC,OAAS,IACf0B,EAAM7B,IAAMiP,EAAQ,CAAChJ,EAAW,GAChCzE,EAAM8D,GAAGhF,MAAM8B,SAASZ,EAAOyE,EAAW0O,IAC1C9S,EAAQL,EAAMrD,KAAK,mBAAoB,cAAe,IAChDgC,OAAS,IACfqB,EAAM4S,QAAUkC,EAChB9U,EAAMgV,WAAaT,EACnB9G,EAAM,GAAKzN,EAAMmF,KAGZhQ,EAAI,EAAGA,EAAIsf,EAAUtY,OAAQhH,IAChC6K,EAAM8E,OAAO3P,EAAIsP,GAAa2P,EAAUjf,GACxC6K,EAAM+E,OAAO5P,EAAIsP,GAAagQ,EAAUtf,GACxC6K,EAAMuS,OAAOpd,EAAIsP,GAAa+P,EAAUrf,GACxC6K,EAAM+U,QAAQ5f,EAAIsP,GAAa4P,EAAWlf,GAI5C,OADA6K,EAAMwS,UAAY8B,GACX,I,6BCvRT,IAAIxZ,EAAU,EAAQ,GAAmBA,QAEzC5F,EAAOD,QAAU,SAAY+K,EAAOyE,EAAWC,EAAS7D,GACtD,IAAIL,EACAyU,EACAxc,EACA4H,EACA1F,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GAEvB,GAAIzE,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAKT,GAAe,MAFfhS,EAASR,EAAMtF,IAAIP,WAAWQ,OAIhB,KAAX6F,GAEW,KAAXA,EAGD,OAAO,EAMT,IAFAyU,EAAM,EAECta,EAAM4F,GAAK,CAGhB,IAFA9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,QAEf6F,IAAW1F,EAAQrC,GAC5B,OAAO,EAGLA,IAAO+H,GACTyU,IAIJ,QAAIA,EAAM,KAINpU,IAIJb,EAAMmF,KAAOV,EAAY,GACzBpE,EAAQL,EAAMrD,KAAK,KAAM,KAAM,IACzB6B,IAAM,CAACiG,EAAWzE,EAAMmF,MAC9B9E,EAAM1B,OAAS1F,MAAMgc,EAAM,GAAG3R,KAAKzL,OAAOC,aAAa0I,MAN9C,K,6BC9CX,IAAI1F,EAAU,EAAQ,GAAmBA,QAIzC,SAASoa,EAAqBlV,EAAOyE,GACnC,IAAIjE,EAAQ7F,EAAK4F,EAAK9H,EAKtB,OAJAkC,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GAGJ,MAFfjE,EAASR,EAAMtF,IAAIP,WAAWQ,OAIhB,KAAX6F,GAEW,KAAXA,GAMC7F,EAAM4F,IACR9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,IAErBG,EAAQrC,KANL,EAYHkC,EAKT,SAASwa,EAAsBnV,EAAOyE,GACpC,IAAIhM,EACAsI,EAAQf,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC/C9J,EAAMoG,EACNR,EAAMP,EAAMgF,OAAOP,GAEvB,GAAI9J,EAAM,GAAK4F,EACb,OAAQ,EAKV,IAFA9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,MAEjB,IAENlC,EAAK,GAGN,OAAQ,EAGV,OAAS,CAEP,GAAIkC,GAAO4F,EACT,OAAQ,EAKV,MAFA9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,OAEhB,IAEPlC,GAAM,IAFT,CAeA,GAAW,KAAPA,GAEM,KAAPA,EAGD,MAGF,OAAQ,EAhBN,GAAIkC,EAAMoG,GAAS,GACjB,OAAQ,EAkBd,OAAIpG,EAAM4F,IACR9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,IAErBG,EAAQrC,KAEH,EAILkC,EAiBTzF,EAAOD,QAAU,SAAc+K,EAAOyE,EAAWC,EAAS7D,GACxD,IAAIpI,EACA2c,EACAjgB,EACAkgB,EACAC,EACArB,EACAsB,EACAC,EACApgB,EACAqgB,EACAC,EACAC,EACAC,EACArV,EACA4S,EACAgB,EACA0B,EACAtB,EACAC,EACAC,EACAqB,EACAnb,EACAob,EACAC,EACAjV,EACA4T,EACAC,EACAvU,EACA4V,GAAyB,EACzBxD,GAAQ,EAEZ,GAAIzS,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAST,GAAIxS,EAAMkW,YAAc,GAAKlW,EAAMuS,OAAO9N,GAAazE,EAAMkW,YAAc,GAAKlW,EAAMuS,OAAO9N,GAAazE,EAAMwS,UAC9G,OAAO,EAiBT,GAZI3R,GAA+B,cAArBb,EAAMgV,YAMdhV,EAAM+E,OAAON,IAAczE,EAAMwS,YACnCyD,GAAyB,IAKxBF,EAAiBZ,EAAsBnV,EAAOyE,KAAe,GAMhE,GALA8Q,GAAY,EACZxU,EAAQf,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC/CmR,EAAcO,OAAOnW,EAAMtF,IAAI8Q,OAAOzK,EAAOgV,EAAiBhV,EAAQ,IAGlEkV,GAA0C,IAAhBL,EAAmB,OAAO,MACnD,OAAKG,EAAiBb,EAAqBlV,EAAOyE,KAAe,GAGtE,OAAO,EAFP8Q,GAAY,EAOd,GAAIU,GACEjW,EAAM+T,WAAWgC,IAAmB/V,EAAMgF,OAAOP,GAAY,OAAO,EAM1E,GAFAkR,EAAiB3V,EAAMtF,IAAIP,WAAW4b,EAAiB,GAEnDlV,EACF,OAAO,EA2BT,IAvBA6U,EAAa1V,EAAMU,OAAOvE,OAEtBoZ,GACFlV,EAAQL,EAAMrD,KAAK,oBAAqB,KAAM,GAE1B,IAAhBiZ,IACFvV,EAAM9B,MAAQ,CAAC,CAAC,QAASqX,MAG3BvV,EAAQL,EAAMrD,KAAK,mBAAoB,KAAM,GAG/C0D,EAAM7B,IAAMiX,EAAY,CAAChR,EAAW,GACpCpE,EAAM1B,OAAS9G,OAAOC,aAAa6d,GAInCxC,EAAW1O,EACXuR,GAAe,EACfpB,EAAkB5U,EAAM8D,GAAGhF,MAAM0F,MAAMvG,SAAS,QAChDsW,EAAgBvU,EAAMgV,WACtBhV,EAAMgV,WAAa,OAEZ7B,EAAWzO,GAAS,CAKzB,IAJA/J,EAAMob,EACNxV,EAAMP,EAAMgF,OAAOmO,GACnBc,EAAUE,EAASnU,EAAMuS,OAAOY,GAAY4C,GAAkB/V,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,IAE9F9J,EAAM4F,GAAK,CAGhB,GAAW,KAFX9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,IAGxBwZ,GAAU,GAAKA,EAASnU,EAAM+U,QAAQ5B,IAAa,MAC9C,IAAW,KAAP1a,EAGT,MAFA0b,IAKFxZ,IAwEF,IAjEE2a,GAJFF,EAAeza,IAEK4F,EAEE,EAEA4T,EAASF,GAKP,IACtBqB,EAAoB,GAKtBD,EAASpB,EAAUqB,GAEnBjV,EAAQL,EAAMrD,KAAK,iBAAkB,KAAM,IACrCgC,OAAS9G,OAAOC,aAAa6d,GACnCtV,EAAM7B,IAAMgX,EAAY,CAAC/Q,EAAW,GAEpCqR,EAAW9V,EAAMyS,MACjBgC,EAAYzU,EAAM+E,OAAON,GACzB+P,EAAYxU,EAAMuS,OAAO9N,GAKzBoR,EAAgB7V,EAAMkW,WACtBlW,EAAMkW,WAAalW,EAAMwS,UACzBxS,EAAMwS,UAAY6C,EAClBrV,EAAMyS,OAAQ,EACdzS,EAAM+E,OAAON,GAAa2Q,EAAepV,EAAM8E,OAAOL,GACtDzE,EAAMuS,OAAO9N,GAAa0P,EAEtBiB,GAAgB7U,GAAOP,EAAM0S,QAAQjO,EAAY,GAQnDzE,EAAMmF,KAAOiR,KAAKC,IAAIrW,EAAMmF,KAAO,EAAGT,GAEtC1E,EAAM8D,GAAGhF,MAAM8B,SAASZ,EAAOyE,EAAWC,GAAS,GAIhD1E,EAAMyS,QAASuD,IAClBvD,GAAQ,GAKVuD,EAAehW,EAAMmF,KAAOV,EAAY,GAAKzE,EAAM0S,QAAQ1S,EAAMmF,KAAO,GACxEnF,EAAMwS,UAAYxS,EAAMkW,WACxBlW,EAAMkW,WAAaL,EACnB7V,EAAM+E,OAAON,GAAagQ,EAC1BzU,EAAMuS,OAAO9N,GAAa+P,EAC1BxU,EAAMyS,MAAQqD,GACdzV,EAAQL,EAAMrD,KAAK,kBAAmB,MAAO,IACvCgC,OAAS9G,OAAOC,aAAa6d,GACnCxC,EAAW1O,EAAYzE,EAAMmF,KAC7BqQ,EAAU,GAAKrC,EACfiC,EAAepV,EAAM8E,OAAOL,GAExB0O,GAAYzO,EACd,MAMF,GAAI1E,EAAMuS,OAAOY,GAAYnT,EAAMwS,UACjC,MAIF,GAAIxS,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,MAMF,IAFAmC,GAAY,EAEPxf,EAAI,EAAGC,EAAIwf,EAAgBzY,OAAQhH,EAAIC,EAAGD,IAC7C,GAAIyf,EAAgBzf,GAAG6K,EAAOmT,EAAUzO,GAAS,GAAO,CACtDiQ,GAAY,EACZ,MAIJ,GAAIA,EACF,MAIF,GAAIY,GAGF,IAFAQ,EAAiBZ,EAAsBnV,EAAOmT,IAEzB,EACnB,WAKF,IAFA4C,EAAiBb,EAAqBlV,EAAOmT,IAExB,EACnB,MAIJ,GAAIwC,IAAmB3V,EAAMtF,IAAIP,WAAW4b,EAAiB,GAC3D,MAoBJ,OAdE1V,EADEkV,EACMvV,EAAMrD,KAAK,qBAAsB,MAAO,GAExCqD,EAAMrD,KAAK,oBAAqB,MAAO,IAG3CgC,OAAS9G,OAAOC,aAAa6d,GACnCF,EAAU,GAAKtC,EACfnT,EAAMmF,KAAOgO,EACbnT,EAAMgV,WAAaT,EAEf9B,GAlRN,SAA6BzS,EAAOlC,GAClC,IAAI3I,EACAC,EACAqJ,EAAQuB,EAAMvB,MAAQ,EAE1B,IAAKtJ,EAAI2I,EAAM,EAAG1I,EAAI4K,EAAMU,OAAOvE,OAAS,EAAGhH,EAAIC,EAAGD,IAChD6K,EAAMU,OAAOvL,GAAGsJ,QAAUA,GAAkC,mBAAzBuB,EAAMU,OAAOvL,GAAGiJ,OACrD4B,EAAMU,OAAOvL,EAAI,GAAG4J,QAAS,EAC7BiB,EAAMU,OAAOvL,GAAG4J,QAAS,EACzB5J,GAAK,GA0QPmhB,CAAoBtW,EAAO0V,IAGtB,I,6BC3XT,IAAIva,EAAqB,EAAQ,GAAmBA,mBAEhDL,EAAU,EAAQ,GAAmBA,QAEzC5F,EAAOD,QAAU,SAAmB+K,EAAOyE,EAAWE,EAAU9D,GAC9D,IAAIpI,EACA8d,EACAC,EACA9R,EACA+R,EACAthB,EACAC,EACAshB,EACAtJ,EACAmH,EACAoC,EACA5V,EACApH,EACAgb,EACAC,EACA9R,EACA2K,EAAQ,EACR9S,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GACnB0O,EAAW1O,EAAY,EAE3B,GAAIzE,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAGT,GAAkC,KAA9BxS,EAAMtF,IAAIP,WAAWQ,GAGvB,OAAO,EAKT,OAASA,EAAM4F,GACb,GAAkC,KAA9BP,EAAMtF,IAAIP,WAAWQ,IAEY,KAAlCqF,EAAMtF,IAAIP,WAAWQ,EAAM,GAE5B,CACA,GAAIA,EAAM,IAAM4F,EACd,OAAO,EAGT,GAAsC,KAAlCP,EAAMtF,IAAIP,WAAWQ,EAAM,GAG7B,OAAO,EAGT,MAUJ,IANA+J,EAAU1E,EAAM4S,QAEhBgC,EAAkB5U,EAAM8D,GAAGhF,MAAM0F,MAAMvG,SAAS,aAChDsW,EAAgBvU,EAAMgV,WACtBhV,EAAMgV,WAAa,YAEZ7B,EAAWzO,IAAY1E,EAAM0S,QAAQS,GAAWA,IAGrD,KAAInT,EAAMuS,OAAOY,GAAYnT,EAAMwS,UAAY,MAK3CxS,EAAMuS,OAAOY,GAAY,GAA7B,CAOA,IAFAwB,GAAY,EAEPxf,EAAI,EAAGC,EAAIwf,EAAgBzY,OAAQhH,EAAIC,EAAGD,IAC7C,GAAIyf,EAAgBzf,GAAG6K,EAAOmT,EAAUzO,GAAS,GAAO,CACtDiQ,GAAY,EACZ,MAIJ,GAAIA,EACF,MAOJ,IAFApU,GADA5G,EAAMqG,EAAM0T,SAASjP,EAAW0O,EAAUnT,EAAMwS,WAAW,GAAOpX,QACxDe,OAELxB,EAAM,EAAGA,EAAM4F,EAAK5F,IAAO,CAG9B,GAAW,MAFXlC,EAAKkB,EAAIQ,WAAWQ,IAKlB,OAAO,EACF,GAAW,KAAPlC,EAET,CACA2U,EAAWzS,EACX,OACgB,KAAPlC,GAIO,KAAPA,KAGTkC,EAEU4F,GAA+B,KAAxB5G,EAAIQ,WAAWQ,KANhC8S,IAYJ,GAAIL,EAAW,GAAsC,KAAjCzT,EAAIQ,WAAWiT,EAAW,GAG5C,OAAO,EAKT,IAAKzS,EAAMyS,EAAW,EAAGzS,EAAM4F,EAAK5F,IAGlC,GAAW,MAFXlC,EAAKkB,EAAIQ,WAAWQ,IAGlB8S,SACK,IAAI3S,EAAQrC,GAGjB,MAQJ,KAFAke,EAAM3W,EAAM8D,GAAGqC,QAAQ4G,qBAAqBpT,EAAKgB,EAAK4F,IAE7CiN,GACP,OAAO,EAKT,GAFAiJ,EAAOzW,EAAM8D,GAAGmD,cAAc0P,EAAIhd,MAE7BqG,EAAM8D,GAAGiD,aAAa0P,GACzB,OAAO,EAYT,IANAF,EAHA5b,EAAMgc,EAAIhc,IAIV6b,EAHA/I,GAASkJ,EAAIlJ,MAMb1M,EAAQpG,EAEDA,EAAM4F,EAAK5F,IAGhB,GAAW,MAFXlC,EAAKkB,EAAIQ,WAAWQ,IAGlB8S,SACK,IAAI3S,EAAQrC,GAGjB,MAmBJ,IAbAke,EAAM3W,EAAM8D,GAAGqC,QAAQ6G,eAAerT,EAAKgB,EAAK4F,GAE5C5F,EAAM4F,GAAOQ,IAAUpG,GAAOgc,EAAInJ,IACpC1K,EAAQ6T,EAAIhd,IACZgB,EAAMgc,EAAIhc,IACV8S,GAASkJ,EAAIlJ,QAEb3K,EAAQ,GACRnI,EAAM4b,EACN9I,EAAQ+I,GAIH7b,EAAM4F,IACX9H,EAAKkB,EAAIQ,WAAWQ,GAEfG,EAAQrC,KAIbkC,IAGF,GAAIA,EAAM4F,GAA+B,KAAxB5G,EAAIQ,WAAWQ,IAC1BmI,EAOF,IAJAA,EAAQ,GACRnI,EAAM4b,EACN9I,EAAQ+I,EAED7b,EAAM4F,IACX9H,EAAKkB,EAAIQ,WAAWQ,GAEfG,EAAQrC,KAIbkC,IAKN,QAAIA,EAAM4F,GAA+B,KAAxB5G,EAAIQ,WAAWQ,SAKhC+b,EAAQvb,EAAmBxB,EAAIT,MAAM,EAAGkU,OAUpCvM,IAIgC,qBAAzBb,EAAM8B,IAAI8U,aACnB5W,EAAM8B,IAAI8U,WAAa,IAGkB,qBAAhC5W,EAAM8B,IAAI8U,WAAWF,KAC9B1W,EAAM8B,IAAI8U,WAAWF,GAAS,CAC5B5T,MAAOA,EACP2T,KAAMA,IAIVzW,EAAMgV,WAAaT,EACnBvU,EAAMmF,KAAOV,EAAYgJ,EAAQ,IAfxB,M,6BC5OX,IAAI3S,EAAU,EAAQ,GAAmBA,QAEzC5F,EAAOD,QAAU,SAAiB+K,EAAOyE,EAAWC,EAAS7D,GAC3D,IAAIpI,EACAgG,EACAoY,EACAxW,EACA1F,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GAEvB,GAAIzE,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAKT,GAAW,MAFX/Z,EAAKuH,EAAMtF,IAAIP,WAAWQ,KAIvBA,GAAO4F,EACR,OAAO,EAOT,IAHA9B,EAAQ,EACRhG,EAAKuH,EAAMtF,IAAIP,aAAaQ,GAEd,KAAPlC,GAEJkC,EAAM4F,GAAO9B,GAAS,GACvBA,IACAhG,EAAKuH,EAAMtF,IAAIP,aAAaQ,GAG9B,QAAI8D,EAAQ,GAAK9D,EAAM4F,IAAQzF,EAAQrC,MAInCoI,IAKJN,EAAMP,EAAM8W,eAAevW,EAAK5F,IAChCkc,EAAM7W,EAAM+W,cAAcxW,EAAK,GAAM5F,IAE3BA,GAAOG,EAAQkF,EAAMtF,IAAIP,WAAW0c,EAAM,MAClDtW,EAAMsW,GAGR7W,EAAMmF,KAAOV,EAAY,GACzBpE,EAAQL,EAAMrD,KAAK,eAAgB,IAAM9E,OAAO4G,GAAQ,IAClDE,OAAS,WAAWzF,MAAM,EAAGuF,GACnC4B,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,OAC9B9E,EAAQL,EAAMrD,KAAK,SAAU,GAAI,IAC3B+B,QAAUsB,EAAMtF,IAAIxB,MAAMyB,EAAK4F,GAAKnF,OAC1CiF,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,MAC9B9E,EAAM5E,SAAW,IACjB4E,EAAQL,EAAMrD,KAAK,gBAAiB,IAAM9E,OAAO4G,IAAS,IACpDE,OAAS,WAAWzF,MAAM,EAAGuF,KApB1B,K,6BCtCXvJ,EAAOD,QAAU,SAAkB+K,EAAOyE,EAAWC,GAGnD,IAAIhG,EACAiW,EACAxf,EACAC,EACAiL,EACA1F,EACA4F,EACA9B,EACA+B,EAEA+T,EADApB,EAAW1O,EAAY,EAEvBmQ,EAAkB5U,EAAM8D,GAAGhF,MAAM0F,MAAMvG,SAAS,aAEpD,GAAI+B,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAOT,IAJA+B,EAAgBvU,EAAMgV,WACtBhV,EAAMgV,WAAa,YAGZ7B,EAAWzO,IAAY1E,EAAM0S,QAAQS,GAAWA,IAGrD,KAAInT,EAAMuS,OAAOY,GAAYnT,EAAMwS,UAAY,GAA/C,CAOA,GAAIxS,EAAMuS,OAAOY,IAAanT,EAAMwS,YAClC7X,EAAMqF,EAAM8E,OAAOqO,GAAYnT,EAAM+E,OAAOoO,KAC5C5S,EAAMP,EAAMgF,OAAOmO,MAKF,MAFf3S,EAASR,EAAMtF,IAAIP,WAAWQ,KAIhB,KAAX6F,KAGD7F,EAAMqF,EAAM8T,UAAUnZ,EAAK6F,IAC3B7F,EAAMqF,EAAM+T,WAAWpZ,KAEZ4F,GAAK,CACd9B,EAAmB,KAAX+B,EAEN,EAAI,EACN,MAOR,KAAIR,EAAMuS,OAAOY,GAAY,GAA7B,CAOA,IAFAwB,GAAY,EAEPxf,EAAI,EAAGC,EAAIwf,EAAgBzY,OAAQhH,EAAIC,EAAGD,IAC7C,GAAIyf,EAAgBzf,GAAG6K,EAAOmT,EAAUzO,GAAS,GAAO,CACtDiQ,GAAY,EACZ,MAIJ,GAAIA,EACF,OAIJ,QAAKlW,IAKLC,EAAUsB,EAAM0T,SAASjP,EAAW0O,EAAUnT,EAAMwS,WAAW,GAAOpX,OACtE4E,EAAMmF,KAAOgO,EAAW,GACxB9S,EAAQL,EAAMrD,KAAK,eAAgB,IAAM9E,OAAO4G,GAAQ,IAClDE,OAAS9G,OAAOC,aAAa0I,GACnCH,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,OAC9B9E,EAAQL,EAAMrD,KAAK,SAAU,GAAI,IAC3B+B,QAAUA,EAChB2B,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,KAAO,GACrC9E,EAAM5E,SAAW,IACjB4E,EAAQL,EAAMrD,KAAK,gBAAiB,IAAM9E,OAAO4G,IAAS,IACpDE,OAAS9G,OAAOC,aAAa0I,GACnCR,EAAMgV,WAAaT,GACZ,K,6BChGT,IAAIyC,EAAc,EAAQ,IAEtBlX,EAAyB,EAAQ,IAAqBA,uBAKtDmX,EAAiB,CAAC,CAAC,oCAAqC,2BAA2B,GAAO,CAAC,QAAS,OAAO,GAAO,CAAC,OAAQ,OAAO,GAAO,CAAC,WAAY,KAAK,GAAO,CAAC,eAAgB,SAAS,GAAO,CAAC,IAAIhf,OAAO,QAAU+e,EAAY1T,KAAK,KAAO,mBAAoB,KAAM,MAAM,GAAO,CAAC,IAAIrL,OAAO6H,EAAuB5H,OAAS,SAAU,MAAM,IAExVhD,EAAOD,QAAU,SAAoB+K,EAAOyE,EAAWC,EAAS7D,GAC9D,IAAI1L,EACAge,EACA9S,EACA6S,EACAvY,EAAMqF,EAAM8E,OAAOL,GAAazE,EAAM+E,OAAON,GAC7ClE,EAAMP,EAAMgF,OAAOP,GAEvB,GAAIzE,EAAMuS,OAAO9N,GAAazE,EAAMwS,WAAa,EAC/C,OAAO,EAGT,IAAKxS,EAAM8D,GAAG/G,QAAQma,KACpB,OAAO,EAGT,GAAkC,KAA9BlX,EAAMtF,IAAIP,WAAWQ,GAGvB,OAAO,EAKT,IAFAuY,EAAWlT,EAAMtF,IAAIxB,MAAMyB,EAAK4F,GAE3BpL,EAAI,EAAGA,EAAI8hB,EAAe9a,SACzB8a,EAAe9hB,GAAG,GAAGiF,KAAK8Y,GADO/d,KAMvC,GAAIA,IAAM8hB,EAAe9a,OACvB,OAAO,EAGT,GAAI0E,EAEF,OAAOoW,EAAe9hB,GAAG,GAM3B,GAHAge,EAAW1O,EAAY,GAGlBwS,EAAe9hB,GAAG,GAAGiF,KAAK8Y,GAC7B,KAAOC,EAAWzO,KACZ1E,EAAMuS,OAAOY,GAAYnT,EAAMwS,WADVW,IASzB,GAJAxY,EAAMqF,EAAM8E,OAAOqO,GAAYnT,EAAM+E,OAAOoO,GAC5C5S,EAAMP,EAAMgF,OAAOmO,GACnBD,EAAWlT,EAAMtF,IAAIxB,MAAMyB,EAAK4F,GAE5B0W,EAAe9hB,GAAG,GAAGiF,KAAK8Y,GAAW,CACf,IAApBA,EAAS/W,QACXgX,IAGF,MASN,OAJAnT,EAAMmF,KAAOgO,GACb9S,EAAQL,EAAMrD,KAAK,aAAc,GAAI,IAC/B6B,IAAM,CAACiG,EAAW0O,GACxB9S,EAAM3B,QAAUsB,EAAM0T,SAASjP,EAAW0O,EAAUnT,EAAMwS,WAAW,IAC9D,I,6BC1ETtd,EAAOD,QAAU,CAAC,UAAW,UAAW,QAAS,OAAQ,WAAY,aAAc,OAAQ,UAAW,SAAU,MAAO,WAAY,KAAM,UAAW,SAAU,MAAO,MAAO,KAAM,KAAM,WAAY,aAAc,SAAU,SAAU,OAAQ,QAAS,WAAY,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,OAAQ,SAAU,KAAM,OAAQ,SAAU,SAAU,KAAM,OAAQ,OAAQ,OAAQ,WAAY,OAAQ,MAAO,WAAY,KAAM,WAAY,SAAU,IAAK,QAAS,UAAW,SAAU,UAAW,QAAS,QAAS,KAAM,QAAS,KAAM,QAAS,QAAS,KAAM,QAAS,O,6BCDljBC,EAAOD,QAAU,SAAmB+K,EAAOyE,GAGzC,IAAI/F,EACAiW,EACAxf,EACAC,EACAiL,EACAkU,EACApB,EAAW1O,EAAY,EACvBmQ,EAAkB5U,EAAM8D,GAAGhF,MAAM0F,MAAMvG,SAAS,aAChDyG,EAAU1E,EAAM4S,QAIpB,IAHA2B,EAAgBvU,EAAMgV,WACtBhV,EAAMgV,WAAa,YAEZ7B,EAAWzO,IAAY1E,EAAM0S,QAAQS,GAAWA,IAGrD,KAAInT,EAAMuS,OAAOY,GAAYnT,EAAMwS,UAAY,MAK3CxS,EAAMuS,OAAOY,GAAY,GAA7B,CAOA,IAFAwB,GAAY,EAEPxf,EAAI,EAAGC,EAAIwf,EAAgBzY,OAAQhH,EAAIC,EAAGD,IAC7C,GAAIyf,EAAgBzf,GAAG6K,EAAOmT,EAAUzO,GAAS,GAAO,CACtDiQ,GAAY,EACZ,MAIJ,GAAIA,EACF,MAcJ,OAVAjW,EAAUsB,EAAM0T,SAASjP,EAAW0O,EAAUnT,EAAMwS,WAAW,GAAOpX,OACtE4E,EAAMmF,KAAOgO,GACb9S,EAAQL,EAAMrD,KAAK,iBAAkB,IAAK,IACpC6B,IAAM,CAACiG,EAAWzE,EAAMmF,OAC9B9E,EAAQL,EAAMrD,KAAK,SAAU,GAAI,IAC3B+B,QAAUA,EAChB2B,EAAM7B,IAAM,CAACiG,EAAWzE,EAAMmF,MAC9B9E,EAAM5E,SAAW,GACjB4E,EAAQL,EAAMrD,KAAK,kBAAmB,KAAM,GAC5CqD,EAAMgV,WAAaT,GACZ,I,6BCpDT,IAAIpW,EAAQ,EAAQ,GAEhBrD,EAAU,EAAQ,GAAmBA,QAEzC,SAASqc,EAAWzc,EAAKoJ,EAAIhC,EAAKpB,GAChC,IAAIjI,EAAIvB,EAAG6J,EAAOpG,EAAKsE,EAAKoW,EAAQlB,EAAQiD,EAqD5C,IApDAzb,KAAKjB,IAAMA,EAEXiB,KAAKmI,GAAKA,EACVnI,KAAKmG,IAAMA,EAIXnG,KAAK+E,OAASA,EACd/E,KAAKmJ,OAAS,GAEdnJ,KAAKqJ,OAAS,GAEdrJ,KAAKoJ,OAAS,GAEdpJ,KAAK4W,OAAS,GAYd5W,KAAKoZ,QAAU,GAEfpZ,KAAK6W,UAAY,EAGjB7W,KAAKwJ,KAAO,EAEZxJ,KAAKiX,QAAU,EAEfjX,KAAK8W,OAAQ,EAEb9W,KAAK0b,UAAY,EAEjB1b,KAAKua,YAAc,EAInBva,KAAKqZ,WAAa,OAClBrZ,KAAK8C,MAAQ,EAEb9C,KAAKkC,OAAS,GAIduZ,GAAe,EAEVrW,EAAQpG,EAAM0a,EAASlB,EAAS,EAAGlV,GAHxC/H,EAAIyE,KAAKjB,KAGuCyB,OAAQxB,EAAMsE,EAAKtE,IAAO,CAGxE,GAFAlC,EAAKvB,EAAEiD,WAAWQ,IAEbyc,EAAc,CACjB,GAAItc,EAAQrC,GAAK,CACf4c,IAEW,IAAP5c,EACF0b,GAAU,EAAIA,EAAS,EAEvBA,IAGF,SAEAiD,GAAe,EAIR,KAAP3e,GAAekC,IAAQsE,EAAM,IACpB,KAAPxG,GACFkC,IAGFgB,KAAKmJ,OAAOnI,KAAKoE,GACjBpF,KAAKqJ,OAAOrI,KAAKhC,GACjBgB,KAAKoJ,OAAOpI,KAAK0Y,GACjB1Z,KAAK4W,OAAO5V,KAAKwX,GACjBxY,KAAKoZ,QAAQpY,KAAK,GAClBya,GAAe,EACf/B,EAAS,EACTlB,EAAS,EACTpT,EAAQpG,EAAM,GAKlBgB,KAAKmJ,OAAOnI,KAAKzF,EAAEiF,QACnBR,KAAKqJ,OAAOrI,KAAKzF,EAAEiF,QACnBR,KAAKoJ,OAAOpI,KAAK,GACjBhB,KAAK4W,OAAO5V,KAAK,GACjBhB,KAAKoZ,QAAQpY,KAAK,GAClBhB,KAAKiX,QAAUjX,KAAKmJ,OAAO3I,OAAS,EAKtCgb,EAAWpgB,UAAU4F,KAAO,SAAUyB,EAAMC,EAAKC,GAC/C,IAAI+B,EAAQ,IAAIlC,EAAMC,EAAMC,EAAKC,GAQjC,OAPA+B,EAAMvB,OAAQ,EACVR,EAAU,GAAG3C,KAAK8C,QAEtB4B,EAAM5B,MAAQ9C,KAAK8C,MACfH,EAAU,GAAG3C,KAAK8C,QAEtB9C,KAAK+E,OAAO/D,KAAK0D,GACVA,GAGT8W,EAAWpgB,UAAU2b,QAAU,SAAiBvN,GAC9C,OAAOxJ,KAAKmJ,OAAOK,GAAQxJ,KAAKoJ,OAAOI,IAASxJ,KAAKqJ,OAAOG,IAG9DgS,EAAWpgB,UAAUub,eAAiB,SAAwBgF,GAC5D,IAAK,IAAI/W,EAAM5E,KAAKiX,QAAS0E,EAAO/W,KAC9B5E,KAAKmJ,OAAOwS,GAAQ3b,KAAKoJ,OAAOuS,GAAQ3b,KAAKqJ,OAAOsS,IADjBA,KAMzC,OAAOA,GAITH,EAAWpgB,UAAUgd,WAAa,SAAoBpZ,GAGpD,IAFA,IAAIlC,EAEK8H,EAAM5E,KAAKjB,IAAIyB,OAAQxB,EAAM4F,IACpC9H,EAAKkD,KAAKjB,IAAIP,WAAWQ,GAEpBG,EAAQrC,IAH4BkC,KAQ3C,OAAOA,GAITwc,EAAWpgB,UAAU+f,eAAiB,SAAwBnc,EAAK0b,GACjE,GAAI1b,GAAO0b,EACT,OAAO1b,EAGT,KAAOA,EAAM0b,GACX,IAAKvb,EAAQa,KAAKjB,IAAIP,aAAaQ,IACjC,OAAOA,EAAM,EAIjB,OAAOA,GAITwc,EAAWpgB,UAAU+c,UAAY,SAAmBnZ,EAAKT,GACvD,IAAK,IAAIqG,EAAM5E,KAAKjB,IAAIyB,OAAQxB,EAAM4F,GAChC5E,KAAKjB,IAAIP,WAAWQ,KAAST,EADQS,KAM3C,OAAOA,GAITwc,EAAWpgB,UAAUggB,cAAgB,SAAuBpc,EAAKT,EAAMmc,GACrE,GAAI1b,GAAO0b,EACT,OAAO1b,EAGT,KAAOA,EAAM0b,GACX,GAAInc,IAASyB,KAAKjB,IAAIP,aAAaQ,GACjC,OAAOA,EAAM,EAIjB,OAAOA,GAITwc,EAAWpgB,UAAU2c,SAAW,SAAkB6D,EAAO9W,EAAK4U,EAAQmC,GACpE,IAAIriB,EACAsiB,EACAhf,EACAif,EACAjE,EACAkE,EACAC,EACAzS,EAAOoS,EAEX,GAAIA,GAAS9W,EACX,MAAO,GAKT,IAFAkX,EAAQ,IAAI1e,MAAMwH,EAAM8W,GAEnBpiB,EAAI,EAAGgQ,EAAO1E,EAAK0E,IAAQhQ,IAAK,CAWnC,IAVAsiB,EAAa,EACbG,EAAYF,EAAQ/b,KAAKmJ,OAAOK,GAI9BsO,EAFEtO,EAAO,EAAI1E,GAAO+W,EAEb7b,KAAKqJ,OAAOG,GAAQ,EAEpBxJ,KAAKqJ,OAAOG,GAGduS,EAAQjE,GAAQgE,EAAapC,GAAQ,CAG1C,GAFA5c,EAAKkD,KAAKjB,IAAIP,WAAWud,GAErB5c,EAAQrC,GACC,IAAPA,EACFgf,GAAc,GAAKA,EAAa9b,KAAKoZ,QAAQ5P,IAAS,EAEtDsS,QAEG,MAAIC,EAAQE,EAAYjc,KAAKoJ,OAAOI,IAIzC,MAFAsS,IAKFC,IAMAC,EAAMxiB,GAHJsiB,EAAapC,EAGJ,IAAIpc,MAAMwe,EAAapC,EAAS,GAAG/R,KAAK,KAAO3H,KAAKjB,IAAIxB,MAAMwe,EAAOjE,GAErE9X,KAAKjB,IAAIxB,MAAMwe,EAAOjE,GAIrC,OAAOkE,EAAMrU,KAAK,KAIpB6T,EAAWpgB,UAAUoH,MAAQA,EAC7BjJ,EAAOD,QAAUkiB,G,6BCpPjB,IAAIpb,EAAQ,EAAQ,GAIhBiT,EAAS,CAAC,CAAC,OAAQ,EAAQ,KAAyB,CAAC,UAAW,EAAQ,KAA4B,CAAC,SAAU,EAAQ,KAA2B,CAAC,YAAa,EAAQ,KAA8B,CAAC,gBAAiB,EAAQ,IAAgCpO,UAAW,CAAC,WAAY,EAAQ,IAA2BA,UAAW,CAAC,OAAQ,EAAQ,KAAyB,CAAC,QAAS,EAAQ,KAA0B,CAAC,WAAY,EAAQ,KAA6B,CAAC,cAAe,EAAQ,KAAgC,CAAC,SAAU,EAAQ,MACzhBiX,EAAU,CAAC,CAAC,gBAAiB,EAAQ,KAAkC,CAAC,gBAAiB,EAAQ,IAAgC9X,aAAc,CAAC,WAAY,EAAQ,IAA2BA,aAAc,CAAC,gBAAiB,EAAQ,MAK3O,SAASwG,IACP,IAAIpR,EASJ,IAFAwG,KAAK6I,MAAQ,IAAIzI,EAEZ5G,EAAI,EAAGA,EAAI6Z,EAAO7S,OAAQhH,IAC7BwG,KAAK6I,MAAM7H,KAAKqS,EAAO7Z,GAAG,GAAI6Z,EAAO7Z,GAAG,IAY1C,IAFAwG,KAAKqM,OAAS,IAAIjM,EAEb5G,EAAI,EAAGA,EAAI0iB,EAAQ1b,OAAQhH,IAC9BwG,KAAKqM,OAAOrL,KAAKkb,EAAQ1iB,GAAG,GAAI0iB,EAAQ1iB,GAAG,IAO/CoR,EAAaxP,UAAUwW,UAAY,SAAUvN,GAC3C,IAAIwN,EACArY,EACAwF,EAAMqF,EAAMrF,IACZ0K,EAAQ1J,KAAK6I,MAAMvG,SAAS,IAC5BgB,EAAMoG,EAAMlJ,OACZkW,EAAarS,EAAM8D,GAAG/G,QAAQsV,WAC9BnJ,EAAQlJ,EAAMkJ,MAElB,GAA0B,qBAAfA,EAAMvO,GAAjB,CAKA,GAAIqF,EAAMvB,MAAQ4T,EAChB,IAAKld,EAAI,EAAGA,EAAI8J,IAKde,EAAMvB,QACN+O,EAAKnI,EAAMlQ,GAAG6K,GAAO,GACrBA,EAAMvB,SAEF+O,GATerY,UAyBrB6K,EAAMrF,IAAMqF,EAAMqN,OAGfG,GACHxN,EAAMrF,MAGRuO,EAAMvO,GAAOqF,EAAMrF,SArCjBqF,EAAMrF,IAAMuO,EAAMvO,IA0CtB4L,EAAaxP,UAAU6J,SAAW,SAAUZ,GAQ1C,IAPA,IAAIwN,EACArY,EACAkQ,EAAQ1J,KAAK6I,MAAMvG,SAAS,IAC5BgB,EAAMoG,EAAMlJ,OACZsE,EAAMT,EAAMqN,OACZgF,EAAarS,EAAM8D,GAAG/G,QAAQsV,WAE3BrS,EAAMrF,IAAM8F,GAAK,CAOtB,GAAIT,EAAMvB,MAAQ4T,EAChB,IAAKld,EAAI,EAAGA,EAAI8J,KACduO,EAAKnI,EAAMlQ,GAAG6K,GAAO,IADF7K,KASvB,GAAIqY,GACF,GAAIxN,EAAMrF,KAAO8F,EACf,WAMJT,EAAM8X,SAAW9X,EAAMtF,IAAIsF,EAAMrF,OAG/BqF,EAAM8X,SACR9X,EAAM+X,eAUVxR,EAAaxP,UAAU2I,MAAQ,SAAU/F,EAAKmK,EAAIhC,EAAK6Q,GACrD,IAAIxd,EAAGkQ,EAAOpG,EACVe,EAAQ,IAAIrE,KAAK4M,MAAM5O,EAAKmK,EAAIhC,EAAK6Q,GAKzC,IAJAhX,KAAKiF,SAASZ,GAEdf,GADAoG,EAAQ1J,KAAKqM,OAAO/J,SAAS,KACjB9B,OAEPhH,EAAI,EAAGA,EAAI8J,EAAK9J,IACnBkQ,EAAMlQ,GAAG6K,IAIbuG,EAAaxP,UAAUwR,MAAQ,EAAQ,IACvCrT,EAAOD,QAAUsR,G,6BCxJjB,SAASyR,EAAiBvf,GACxB,OAAQA,GACN,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,GAGL,KAAK,IAGL,KAAK,IAGL,KAAK,IAGH,OAAO,EAET,QACE,OAAO,GAIbvD,EAAOD,QAAU,SAAc+K,EAAOa,GAGpC,IAFA,IAAIlG,EAAMqF,EAAMrF,IAETA,EAAMqF,EAAMqN,SAAW2K,EAAiBhY,EAAMtF,IAAIP,WAAWQ,KAClEA,IAGF,OAAIA,IAAQqF,EAAMrF,MAIbkG,IACHb,EAAM8X,SAAW9X,EAAMtF,IAAIxB,MAAM8G,EAAMrF,IAAKA,IAG9CqF,EAAMrF,IAAMA,GACL,K,6BCnGT,IAAIG,EAAU,EAAQ,GAAmBA,QAEzC5F,EAAOD,QAAU,SAAiB+K,EAAOa,GACvC,IAAIoX,EACA1X,EACA5F,EAAMqF,EAAMrF,IAEhB,GAAkC,KAA9BqF,EAAMtF,IAAIP,WAAWQ,GAGvB,OAAO,EAyBT,IAtBAsd,EAAOjY,EAAM8X,QAAQ3b,OAAS,EAC9BoE,EAAMP,EAAMqN,OAKPxM,IACCoX,GAAQ,GAAwC,KAAnCjY,EAAM8X,QAAQ3d,WAAW8d,GACpCA,GAAQ,GAA4C,KAAvCjY,EAAM8X,QAAQ3d,WAAW8d,EAAO,IAC/CjY,EAAM8X,QAAU9X,EAAM8X,QAAQje,QAAQ,MAAO,IAC7CmG,EAAMrD,KAAK,YAAa,KAAM,KAE9BqD,EAAM8X,QAAU9X,EAAM8X,QAAQ5e,MAAM,GAAI,GACxC8G,EAAMrD,KAAK,YAAa,KAAM,IAGhCqD,EAAMrD,KAAK,YAAa,KAAM,IAIlChC,IAEOA,EAAM4F,GAAOzF,EAAQkF,EAAMtF,IAAIP,WAAWQ,KAC/CA,IAIF,OADAqF,EAAMrF,IAAMA,GACL,I,6BCpCT,IAJA,IAAIG,EAAU,EAAQ,GAAmBA,QAErCod,EAAU,GAEL/iB,EAAI,EAAGA,EAAI,IAAKA,IACvB+iB,EAAQvb,KAAK,GAGf,qCAAqC0O,MAAM,IAAIjS,SAAQ,SAAUX,GAC/Dyf,EAAQzf,EAAG0B,WAAW,IAAM,KAG9BjF,EAAOD,QAAU,SAAgB+K,EAAOa,GACtC,IAAIpI,EACAkC,EAAMqF,EAAMrF,IACZ4F,EAAMP,EAAMqN,OAEhB,GAAkC,KAA9BrN,EAAMtF,IAAIP,WAAWQ,GAGvB,OAAO,EAKT,KAFAA,EAEU4F,EAAK,CAGb,IAFA9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,IAEjB,KAAuB,IAAhBud,EAAQzf,GAMtB,OALKoI,IACHb,EAAM8X,SAAW9X,EAAMtF,IAAIC,IAG7BqF,EAAMrF,KAAO,GACN,EAGT,GAAW,KAAPlC,EAAa,CAOf,IANKoI,GACHb,EAAMrD,KAAK,YAAa,KAAM,GAGhChC,IAEOA,EAAM4F,IACX9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,GAErBG,EAAQrC,KAIbkC,IAIF,OADAqF,EAAMrF,IAAMA,GACL,GASX,OALKkG,IACHb,EAAM8X,SAAW,MAGnB9X,EAAMrF,OACC,I,6BChETzF,EAAOD,QAAU,SAAkB+K,EAAOa,GACxC,IAAIE,EACAR,EACAC,EACA2X,EACAC,EACA/X,EACA1F,EAAMqF,EAAMrF,IAGhB,GAAW,KAFFqF,EAAMtF,IAAIP,WAAWQ,GAK5B,OAAO,EAOT,IAJAoG,EAAQpG,EACRA,IACA4F,EAAMP,EAAMqN,OAEL1S,EAAM4F,GAAqC,KAA9BP,EAAMtF,IAAIP,WAAWQ,IAGvCA,IAMF,IAHA6F,EAASR,EAAMtF,IAAIxB,MAAM6H,EAAOpG,GAChCwd,EAAaC,EAAWzd,GAEoC,KAApDwd,EAAanY,EAAMtF,IAAId,QAAQ,IAAKwe,KAAmB,CAG7D,IAFAA,EAAWD,EAAa,EAEjBC,EAAW7X,GAA0C,KAAnCP,EAAMtF,IAAIP,WAAWie,IAG5CA,IAGF,GAAIA,EAAWD,IAAe3X,EAAOrE,OAQnC,OAPK0E,KACHR,EAAQL,EAAMrD,KAAK,cAAe,OAAQ,IACpCgC,OAAS6B,EACfH,EAAM3B,QAAUsB,EAAMtF,IAAIxB,MAAMyB,EAAKwd,GAAYte,QAAQ,MAAO,KAAKA,QAAQ,WAAY,OAG3FmG,EAAMrF,IAAMyd,GACL,EASX,OALKvX,IACHb,EAAM8X,SAAWtX,GAGnBR,EAAMrF,KAAO6F,EAAOrE,QACb,I,6BCvDT,IAAIhB,EAAqB,EAAQ,GAAmBA,mBAEhDL,EAAU,EAAQ,GAAmBA,QAEzC5F,EAAOD,QAAU,SAAc+K,EAAOa,GACpC,IAAItC,EACArE,EACAwc,EACAtJ,EACAiL,EACA1d,EACAgc,EACA2B,EACAxV,EAEA2T,EAAO,GACPnJ,EAAStN,EAAMrF,IACf4F,EAAMP,EAAMqN,OACZtM,EAAQf,EAAMrF,IACd4d,GAAiB,EAErB,GAAwC,KAApCvY,EAAMtF,IAAIP,WAAW6F,EAAMrF,KAG7B,OAAO,EAMT,GAHA0d,EAAarY,EAAMrF,IAAM,GACzByS,EAAWpN,EAAM8D,GAAGqC,QAAQ2G,eAAe9M,EAAOA,EAAMrF,KAAK,IAE9C,EACb,OAAO,EAKT,IAFAA,EAAMyS,EAAW,GAEP7M,GAAqC,KAA9BP,EAAMtF,IAAIP,WAAWQ,GAEpC,CAUA,IALA4d,GAAiB,EAGjB5d,IAEOA,EAAM4F,IACXrG,EAAO8F,EAAMtF,IAAIP,WAAWQ,GAEvBG,EAAQZ,IAAkB,KAATA,GAHNS,KAQlB,GAAIA,GAAO4F,EACT,OAAO,EAsBT,IAjBAQ,EAAQpG,GACRgc,EAAM3W,EAAM8D,GAAGqC,QAAQ4G,qBAAqB/M,EAAMtF,IAAKC,EAAKqF,EAAMqN,SAE1DG,KACNiJ,EAAOzW,EAAM8D,GAAGmD,cAAc0P,EAAIhd,KAE9BqG,EAAM8D,GAAGiD,aAAa0P,GACxB9b,EAAMgc,EAAIhc,IAEV8b,EAAO,IAMX1V,EAAQpG,EAEDA,EAAM4F,IACXrG,EAAO8F,EAAMtF,IAAIP,WAAWQ,GAEvBG,EAAQZ,IAAkB,KAATA,GAHNS,KAYlB,GAFAgc,EAAM3W,EAAM8D,GAAGqC,QAAQ6G,eAAehN,EAAMtF,IAAKC,EAAKqF,EAAMqN,QAExD1S,EAAM4F,GAAOQ,IAAUpG,GAAOgc,EAAInJ,GAKpC,IAJA1K,EAAQ6T,EAAIhd,IACZgB,EAAMgc,EAAIhc,IAGHA,EAAM4F,IACXrG,EAAO8F,EAAMtF,IAAIP,WAAWQ,GAEvBG,EAAQZ,IAAkB,KAATA,GAHNS,UAQlBmI,EAAQ,IAGNnI,GAAO4F,GAAqC,KAA9BP,EAAMtF,IAAIP,WAAWQ,MAIrC4d,GAAiB,GAGnB5d,IAGF,GAAI4d,EAAgB,CAIlB,GAAoC,qBAAzBvY,EAAM8B,IAAI8U,WACnB,OAAO,EA0BT,GAvBIjc,EAAM4F,GAAqC,KAA9BP,EAAMtF,IAAIP,WAAWQ,IAGpCoG,EAAQpG,EAAM,GACdA,EAAMqF,EAAM8D,GAAGqC,QAAQ2G,eAAe9M,EAAOrF,KAElC,EACT+b,EAAQ1W,EAAMtF,IAAIxB,MAAM6H,EAAOpG,KAE/BA,EAAMyS,EAAW,GAGnBzS,EAAMyS,EAAW,EAKdsJ,IACHA,EAAQ1W,EAAMtF,IAAIxB,MAAMmf,EAAYjL,MAGtCkL,EAAMtY,EAAM8B,IAAI8U,WAAWzb,EAAmBub,KAI5C,OADA1W,EAAMrF,IAAM2S,GACL,EAGTmJ,EAAO6B,EAAI7B,KACX3T,EAAQwV,EAAIxV,MAuBd,OAhBKjC,IACHb,EAAMrF,IAAM0d,EACZrY,EAAMqN,OAASD,EACPpN,EAAMrD,KAAK,YAAa,IAAK,GAC/B4B,MAAQA,EAAQ,CAAC,CAAC,OAAQkY,IAE5B3T,GACFvE,EAAM5B,KAAK,CAAC,QAASmG,IAGvB9C,EAAM8D,GAAGM,OAAOxD,SAASZ,GACjBA,EAAMrD,KAAK,aAAc,KAAM,IAGzCqD,EAAMrF,IAAMA,EACZqF,EAAMqN,OAAS9M,GACR,I,6BCjLT,IAAIpF,EAAqB,EAAQ,GAAmBA,mBAEhDL,EAAU,EAAQ,GAAmBA,QAEzC5F,EAAOD,QAAU,SAAe+K,EAAOa,GACrC,IAAItC,EACArE,EACAwE,EACAgY,EACAtJ,EACAiL,EACA1d,EACA2d,EACA3B,EACA7T,EACAzC,EACAK,EACAK,EACA0V,EAAO,GACPnJ,EAAStN,EAAMrF,IACf4F,EAAMP,EAAMqN,OAEhB,GAAwC,KAApCrN,EAAMtF,IAAIP,WAAW6F,EAAMrF,KAG7B,OAAO,EAGT,GAA4C,KAAxCqF,EAAMtF,IAAIP,WAAW6F,EAAMrF,IAAM,GAGnC,OAAO,EAMT,GAHA0d,EAAarY,EAAMrF,IAAM,GACzByS,EAAWpN,EAAM8D,GAAGqC,QAAQ2G,eAAe9M,EAAOA,EAAMrF,IAAM,GAAG,IAElD,EACb,OAAO,EAKT,IAFAA,EAAMyS,EAAW,GAEP7M,GAAqC,KAA9BP,EAAMtF,IAAIP,WAAWQ,GAEpC,CAQA,IAFAA,IAEOA,EAAM4F,IACXrG,EAAO8F,EAAMtF,IAAIP,WAAWQ,GAEvBG,EAAQZ,IAAkB,KAATA,GAHNS,KAQlB,GAAIA,GAAO4F,EACT,OAAO,EAsBT,IAjBAQ,EAAQpG,GACRgc,EAAM3W,EAAM8D,GAAGqC,QAAQ4G,qBAAqB/M,EAAMtF,IAAKC,EAAKqF,EAAMqN,SAE1DG,KACNiJ,EAAOzW,EAAM8D,GAAGmD,cAAc0P,EAAIhd,KAE9BqG,EAAM8D,GAAGiD,aAAa0P,GACxB9b,EAAMgc,EAAIhc,IAEV8b,EAAO,IAMX1V,EAAQpG,EAEDA,EAAM4F,IACXrG,EAAO8F,EAAMtF,IAAIP,WAAWQ,GAEvBG,EAAQZ,IAAkB,KAATA,GAHNS,KAYlB,GAFAgc,EAAM3W,EAAM8D,GAAGqC,QAAQ6G,eAAehN,EAAMtF,IAAKC,EAAKqF,EAAMqN,QAExD1S,EAAM4F,GAAOQ,IAAUpG,GAAOgc,EAAInJ,GAKpC,IAJA1K,EAAQ6T,EAAIhd,IACZgB,EAAMgc,EAAIhc,IAGHA,EAAM4F,IACXrG,EAAO8F,EAAMtF,IAAIP,WAAWQ,GAEvBG,EAAQZ,IAAkB,KAATA,GAHNS,UAQlBmI,EAAQ,GAGV,GAAInI,GAAO4F,GAAqC,KAA9BP,EAAMtF,IAAIP,WAAWQ,GAIrC,OADAqF,EAAMrF,IAAM2S,GACL,EAGT3S,QACK,CAIL,GAAoC,qBAAzBqF,EAAM8B,IAAI8U,WACnB,OAAO,EA0BT,GAvBIjc,EAAM4F,GAAqC,KAA9BP,EAAMtF,IAAIP,WAAWQ,IAGpCoG,EAAQpG,EAAM,GACdA,EAAMqF,EAAM8D,GAAGqC,QAAQ2G,eAAe9M,EAAOrF,KAElC,EACT+b,EAAQ1W,EAAMtF,IAAIxB,MAAM6H,EAAOpG,KAE/BA,EAAMyS,EAAW,GAGnBzS,EAAMyS,EAAW,EAKdsJ,IACHA,EAAQ1W,EAAMtF,IAAIxB,MAAMmf,EAAYjL,MAGtCkL,EAAMtY,EAAM8B,IAAI8U,WAAWzb,EAAmBub,KAI5C,OADA1W,EAAMrF,IAAM2S,GACL,EAGTmJ,EAAO6B,EAAI7B,KACX3T,EAAQwV,EAAIxV,MAsBd,OAfKjC,IACHnC,EAAUsB,EAAMtF,IAAIxB,MAAMmf,EAAYjL,GACtCpN,EAAM8D,GAAGM,OAAO1E,MAAMhB,EAASsB,EAAM8D,GAAI9D,EAAM8B,IAAKpB,EAAS,KAC7DL,EAAQL,EAAMrD,KAAK,QAAS,MAAO,IAC7B4B,MAAQA,EAAQ,CAAC,CAAC,MAAOkY,GAAO,CAAC,MAAO,KAC9CpW,EAAM5E,SAAWiF,EACjBL,EAAM3B,QAAUA,EAEZoE,GACFvE,EAAM5B,KAAK,CAAC,QAASmG,KAIzB9C,EAAMrF,IAAMA,EACZqF,EAAMqN,OAAS9M,GACR,I,6BClLT,IAAIiY,EAAW,2IACXC,EAAc,uDAElBvjB,EAAOD,QAAU,SAAkB+K,EAAOa,GACxC,IAAI6X,EACAC,EACAC,EACAzW,EACAwN,EACAtP,EACA1F,EAAMqF,EAAMrF,IAEhB,OAAkC,KAA9BqF,EAAMtF,IAAIP,WAAWQ,QAMzB+d,EAAO1Y,EAAMtF,IAAIxB,MAAMyB,IAEdf,QAAQ,KAAO,KAIpB6e,EAAYre,KAAKse,IAEnBvW,GADAwW,EAAYD,EAAK3e,MAAM0e,IACP,GAAGvf,MAAM,GAAI,GAC7ByW,EAAU3P,EAAM8D,GAAGmD,cAAc9E,KAE5BnC,EAAM8D,GAAGiD,aAAa4I,KAItB9O,KACHR,EAAQL,EAAMrD,KAAK,YAAa,IAAK,IAC/B4B,MAAQ,CAAC,CAAC,OAAQoR,IACxBtP,EAAM1B,OAAS,WACf0B,EAAMzB,KAAO,QACbyB,EAAQL,EAAMrD,KAAK,OAAQ,GAAI,IACzB+B,QAAUsB,EAAM8D,GAAGwD,kBAAkBnF,IAC3C9B,EAAQL,EAAMrD,KAAK,aAAc,KAAM,IACjCgC,OAAS,WACf0B,EAAMzB,KAAO,QAGfoB,EAAMrF,KAAOge,EAAU,GAAGxc,QACnB,MAGLqc,EAASpe,KAAKse,KAEhBvW,GADAyW,EAAaF,EAAK3e,MAAMye,IACP,GAAGtf,MAAM,GAAI,GAC9ByW,EAAU3P,EAAM8D,GAAGmD,cAAc,UAAY9E,KAExCnC,EAAM8D,GAAGiD,aAAa4I,KAItB9O,KACHR,EAAQL,EAAMrD,KAAK,YAAa,IAAK,IAC/B4B,MAAQ,CAAC,CAAC,OAAQoR,IACxBtP,EAAM1B,OAAS,WACf0B,EAAMzB,KAAO,QACbyB,EAAQL,EAAMrD,KAAK,OAAQ,GAAI,IACzB+B,QAAUsB,EAAM8D,GAAGwD,kBAAkBnF,IAC3C9B,EAAQL,EAAMrD,KAAK,aAAc,KAAM,IACjCgC,OAAS,WACf0B,EAAMzB,KAAO,QAGfoB,EAAMrF,KAAOie,EAAW,GAAGzc,QACpB,Q,6BCxEX,IAAI0D,EAAc,EAAQ,IAAqBA,YAa/C3K,EAAOD,QAAU,SAAqB+K,EAAOa,GAC3C,IAAIpI,EACAsB,EACAwG,EAEA5F,EAAMqF,EAAMrF,IAEhB,QAAKqF,EAAM8D,GAAG/G,QAAQma,OAKtB3W,EAAMP,EAAMqN,SAEsB,KAA9BrN,EAAMtF,IAAIP,WAAWQ,IAEtBA,EAAM,GAAK4F,OAOH,MAFX9H,EAAKuH,EAAMtF,IAAIP,WAAWQ,EAAM,KAItB,KAAPlC,GAEO,KAAPA,IAtCL,SAAkBA,GAEhB,IAAIogB,EAAU,GAALpgB,EAET,OAAOogB,GAAM,IAEVA,GAAM,IAkCLC,CAASrgB,SAIbsB,EAAQiG,EAAMtF,IAAIxB,MAAMyB,GAAKZ,MAAM8F,MAM9BgB,IACKb,EAAMrD,KAAK,cAAe,GAAI,GAChC+B,QAAUsB,EAAMtF,IAAIxB,MAAMyB,EAAKA,EAAMZ,EAAM,GAAGoC,SAGtD6D,EAAMrF,KAAOZ,EAAM,GAAGoC,QACf,Q,6BC1DT,IAAI/D,EAAW,EAAQ,IAEnBZ,EAAM,EAAQ,GAAmBA,IAEjCC,EAAoB,EAAQ,GAAmBA,kBAE/CC,EAAgB,EAAQ,GAAmBA,cAE3CqhB,EAAa,uCACbC,EAAW,4BAEf9jB,EAAOD,QAAU,SAAgB+K,EAAOa,GACtC,IACI3G,EACAH,EACAY,EAAMqF,EAAMrF,IACZ4F,EAAMP,EAAMqN,OAEhB,GAAkC,KAA9BrN,EAAMtF,IAAIP,WAAWQ,GAGvB,OAAO,EAGT,GAAIA,EAAM,EAAI4F,EAGZ,GAAW,KAFNP,EAAMtF,IAAIP,WAAWQ,EAAM,IAO9B,GAFAZ,EAAQiG,EAAMtF,IAAIxB,MAAMyB,GAAKZ,MAAMgf,GASjC,OANKlY,IACH3G,EAAqC,MAA9BH,EAAM,GAAG,GAAGM,cAAwBC,SAASP,EAAM,GAAGb,MAAM,GAAI,IAAMoB,SAASP,EAAM,GAAI,IAChGiG,EAAM8X,SAAWrgB,EAAkByC,GAAQxC,EAAcwC,GAAQxC,EAAc,QAGjFsI,EAAMrF,KAAOZ,EAAM,GAAGoC,QACf,OAKT,IAFApC,EAAQiG,EAAMtF,IAAIxB,MAAMyB,GAAKZ,MAAMif,KAG7BxhB,EAAIY,EAAU2B,EAAM,IAMtB,OALK8G,IACHb,EAAM8X,SAAW1f,EAAS2B,EAAM,KAGlCiG,EAAMrF,KAAOZ,EAAM,GAAGoC,QACf,EAWf,OALK0E,IACHb,EAAM8X,SAAW,KAGnB9X,EAAMrF,OACC,I,6BC7DT,SAASse,EAAkBjZ,EAAOC,GAChC,IAAIiZ,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAAgB,GAChBnZ,EAAMN,EAAW9D,OAErB,IAAK+c,EAAY,EAAGA,EAAY3Y,EAAK2Y,IAOnC,IANAE,EAASnZ,EAAWiZ,IAKb/c,OAASid,EAAOjd,QAAU,EAC5Bid,EAAOhY,MAAZ,CAWA,IARKsY,EAAc1iB,eAAeoiB,EAAO5Y,UACvCkZ,EAAcN,EAAO5Y,QAAU,EAAE,GAAI,GAAI,IAG3C8Y,EAAeI,EAAcN,EAAO5Y,QAAQ4Y,EAAOjd,OAAS,GAC5Dod,GAAmB,EACnBJ,EAAYD,EAAYE,EAAOnY,KAAO,EAE/BkY,EAAYG,EAAcH,GAAaE,EAAOpY,KAAO,EAE1D,IADAoY,EAASpZ,EAAWkZ,IACT3Y,SAAW4Y,EAAO5Y,UACJ,IAArB+Y,IAAwBA,EAAkBJ,GAE1CE,EAAOnY,MAAQmY,EAAO5Y,IAAM,GAAK4Y,EAAO5a,QAAU2a,EAAO3a,QAC3D+a,GAAa,GAQTH,EAAOjY,OAASgY,EAAOlY,QACpBmY,EAAOld,OAASid,EAAOjd,QAAU,IAAM,IACtCkd,EAAOld,OAAS,IAAM,GAAKid,EAAOjd,OAAS,IAAM,IACnDqd,GAAa,KAKdA,IAAY,CAKfC,EAAWN,EAAY,IAAMlZ,EAAWkZ,EAAY,GAAGjY,KAAOjB,EAAWkZ,EAAY,GAAGlY,KAAO,EAAI,EACnGmY,EAAOnY,KAAOiY,EAAYC,EAAYM,EACtCL,EAAOlY,MAAO,EACdmY,EAAO5Y,IAAMyY,EACbG,EAAOpY,KAAOwY,EACdJ,EAAOjY,OAAQ,EACfmY,GAAmB,EACnB,OAKmB,IAArBA,IAQFG,EAAcN,EAAO5Y,SAAS4Y,EAAOjd,QAAU,GAAK,GAAKod,IAK/DrkB,EAAOD,QAAU,SAAoB+K,GACnC,IAAIsB,EACAC,EAAcvB,EAAMuB,YACpBhB,EAAMP,EAAMuB,YAAYpF,OAG5B,IAFA8c,EAAkBjZ,EAAOA,EAAMC,YAE1BqB,EAAO,EAAGA,EAAOf,EAAKe,IACrBC,EAAYD,IAASC,EAAYD,GAAMrB,YACzCgZ,EAAkBjZ,EAAOuB,EAAYD,GAAMrB,c,6BCpFjD/K,EAAOD,QAAU,SAAuB+K,GACtC,IAAIsB,EACAmS,EACAhV,EAAQ,EACRiC,EAASV,EAAMU,OACfH,EAAMP,EAAMU,OAAOvE,OAEvB,IAAKmF,EAAOmS,EAAO,EAAGnS,EAAOf,EAAKe,IAG5BZ,EAAOY,GAAMhD,QAAU,GAAGG,IAE9BiC,EAAOY,GAAM7C,MAAQA,EACjBiC,EAAOY,GAAMhD,QAAU,GAAGG,IAEJ,SAAtBiC,EAAOY,GAAMlD,MAAmBkD,EAAO,EAAIf,GAAiC,SAA1BG,EAAOY,EAAO,GAAGlD,KAErEsC,EAAOY,EAAO,GAAG5C,QAAUgC,EAAOY,GAAM5C,QAAUgC,EAAOY,EAAO,GAAG5C,SAE/D4C,IAASmS,IACX/S,EAAO+S,GAAQ/S,EAAOY,IAGxBmS,KAIAnS,IAASmS,IACX/S,EAAOvE,OAASsX,K,6BCnCpB,IAAItV,EAAQ,EAAQ,GAEhBpD,EAAe,EAAQ,GAAmBA,aAE1CE,EAAc,EAAQ,GAAmBA,YAEzCD,EAAiB,EAAQ,GAAmBA,eAEhD,SAAS2e,EAAYjf,EAAKoJ,EAAIhC,EAAK6Q,GACjChX,KAAKjB,IAAMA,EACXiB,KAAKmG,IAAMA,EACXnG,KAAKmI,GAAKA,EACVnI,KAAK+E,OAASiS,EACdhX,KAAK4F,YAActI,MAAM0Z,EAAUxW,QACnCR,KAAKhB,IAAM,EACXgB,KAAK0R,OAAS1R,KAAKjB,IAAIyB,OACvBR,KAAK8C,MAAQ,EACb9C,KAAKmc,QAAU,GACfnc,KAAKie,aAAe,EAGpBje,KAAKuN,MAAQ,GAEbvN,KAAKsE,WAAa,GAElBtE,KAAKke,iBAAmB,GAK1BF,EAAY5iB,UAAUghB,YAAc,WAClC,IAAI1X,EAAQ,IAAIlC,EAAM,OAAQ,GAAI,GAKlC,OAJAkC,EAAM3B,QAAU/C,KAAKmc,QACrBzX,EAAM5B,MAAQ9C,KAAKie,aACnBje,KAAK+E,OAAO/D,KAAK0D,GACjB1E,KAAKmc,QAAU,GACRzX,GAMTsZ,EAAY5iB,UAAU4F,KAAO,SAAUyB,EAAMC,EAAKC,GAC5C3C,KAAKmc,SACPnc,KAAKoc,cAGP,IAAI1X,EAAQ,IAAIlC,EAAMC,EAAMC,EAAKC,GAC7Bwb,EAAa,KAyBjB,OAvBIxb,EAAU,IAEZ3C,KAAK8C,QACL9C,KAAKsE,WAAatE,KAAKke,iBAAiBlZ,OAG1CN,EAAM5B,MAAQ9C,KAAK8C,MAEfH,EAAU,IAEZ3C,KAAK8C,QAEL9C,KAAKke,iBAAiBld,KAAKhB,KAAKsE,YAEhCtE,KAAKsE,WAAa,GAClB6Z,EAAa,CACX7Z,WAAYtE,KAAKsE,aAIrBtE,KAAKie,aAAeje,KAAK8C,MACzB9C,KAAK+E,OAAO/D,KAAK0D,GACjB1E,KAAK4F,YAAY5E,KAAKmd,GACfzZ,GASTsZ,EAAY5iB,UAAUiK,WAAa,SAAUD,EAAOgZ,GAClD,IACI3I,EACAC,EACA2I,EACA7Y,EACAE,EACAmQ,EACAF,EACAG,EACAF,EATA5W,EAAMoG,EAUNkZ,GAAgB,EAChBC,GAAiB,EACjB3Z,EAAM5E,KAAK0R,OACX7M,EAAS7E,KAAKjB,IAAIP,WAAW4G,GAIjC,IAFAqQ,EAAWrQ,EAAQ,EAAIpF,KAAKjB,IAAIP,WAAW4G,EAAQ,GAAK,GAEjDpG,EAAM4F,GAAO5E,KAAKjB,IAAIP,WAAWQ,KAAS6F,GAC/C7F,IAmCF,OAhCAqf,EAAQrf,EAAMoG,EAEdsQ,EAAW1W,EAAM4F,EAAM5E,KAAKjB,IAAIP,WAAWQ,GAAO,GAClD2W,EAAkBtW,EAAeoW,IAAanW,EAAYpD,OAAOC,aAAasZ,IAC9EG,EAAkBvW,EAAeqW,IAAapW,EAAYpD,OAAOC,aAAauZ,IAC9EG,EAAmBzW,EAAaqW,IAChCK,EAAmB1W,EAAasW,IAG9B4I,GAAgB,EACP1I,IACHC,GAAoBF,IACxB2I,GAAgB,IAIhBzI,EACF0I,GAAiB,EACR5I,IACHG,GAAoBF,IACxB2I,GAAiB,IAIhBH,GAIH5Y,EAAW8Y,EACX5Y,EAAY6Y,IAJZ/Y,EAAW8Y,KAAmBC,GAAkB5I,GAChDjQ,EAAY6Y,KAAoBD,GAAiB1I,IAM5C,CACLpQ,SAAUA,EACVE,UAAWA,EACXlF,OAAQ6d,IAKZL,EAAY5iB,UAAUoH,MAAQA,EAC9BjJ,EAAOD,QAAU0kB,G,6BC/IjB,SAAS5gB,EAAO3B,GAGd,IAAI4B,EAAUC,MAAMlC,UAAUmC,MAAM5D,KAAK6D,UAAW,GAUpD,OATAH,EAAQI,SAAQ,SAAUlB,GACnBA,GAILrC,OAAOyD,KAAKpB,GAAQkB,SAAQ,SAAU1C,GACpCU,EAAIV,GAAOwB,EAAOxB,SAGfU,EAGT,SAASqC,EAAOrC,GACd,OAAOvB,OAAOkB,UAAUyC,SAASlE,KAAK8B,GAexC,SAAS+iB,EAAW/iB,GAClB,MAAuB,sBAAhBqC,EAAOrC,GAGhB,SAAS8D,EAASvB,GAChB,OAAOA,EAAIE,QAAQ,uBAAwB,QAI7C,IAAIugB,EAAiB,CACnBC,WAAW,EACXC,YAAY,EACZC,SAAS,GASX,IAAIC,EAAiB,CACnB,QAAS,CACPC,SAAU,SAAkB9L,EAAMhU,EAAK0B,GACrC,IAAIqc,EAAO/J,EAAKzV,MAAMyB,GAOtB,OALK0B,EAAKqe,GAAGC,OAEXte,EAAKqe,GAAGC,KAAO,IAAI1iB,OAAO,UAAYoE,EAAKqe,GAAGE,SAAWve,EAAKqe,GAAGG,qBAAuBxe,EAAKqe,GAAGI,SAAU,MAGxGze,EAAKqe,GAAGC,KAAKvgB,KAAKse,GACbA,EAAK3e,MAAMsC,EAAKqe,GAAGC,MAAM,GAAGxe,OAG9B,IAGX,SAAU,QACV,OAAQ,QACR,KAAM,CACJse,SAAU,SAAkB9L,EAAMhU,EAAK0B,GACrC,IAAIqc,EAAO/J,EAAKzV,MAAMyB,GAStB,OAPK0B,EAAKqe,GAAGK,UAEX1e,EAAKqe,GAAGK,QAAU,IAAI9iB,OAAO,IAAMoE,EAAKqe,GAAGE,SAE3C,sBAAwBve,EAAKqe,GAAGM,WAAa,SAAW3e,EAAKqe,GAAGO,gBAAkB,IAAM5e,EAAKqe,GAAGQ,SAAW7e,EAAKqe,GAAGS,oBAAsB9e,EAAKqe,GAAGI,SAAU,MAGzJze,EAAKqe,GAAGK,QAAQ3gB,KAAKse,GAEnB/d,GAAO,GAAuB,MAAlBgU,EAAKhU,EAAM,IAIvBA,GAAO,GAAuB,MAAlBgU,EAAKhU,EAAM,GAHlB,EAOF+d,EAAK3e,MAAMsC,EAAKqe,GAAGK,SAAS,GAAG5e,OAGjC,IAGX,UAAW,CACTse,SAAU,SAAkB9L,EAAMhU,EAAK0B,GACrC,IAAIqc,EAAO/J,EAAKzV,MAAMyB,GAMtB,OAJK0B,EAAKqe,GAAGU,SACX/e,EAAKqe,GAAGU,OAAS,IAAInjB,OAAO,IAAMoE,EAAKqe,GAAGW,eAAiB,IAAMhf,EAAKqe,GAAGY,gBAAiB,MAGxFjf,EAAKqe,GAAGU,OAAOhhB,KAAKse,GACfA,EAAK3e,MAAMsC,EAAKqe,GAAGU,QAAQ,GAAGjf,OAGhC,KASTof,EAAe,wFAA8ElQ,MAAM,KA6BvG,SAASmQ,EAAQnf,GAEf,IAAIqe,EAAKre,EAAKqe,GAAK,EAAQ,GAAR,CAAoBre,EAAKof,UAGxCC,EAAOrf,EAAKsf,SAASziB,QAWzB,SAAS0iB,EAAMC,GACb,OAAOA,EAAIhiB,QAAQ,SAAU6gB,EAAGoB,UAVlCzf,EAAK0f,YAEA1f,EAAK2f,mBACRN,EAAK/e,KAzCa,2VA4CpB+e,EAAK/e,KAAK+d,EAAGuB,QACbvB,EAAGoB,SAAWJ,EAAKpY,KAAK,KAMxBoX,EAAGwB,YAAcjkB,OAAO2jB,EAAMlB,EAAGyB,iBAAkB,KACnDzB,EAAG0B,WAAankB,OAAO2jB,EAAMlB,EAAG2B,gBAAiB,KACjD3B,EAAG4B,iBAAmBrkB,OAAO2jB,EAAMlB,EAAG6B,sBAAuB,KAC7D7B,EAAG8B,gBAAkBvkB,OAAO2jB,EAAMlB,EAAG+B,qBAAsB,KAI3D,IAAIC,EAAU,GAGd,SAASC,EAAYjnB,EAAMknB,GACzB,MAAM,IAAI1f,MAAM,+BAAiCxH,EAAO,MAAQknB,GAHlEvgB,EAAKwgB,aAAe,GAMpBhnB,OAAOyD,KAAK+C,EAAKygB,aAAa1jB,SAAQ,SAAU1D,GAC9C,IAAIknB,EAAMvgB,EAAKygB,YAAYpnB,GAE3B,GAAY,OAARknB,EAAJ,CAIA,IAAIG,EAAW,CACbtC,SAAU,KACVuC,KAAM,MAIR,GAFA3gB,EAAKwgB,aAAannB,GAAQqnB,EAzKL,oBAAhBtjB,EA2KQmjB,GAiBX,OAzLN,SAAkBxlB,GAChB,MAAuB,oBAAhBqC,EAAOrC,GAwKN6lB,CAASL,EAAInC,UAENN,EAAWyC,EAAInC,UACxBsC,EAAStC,SAAWmC,EAAInC,SAExBkC,EAAYjnB,EAAMknB,GAJlBG,EAAStC,SArEjB,SAAyBC,GACvB,OAAO,SAAU/L,EAAMhU,GACrB,IAAI+d,EAAO/J,EAAKzV,MAAMyB,GAEtB,OAAI+f,EAAGtgB,KAAKse,GACHA,EAAK3e,MAAM2gB,GAAI,GAAGve,OAGpB,GA6DiB+gB,CAAgBN,EAAInC,eAOtCN,EAAWyC,EAAIO,WACjBJ,EAASI,UAAYP,EAAIO,UACfP,EAAIO,UAGdR,EAAYjnB,EAAMknB,GAFlBG,EAASI,UAlER,SAAUpjB,EAAOsC,GACtBA,EAAK8gB,UAAUpjB,MA3HnB,SAAkB3C,GAChB,MAAuB,oBAAhBqC,EAAOrC,GAmMRmC,CAASqjB,GAKbD,EAAYjnB,EAAMknB,GAJhBF,EAAQ/f,KAAKjH,OASjBgnB,EAAQtjB,SAAQ,SAAUgkB,GACnB/gB,EAAKwgB,aAAaxgB,EAAKygB,YAAYM,MAMxC/gB,EAAKwgB,aAAaO,GAAO3C,SAAWpe,EAAKwgB,aAAaxgB,EAAKygB,YAAYM,IAAQ3C,SAC/Epe,EAAKwgB,aAAaO,GAAOD,UAAY9gB,EAAKwgB,aAAaxgB,EAAKygB,YAAYM,IAAQD,cAKlF9gB,EAAKwgB,aAAa,IAAM,CACtBpC,SAAU,KACV0C,UAnGK,SAAUpjB,EAAOsC,GACtBA,EAAK8gB,UAAUpjB,KAuGjB,IAAIsjB,EAAQxnB,OAAOyD,KAAK+C,EAAKwgB,cAAc3U,QAAO,SAAUxS,GAE1D,OAAOA,EAAKyG,OAAS,GAAKE,EAAKwgB,aAAannB,MAC3C8I,IAAItD,GAAUoI,KAAK,KAEtBjH,EAAKqe,GAAG4C,YAAcrlB,OAAO,yBAA2ByiB,EAAG6C,SAAW,MAAQF,EAAQ,IAAK,KAC3FhhB,EAAKqe,GAAG8C,cAAgBvlB,OAAO,yBAA2ByiB,EAAG6C,SAAW,MAAQF,EAAQ,IAAK,MAC7FhhB,EAAKqe,GAAG3K,QAAU9X,OAAO,IAAMoE,EAAKqe,GAAG4C,YAAYplB,OAAS,MAAQmE,EAAKqe,GAAG8B,gBAAgBtkB,OAAS,MAAO,KAjI9G,SAAwBmE,GACtBA,EAAKohB,WAAa,EAClBphB,EAAKqhB,eAAiB,GAmItBC,CAAethB,GASjB,SAASuhB,EAAMvhB,EAAMwhB,GACnB,IAAI9c,EAAQ1E,EAAKohB,UACbhd,EAAMpE,EAAKyhB,eACXnP,EAAOtS,EAAKqhB,eAAexkB,MAAM6H,EAAON,GAQ5C9E,KAAKqU,OAAS3T,EAAK0hB,WAAW1jB,cAO9BsB,KAAKqB,MAAQ+D,EAAQ8c,EAOrBliB,KAAKsU,UAAYxP,EAAMod,EAOvBliB,KAAKqiB,IAAMrP,EAOXhT,KAAKgT,KAAOA,EAOZhT,KAAKwG,IAAMwM,EAGb,SAASsP,EAAY5hB,EAAMwhB,GACzB,IAAI9jB,EAAQ,IAAI6jB,EAAMvhB,EAAMwhB,GAI5B,OAFAxhB,EAAKwgB,aAAa9iB,EAAMiW,QAAQmN,UAAUpjB,EAAOsC,GAE1CtC,EA0CT,SAASyM,EAAU0X,EAASnhB,GAC1B,KAAMpB,gBAAgB6K,GACpB,OAAO,IAAIA,EAAU0X,EAASnhB,GA7TlC,IAAsB3F,EAgUf2F,IAhUe3F,EAiUD8mB,EAhUZroB,OAAOyD,KAAKlC,GAAO,IAAI+mB,QAAO,SAAUC,EAAKlS,GAClD,OAAOkS,GAAOhE,EAAepjB,eAAekV,MAC3C,KA+TCnP,EAAUmhB,EACVA,EAAU,KAIdviB,KAAK8f,SAAW1iB,EAAO,GAAIqhB,EAAgBrd,GAE3CpB,KAAK8hB,WAAa,EAClB9hB,KAAKmiB,gBAAkB,EAEvBniB,KAAKoiB,WAAa,GAClBpiB,KAAK+hB,eAAiB,GACtB/hB,KAAKmhB,YAAc/jB,EAAO,GAAIyhB,EAAgB0D,GAC9CviB,KAAKkhB,aAAe,GACpBlhB,KAAKggB,SAAWJ,EAChB5f,KAAKqgB,mBAAoB,EACzBrgB,KAAK+e,GAAK,GACVc,EAAQ7f,MAWV6K,EAAUzP,UAAUsnB,IAAM,SAAarO,EAAQsO,GAG7C,OAFA3iB,KAAKmhB,YAAY9M,GAAUsO,EAC3B9C,EAAQ7f,MACDA,MAUT6K,EAAUzP,UAAU6Q,IAAM,SAAa7K,GAErC,OADApB,KAAK8f,SAAW1iB,EAAO4C,KAAK8f,SAAU1e,GAC/BpB,MAST6K,EAAUzP,UAAUqD,KAAO,SAAcuU,GAKvC,GAHAhT,KAAK+hB,eAAiB/O,EACtBhT,KAAK8hB,WAAa,GAEb9O,EAAKxS,OACR,OAAO,EAGT,IAAI5G,EAAGgpB,EAAIC,EAAIvf,EAAK4e,EAAOY,EAAM/D,EAAIgE,EAErC,GAAI/iB,KAAK+e,GAAG4C,YAAYljB,KAAKuU,GAI3B,KAHA+L,EAAK/e,KAAK+e,GAAG8C,eACVvN,UAAY,EAEgB,QAAvB1a,EAAImlB,EAAGnY,KAAKoM,KAGlB,GAFA1P,EAAMtD,KAAKgjB,aAAahQ,EAAMpZ,EAAE,GAAImlB,EAAGzK,WAE9B,CACPtU,KAAKoiB,WAAaxoB,EAAE,GACpBoG,KAAK8hB,UAAYloB,EAAEyH,MAAQzH,EAAE,GAAG4G,OAChCR,KAAKmiB,eAAiBvoB,EAAEyH,MAAQzH,EAAE,GAAG4G,OAAS8C,EAC9C,MA6CN,OAxCItD,KAAK8f,SAASpB,WAAa1e,KAAKkhB,aAAa,WAE/C6B,EAAU/P,EAAKxE,OAAOxO,KAAK+e,GAAG8B,mBAEf,IAET7gB,KAAK8hB,UAAY,GAAKiB,EAAU/iB,KAAK8hB,YAC0D,QAA5Fc,EAAK5P,EAAK5U,MAAM4B,KAAK8f,SAASlB,QAAU5e,KAAK+e,GAAG0B,WAAazgB,KAAK+e,GAAG4B,qBACxEuB,EAAQU,EAAGvhB,MAAQuhB,EAAG,GAAGpiB,QAErBR,KAAK8hB,UAAY,GAAKI,EAAQliB,KAAK8hB,aACrC9hB,KAAKoiB,WAAa,GAClBpiB,KAAK8hB,UAAYI,EACjBliB,KAAKmiB,eAAiBS,EAAGvhB,MAAQuhB,EAAG,GAAGpiB,SAO7CR,KAAK8f,SAASnB,YAAc3e,KAAKkhB,aAAa,YAEvClO,EAAK/U,QAAQ,MAER,GAGmC,QAA1C4kB,EAAK7P,EAAK5U,MAAM4B,KAAK+e,GAAGwB,gBAC3B2B,EAAQW,EAAGxhB,MAAQwhB,EAAG,GAAGriB,OACzBsiB,EAAOD,EAAGxhB,MAAQwhB,EAAG,GAAGriB,QAEpBR,KAAK8hB,UAAY,GAAKI,EAAQliB,KAAK8hB,WAAaI,IAAUliB,KAAK8hB,WAAagB,EAAO9iB,KAAKmiB,kBAC1FniB,KAAKoiB,WAAa,UAClBpiB,KAAK8hB,UAAYI,EACjBliB,KAAKmiB,eAAiBW,IAMvB9iB,KAAK8hB,WAAa,GAW3BjX,EAAUzP,UAAUgZ,QAAU,SAAiBpB,GAC7C,OAAOhT,KAAK+e,GAAG3K,QAAQ3V,KAAKuU,IAa9BnI,EAAUzP,UAAU4nB,aAAe,SAAsBhQ,EAAMqB,EAAQrV,GAErE,OAAKgB,KAAKkhB,aAAa7M,EAAO3V,eAIvBsB,KAAKkhB,aAAa7M,EAAO3V,eAAeogB,SAAS9L,EAAMhU,EAAKgB,MAH1D,GAuBX6K,EAAUzP,UAAUgD,MAAQ,SAAe4U,GACzC,IAAIkP,EAAQ,EACRhgB,EAAS,GAETlC,KAAK8hB,WAAa,GAAK9hB,KAAK+hB,iBAAmB/O,IACjD9Q,EAAOlB,KAAKshB,EAAYtiB,KAAMkiB,IAC9BA,EAAQliB,KAAKmiB,gBAMf,IAFA,IAAIpF,EAAOmF,EAAQlP,EAAKzV,MAAM2kB,GAASlP,EAEhChT,KAAKvB,KAAKse,IACf7a,EAAOlB,KAAKshB,EAAYtiB,KAAMkiB,IAC9BnF,EAAOA,EAAKxf,MAAMyC,KAAKmiB,gBACvBD,GAASliB,KAAKmiB,eAGhB,OAAIjgB,EAAO1B,OACF0B,EAGF,MAmBT2I,EAAUzP,UAAU2kB,KAAO,SAAche,EAAMkhB,GAG7C,OAFAlhB,EAAOzE,MAAM2E,QAAQF,GAAQA,EAAO,CAACA,GAEhCkhB,GAOLjjB,KAAKggB,SAAWhgB,KAAKggB,SAAS9gB,OAAO6C,GAAMmhB,OAAO3W,QAAO,SAAU4W,EAAIhhB,EAAKihB,GAC1E,OAAOD,IAAOC,EAAIjhB,EAAM,MACvBkhB,UACHxD,EAAQ7f,MACDA,OAVLA,KAAKggB,SAAWje,EAAKxE,QACrByC,KAAKqgB,mBAAoB,EACzBR,EAAQ7f,MACDA,OAgBX6K,EAAUzP,UAAUomB,UAAY,SAAmBpjB,GAG5CA,EAAMiW,SACTjW,EAAMoI,IAAM,UAAYpI,EAAMoI,KAGX,YAAjBpI,EAAMiW,QAAyB,YAAY5V,KAAKL,EAAMoI,OACxDpI,EAAMoI,IAAM,UAAYpI,EAAMoI,MAUlCqE,EAAUzP,UAAUglB,UAAY,aAEhC7mB,EAAOD,QAAUuR,G,6BClnBjBtR,EAAOD,QAAU,SAAUgqB,GACzB,IAAIvE,EAAK,GAETA,EAAGwE,QAAU,EAAQ,IAAiChnB,OACtDwiB,EAAGyE,OAAS,EAAQ,IAAgCjnB,OACpDwiB,EAAG0E,MAAQ,EAAQ,IAA+BlnB,OAClDwiB,EAAG2E,MAAQ,EAAQ,GAA+BnnB,OAElDwiB,EAAG6C,SAAW,CAAC7C,EAAG0E,MAAO1E,EAAG2E,MAAO3E,EAAGyE,QAAQ7b,KAAK,KAEnDoX,EAAG4E,QAAU,CAAC5E,EAAG0E,MAAO1E,EAAGyE,QAAQ7b,KAAK,KA4DxC,OArDAoX,EAAG6E,kBAAoB,oBAAmC7E,EAAG6C,SAAW,IAAM7C,EAAGwE,QAAU,IAI3FxE,EAAG8E,QAAU,yFAEb9E,EAAGE,SAAW,YAAcF,EAAG4E,QAAU,uBACzC5E,EAAGQ,SAAW,kFACdR,EAAGS,oBAAsB,mBAAkCT,EAAG6C,SAAW,6BAA+B7C,EAAG6C,SAAW,KACtH7C,EAAGI,SAAW,iBAAkCJ,EAAG4E,QAAU,IAA/C,8CAAkH5E,EAAG4E,QAArH,wBAA8J5E,EAAG4E,QAAjK,wBAA0M5E,EAAG4E,QAA7M,wBAAsP5E,EAAG4E,QAAzP,yBAAkS5E,EAAG4E,QAArS,qBAA2U5E,EAAG6E,kBAA9U,sCAQH7E,EAAG4E,QAAU,WAAaL,GAAQA,EAAK,OAAS,6BACzD,SAAW,SAAWvE,EAAG4E,QATb,YAUH5E,EAAG4E,QAVA,gBAUiC5E,EAAG4E,QAVpC,iBAad5E,EAAGW,eAAiB,iEACpBX,EAAGuB,OAAS,wBAGZvB,EAAGO,gBACH,MAAQP,EAAGuB,OAAS,IAAMvB,EAAG6E,kBAA7B,UACA7E,EAAGM,WAAa,MAAQN,EAAGuB,OAAX,OAAkCvB,EAAG6E,kBAArC,QAA6E7E,EAAG6E,kBAAoB,QAAU7E,EAAG6E,kBAAoB,UAAY7E,EAAG6E,kBAApJ,KAChB7E,EAAG+E,SAAW,eAGA/E,EAAGM,WAAa,SAAWN,EAAGM,WAH9B,KAMdN,EAAGgF,eAAiB,MAAQhF,EAAG8E,QAAX,aAAyC9E,EAAGM,WAA5C,qBACpBN,EAAGiF,qBAAuB,YAAcjF,EAAGM,WAAa,oBACxDN,EAAGY,gBAAkBZ,EAAG+E,SAAW/E,EAAGS,oBACtCT,EAAGkF,sBAAwBlF,EAAGgF,eAAiBhF,EAAGS,oBAClDT,EAAGG,qBAAuBH,EAAG+E,SAAW/E,EAAGQ,SAAWR,EAAGS,oBACzDT,EAAGmF,2BAA6BnF,EAAGgF,eAAiBhF,EAAGQ,SAAWR,EAAGS,oBACrET,EAAGoF,iCAAmCpF,EAAGiF,qBAAuBjF,EAAGQ,SAAWR,EAAGS,oBAIjFT,EAAG+B,oBAAsB,sDAAwD/B,EAAG6C,SAAW,SAC/F7C,EAAGyB,gBAAkB,uBAAsCzB,EAAG4E,QAAzC,KAA+D5E,EAAGW,eAAiB,IAAMX,EAAGkF,sBAAwB,IACzIlF,EAAG2B,eAEH,wCAA0C3B,EAAG6C,SAA7C,0BAAyF7C,EAAGmF,2BAA6BnF,EAAGI,SAAW,IACvIJ,EAAG6B,qBAEH,wCAA0C7B,EAAG6C,SAA7C,0BAAyF7C,EAAGoF,iCAAmCpF,EAAGI,SAAW,IACtIJ,I,iBCxET,kCAAmD,OAAOvjB,EAAU,mBAAqBjB,QAAU,iBAAmBA,OAAOmB,SAAW,SAAUD,GAAO,cAAcA,GAAS,SAAUA,GAAO,OAAOA,GAAO,mBAAqBlB,QAAUkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,GAAQD,EAAQC,IAKzU,SAAW2oB,GAET,IAAIC,EAAmF,UAArB7oB,EAAQlC,IAAyBA,IAAYA,EAAQgrB,UAAYhrB,EAC/HirB,EAAgF,UAApB/oB,EAAQjC,IAAwBA,IAAWA,EAAO+qB,UAAY/qB,EAC1HirB,EAAgF,WAAhD,qBAAXC,EAAyB,YAAcjpB,EAAQipB,KAAwBA,EAE5FD,EAAWC,SAAWD,GAAcA,EAAWrkB,SAAWqkB,GAAcA,EAAW9jB,OAAS8jB,IAC9FJ,EAAOI,GAST,IAAI1Z,EAsCJ/P,EAnCA2pB,EAAS,WAITC,EAAO,GAYPC,EAAgB,QACZC,EAAgB,eAEpBC,EAAkB,4BAIlBC,EAAS,CACP,SAAY,kDACZ,YAAa,iDACb,gBAAiB,iBAKfC,EAAQvK,KAAKuK,MACbC,EAAqB/oB,OAAOC,aAahC,SAAS+oB,EAAMziB,GACb,MAAM,IAAI0iB,WAAWJ,EAAOtiB,IAY9B,SAASI,EAAIuiB,EAAOlkB,GAIlB,IAHA,IAAIV,EAAS4kB,EAAM5kB,OACf0B,EAAS,GAEN1B,KACL0B,EAAO1B,GAAUU,EAAGkkB,EAAM5kB,IAG5B,OAAO0B,EAcT,SAASmjB,EAAUlY,EAAQjM,GACzB,IAAIokB,EAAQnY,EAAOuC,MAAM,KACrBxN,EAAS,GAab,OAXIojB,EAAM9kB,OAAS,IAGjB0B,EAASojB,EAAM,GAAK,IACpBnY,EAASmY,EAAM,IAOVpjB,EADOW,GAFdsK,EAASA,EAAOjP,QAAQ4mB,EAAiB,MACrBpV,MAAM,KACAxO,GAAIyG,KAAK,KAkBrC,SAAS4d,EAAWpY,GAOlB,IANA,IAGI1S,EACA+qB,EAJAC,EAAS,GACTC,EAAU,EACVllB,EAAS2M,EAAO3M,OAIbklB,EAAUllB,IACf/F,EAAQ0S,EAAO3O,WAAWknB,OAEb,OAAUjrB,GAAS,OAAUirB,EAAUllB,EAI1B,QAAX,OAFbglB,EAAQrY,EAAO3O,WAAWknB,OAIxBD,EAAOzkB,OAAe,KAARvG,IAAkB,KAAe,KAAR+qB,GAAiB,QAIxDC,EAAOzkB,KAAKvG,GACZirB,KAGFD,EAAOzkB,KAAKvG,GAIhB,OAAOgrB,EAYT,SAASE,EAAWP,GAClB,OAAOviB,EAAIuiB,GAAO,SAAU3qB,GAC1B,IAAIgrB,EAAS,GASb,OAPIhrB,EAAQ,QAEVgrB,GAAUR,GADVxqB,GAAS,SAC8B,GAAK,KAAQ,OACpDA,EAAQ,MAAiB,KAARA,GAGnBgrB,GAAUR,EAAmBxqB,MAE5BkN,KAAK,IAyCV,SAASie,EAAaC,EAAOC,GAG3B,OAAOD,EAAQ,GAAK,IAAMA,EAAQ,MAAgB,GAARC,IAAc,GAS1D,SAASC,EAAMC,EAAOC,EAAWC,GAC/B,IAAI3V,EAAI,EAIR,IAHAyV,EAAQE,EAAYlB,EAAMgB,EAnNjB,KAmNiCA,GAAS,EACnDA,GAAShB,EAAMgB,EAAQC,GAEhBD,EAAQG,IAA2B5V,GAAKoU,EAC7CqB,EAAQhB,EAAMgB,EAjMFrB,IAoMd,OAAOK,EAAMzU,EAAI,GAAsByV,GAASA,EA3NvC,KAsOX,SAASniB,EAAOuiB,GAEd,IAEIC,EAIAC,EACA/hB,EACAlD,EACAklB,EACAC,EACAjW,EACAsV,EACAnrB,EAGJ+rB,EA9EoBC,EA8DhBjB,EAAS,GACTkB,EAAcP,EAAM5lB,OAEpBhH,EAAI,EACJyB,EAzOS,IA0OT2rB,EA3OY,GAgQhB,KANAN,EAAQF,EAAMpW,YAvPJ,MAyPE,IACVsW,EAAQ,GAGL/hB,EAAI,EAAGA,EAAI+hB,IAAS/hB,EAEnB6hB,EAAM5nB,WAAW+F,IAAM,KACzB2gB,EAAM,aAGRO,EAAOzkB,KAAKolB,EAAM5nB,WAAW+F,IAK/B,IAAKlD,EAAQilB,EAAQ,EAAIA,EAAQ,EAAI,EAAGjlB,EAAQslB,GAAc,CAM5D,IAAKJ,EAAO/sB,EAAGgtB,EAAI,EAAGjW,EAAIoU,EACpBtjB,GAASslB,GACXzB,EAAM,mBAGRW,GA9GgBa,EA8GKN,EAAM5nB,WAAW6C,MA7G1B,GAAK,GACZqlB,EAAY,GAGjBA,EAAY,GAAK,GACZA,EAAY,GAGjBA,EAAY,GAAK,GACZA,EAAY,GAGd/B,IAmGUA,GAAQkB,EAAQb,GAAON,EAASlrB,GAAKgtB,KAChDtB,EAAM,YAGR1rB,GAAKqsB,EAAQW,IAGTX,GAFJnrB,EAAI6V,GAAKqW,EAjSJ,EAiSkBrW,GAAKqW,EAhSvB,MAgS4CrW,EAAIqW,IAZtBrW,GAAKoU,EAoBhC6B,EAAIxB,EAAMN,GAFd+B,EAAa9B,EAAOjqB,KAGlBwqB,EAAM,YAGRsB,GAAKC,EAIPG,EAAOb,EAAMvsB,EAAI+sB,EADjBF,EAAMZ,EAAOjlB,OAAS,EACc,GAAR+lB,GAGxBvB,EAAMxrB,EAAI6sB,GAAO3B,EAASzpB,GAC5BiqB,EAAM,YAGRjqB,GAAK+pB,EAAMxrB,EAAI6sB,GACf7sB,GAAK6sB,EAELZ,EAAO9jB,OAAOnI,IAAK,EAAGyB,GAGxB,OAAO0qB,EAAWF,GAWpB,SAAS7hB,EAAOwiB,GACd,IAAInrB,EACA+qB,EACAa,EACAC,EACAF,EACAriB,EACA3K,EACAmtB,EACAxW,EACA7V,EACAssB,EAIJL,EAGAM,EACIR,EACAS,EARAzB,EAAS,GAkBb,IANAkB,GAFAP,EAAQb,EAAWa,IAEC5lB,OAEpBvF,EA9Va,IA+Vb+qB,EAAQ,EACRY,EAjWgB,GAmWXriB,EAAI,EAAGA,EAAIoiB,IAAepiB,GAC7ByiB,EAAeZ,EAAM7hB,IAEF,KACjBkhB,EAAOzkB,KAAKikB,EAAmB+B,IAanC,IATAH,EAAiBC,EAAcrB,EAAOjlB,OAIlCsmB,GACFrB,EAAOzkB,KA7WC,KAiXH6lB,EAAiBF,GAAa,CAGnC,IAAK/sB,EAAI8qB,EAAQngB,EAAI,EAAGA,EAAIoiB,IAAepiB,GACzCyiB,EAAeZ,EAAM7hB,KAEDtJ,GAAK+rB,EAAeptB,IACtCA,EAAIotB,GAeR,IAPIptB,EAAIqB,EAAI+pB,GAAON,EAASsB,IAF5BiB,EAAwBJ,EAAiB,KAGvC3B,EAAM,YAGRc,IAAUpsB,EAAIqB,GAAKgsB,EACnBhsB,EAAIrB,EAEC2K,EAAI,EAAGA,EAAIoiB,IAAepiB,EAO7B,IANAyiB,EAAeZ,EAAM7hB,IAEFtJ,KAAO+qB,EAAQtB,GAChCQ,EAAM,YAGJ8B,GAAgB/rB,EAAG,CAErB,IAAK8rB,EAAIf,EAAOzV,EAAIoU,IAGdoC,GAFJrsB,EAAI6V,GAAKqW,EAxZR,EAwZsBrW,GAAKqW,EAvZ3B,MAuZgDrW,EAAIqW,IAD5BrW,GAAKoU,EAO9BuC,EAAUH,EAAIrsB,EACd+rB,EAAa9B,EAAOjqB,EACpB+qB,EAAOzkB,KAAKikB,EAAmBW,EAAalrB,EAAIwsB,EAAUT,EAAY,KACtEM,EAAI/B,EAAMkC,EAAUT,GAGtBhB,EAAOzkB,KAAKikB,EAAmBW,EAAamB,EAAG,KAC/CH,EAAOb,EAAMC,EAAOiB,EAAuBJ,GAAkBC,GAC7Dd,EAAQ,IACNa,IAIJb,IACA/qB,EAGJ,OAAOwqB,EAAO9d,KAAK,IAuErB,GA5BAmD,EAAW,CAMT,QAAW,QASX,KAAQ,CACN,OAAUya,EACV,OAAUI,GAEZ,OAAU9hB,EACV,OAAUD,EACV,QA/BF,SAAiBwiB,GACf,OAAOf,EAAUe,GAAO,SAAUjZ,GAChC,OAAO0X,EAAcpmB,KAAK0O,GAAU,OAASvJ,EAAOuJ,GAAUA,MA8BhE,UAlDF,SAAmBiZ,GACjB,OAAOf,EAAUe,GAAO,SAAUjZ,GAChC,OAAOyX,EAAcnmB,KAAK0O,GAAUtJ,EAAOsJ,EAAO5P,MAAM,GAAGmB,eAAiByO,OAsDtB,UAAvB3R,EAAQ,QAA2B,WAGnE,KAFD,aACE,OAAOsP,GACR,mCACI,GAAIuZ,GAAeE,EACxB,GAAIhrB,EAAOD,SAAW+qB,EAEpBE,EAAWjrB,QAAUwR,OAGrB,IAAK/P,KAAO+P,EACVA,EAASzP,eAAeN,KAASspB,EAAYtpB,GAAO+P,EAAS/P,SAKjEqpB,EAAKtZ,SAAWA,EA9hBpB,CAgiBG9K,Q,sDCliBHzG,EAAOD,QAAU,CACf8H,QAAS,CACPma,MAAM,EAEN1I,UAAU,EAEVE,QAAQ,EAERL,WAAY,YAEZ3G,SAAS,EAGTmJ,aAAa,EAMbqB,OAAQ,2BASR9D,UAAW,KACXiE,WAAY,KAGdvK,WAAY,CACVnC,KAAM,GACN7G,MAAO,GACPsF,OAAQ,M,6BClCZlP,EAAOD,QAAU,CACf8H,QAAS,CACPma,MAAM,EAEN1I,UAAU,EAEVE,QAAQ,EAERL,WAAY,YAEZ3G,SAAS,EAGTmJ,aAAa,EAMbqB,OAAQ,2BASR9D,UAAW,KACXiE,WAAY,IAGdvK,WAAY,CACVnC,KAAM,CACJN,MAAO,CAAC,YAAa,QAAS,WAEhCvG,MAAO,CACLuG,MAAO,CAAC,cAEVjB,OAAQ,CACNiB,MAAO,CAAC,QACR0C,OAAQ,CAAC,gBAAiB,qB,6BC1ChC7S,EAAOD,QAAU,CACf8H,QAAS,CACPma,MAAM,EAEN1I,UAAU,EAEVE,QAAQ,EAERL,WAAY,YAEZ3G,SAAS,EAGTmJ,aAAa,EAMbqB,OAAQ,2BASR9D,UAAW,KACXiE,WAAY,IAGdvK,WAAY,CACVnC,KAAM,CACJN,MAAO,CAAC,YAAa,QAAS,WAEhCvG,MAAO,CACLuG,MAAO,CAAC,aAAc,OAAQ,QAAS,UAAW,KAAM,aAAc,WAAY,OAAQ,YAAa,cAEzGjB,OAAQ,CACNiB,MAAO,CAAC,WAAY,YAAa,WAAY,SAAU,SAAU,cAAe,QAAS,OAAQ,UAAW,QAC5G0C,OAAQ,CAAC,gBAAiB,WAAY,qB,6BC1C5C,IAAI+a,EAAK,EAAQ,IAIjB,SAAS/pB,EAAO3B,GAGd,IAAI4B,EAAUC,MAAMlC,UAAUmC,MAAM5D,KAAK6D,UAAW,GAMpD,OALAH,EAAQI,SAAQ,SAAUlB,GACxBrC,OAAOyD,KAAKpB,GAAQkB,SAAQ,SAAU1C,GACpCU,EAAIV,GAAOwB,EAAOxB,SAGfU,EAQT,SAAS+lB,EAAU4F,GAEjB,MAAI,iBAAiB3oB,KAAK2oB,GACjB,GAGF,IAAMA,EAAKlpB,QAAQ,aAAc,IAAIQ,cAK9C,SAAS2oB,EAAU5gB,GACjB,OAAKA,GAAYvK,OAAOuK,KAAcA,EAI/BA,EAASiJ,MAAM,KAAK,GAAGjQ,OAAOf,cAH5B,GAsBX,IAAIqH,EAASxM,EAAOD,QAAU,SAAgB8H,GAC5CA,EAAUA,GAAW,GAErBlH,OAAOC,eAAe6F,KAAM,QAAS,CACnCvF,MAAOP,OAAOY,OAAO,QAGvBZ,OAAOC,eAAe6F,KAAM,aAAc,CACxCvF,MAAOP,OAAOY,OAAO,QAGvBZ,OAAOC,eAAe6F,KAAM,cAAe,CACzCvF,MAAO2G,EAAQkmB,cAGblmB,EAAQmmB,WACVrtB,OAAOyD,KAAKwpB,GAAI1pB,SAAQ,SAAU+pB,GAChC,IAAIvG,EAAMkG,EAAGK,GAETvG,EAAIwG,YACNznB,KAAK0nB,SAASF,EAAMvG,EAAIwG,cAEzBznB,OAUP+F,EAAO3K,UAAUusB,MAAQ,WACvB,IAAI/tB,EAAI,IAAImM,EAAO,CACjBuhB,YAAatnB,KAAKsnB,cAIpB,OAFAlqB,EAAOxD,EAAEguB,MAAO5nB,KAAK4nB,OACrBxqB,EAAOxD,EAAE6tB,WAAYznB,KAAKynB,YACnB7tB,GA2CTmM,EAAO3K,UAAUssB,SAAW,SAAkBjhB,EAAUghB,EAAYI,IAClEJ,EAAanqB,MAAM2E,QAAQwlB,GAAcA,EAAa,CAACA,IAE5ChqB,SAAQ,SAAUqqB,GAC3B9nB,KAAK4nB,MAAMpG,EAAUsG,IAAQrhB,IAC5BzG,OAEC6nB,GAAsE,qBAA5C7nB,KAAKynB,WAAWhhB,EAAS/H,kBACrDsB,KAAKynB,WAAWhhB,EAAS/H,eAAiB8iB,EAAUiG,EAAW,MAUnE1hB,EAAO3K,UAAUsL,YAAc,SAAqB0gB,EAAMtgB,GACxD,OAAO9G,KAAK4nB,MAAMpG,EAAU4F,KAAUtgB,GAAY9G,KAAKsnB,aASzDvhB,EAAO3K,UAAU2sB,aAAe,SAAsBthB,GACpD,OAAOzG,KAAKynB,WAAWJ,EAAU5gB,KAInC,IAAIuhB,EAAe,IAAI1rB,OAAO,CAAC,SAAU,SAAU,gBAAgBqL,KAAK,MAOxE5B,EAAO3K,UAAU6sB,OAAS,SAAgBxhB,GACxC,OAAOuhB,EAAavpB,KAAK4oB,EAAU5gB,KASrC,IAAIyhB,EAAU,IAAIniB,EAAO,CACvBwhB,WAAW,IASbxhB,EAAOW,YAAc,SAAsB0gB,EAAMtgB,GAC/C,OAAOohB,EAAQxhB,YAAY0gB,EAAMtgB,IAUnCf,EAAOgiB,aAAe,SAAuBthB,GAC3C,OAAOyhB,EAAQH,aAAathB,IAU9BV,EAAOkiB,OAAS,SAAiBxhB,GAC/B,OAAOyhB,EAAQD,OAAOxhB,K,gBCrNxBlN,EAAOD,QAAU,EAAQ,K,ql3ICTzB,yBAKA6G,OAAOgoB,iBAAiB,QAAQ,WAEhC,IAAMhgB,EAAKigB,EAAQ,GAARA,CAAuB,CAAErV,QAAQ,IAAQvG,IAAI4b,EAAQ,IAA4B,CAC1FrgB,WAAY,CACVS,gBAAgB,EAChB2B,eAAe,EACf7C,eAAe,KAOX/K,EAAS8rB,SAASC,eAAe,mBACfD,SAASC,eAAe,mBAChCC,UAAYpgB,EAAG2E,OAAOvQ,EAAOgsB","file":"js/markdown_viewer-9d2efa58ec21e8a1ee28.js","sourcesContent":[" \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, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\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 = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 140);\n","// Utilities\n//\n'use strict';\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nfunction _class(obj) {\n  return Object.prototype.toString.call(obj);\n}\n\nfunction isString(obj) {\n  return _class(obj) === '[object String]';\n}\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction has(object, key) {\n  return _hasOwnProperty.call(object, key);\n} // Merge objects\n//\n\n\nfunction assign(obj\n/*from1, from2, from3, ...*/\n) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n  sources.forEach(function (source) {\n    if (!source) {\n      return;\n    }\n\n    if (_typeof(source) !== 'object') {\n      throw new TypeError(source + 'must be object');\n    }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n  return obj;\n} // Remove element from array and put another array at those position.\n// Useful for some operations with tokens\n\n\nfunction arrayReplaceAt(src, pos, newElements) {\n  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nfunction isValidEntityCode(c) {\n  /*eslint no-bitwise:0*/\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) {\n    return false;\n  } // never used\n\n\n  if (c >= 0xFDD0 && c <= 0xFDEF) {\n    return false;\n  }\n\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) {\n    return false;\n  } // control codes\n\n\n  if (c >= 0x00 && c <= 0x08) {\n    return false;\n  }\n\n  if (c === 0x0B) {\n    return false;\n  }\n\n  if (c >= 0x0E && c <= 0x1F) {\n    return false;\n  }\n\n  if (c >= 0x7F && c <= 0x9F) {\n    return false;\n  } // out of range\n\n\n  if (c > 0x10FFFF) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction fromCodePoint(c) {\n  /*eslint no-bitwise:0*/\n  if (c > 0xffff) {\n    c -= 0x10000;\n    var surrogate1 = 0xd800 + (c >> 10),\n        surrogate2 = 0xdc00 + (c & 0x3ff);\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n\n  return String.fromCharCode(c);\n}\n\nvar UNESCAPE_MD_RE = /\\\\([!\"#$%&'()*+,\\-.\\/:;<=>?@[\\\\\\]^_`{|}~])/g;\nvar ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;\nvar UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');\nvar DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;\n\nvar entities = require('./entities');\n\nfunction replaceEntityPattern(match, name) {\n  var code = 0;\n\n  if (has(entities, name)) {\n    return entities[name];\n  }\n\n  if (name.charCodeAt(0) === 0x23\n  /* # */\n  && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    code = name[1].toLowerCase() === 'x' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);\n\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code);\n    }\n  }\n\n  return match;\n}\n/*function replaceEntities(str) {\n  if (str.indexOf('&') < 0) { return str; }\n\n  return str.replace(ENTITY_RE, replaceEntityPattern);\n}*/\n\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) {\n    return str;\n  }\n\n  return str.replace(UNESCAPE_MD_RE, '$1');\n}\n\nfunction unescapeAll(str) {\n  if (str.indexOf('\\\\') < 0 && str.indexOf('&') < 0) {\n    return str;\n  }\n\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) {\n      return escaped;\n    }\n\n    return replaceEntityPattern(match, entity);\n  });\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nvar HTML_ESCAPE_TEST_RE = /[&<>\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nvar HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\n\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\n\nfunction escapeHtml(str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n\n  return str;\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nvar REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g;\n\nfunction escapeRE(str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$&');\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nfunction isSpace(code) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true;\n  }\n\n  return false;\n} // Zs (unicode class) || [\\t\\f\\v\\r\\n]\n\n\nfunction isWhiteSpace(code) {\n  if (code >= 0x2000 && code <= 0x200A) {\n    return true;\n  }\n\n  switch (code) {\n    case 0x09: // \\t\n\n    case 0x0A: // \\n\n\n    case 0x0B: // \\v\n\n    case 0x0C: // \\f\n\n    case 0x0D: // \\r\n\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true;\n  }\n\n  return false;\n} ////////////////////////////////////////////////////////////////////////////////\n\n/*eslint-disable max-len*/\n\n\nvar UNICODE_PUNCT_RE = require('uc.micro/categories/P/regex'); // Currently without astral characters support.\n\n\nfunction isPunctChar(ch) {\n  return UNICODE_PUNCT_RE.test(ch);\n} // Markdown ASCII punctuation characters.\n//\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\n//\n// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.\n//\n\n\nfunction isMdAsciiPunct(ch) {\n  switch (ch) {\n    case 0x21\n    /* ! */\n    :\n    case 0x22\n    /* \" */\n    :\n    case 0x23\n    /* # */\n    :\n    case 0x24\n    /* $ */\n    :\n    case 0x25\n    /* % */\n    :\n    case 0x26\n    /* & */\n    :\n    case 0x27\n    /* ' */\n    :\n    case 0x28\n    /* ( */\n    :\n    case 0x29\n    /* ) */\n    :\n    case 0x2A\n    /* * */\n    :\n    case 0x2B\n    /* + */\n    :\n    case 0x2C\n    /* , */\n    :\n    case 0x2D\n    /* - */\n    :\n    case 0x2E\n    /* . */\n    :\n    case 0x2F\n    /* / */\n    :\n    case 0x3A\n    /* : */\n    :\n    case 0x3B\n    /* ; */\n    :\n    case 0x3C\n    /* < */\n    :\n    case 0x3D\n    /* = */\n    :\n    case 0x3E\n    /* > */\n    :\n    case 0x3F\n    /* ? */\n    :\n    case 0x40\n    /* @ */\n    :\n    case 0x5B\n    /* [ */\n    :\n    case 0x5C\n    /* \\ */\n    :\n    case 0x5D\n    /* ] */\n    :\n    case 0x5E\n    /* ^ */\n    :\n    case 0x5F\n    /* _ */\n    :\n    case 0x60\n    /* ` */\n    :\n    case 0x7B\n    /* { */\n    :\n    case 0x7C\n    /* | */\n    :\n    case 0x7D\n    /* } */\n    :\n    case 0x7E\n    /* ~ */\n    :\n      return true;\n\n    default:\n      return false;\n  }\n} // Hepler to unify [reference labels].\n//\n\n\nfunction normalizeReference(str) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' '); // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug\n  // fixed in v12 (couldn't find any details).\n  //\n  // So treat this one as a special case\n  // (remove this when node v10 is no longer supported).\n  //\n\n  if ('ẞ'.toLowerCase() === 'Ṿ') {\n    str = str.replace(/ẞ/g, 'ß');\n  } // .toLowerCase().toUpperCase() should get rid of all differences\n  // between letter variants.\n  //\n  // Simple .toLowerCase() doesn't normalize 125 code points correctly,\n  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:\n  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n\n\n  return str.toLowerCase().toUpperCase();\n} ////////////////////////////////////////////////////////////////////////////////\n// Re-export libraries commonly used in both markdown-it and its plugins,\n// so plugins won't have to depend on them explicitly, which reduces their\n// bundled size (e.g. a browser build).\n//\n\n\nexports.lib = {};\nexports.lib.mdurl = require('mdurl');\nexports.lib.ucmicro = require('uc.micro');\nexports.assign = assign;\nexports.isString = isString;\nexports.has = has;\nexports.unescapeMd = unescapeMd;\nexports.unescapeAll = unescapeAll;\nexports.isValidEntityCode = isValidEntityCode;\nexports.fromCodePoint = fromCodePoint; // exports.replaceEntities     = replaceEntities;\n\nexports.escapeHtml = escapeHtml;\nexports.arrayReplaceAt = arrayReplaceAt;\nexports.isSpace = isSpace;\nexports.isWhiteSpace = isWhiteSpace;\nexports.isMdAsciiPunct = isMdAsciiPunct;\nexports.isPunctChar = isPunctChar;\nexports.escapeRE = escapeRE;\nexports.normalizeReference = normalizeReference;","module.exports = function (module) {\n  if (!module.webpackPolyfill) {\n    module.deprecate = function () {};\n\n    module.paths = []; // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nvar g; // This works in non-strict mode\n\ng = function () {\n  return this;\n}();\n\ntry {\n  // This works if eval is allowed (see CSP)\n  g = g || new Function(\"return this\")();\n} catch (e) {\n  // This works if the window reference is available\n  if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n} // g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\n\nmodule.exports = g;","module.exports = /[!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166D\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4E\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]|\\uD800[\\uDD00-\\uDD02\\uDF9F\\uDFD0]|\\uD801\\uDD6F|\\uD802[\\uDC57\\uDD1F\\uDD3F\\uDE50-\\uDE58\\uDE7F\\uDEF0-\\uDEF6\\uDF39-\\uDF3F\\uDF99-\\uDF9C]|\\uD803[\\uDF55-\\uDF59]|\\uD804[\\uDC47-\\uDC4D\\uDCBB\\uDCBC\\uDCBE-\\uDCC1\\uDD40-\\uDD43\\uDD74\\uDD75\\uDDC5-\\uDDC8\\uDDCD\\uDDDB\\uDDDD-\\uDDDF\\uDE38-\\uDE3D\\uDEA9]|\\uD805[\\uDC4B-\\uDC4F\\uDC5B\\uDC5D\\uDCC6\\uDDC1-\\uDDD7\\uDE41-\\uDE43\\uDE60-\\uDE6C\\uDF3C-\\uDF3E]|\\uD806[\\uDC3B\\uDE3F-\\uDE46\\uDE9A-\\uDE9C\\uDE9E-\\uDEA2]|\\uD807[\\uDC41-\\uDC45\\uDC70\\uDC71\\uDEF7\\uDEF8]|\\uD809[\\uDC70-\\uDC74]|\\uD81A[\\uDE6E\\uDE6F\\uDEF5\\uDF37-\\uDF3B\\uDF44]|\\uD81B[\\uDE97-\\uDE9A]|\\uD82F\\uDC9F|\\uD836[\\uDE87-\\uDE8B]|\\uD83A[\\uDD5E\\uDD5F]/;","/**\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 * new Ruler()\n **/\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__ = []; // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n\n  this.__cache__ = null;\n} ////////////////////////////////////////////////////////////////////////////////\n// Helper methods, should not be used directly\n// Find rule index by name\n//\n\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\n  return -1;\n}; // Build rules lookup cache\n//\n\n\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = ['']; // collect unique names\n\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) {\n      return;\n    }\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  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) {\n        return;\n      }\n\n      if (chain && rule.alt.indexOf(chain) < 0) {\n        return;\n      }\n\n      self.__cache__[chain].push(rule.fn);\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 typographer 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 **/\n\n\nRuler.prototype.at = function (name, fn, options) {\n  var index = this.__find__(name);\n\n  var opt = options || {};\n\n  if (index === -1) {\n    throw new Error('Parser rule not found: ' + name);\n  }\n\n  this.__rules__[index].fn = fn;\n  this.__rules__[index].alt = opt.alt || [];\n  this.__cache__ = null;\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 **/\n\n\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var index = this.__find__(beforeName);\n\n  var opt = options || {};\n\n  if (index === -1) {\n    throw new Error('Parser rule not found: ' + beforeName);\n  }\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 * 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 **/\n\n\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var index = this.__find__(afterName);\n\n  var opt = options || {};\n\n  if (index === -1) {\n    throw new Error('Parser rule not found: ' + afterName);\n  }\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 * 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 **/\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 * 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 **/\n\n\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n\n  var result = []; // Search by name and enable\n\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) {\n        return;\n      }\n\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n\n    this.__rules__[idx].enabled = true;\n    result.push(name);\n  }, this);\n  this.__cache__ = null;\n  return result;\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 **/\n\n\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n\n  this.__rules__.forEach(function (rule) {\n    rule.enabled = false;\n  });\n\n  this.enable(list, ignoreInvalid);\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 **/\n\n\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n\n  var result = []; // Search by name and disable\n\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) {\n        return;\n      }\n\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n\n    this.__rules__[idx].enabled = false;\n    result.push(name);\n  }, this);\n  this.__cache__ = null;\n  return result;\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 **/\n\n\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  } // Chain can be empty, if rules disabled. But we still have to return Array.\n\n\n  return this.__cache__[chainName] || [];\n};\n\nmodule.exports = Ruler;","// Token class\n'use strict';\n/**\n * class Token\n **/\n\n/**\n * new Token(type, tag, nesting)\n *\n * Create new token and fill passed properties.\n **/\n\nfunction Token(type, tag, nesting) {\n  /**\n   * Token#type -> String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type = type;\n  /**\n   * Token#tag -> String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n\n  this.tag = tag;\n  /**\n   * Token#attrs -> Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n\n  this.attrs = null;\n  /**\n   * Token#map -> Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n\n  this.map = null;\n  /**\n   * Token#nesting -> Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n\n  this.nesting = nesting;\n  /**\n   * Token#level -> Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n\n  this.level = 0;\n  /**\n   * Token#children -> Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n\n  this.children = null;\n  /**\n   * Token#content -> String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n\n  this.content = '';\n  /**\n   * Token#markup -> String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n\n  this.markup = '';\n  /**\n   * Token#info -> String\n   *\n   * fence infostring\n   **/\n\n  this.info = '';\n  /**\n   * Token#meta -> Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n\n  this.meta = null;\n  /**\n   * Token#block -> Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n\n  this.block = false;\n  /**\n   * Token#hidden -> Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n\n  this.hidden = false;\n}\n/**\n * Token.attrIndex(name) -> Number\n *\n * Search attribute index by name.\n **/\n\n\nToken.prototype.attrIndex = function attrIndex(name) {\n  var attrs, i, len;\n\n  if (!this.attrs) {\n    return -1;\n  }\n\n  attrs = this.attrs;\n\n  for (i = 0, len = attrs.length; i < len; i++) {\n    if (attrs[i][0] === name) {\n      return i;\n    }\n  }\n\n  return -1;\n};\n/**\n * Token.attrPush(attrData)\n *\n * Add `[ name, value ]` attribute to list. Init attrs if necessary\n **/\n\n\nToken.prototype.attrPush = function attrPush(attrData) {\n  if (this.attrs) {\n    this.attrs.push(attrData);\n  } else {\n    this.attrs = [attrData];\n  }\n};\n/**\n * Token.attrSet(name, value)\n *\n * Set `name` attribute to `value`. Override old value if exists.\n **/\n\n\nToken.prototype.attrSet = function attrSet(name, value) {\n  var idx = this.attrIndex(name),\n      attrData = [name, value];\n\n  if (idx < 0) {\n    this.attrPush(attrData);\n  } else {\n    this.attrs[idx] = attrData;\n  }\n};\n/**\n * Token.attrGet(name)\n *\n * Get the value of attribute `name`, or null if it does not exist.\n **/\n\n\nToken.prototype.attrGet = function attrGet(name) {\n  var idx = this.attrIndex(name),\n      value = null;\n\n  if (idx >= 0) {\n    value = this.attrs[idx][1];\n  }\n\n  return value;\n};\n/**\n * Token.attrJoin(name, value)\n *\n * Join value to existing attribute via space. Or create new attribute if not\n * exists. Useful to operate with token classes.\n **/\n\n\nToken.prototype.attrJoin = function attrJoin(name, value) {\n  var idx = this.attrIndex(name);\n\n  if (idx < 0) {\n    this.attrPush([name, value]);\n  } else {\n    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;\n  }\n};\n\nmodule.exports = Token;","'use strict';\n\nmodule.exports = require('./lib/');","// HTML5 entities map: { name -> utf16string }\n//\n'use strict';\n/*eslint quotes:0*/\n\nmodule.exports = require('entities/lib/maps/entities.json');","'use strict';\n\nmodule.exports.encode = require('./encode');\nmodule.exports.decode = require('./decode');\nmodule.exports.format = require('./format');\nmodule.exports.parse = require('./parse');","module.exports = /[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;","module.exports = /[\\0-\\x1F\\x7F-\\x9F]/;","module.exports = /[ \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/;","// Regexps to match html elements\n'use strict';\n\nvar attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\nvar unquoted = '[^\"\\'=<>`\\\\x00-\\\\x20]+';\nvar single_quoted = \"'[^']*'\";\nvar double_quoted = '\"[^\"]*\"';\nvar attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';\nvar attribute = '(?:\\\\s+' + attr_name + '(?:\\\\s*=\\\\s*' + attr_value + ')?)';\nvar open_tag = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\nvar close_tag = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nvar comment = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';\nvar processing = '<[?].*?[?]>';\nvar declaration = '<![A-Z]+\\\\s+[^>]*>';\nvar cdata = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\nvar HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')');\nvar HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');\nmodule.exports.HTML_TAG_RE = HTML_TAG_RE;\nmodule.exports.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE;","// ~~strike through~~\n//\n'use strict'; // Insert each marker as a separate text token, and add it to delimiter list\n//\n\nmodule.exports.tokenize = function strikethrough(state, silent) {\n  var i,\n      scanned,\n      token,\n      len,\n      ch,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) {\n    return false;\n  }\n\n  if (marker !== 0x7E\n  /* ~ */\n  ) {\n    return false;\n  }\n\n  scanned = state.scanDelims(state.pos, true);\n  len = scanned.length;\n  ch = String.fromCharCode(marker);\n\n  if (len < 2) {\n    return false;\n  }\n\n  if (len % 2) {\n    token = state.push('text', '', 0);\n    token.content = ch;\n    len--;\n  }\n\n  for (i = 0; i < len; i += 2) {\n    token = state.push('text', '', 0);\n    token.content = ch + ch;\n    state.delimiters.push({\n      marker: marker,\n      length: 0,\n      // disable \"rule of 3\" length checks meant for emphasis\n      jump: i,\n      token: state.tokens.length - 1,\n      end: -1,\n      open: scanned.can_open,\n      close: scanned.can_close\n    });\n  }\n\n  state.pos += scanned.length;\n  return true;\n};\n\nfunction postProcess(state, delimiters) {\n  var i,\n      j,\n      startDelim,\n      endDelim,\n      token,\n      loneMarkers = [],\n      max = delimiters.length;\n\n  for (i = 0; i < max; i++) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x7E\n    /* ~ */\n    ) {\n      continue;\n    }\n\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end];\n    token = state.tokens[startDelim.token];\n    token.type = 's_open';\n    token.tag = 's';\n    token.nesting = 1;\n    token.markup = '~~';\n    token.content = '';\n    token = state.tokens[endDelim.token];\n    token.type = 's_close';\n    token.tag = 's';\n    token.nesting = -1;\n    token.markup = '~~';\n    token.content = '';\n\n    if (state.tokens[endDelim.token - 1].type === 'text' && state.tokens[endDelim.token - 1].content === '~') {\n      loneMarkers.push(endDelim.token - 1);\n    }\n  } // If a marker sequence has an odd number of characters, it's splitted\n  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the\n  // start of the sequence.\n  //\n  // So, we have to move all those markers after subsequent s_close tags.\n  //\n\n\n  while (loneMarkers.length) {\n    i = loneMarkers.pop();\n    j = i + 1;\n\n    while (j < state.tokens.length && state.tokens[j].type === 's_close') {\n      j++;\n    }\n\n    j--;\n\n    if (i !== j) {\n      token = state.tokens[j];\n      state.tokens[j] = state.tokens[i];\n      state.tokens[i] = token;\n    }\n  }\n} // Walk through delimiter list and replace text tokens with tags\n//\n\n\nmodule.exports.postProcess = function strikethrough(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};","// Process *this* and _that_\n//\n'use strict'; // Insert each marker as a separate text token, and add it to delimiter list\n//\n\nmodule.exports.tokenize = function emphasis(state, silent) {\n  var i,\n      scanned,\n      token,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) {\n    return false;\n  }\n\n  if (marker !== 0x5F\n  /* _ */\n  && marker !== 0x2A\n  /* * */\n  ) {\n    return false;\n  }\n\n  scanned = state.scanDelims(state.pos, marker === 0x2A);\n\n  for (i = 0; i < scanned.length; i++) {\n    token = state.push('text', '', 0);\n    token.content = String.fromCharCode(marker);\n    state.delimiters.push({\n      // Char code of the starting marker (number).\n      //\n      marker: marker,\n      // Total length of these series of delimiters.\n      //\n      length: scanned.length,\n      // An amount of characters before this one that's equivalent to\n      // current one. In plain English: if this delimiter does not open\n      // an emphasis, neither do previous `jump` characters.\n      //\n      // Used to skip sequences like \"*****\" in one step, for 1st asterisk\n      // value will be 0, for 2nd it's 1 and so on.\n      //\n      jump: i,\n      // A position of the token this delimiter corresponds to.\n      //\n      token: state.tokens.length - 1,\n      // If this delimiter is matched as a valid opener, `end` will be\n      // equal to its position, otherwise it's `-1`.\n      //\n      end: -1,\n      // Boolean flags that determine if this delimiter could open or close\n      // an emphasis.\n      //\n      open: scanned.can_open,\n      close: scanned.can_close\n    });\n  }\n\n  state.pos += scanned.length;\n  return true;\n};\n\nfunction postProcess(state, delimiters) {\n  var i,\n      startDelim,\n      endDelim,\n      token,\n      ch,\n      isStrong,\n      max = delimiters.length;\n\n  for (i = max - 1; i >= 0; i--) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x5F\n    /* _ */\n    && startDelim.marker !== 0x2A\n    /* * */\n    ) {\n      continue;\n    } // Process only opening markers\n\n\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end]; // If the previous delimiter has the same marker and is adjacent to this one,\n    // merge those into one strong delimiter.\n    //\n    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`\n    //\n\n    isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && delimiters[i - 1].token === startDelim.token - 1 && delimiters[startDelim.end + 1].token === endDelim.token + 1 && delimiters[i - 1].marker === startDelim.marker;\n    ch = String.fromCharCode(startDelim.marker);\n    token = state.tokens[startDelim.token];\n    token.type = isStrong ? 'strong_open' : 'em_open';\n    token.tag = isStrong ? 'strong' : 'em';\n    token.nesting = 1;\n    token.markup = isStrong ? ch + ch : ch;\n    token.content = '';\n    token = state.tokens[endDelim.token];\n    token.type = isStrong ? 'strong_close' : 'em_close';\n    token.tag = isStrong ? 'strong' : 'em';\n    token.nesting = -1;\n    token.markup = isStrong ? ch + ch : ch;\n    token.content = '';\n\n    if (isStrong) {\n      state.tokens[delimiters[i - 1].token].content = '';\n      state.tokens[delimiters[startDelim.end + 1].token].content = '';\n      i--;\n    }\n  }\n} // Walk through delimiter list and replace text tokens with tags\n//\n\n\nmodule.exports.postProcess = function emphasis(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","/*! markdown-it-html5-embed https://github.com/cmrd-senya/markdown-it-html5-embed @license MPLv2 */\n// This is a plugin for markdown-it which adds support for embedding audio/video in the HTML5 way.\n'use strict';\n\nvar Mimoza = require('mimoza'); // Default UI messages. You can customize and add simple translations via\n// options.messages. The language has to be provided via the markdown-it\n// environment, e.g.:\n//\n// md.render('some text', { language: 'some code' })\n//\n// It will default to English if not provided. To use your own i18n framework,\n// you have to provide a translation function via options.translateFn.\n//\n// The \"untitled video\" / \"untitled audio\" messages are only relevant to usage\n// inside alternative render functions, where you can access the title between [] as\n// {{title}}, and this text is used if no title is provided.\n\n\nvar messages = {\n  en: {\n    'video not supported': 'Your browser does not support playing HTML5 video. ' + 'You can <a href=\"%s\" download>download a copy of the video file</a> instead.',\n    'audio not supported': 'Your browser does not support playing HTML5 audio. ' + 'You can <a href=\"%s\" download>download a copy of the audio file</a> instead.',\n    'content description': 'Here is a description of the content: %s',\n    'untitled video': 'Untitled video',\n    'untitled audio': 'Untitled audio'\n  }\n};\n\nfunction clearTokens(tokens, idx) {\n  for (var i = idx; i < tokens.length; i++) {\n    switch (tokens[i].type) {\n      case 'link_close':\n        tokens[i].hidden = true;\n        break;\n\n      case 'text':\n        tokens[i].content = '';\n        break;\n\n      default:\n        throw \"Unexpected token: \" + tokens[i].type;\n    }\n  }\n}\n\nfunction parseToken(tokens, idx, env) {\n  var parsed = {};\n  var token = tokens[idx];\n  var description = '';\n  var aIndex = token.attrIndex('src');\n  parsed.isLink = aIndex < 0;\n\n  if (parsed.isLink) {\n    aIndex = token.attrIndex('href');\n    description = tokens[idx + 1].content;\n  } else {\n    description = token.content;\n  }\n\n  parsed.url = token.attrs[aIndex][1];\n  parsed.mimeType = Mimoza.getMimeType(parsed.url);\n  var RE = /^(audio|video)\\/.*/gi;\n  var mimetype_matches = RE.exec(parsed.mimeType);\n\n  if (mimetype_matches === null) {\n    parsed.mediaType = null;\n  } else {\n    parsed.mediaType = mimetype_matches[1];\n  }\n\n  if (parsed.mediaType !== null) {\n    // For use as titles in alternative render functions, we store the description\n    // in parsed.title. For use as fallback text, we store it in parsed.fallback\n    // alongside the standard fallback text.\n    parsed.fallback = translate({\n      messageKey: parsed.mediaType + ' not supported',\n      messageParam: parsed.url,\n      language: env.language\n    });\n\n    if (description.trim().length) {\n      parsed.fallback += '\\n' + translate({\n        messageKey: 'content description',\n        messageParam: description,\n        language: env.language\n      });\n      parsed.title = description;\n    } else {\n      parsed.title = translate({\n        messageKey: 'untitled ' + parsed.mediaType,\n        language: env.language\n      });\n    }\n  }\n\n  return parsed;\n}\n\nfunction isAllowedMimeType(parsed, options) {\n  return parsed.mediaType !== null && (!options.isAllowedMimeType || options.isAllowedMimeType([parsed.mimeType, parsed.mediaType]));\n}\n\nfunction isAllowedSchema(parsed, options) {\n  if (!options.isAllowedHttp && parsed.url.match('^http://')) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction isAllowedToEmbed(parsed, options) {\n  return isAllowedMimeType(parsed, options) && isAllowedSchema(parsed, options);\n}\n\nfunction renderMediaEmbed(parsed, mediaAttributes) {\n  var attributes = mediaAttributes[parsed.mediaType];\n  return ['<' + parsed.mediaType + ' ' + attributes + '>', '<source type=\"' + parsed.mimeType + '\" src=\"' + parsed.url + '\"></source>', parsed.fallback, '</' + parsed.mediaType + '>'].join('\\n');\n}\n\nfunction html5EmbedRenderer(tokens, idx, options, env, renderer, defaultRender) {\n  var parsed = parseToken(tokens, idx, env);\n\n  if (!isAllowedToEmbed(parsed, options.html5embed)) {\n    return defaultRender(tokens, idx, options, env, renderer);\n  }\n\n  if (parsed.isLink) {\n    clearTokens(tokens, idx + 1);\n  }\n\n  return renderMediaEmbed(parsed, options.html5embed.attributes);\n}\n\nfunction forEachLinkOpen(state, action) {\n  state.tokens.forEach(function (token, _idx, _tokens) {\n    if (token.type === \"inline\") {\n      token.children.forEach(function (token, idx, tokens) {\n        if (token.type === \"link_open\") {\n          action(tokens, idx);\n        }\n      });\n    }\n  });\n}\n\nfunction findDirective(state, startLine, _endLine, silent, regexp, build_token) {\n  var pos = state.bMarks[startLine] + state.tShift[startLine];\n  var max = state.eMarks[startLine]; // Detect directive markdown\n\n  var currentLine = state.src.substring(pos, max);\n  var match = regexp.exec(currentLine);\n\n  if (match === null || match.length < 1) {\n    return false;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  state.line = startLine + 1; // Build content\n\n  var token = build_token();\n  token.map = [startLine, state.line];\n  token.markup = currentLine;\n  return true;\n}\n/**\n * Very basic translation function. To translate or customize the UI messages,\n * set options.messages. To also customize the translation function itself, set\n * option.translateFn to a function that handles the same message object format.\n *\n * @param {Object} messageObj\n *  the message object\n * @param {String} messageObj.messageKey\n *  an identifier used for looking up the message in i18n files\n * @param {String} messageObj.messageParam\n *  for substitution of %s for filename and description in the respective\n *  messages\n * @param {String} [messageObj.language='en']\n *  a language code, ignored in the default implementation\n * @this {Object}\n *  the built-in default messages, or options.messages if set\n */\n\n\nfunction translate(messageObj) {\n  // Default to English if we don't have this message, or don't support this\n  // language at all\n  var language = messageObj.language && this[messageObj.language] && this[messageObj.language][messageObj.messageKey] ? messageObj.language : 'en';\n  var rv = this[language][messageObj.messageKey];\n\n  if (messageObj.messageParam) {\n    rv = rv.replace('%s', messageObj.messageParam);\n  }\n\n  return rv;\n}\n\nmodule.exports = function html5_embed_plugin(md, options) {\n  var gstate;\n  var defaults = {\n    attributes: {\n      audio: 'controls preload=\"metadata\"',\n      video: 'controls preload=\"metadata\"'\n    },\n    useImageSyntax: true,\n    inline: true,\n    autoAppend: false,\n    embedPlaceDirectiveRegexp: /^\\[\\[html5media\\]\\]/im,\n    messages: messages\n  };\n  var options = md.utils.assign({}, defaults, options.html5embed);\n\n  if (!options.inline) {\n    md.block.ruler.before(\"paragraph\", \"html5embed\", function (state, startLine, endLine, silent) {\n      return findDirective(state, startLine, endLine, silent, options.embedPlaceDirectiveRegexp, function () {\n        return state.push(\"html5media\", \"html5media\", 0);\n      });\n    });\n\n    md.renderer.rules.html5media = function (tokens, index, _, env) {\n      var result = \"\";\n      forEachLinkOpen(gstate, function (tokens, idx) {\n        var parsed = parseToken(tokens, idx, env);\n\n        if (!isAllowedToEmbed(parsed, options)) {\n          return;\n        }\n\n        result += renderMediaEmbed(parsed, options.attributes);\n      });\n\n      if (result.length) {\n        result += \"\\n\";\n      }\n\n      return result;\n    }; // Catch all the tokens for iteration later\n\n\n    md.core.ruler.push(\"grab_state\", function (state) {\n      gstate = state;\n\n      if (options.autoAppend) {\n        var token = new state.Token(\"html5media\", \"\", 0);\n        state.tokens.push(token);\n      }\n    });\n  }\n\n  if (typeof options.isAllowedMimeType === \"undefined\") {\n    options.isAllowedMimeType = options.is_allowed_mime_type;\n  }\n\n  if (options.inline && options.useImageSyntax) {\n    var defaultRender = md.renderer.rules.image;\n\n    md.renderer.rules.image = function (tokens, idx, opt, env, self) {\n      opt.html5embed = options;\n      return html5EmbedRenderer(tokens, idx, opt, env, self, defaultRender);\n    };\n  }\n\n  if (options.inline && options.useLinkSyntax) {\n    var defaultRender = md.renderer.rules.link_open || function (tokens, idx, options, env, self) {\n      return self.renderToken(tokens, idx, options);\n    };\n\n    md.renderer.rules.link_open = function (tokens, idx, opt, env, self) {\n      opt.html5embed = options;\n      return html5EmbedRenderer(tokens, idx, opt, env, self, defaultRender);\n    };\n  } // options.messages will be set to built-in messages at the beginning of this\n  // file if not configured\n\n\n  translate = typeof options.translateFn == 'function' ? options.translateFn.bind(options.messages) : translate.bind(options.messages);\n\n  if (typeof options.renderFn == 'function') {\n    renderMediaEmbed = options.renderFn;\n  }\n};","// Main parser class\n'use strict';\n\nvar utils = require('./common/utils');\n\nvar helpers = require('./helpers');\n\nvar Renderer = require('./renderer');\n\nvar ParserCore = require('./parser_core');\n\nvar ParserBlock = require('./parser_block');\n\nvar ParserInline = require('./parser_inline');\n\nvar LinkifyIt = require('linkify-it');\n\nvar mdurl = require('mdurl');\n\nvar punycode = require('punycode');\n\nvar config = {\n  'default': require('./presets/default'),\n  zero: require('./presets/zero'),\n  commonmark: require('./presets/commonmark')\n}; ////////////////////////////////////////////////////////////////////////////////\n//\n// This validator can prohibit more than really needed to prevent XSS. It's a\n// tradeoff to keep code simple and to be secure by default.\n//\n// If you need different setup - override validator method as you wish. Or\n// replace it with dummy function and use external sanitizer.\n//\n\nvar BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;\nvar GOOD_DATA_RE = /^data:image\\/(gif|png|jpeg|webp);/;\n\nfunction validateLink(url) {\n  // url should be normalized at this point, and existing entities are decoded\n  var str = url.trim().toLowerCase();\n  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) ? true : false : true;\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nvar RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:'];\n\nfunction normalizeLink(url) {\n  var parsed = mdurl.parse(url, true);\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toASCII(parsed.hostname);\n      } catch (er) {\n        /**/\n      }\n    }\n  }\n\n  return mdurl.encode(mdurl.format(parsed));\n}\n\nfunction normalizeLinkText(url) {\n  var parsed = mdurl.parse(url, true);\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toUnicode(parsed.hostname);\n      } catch (er) {\n        /**/\n      }\n    }\n  }\n\n  return mdurl.decode(mdurl.format(parsed));\n}\n/**\n * class MarkdownIt\n *\n * Main parser/renderer class.\n *\n * ##### Usage\n *\n * ```javascript\n * // node.js, \"classic\" way:\n * var MarkdownIt = require('markdown-it'),\n *     md = new MarkdownIt();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // node.js, the same, but with sugar:\n * var md = require('markdown-it')();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // browser without AMD, added to \"window\" on script load\n * // Note, there are no dash.\n * var md = window.markdownit();\n * var result = md.render('# markdown-it rulezz!');\n * ```\n *\n * Single line rendering, without paragraph wrap:\n *\n * ```javascript\n * var md = require('markdown-it')();\n * var result = md.renderInline('__markdown-it__ rulezz!');\n * ```\n **/\n\n/**\n * new MarkdownIt([presetName, options])\n * - presetName (String): optional, `commonmark` / `zero`\n * - options (Object)\n *\n * Creates parser instanse with given config. Can be called without `new`.\n *\n * ##### presetName\n *\n * MarkdownIt provides named presets as a convenience to quickly\n * enable/disable active syntax rules and options for common use cases.\n *\n * - [\"commonmark\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -\n *   configures parser to strict [CommonMark](http://commonmark.org/) mode.\n * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -\n *   similar to GFM, used when no preset name given. Enables all available rules,\n *   but still without html, typographer & autolinker.\n * - [\"zero\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -\n *   all rules disabled. Useful to quickly setup your config via `.enable()`.\n *   For example, when you need only `bold` and `italic` markup and nothing else.\n *\n * ##### options:\n *\n * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!\n *   That's not safe! You may need external sanitizer to protect output from XSS.\n *   It's better to extend features via plugins, instead of enabling HTML.\n * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags\n *   (`<br />`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `<br>`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +\n *   quotes beautification (smartquotes).\n * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement\n *   pairs, when typographer enabled and smartquotes on. For example, you can\n *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and\n *   `['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›']` for French (including nbsp).\n * - __highlight__ - `null`. Highlighter function for fenced code blocks.\n *   Highlighter `function (str, lang)` should return escaped HTML. It can also\n *   return empty string if the source was not changed and should be escaped\n *   externaly. If result starts with <pre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(lang, str, true).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `<pre>`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return '<pre class=\"hljs\"><code>' +\n *                hljs.highlight(lang, str, true).value +\n *                '</code></pre>';\n *       } catch (__) {}\n *     }\n *\n *     return '<pre class=\"hljs\"><code>' + md.utils.escapeHtml(str) + '</code></pre>';\n *   }\n * });\n * ```\n *\n **/\n\n\nfunction MarkdownIt(presetName, options) {\n  if (!(this instanceof MarkdownIt)) {\n    return new MarkdownIt(presetName, options);\n  }\n\n  if (!options) {\n    if (!utils.isString(presetName)) {\n      options = presetName || {};\n      presetName = 'default';\n    }\n  }\n  /**\n   * MarkdownIt#inline -> ParserInline\n   *\n   * Instance of [[ParserInline]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n\n\n  this.inline = new ParserInline();\n  /**\n   * MarkdownIt#block -> ParserBlock\n   *\n   * Instance of [[ParserBlock]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n\n  this.block = new ParserBlock();\n  /**\n   * MarkdownIt#core -> Core\n   *\n   * Instance of [[Core]] chain executor. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n\n  this.core = new ParserCore();\n  /**\n   * MarkdownIt#renderer -> Renderer\n   *\n   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   *\n   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).\n   **/\n\n  this.renderer = new Renderer();\n  /**\n   * MarkdownIt#linkify -> LinkifyIt\n   *\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)\n   * rule.\n   **/\n\n  this.linkify = new LinkifyIt();\n  /**\n   * MarkdownIt#validateLink(url) -> Boolean\n   *\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   **/\n\n  this.validateLink = validateLink;\n  /**\n   * MarkdownIt#normalizeLink(url) -> String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n\n  this.normalizeLink = normalizeLink;\n  /**\n   * MarkdownIt#normalizeLinkText(url) -> String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n\n  this.normalizeLinkText = normalizeLinkText; // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -> utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js).\n   **/\n\n  this.utils = utils;\n  /**\n   * MarkdownIt#helpers -> helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n\n  this.helpers = utils.assign({}, helpers);\n  this.options = {};\n  this.configure(presetName);\n\n  if (options) {\n    this.set(options);\n  }\n}\n/** chainable\n * MarkdownIt.set(options)\n *\n * Set parser options (in the same format as in constructor). Probably, you\n * will never need it, but you can change options after constructor call.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .set({ html: true, breaks: true })\n *             .set({ typographer, true });\n * ```\n *\n * __Note:__ To achieve the best possible performance, don't modify a\n * `markdown-it` instance options on the fly. If you need multiple configurations\n * it's best to create multiple instances and initialize each with separate\n * config.\n **/\n\n\nMarkdownIt.prototype.set = function (options) {\n  utils.assign(this.options, options);\n  return this;\n};\n/** chainable, internal\n * MarkdownIt.configure(presets)\n *\n * Batch load of all options and compenent settings. This is internal method,\n * and you probably will not need it. But if you with - see available presets\n * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)\n *\n * We strongly recommend to use presets instead of direct config loads. That\n * will give better compatibility with next versions.\n **/\n\n\nMarkdownIt.prototype.configure = function (presets) {\n  var self = this,\n      presetName;\n\n  if (utils.isString(presets)) {\n    presetName = presets;\n    presets = config[presetName];\n\n    if (!presets) {\n      throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name');\n    }\n  }\n\n  if (!presets) {\n    throw new Error('Wrong `markdown-it` preset, can\\'t be empty');\n  }\n\n  if (presets.options) {\n    self.set(presets.options);\n  }\n\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enableOnly(presets.components[name].rules);\n      }\n\n      if (presets.components[name].rules2) {\n        self[name].ruler2.enableOnly(presets.components[name].rules2);\n      }\n    });\n  }\n\n  return this;\n};\n/** chainable\n * MarkdownIt.enable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to enable\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable list or rules. It will automatically find appropriate components,\n * containing rules with given names. If rule not found, and `ignoreInvalid`\n * not set - throws exception.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .enable(['sub', 'sup'])\n *             .disable('smartquotes');\n * ```\n **/\n\n\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.enable(list, true));\n  }, this);\n  result = result.concat(this.inline.ruler2.enable(list, true));\n  var missed = list.filter(function (name) {\n    return result.indexOf(name) < 0;\n  });\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);\n  }\n\n  return this;\n};\n/** chainable\n * MarkdownIt.disable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * The same as [[MarkdownIt.enable]], but turn specified rules off.\n **/\n\n\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) {\n    list = [list];\n  }\n\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.disable(list, true));\n  }, this);\n  result = result.concat(this.inline.ruler2.disable(list, true));\n  var missed = list.filter(function (name) {\n    return result.indexOf(name) < 0;\n  });\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);\n  }\n\n  return this;\n};\n/** chainable\n * MarkdownIt.use(plugin, params)\n *\n * Load specified plugin with given params into current parser instance.\n * It's just a sugar to call `plugin(md, params)` with curring.\n *\n * ##### Example\n *\n * ```javascript\n * var iterator = require('markdown-it-for-inline');\n * var md = require('markdown-it')()\n *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');\n *             });\n * ```\n **/\n\n\nMarkdownIt.prototype.use = function (plugin\n/*, params, ... */\n) {\n  var args = [this].concat(Array.prototype.slice.call(arguments, 1));\n  plugin.apply(plugin, args);\n  return this;\n};\n/** internal\n * MarkdownIt.parse(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Parse input string and returns list of block tokens (special token type\n * \"inline\" will contain list of inline tokens). You should not call this\n * method directly, until you write custom renderer (for example, to produce\n * AST).\n *\n * `env` is used to pass data between \"distributed\" rules and return additional\n * metadata like reference info, needed for the renderer. It also can be used to\n * inject data in specific cases. Usually, you will be ok to pass `{}`,\n * and then pass updated object to renderer.\n **/\n\n\nMarkdownIt.prototype.parse = function (src, env) {\n  if (typeof src !== 'string') {\n    throw new Error('Input data should be a String');\n  }\n\n  var state = new this.core.State(src, this, env);\n  this.core.process(state);\n  return state.tokens;\n};\n/**\n * MarkdownIt.render(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Render markdown string into html. It does all magic for you :).\n *\n * `env` can be used to inject additional metadata (`{}` by default).\n * But you will not need it with high probability. See also comment\n * in [[MarkdownIt.parse]].\n **/\n\n\nMarkdownIt.prototype.render = function (src, env) {\n  env = env || {};\n  return this.renderer.render(this.parse(src, env), this.options, env);\n};\n/** internal\n * MarkdownIt.parseInline(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the\n * block tokens list with the single `inline` element, containing parsed inline\n * tokens in `children` property. Also updates `env` object.\n **/\n\n\nMarkdownIt.prototype.parseInline = function (src, env) {\n  var state = new this.core.State(src, this, env);\n  state.inlineMode = true;\n  this.core.process(state);\n  return state.tokens;\n};\n/**\n * MarkdownIt.renderInline(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `<p>` tags.\n **/\n\n\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {};\n  return this.renderer.render(this.parseInline(src, env), this.options, env);\n};\n\nmodule.exports = MarkdownIt;","'use strict';\n\nvar encodeCache = {}; // Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\n\nfunction getEncodeCache(exclude) {\n  var i,\n      ch,\n      cache = encodeCache[exclude];\n\n  if (cache) {\n    return cache;\n  }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n} // Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\n\n\nfunction encode(string, exclude, keepEscaped) {\n  var i,\n      l,\n      code,\n      nextCode,\n      cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25\n    /* % */\n    && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\nmodule.exports = encode;","'use strict';\n/* eslint-disable no-bitwise */\n\nvar decodeCache = {};\n\nfunction getDecodeCache(exclude) {\n  var i,\n      ch,\n      cache = decodeCache[exclude];\n\n  if (cache) {\n    return cache;\n  }\n\n  cache = decodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n    cache.push(ch);\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    ch = exclude.charCodeAt(i);\n    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);\n  }\n\n  return cache;\n} // Decode percent-encoded string.\n//\n\n\nfunction decode(string, exclude) {\n  var cache;\n\n  if (typeof exclude !== 'string') {\n    exclude = decode.defaultChars;\n  }\n\n  cache = getDecodeCache(exclude);\n  return string.replace(/(%[a-f0-9]{2})+/gi, function (seq) {\n    var i,\n        l,\n        b1,\n        b2,\n        b3,\n        b4,\n        chr,\n        result = '';\n\n    for (i = 0, l = seq.length; i < l; i += 3) {\n      b1 = parseInt(seq.slice(i + 1, i + 3), 16);\n\n      if (b1 < 0x80) {\n        result += cache[b1];\n        continue;\n      }\n\n      if ((b1 & 0xE0) === 0xC0 && i + 3 < l) {\n        // 110xxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n\n        if ((b2 & 0xC0) === 0x80) {\n          chr = b1 << 6 & 0x7C0 | b2 & 0x3F;\n\n          if (chr < 0x80) {\n            result += \"\\uFFFD\\uFFFD\";\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 3;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF0) === 0xE0 && i + 6 < l) {\n        // 1110xxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n          chr = b1 << 12 & 0xF000 | b2 << 6 & 0xFC0 | b3 & 0x3F;\n\n          if (chr < 0x800 || chr >= 0xD800 && chr <= 0xDFFF) {\n            result += \"\\uFFFD\\uFFFD\\uFFFD\";\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 6;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF8) === 0xF0 && i + 9 < l) {\n        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n        b4 = parseInt(seq.slice(i + 10, i + 12), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {\n          chr = b1 << 18 & 0x1C0000 | b2 << 12 & 0x3F000 | b3 << 6 & 0xFC0 | b4 & 0x3F;\n\n          if (chr < 0x10000 || chr > 0x10FFFF) {\n            result += \"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\";\n          } else {\n            chr -= 0x10000;\n            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));\n          }\n\n          i += 9;\n          continue;\n        }\n      }\n\n      result += \"\\uFFFD\";\n    }\n\n    return result;\n  });\n}\n\ndecode.defaultChars = ';/?:@&=+$,#';\ndecode.componentChars = '';\nmodule.exports = decode;","'use strict';\n\nmodule.exports = function format(url) {\n  var result = '';\n  result += url.protocol || '';\n  result += url.slashes ? '//' : '';\n  result += url.auth ? url.auth + '@' : '';\n\n  if (url.hostname && url.hostname.indexOf(':') !== -1) {\n    // ipv6 address\n    result += '[' + url.hostname + ']';\n  } else {\n    result += url.hostname || '';\n  }\n\n  result += url.port ? ':' + url.port : '';\n  result += url.pathname || '';\n  result += url.search || '';\n  result += url.hash || '';\n  return result;\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict'; //\n// Changes from joyent/node:\n//\n// 1. No leading slash in paths,\n//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`\n//\n// 2. Backslashes are not replaced with slashes,\n//    so `http:\\\\example.org\\` is treated like a relative path\n//\n// 3. Trailing colon is treated like a part of the path,\n//    i.e. in `http://example.org:foo` pathname is `:foo`\n//\n// 4. Nothing is URL-encoded in the resulting object,\n//    (in joyent/node some chars in auth and paths are encoded)\n//\n// 5. `url.parse()` does not have `parseQueryString` argument\n//\n// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,\n//    which can be constructed using other parts of the url.\n//\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.pathname = null;\n} // Reference: RFC 3986, RFC 1808, RFC 2396\n// define these here so at least they only have to be\n// compiled once on the first module load.\n\n\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n    // Special case for a simple path URL\nsimplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n    // RFC 2396: characters reserved for delimiting URLs.\n// We actually just auto-escape these.\ndelims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n    // RFC 2396: characters not allowed for various reasons.\nunwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\nautoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n// Note that any invalid chars are also handled, but these\n// are the ones that are *expected* to be seen, so we fast-path\n// them.\nnonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n\n/* eslint-disable no-script-url */\n// protocols that never have a hostname.\nhostlessProtocol = {\n  'javascript': true,\n  'javascript:': true\n},\n    // protocols that always contain a // bit.\nslashedProtocol = {\n  'http': true,\n  'https': true,\n  'ftp': true,\n  'gopher': true,\n  'file': true,\n  'http:': true,\n  'https:': true,\n  'ftp:': true,\n  'gopher:': true,\n  'file:': true\n};\n/* eslint-enable no-script-url */\n\nfunction urlParse(url, slashesDenoteHost) {\n  if (url && url instanceof Url) {\n    return url;\n  }\n\n  var u = new Url();\n  u.parse(url, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function (url, slashesDenoteHost) {\n  var i,\n      l,\n      lowerProto,\n      hec,\n      slashes,\n      rest = url; // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n\n    if (simplePath) {\n      this.pathname = simplePath[1];\n\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n      }\n\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n\n  if (proto) {\n    proto = proto[0];\n    lowerProto = proto.toLowerCase();\n    this.protocol = proto;\n    rest = rest.substr(proto.length);\n  } // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n\n\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    slashes = rest.substr(0, 2) === '//';\n\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n\n    for (i = 0; i < hostEndingChars.length; i++) {\n      hec = rest.indexOf(hostEndingChars[i]);\n\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    } // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n\n\n    var auth, atSign;\n\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    } // Now we have a portion which is definitely the auth.\n    // Pull that off.\n\n\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = auth;\n    } // the host is the remaining to the left of the first non-host char\n\n\n    hostEnd = -1;\n\n    for (i = 0; i < nonHostChars.length; i++) {\n      hec = rest.indexOf(nonHostChars[i]);\n\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    } // if we still have not hit it, then the entire thing is a host.\n\n\n    if (hostEnd === -1) {\n      hostEnd = rest.length;\n    }\n\n    if (rest[hostEnd - 1] === ':') {\n      hostEnd--;\n    }\n\n    var host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd); // pull out port.\n\n    this.parseHost(host); // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n\n    this.hostname = this.hostname || ''; // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n\n    var ipv6Hostname = this.hostname[0] === '[' && this.hostname[this.hostname.length - 1] === ']'; // validate a little.\n\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n\n      for (i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n\n        if (!part) {\n          continue;\n        }\n\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          } // we test again with ASCII char only\n\n\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n\n            if (notHost.length) {\n              rest = notHost.join('.') + rest;\n            }\n\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } // strip [ and ] from the hostname\n    // the host field still retains them, though\n\n\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n    }\n  } // chop off from the tail first.\n\n\n  var hash = rest.indexOf('#');\n\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n\n  var qm = rest.indexOf('?');\n\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    rest = rest.slice(0, qm);\n  }\n\n  if (rest) {\n    this.pathname = rest;\n  }\n\n  if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {\n    this.pathname = '';\n  }\n\n  return this;\n};\n\nUrl.prototype.parseHost = function (host) {\n  var port = portPattern.exec(host);\n\n  if (port) {\n    port = port[0];\n\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n\n    host = host.substr(0, host.length - port.length);\n  }\n\n  if (host) {\n    this.hostname = host;\n  }\n};\n\nmodule.exports = urlParse;","'use strict';\n\nexports.Any = require('./properties/Any/regex');\nexports.Cc = require('./categories/Cc/regex');\nexports.Cf = require('./categories/Cf/regex');\nexports.P = require('./categories/P/regex');\nexports.Z = require('./categories/Z/regex');","module.exports = /[\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB]|\\uD804[\\uDCBD\\uDCCD]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]/;","// Just a shortcut for bulk export\n'use strict';\n\nexports.parseLinkLabel = require('./parse_link_label');\nexports.parseLinkDestination = require('./parse_link_destination');\nexports.parseLinkTitle = require('./parse_link_title');","// Parse link label\n//\n// this function assumes that first character (\"[\") already matches;\n// returns the end of the label\n//\n'use strict';\n\nmodule.exports = function parseLinkLabel(state, start, disableNested) {\n  var level,\n      found,\n      marker,\n      prevPos,\n      labelEnd = -1,\n      max = state.posMax,\n      oldPos = state.pos;\n  state.pos = start + 1;\n  level = 1;\n\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos);\n\n    if (marker === 0x5D\n    /* ] */\n    ) {\n      level--;\n\n      if (level === 0) {\n        found = true;\n        break;\n      }\n    }\n\n    prevPos = state.pos;\n    state.md.inline.skipToken(state);\n\n    if (marker === 0x5B\n    /* [ */\n    ) {\n      if (prevPos === state.pos - 1) {\n        // increase level if we find text `[`, which is not a part of any token\n        level++;\n      } else if (disableNested) {\n        state.pos = oldPos;\n        return -1;\n      }\n    }\n  }\n\n  if (found) {\n    labelEnd = state.pos;\n  } // restore old state\n\n\n  state.pos = oldPos;\n  return labelEnd;\n};","// Parse link destination\n//\n'use strict';\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\nmodule.exports = function parseLinkDestination(str, pos, max) {\n  var code,\n      level,\n      lines = 0,\n      start = pos,\n      result = {\n    ok: false,\n    pos: 0,\n    lines: 0,\n    str: ''\n  };\n\n  if (str.charCodeAt(pos) === 0x3C\n  /* < */\n  ) {\n    pos++;\n\n    while (pos < max) {\n      code = str.charCodeAt(pos);\n\n      if (code === 0x0A\n      /* \\n */\n      ) {\n        return result;\n      }\n\n      if (code === 0x3E\n      /* > */\n      ) {\n        result.pos = pos + 1;\n        result.str = unescapeAll(str.slice(start + 1, pos));\n        result.ok = true;\n        return result;\n      }\n\n      if (code === 0x5C\n      /* \\ */\n      && pos + 1 < max) {\n        pos += 2;\n        continue;\n      }\n\n      pos++;\n    } // no closing '>'\n\n\n    return result;\n  } // this should be ... } else { ... branch\n\n\n  level = 0;\n\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n\n    if (code === 0x20) {\n      break;\n    } // ascii control characters\n\n\n    if (code < 0x20 || code === 0x7F) {\n      break;\n    }\n\n    if (code === 0x5C\n    /* \\ */\n    && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    if (code === 0x28\n    /* ( */\n    ) {\n      level++;\n    }\n\n    if (code === 0x29\n    /* ) */\n    ) {\n      if (level === 0) {\n        break;\n      }\n\n      level--;\n    }\n\n    pos++;\n  }\n\n  if (start === pos) {\n    return result;\n  }\n\n  if (level !== 0) {\n    return result;\n  }\n\n  result.str = unescapeAll(str.slice(start, pos));\n  result.lines = lines;\n  result.pos = pos;\n  result.ok = true;\n  return result;\n};","// Parse link title\n//\n'use strict';\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\nmodule.exports = function parseLinkTitle(str, pos, max) {\n  var code,\n      marker,\n      lines = 0,\n      start = pos,\n      result = {\n    ok: false,\n    pos: 0,\n    lines: 0,\n    str: ''\n  };\n\n  if (pos >= max) {\n    return result;\n  }\n\n  marker = str.charCodeAt(pos);\n\n  if (marker !== 0x22\n  /* \" */\n  && marker !== 0x27\n  /* ' */\n  && marker !== 0x28\n  /* ( */\n  ) {\n    return result;\n  }\n\n  pos++; // if opening marker is \"(\", switch it to closing marker \")\"\n\n  if (marker === 0x28) {\n    marker = 0x29;\n  }\n\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n\n    if (code === marker) {\n      result.pos = pos + 1;\n      result.lines = lines;\n      result.str = unescapeAll(str.slice(start + 1, pos));\n      result.ok = true;\n      return result;\n    } else if (code === 0x0A) {\n      lines++;\n    } else if (code === 0x5C\n    /* \\ */\n    && pos + 1 < max) {\n      pos++;\n\n      if (str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n\n    pos++;\n  }\n\n  return result;\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\nvar assign = require('./common/utils').assign;\n\nvar unescapeAll = require('./common/utils').unescapeAll;\n\nvar escapeHtml = require('./common/utils').escapeHtml; ////////////////////////////////////////////////////////////////////////////////\n\n\nvar default_rules = {};\n\ndefault_rules.code_inline = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n  return '<code' + slf.renderAttrs(token) + '>' + escapeHtml(tokens[idx].content) + '</code>';\n};\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n  return '<pre' + slf.renderAttrs(token) + '><code>' + escapeHtml(tokens[idx].content) + '</code></pre>\\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,\n      i,\n      tmpAttrs,\n      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  } // If language exists, inject class gently, without modifying 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\n\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][1] += ' ' + options.langPrefix + langName;\n    } // Fake token just to render attributes\n\n\n    tmpToken = {\n      attrs: tmpAttrs\n    };\n    return '<pre><code' + slf.renderAttrs(tmpToken) + '>' + highlighted + '</code></pre>\\n';\n  }\n\n  return '<pre><code' + slf.renderAttrs(token) + '>' + highlighted + '</code></pre>\\n';\n};\n\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx]; // \"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] = slf.renderInlineAsText(token.children, options, env);\n  return slf.renderToken(tokens, idx, options);\n};\n\ndefault_rules.hardbreak = function (tokens, idx, options\n/*, env */\n) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\n\ndefault_rules.softbreak = function (tokens, idx, options\n/*, env */\n) {\n  return options.breaks ? options.xhtmlOut ? '<br />\\n' : '<br>\\n' : '\\n';\n};\n\ndefault_rules.text = function (tokens, idx\n/*, options, env */\n) {\n  return escapeHtml(tokens[idx].content);\n};\n\ndefault_rules.html_block = function (tokens, idx\n/*, options, env */\n) {\n  return tokens[idx].content;\n};\n\ndefault_rules.html_inline = function (tokens, idx\n/*, options, env */\n) {\n  return tokens[idx].content;\n};\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\n\n\nfunction Renderer() {\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 independent 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 * Renderer.renderAttrs(token) -> String\n *\n * Render token attributes to string.\n **/\n\n\nRenderer.prototype.renderAttrs = function renderAttrs(token) {\n  var i, l, result;\n\n  if (!token.attrs) {\n    return '';\n  }\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 * 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 **/\n\n\nRenderer.prototype.renderToken = function renderToken(tokens, idx, options) {\n  var nextToken,\n      result = '',\n      needLf = false,\n      token = tokens[idx]; // Tight list paragraphs\n\n  if (token.hidden) {\n    return '';\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\n\n  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {\n    result += '\\n';\n  } // Add token name, e.g. `<img`\n\n\n  result += (token.nesting === -1 ? '</' : '<') + token.tag; // Encode attributes, e.g. `<img src=\"foo\"`\n\n  result += this.renderAttrs(token); // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n\n  if (token.nesting === 0 && options.xhtmlOut) {\n    result += ' /';\n  } // Check if we need to add a newline after this tag\n\n\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        } 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  return result;\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 **/\n\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/** 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 **/\n\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 * 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 **/\n\n\nRenderer.prototype.render = function (tokens, options, env) {\n  var i,\n      len,\n      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;","/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n'use strict';\n\nvar Ruler = require('./ruler');\n\nvar _rules = [['normalize', require('./rules_core/normalize')], ['block', require('./rules_core/block')], ['inline', require('./rules_core/inline')], ['linkify', require('./rules_core/linkify')], ['replacements', require('./rules_core/replacements')], ['smartquotes', require('./rules_core/smartquotes')]];\n/**\n * new Core()\n **/\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 * Core.process(state)\n *\n * Executes core chain rules.\n **/\n\n\nCore.prototype.process = function (state) {\n  var i, l, rules;\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');\nmodule.exports = Core;","// Normalize input string\n'use strict'; // https://spec.commonmark.org/0.29/#line-ending\n\nvar NEWLINES_RE = /\\r\\n?|\\n/g;\nvar NULL_RE = /\\0/g;\n\nmodule.exports = function normalize(state) {\n  var str; // Normalize newlines\n\n  str = state.src.replace(NEWLINES_RE, '\\n'); // Replace NULL characters\n\n  str = str.replace(NULL_RE, \"\\uFFFD\");\n  state.src = str;\n};","'use strict';\n\nmodule.exports = function block(state) {\n  var token;\n\n  if (state.inlineMode) {\n    token = new state.Token('inline', '', 0);\n    token.content = state.src;\n    token.map = [0, 1];\n    token.children = [];\n    state.tokens.push(token);\n  } else {\n    state.md.block.parse(state.src, state.md, state.env, state.tokens);\n  }\n};","'use strict';\n\nmodule.exports = function inline(state) {\n  var tokens = state.tokens,\n      tok,\n      i,\n      l; // Parse inlines\n\n  for (i = 0, l = tokens.length; i < l; i++) {\n    tok = tokens[i];\n\n    if (tok.type === 'inline') {\n      state.md.inline.parse(tok.content, state.md, state.env, tok.children);\n    }\n  }\n};","// Replace link-like texts with link nodes.\n//\n// Currently restricted by `md.validateLink()` to http/https/ftp\n//\n'use strict';\n\nvar arrayReplaceAt = require('../common/utils').arrayReplaceAt;\n\nfunction isLinkOpen(str) {\n  return /^<a[>\\s]/i.test(str);\n}\n\nfunction isLinkClose(str) {\n  return /^<\\/a\\s*>/i.test(str);\n}\n\nmodule.exports = function linkify(state) {\n  var i,\n      j,\n      l,\n      tokens,\n      token,\n      currentToken,\n      nodes,\n      ln,\n      text,\n      pos,\n      lastPos,\n      level,\n      htmlLinkLevel,\n      url,\n      fullUrl,\n      urlText,\n      blockTokens = state.tokens,\n      links;\n\n  if (!state.md.options.linkify) {\n    return;\n  }\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline' || !state.md.linkify.pretest(blockTokens[j].content)) {\n      continue;\n    }\n\n    tokens = blockTokens[j].children;\n    htmlLinkLevel = 0; // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n\n    for (i = tokens.length - 1; i >= 0; i--) {\n      currentToken = tokens[i]; // Skip content of markdown links\n\n      if (currentToken.type === 'link_close') {\n        i--;\n\n        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {\n          i--;\n        }\n\n        continue;\n      } // Skip content of html tag links\n\n\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {\n          htmlLinkLevel--;\n        }\n\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++;\n        }\n      }\n\n      if (htmlLinkLevel > 0) {\n        continue;\n      }\n\n      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {\n        text = currentToken.content;\n        links = state.md.linkify.match(text); // Now split string to nodes\n\n        nodes = [];\n        level = currentToken.level;\n        lastPos = 0;\n\n        for (ln = 0; ln < links.length; ln++) {\n          url = links[ln].url;\n          fullUrl = state.md.normalizeLink(url);\n\n          if (!state.md.validateLink(fullUrl)) {\n            continue;\n          }\n\n          urlText = links[ln].text; // Linkifier might send raw hostnames like \"example.com\", where url\n          // starts with domain name. So we prepend http:// in those cases,\n          // and remove it afterwards.\n          //\n\n          if (!links[ln].schema) {\n            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\\/\\//, '');\n          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {\n            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');\n          } else {\n            urlText = state.md.normalizeLinkText(urlText);\n          }\n\n          pos = links[ln].index;\n\n          if (pos > lastPos) {\n            token = new state.Token('text', '', 0);\n            token.content = text.slice(lastPos, pos);\n            token.level = level;\n            nodes.push(token);\n          }\n\n          token = new state.Token('link_open', 'a', 1);\n          token.attrs = [['href', fullUrl]];\n          token.level = level++;\n          token.markup = 'linkify';\n          token.info = 'auto';\n          nodes.push(token);\n          token = new state.Token('text', '', 0);\n          token.content = urlText;\n          token.level = level;\n          nodes.push(token);\n          token = new state.Token('link_close', 'a', -1);\n          token.level = --level;\n          token.markup = 'linkify';\n          token.info = 'auto';\n          nodes.push(token);\n          lastPos = links[ln].lastIndex;\n        }\n\n        if (lastPos < text.length) {\n          token = new state.Token('text', '', 0);\n          token.content = text.slice(lastPos);\n          token.level = level;\n          nodes.push(token);\n        } // replace current node\n\n\n        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);\n      }\n    }\n  }\n};","// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// (p) (P) -> §\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → &ndash;, --- → &mdash;\n//\n'use strict'; // TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - miltiplication 2 x 4 -> 2 × 4\n\nvar RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/; // Workaround for phantomjs - need regex without /g flag,\n// or root check will fail every second time\n\nvar SCOPED_ABBR_TEST_RE = /\\((c|tm|r|p)\\)/i;\nvar SCOPED_ABBR_RE = /\\((c|tm|r|p)\\)/ig;\nvar SCOPED_ABBR = {\n  c: '©',\n  r: '®',\n  p: '§',\n  tm: '™'\n};\n\nfunction replaceFn(match, name) {\n  return SCOPED_ABBR[name.toLowerCase()];\n}\n\nfunction replace_scoped(inlineTokens) {\n  var i,\n      token,\n      inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\nfunction replace_rare(inlineTokens) {\n  var i,\n      token,\n      inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content.replace(/\\+-/g, '±') // .., ..., ....... -> …\n        // but ?..... & !..... -> ?.. & !..\n        .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..').replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',') // em-dash\n        .replace(/(^|[^-])---([^-]|$)/mg, \"$1\\u2014$2\") // en-dash\n        .replace(/(^|\\s)--(\\s|$)/mg, \"$1\\u2013$2\").replace(/(^|[^-\\s])--([^-\\s]|$)/mg, \"$1\\u2013$2\");\n      }\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\nmodule.exports = function replace(state) {\n  var blkIdx;\n\n  if (!state.md.options.typographer) {\n    return;\n  }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline') {\n      continue;\n    }\n\n    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {\n      replace_scoped(state.tokens[blkIdx].children);\n    }\n\n    if (RARE_RE.test(state.tokens[blkIdx].content)) {\n      replace_rare(state.tokens[blkIdx].children);\n    }\n  }\n};","// Convert straight quotation marks to typographic ones\n//\n'use strict';\n\nvar isWhiteSpace = require('../common/utils').isWhiteSpace;\n\nvar isPunctChar = require('../common/utils').isPunctChar;\n\nvar isMdAsciiPunct = require('../common/utils').isMdAsciiPunct;\n\nvar QUOTE_TEST_RE = /['\"]/;\nvar QUOTE_RE = /['\"]/g;\nvar APOSTROPHE = \"\\u2019\";\n/* ’ */\n\nfunction replaceAt(str, index, ch) {\n  return str.substr(0, index) + ch + str.substr(index + 1);\n}\n\nfunction process_inlines(tokens, state) {\n  var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar, isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace, canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;\n  stack = [];\n\n  for (i = 0; i < tokens.length; i++) {\n    token = tokens[i];\n    thisLevel = tokens[i].level;\n\n    for (j = stack.length - 1; j >= 0; j--) {\n      if (stack[j].level <= thisLevel) {\n        break;\n      }\n    }\n\n    stack.length = j + 1;\n\n    if (token.type !== 'text') {\n      continue;\n    }\n\n    text = token.content;\n    pos = 0;\n    max = text.length;\n    /*eslint no-labels:0,block-scoped-var:0*/\n\n    OUTER: while (pos < max) {\n      QUOTE_RE.lastIndex = pos;\n      t = QUOTE_RE.exec(text);\n\n      if (!t) {\n        break;\n      }\n\n      canOpen = canClose = true;\n      pos = t.index + 1;\n      isSingle = t[0] === \"'\"; // Find previous character,\n      // default to space if it's the beginning of the line\n      //\n\n      lastChar = 0x20;\n\n      if (t.index - 1 >= 0) {\n        lastChar = text.charCodeAt(t.index - 1);\n      } else {\n        for (j = i - 1; j >= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20\n\n          if (tokens[j].type !== 'text') continue;\n          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);\n          break;\n        }\n      } // Find next character,\n      // default to space if it's the end of the line\n      //\n\n\n      nextChar = 0x20;\n\n      if (pos < max) {\n        nextChar = text.charCodeAt(pos);\n      } else {\n        for (j = i + 1; j < tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20\n\n          if (tokens[j].type !== 'text') continue;\n          nextChar = tokens[j].content.charCodeAt(0);\n          break;\n        }\n      }\n\n      isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n      isLastWhiteSpace = isWhiteSpace(lastChar);\n      isNextWhiteSpace = isWhiteSpace(nextChar);\n\n      if (isNextWhiteSpace) {\n        canOpen = false;\n      } else if (isNextPunctChar) {\n        if (!(isLastWhiteSpace || isLastPunctChar)) {\n          canOpen = false;\n        }\n      }\n\n      if (isLastWhiteSpace) {\n        canClose = false;\n      } else if (isLastPunctChar) {\n        if (!(isNextWhiteSpace || isNextPunctChar)) {\n          canClose = false;\n        }\n      }\n\n      if (nextChar === 0x22\n      /* \" */\n      && t[0] === '\"') {\n        if (lastChar >= 0x30\n        /* 0 */\n        && lastChar <= 0x39\n        /* 9 */\n        ) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false;\n        }\n      }\n\n      if (canOpen && canClose) {\n        // treat this as the middle of the word\n        canOpen = false;\n        canClose = isNextPunctChar;\n      }\n\n      if (!canOpen && !canClose) {\n        // middle of word\n        if (isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\n        }\n\n        continue;\n      }\n\n      if (canClose) {\n        // this could be a closing quote, rewind the stack to get a match\n        for (j = stack.length - 1; j >= 0; j--) {\n          item = stack[j];\n\n          if (stack[j].level < thisLevel) {\n            break;\n          }\n\n          if (item.single === isSingle && stack[j].level === thisLevel) {\n            item = stack[j];\n\n            if (isSingle) {\n              openQuote = state.md.options.quotes[2];\n              closeQuote = state.md.options.quotes[3];\n            } else {\n              openQuote = state.md.options.quotes[0];\n              closeQuote = state.md.options.quotes[1];\n            } // replace token.content *before* tokens[item.token].content,\n            // because, if they are pointing at the same token, replaceAt\n            // could mess up indices when quote length != 1\n\n\n            token.content = replaceAt(token.content, t.index, closeQuote);\n            tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, openQuote);\n            pos += closeQuote.length - 1;\n\n            if (item.token === i) {\n              pos += openQuote.length - 1;\n            }\n\n            text = token.content;\n            max = text.length;\n            stack.length = j;\n            continue OUTER;\n          }\n        }\n      }\n\n      if (canOpen) {\n        stack.push({\n          token: i,\n          pos: t.index,\n          single: isSingle,\n          level: thisLevel\n        });\n      } else if (canClose && isSingle) {\n        token.content = replaceAt(token.content, t.index, APOSTROPHE);\n      }\n    }\n  }\n}\n\nmodule.exports = function smartquotes(state) {\n  /*eslint max-depth:0*/\n  var blkIdx;\n\n  if (!state.md.options.typographer) {\n    return;\n  }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline' || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {\n      continue;\n    }\n\n    process_inlines(state.tokens[blkIdx].children, state);\n  }\n};","// Core state object\n//\n'use strict';\n\nvar Token = require('../token');\n\nfunction StateCore(src, md, env) {\n  this.src = src;\n  this.env = env;\n  this.tokens = [];\n  this.inlineMode = false;\n  this.md = md; // link to parser instance\n} // re-export Token class to use in core rules\n\n\nStateCore.prototype.Token = Token;\nmodule.exports = StateCore;","/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n'use strict';\n\nvar Ruler = require('./ruler');\n\nvar _rules = [// 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']], ['code', require('./rules_block/code')], ['fence', require('./rules_block/fence'), ['paragraph', 'reference', 'blockquote', 'list']], ['blockquote', require('./rules_block/blockquote'), ['paragraph', 'reference', 'blockquote', 'list']], ['hr', require('./rules_block/hr'), ['paragraph', 'reference', 'blockquote', 'list']], ['list', require('./rules_block/list'), ['paragraph', 'reference', 'blockquote']], ['reference', require('./rules_block/reference')], ['heading', require('./rules_block/heading'), ['paragraph', 'reference', 'blockquote']], ['lheading', require('./rules_block/lheading')], ['html_block', require('./rules_block/html_block'), ['paragraph', 'reference', 'blockquote']], ['paragraph', require('./rules_block/paragraph')]];\n/**\n * new ParserBlock()\n **/\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], {\n      alt: (_rules[i][2] || []).slice()\n    });\n  }\n} // Generate tokens for input range\n//\n\n\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var ok,\n      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\n    if (line >= endLine) {\n      break;\n    } // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n\n\n    if (state.sCount[line] < state.blkIndent) {\n      break;\n    } // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n\n\n    if (state.level >= maxNesting) {\n      state.line = endLine;\n      break;\n    } // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n\n\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n\n      if (ok) {\n        break;\n      }\n    } // set state.tight if we had an empty line before current tag\n    // i.e. latest empty line should not count\n\n\n    state.tight = !hasEmptyLines; // paragraph might \"eat\" one newline after it in nested lists\n\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      state.line = line;\n    }\n  }\n};\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\n\n\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  var state;\n\n  if (!src) {\n    return;\n  }\n\n  state = new this.State(src, md, env, outTokens);\n  this.tokenize(state, state.line, state.lineMax);\n};\n\nParserBlock.prototype.State = require('./rules_block/state_block');\nmodule.exports = ParserBlock;","// GFM table, non-standard\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nfunction getLine(state, line) {\n  var pos = state.bMarks[line] + state.blkIndent,\n      max = state.eMarks[line];\n  return state.src.substr(pos, max - pos);\n}\n\nfunction escapedSplit(str) {\n  var result = [],\n      pos = 0,\n      max = str.length,\n      ch,\n      escapes = 0,\n      lastPos = 0,\n      backTicked = false,\n      lastBackTick = 0;\n  ch = str.charCodeAt(pos);\n\n  while (pos < max) {\n    if (ch === 0x60\n    /* ` */\n    ) {\n      if (backTicked) {\n        // make \\` close code sequence, but not open it;\n        // the reason is: `\\` is correct code block\n        backTicked = false;\n        lastBackTick = pos;\n      } else if (escapes % 2 === 0) {\n        backTicked = true;\n        lastBackTick = pos;\n      }\n    } else if (ch === 0x7c\n    /* | */\n    && escapes % 2 === 0 && !backTicked) {\n      result.push(str.substring(lastPos, pos));\n      lastPos = pos + 1;\n    }\n\n    if (ch === 0x5c\n    /* \\ */\n    ) {\n      escapes++;\n    } else {\n      escapes = 0;\n    }\n\n    pos++; // If there was an un-closed backtick, go back to just after\n    // the last backtick, but as if it was a normal character\n\n    if (pos === max && backTicked) {\n      backTicked = false;\n      pos = lastBackTick + 1;\n    }\n\n    ch = str.charCodeAt(pos);\n  }\n\n  result.push(str.substring(lastPos));\n  return result;\n}\n\nmodule.exports = function table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, nextLine, columns, columnCount, token, aligns, t, tableLines, tbodyLines; // should have at least two lines\n\n  if (startLine + 2 > endLine) {\n    return false;\n  }\n\n  nextLine = startLine + 1;\n\n  if (state.sCount[nextLine] < state.blkIndent) {\n    return false;\n  } // if it's indented more than 3 spaces, it should be a code block\n\n\n  if (state.sCount[nextLine] - state.blkIndent >= 4) {\n    return false;\n  } // first character of the second line should be '|', '-', ':',\n  // and no other characters are allowed but spaces;\n  // basically, this is the equivalent of /^[-:|][-:|\\s]*$/ regexp\n\n\n  pos = state.bMarks[nextLine] + state.tShift[nextLine];\n\n  if (pos >= state.eMarks[nextLine]) {\n    return false;\n  }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch !== 0x7C\n  /* | */\n  && ch !== 0x2D\n  /* - */\n  && ch !== 0x3A\n  /* : */\n  ) {\n    return false;\n  }\n\n  while (pos < state.eMarks[nextLine]) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch !== 0x7C\n    /* | */\n    && ch !== 0x2D\n    /* - */\n    && ch !== 0x3A\n    /* : */\n    && !isSpace(ch)) {\n      return false;\n    }\n\n    pos++;\n  }\n\n  lineText = getLine(state, startLine + 1);\n  columns = lineText.split('|');\n  aligns = [];\n\n  for (i = 0; i < columns.length; i++) {\n    t = columns[i].trim();\n\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === columns.length - 1) {\n        continue;\n      } else {\n        return false;\n      }\n    }\n\n    if (!/^:?-+:?$/.test(t)) {\n      return false;\n    }\n\n    if (t.charCodeAt(t.length - 1) === 0x3A\n    /* : */\n    ) {\n      aligns.push(t.charCodeAt(0) === 0x3A\n      /* : */\n      ? 'center' : 'right');\n    } else if (t.charCodeAt(0) === 0x3A\n    /* : */\n    ) {\n      aligns.push('left');\n    } else {\n      aligns.push('');\n    }\n  }\n\n  lineText = getLine(state, startLine).trim();\n\n  if (lineText.indexOf('|') === -1) {\n    return false;\n  }\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  columns = escapedSplit(lineText.replace(/^\\||\\|$/g, '')); // header row will define an amount of columns in the entire table,\n  // and align row shouldn't be smaller than that (the rest of the rows can)\n\n  columnCount = columns.length;\n\n  if (columnCount > aligns.length) {\n    return false;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  token = state.push('table_open', 'table', 1);\n  token.map = tableLines = [startLine, 0];\n  token = state.push('thead_open', 'thead', 1);\n  token.map = [startLine, startLine + 1];\n  token = state.push('tr_open', 'tr', 1);\n  token.map = [startLine, startLine + 1];\n\n  for (i = 0; i < columns.length; i++) {\n    token = state.push('th_open', 'th', 1);\n    token.map = [startLine, startLine + 1];\n\n    if (aligns[i]) {\n      token.attrs = [['style', 'text-align:' + aligns[i]]];\n    }\n\n    token = state.push('inline', '', 0);\n    token.content = columns[i].trim();\n    token.map = [startLine, startLine + 1];\n    token.children = [];\n    token = state.push('th_close', 'th', -1);\n  }\n\n  token = state.push('tr_close', 'tr', -1);\n  token = state.push('thead_close', 'thead', -1);\n  token = state.push('tbody_open', 'tbody', 1);\n  token.map = tbodyLines = [startLine + 2, 0];\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.sCount[nextLine] < state.blkIndent) {\n      break;\n    }\n\n    lineText = getLine(state, nextLine).trim();\n\n    if (lineText.indexOf('|') === -1) {\n      break;\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      break;\n    }\n\n    columns = escapedSplit(lineText.replace(/^\\||\\|$/g, ''));\n    token = state.push('tr_open', 'tr', 1);\n\n    for (i = 0; i < columnCount; i++) {\n      token = state.push('td_open', 'td', 1);\n\n      if (aligns[i]) {\n        token.attrs = [['style', 'text-align:' + aligns[i]]];\n      }\n\n      token = state.push('inline', '', 0);\n      token.content = columns[i] ? columns[i].trim() : '';\n      token.children = [];\n      token = state.push('td_close', 'td', -1);\n    }\n\n    token = state.push('tr_close', 'tr', -1);\n  }\n\n  token = state.push('tbody_close', 'tbody', -1);\n  token = state.push('table_close', 'table', -1);\n  tableLines[1] = tbodyLines[1] = nextLine;\n  state.line = nextLine;\n  return true;\n};","// Code block (4 spaces padded)\n'use strict';\n\nmodule.exports = function code(state, startLine, endLine\n/*, silent*/\n) {\n  var nextLine, last, token;\n\n  if (state.sCount[startLine] - state.blkIndent < 4) {\n    return false;\n  }\n\n  last = nextLine = startLine + 1;\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n\n    break;\n  }\n\n  state.line = last;\n  token = state.push('code_block', 'code', 0);\n  token.content = state.getLines(startLine, last, 4 + state.blkIndent, true);\n  token.map = [startLine, state.line];\n  return true;\n};","// fences (``` lang, ~~~ lang)\n'use strict';\n\nmodule.exports = function fence(state, startLine, endLine, silent) {\n  var marker,\n      len,\n      params,\n      nextLine,\n      mem,\n      token,\n      markup,\n      haveEndMarker = false,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  if (pos + 3 > max) {\n    return false;\n  }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x7E\n  /* ~ */\n  && marker !== 0x60\n  /* ` */\n  ) {\n    return false;\n  } // scan marker length\n\n\n  mem = pos;\n  pos = state.skipChars(pos, marker);\n  len = pos - mem;\n\n  if (len < 3) {\n    return false;\n  }\n\n  markup = state.src.slice(mem, pos);\n  params = state.src.slice(pos, max);\n\n  if (marker === 0x60\n  /* ` */\n  ) {\n    if (params.indexOf(String.fromCharCode(marker)) >= 0) {\n      return false;\n    }\n  } // Since start is found, we can report success here in validation mode\n\n\n  if (silent) {\n    return true;\n  } // search end of block\n\n\n  nextLine = startLine;\n\n  for (;;) {\n    nextLine++;\n\n    if (nextLine >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break;\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos < max && state.sCount[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break;\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) {\n      continue;\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n\n    pos = state.skipChars(pos, marker); // closing code fence must be at least as long as the opening one\n\n    if (pos - mem < len) {\n      continue;\n    } // make sure tail has spaces only\n\n\n    pos = state.skipSpaces(pos);\n\n    if (pos < max) {\n      continue;\n    }\n\n    haveEndMarker = true; // found!\n\n    break;\n  } // If a fence has heading spaces, they should be removed from its inner block\n\n\n  len = state.sCount[startLine];\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n  token = state.push('fence', 'code', 0);\n  token.info = params;\n  token.content = state.getLines(startLine + 1, nextLine, len, true);\n  token.markup = markup;\n  token.map = [startLine, state.line];\n  return true;\n};","// Block quotes\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nmodule.exports = function blockquote(state, startLine, endLine, silent) {\n  var adjustTab,\n      ch,\n      i,\n      initial,\n      l,\n      lastLineEmpty,\n      lines,\n      nextLine,\n      offset,\n      oldBMarks,\n      oldBSCount,\n      oldIndent,\n      oldParentType,\n      oldSCount,\n      oldTShift,\n      spaceAfterMarker,\n      terminate,\n      terminatorRules,\n      token,\n      wasOutdented,\n      oldLineMax = state.lineMax,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  } // check the block quote marker\n\n\n  if (state.src.charCodeAt(pos++) !== 0x3E\n  /* > */\n  ) {\n    return false;\n  } // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n\n\n  if (silent) {\n    return true;\n  } // skip spaces after \">\" and re-calculate offset\n\n\n  initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]); // skip one optional space after '>'\n\n  if (state.src.charCodeAt(pos) === 0x20\n  /* space */\n  ) {\n    // ' >   test '\n    //     ^ -- position start of line here:\n    pos++;\n    initial++;\n    offset++;\n    adjustTab = false;\n    spaceAfterMarker = true;\n  } else if (state.src.charCodeAt(pos) === 0x09\n  /* tab */\n  ) {\n    spaceAfterMarker = true;\n\n    if ((state.bsCount[startLine] + offset) % 4 === 3) {\n      // '  >\\t  test '\n      //       ^ -- position start of line here (tab has width===1)\n      pos++;\n      initial++;\n      offset++;\n      adjustTab = false;\n    } else {\n      // ' >\\t  test '\n      //    ^ -- position start of line here + shift bsCount slightly\n      //         to make extra space appear\n      adjustTab = true;\n    }\n  } else {\n    spaceAfterMarker = false;\n  }\n\n  oldBMarks = [state.bMarks[startLine]];\n  state.bMarks[startLine] = pos;\n\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (isSpace(ch)) {\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;\n      } else {\n        offset++;\n      }\n    } else {\n      break;\n    }\n\n    pos++;\n  }\n\n  oldBSCount = [state.bsCount[startLine]];\n  state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);\n  lastLineEmpty = pos >= max;\n  oldSCount = [state.sCount[startLine]];\n  state.sCount[startLine] = offset - initial;\n  oldTShift = [state.tShift[startLine]];\n  state.tShift[startLine] = pos - state.bMarks[startLine];\n  terminatorRules = state.md.block.ruler.getRules('blockquote');\n  oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n  wasOutdented = false; // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n\n  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    > current blockquote\n    // 2. checking this line\n    // ```\n    if (state.sCount[nextLine] < state.blkIndent) wasOutdented = true;\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E\n    /* > */\n    && !wasOutdented) {\n      // This line is inside the blockquote.\n      // skip spaces after \">\" and re-calculate offset\n      initial = offset = state.sCount[nextLine] + pos - (state.bMarks[nextLine] + state.tShift[nextLine]); // skip one optional space after '>'\n\n      if (state.src.charCodeAt(pos) === 0x20\n      /* space */\n      ) {\n        // ' >   test '\n        //     ^ -- position start of line here:\n        pos++;\n        initial++;\n        offset++;\n        adjustTab = false;\n        spaceAfterMarker = true;\n      } else if (state.src.charCodeAt(pos) === 0x09\n      /* tab */\n      ) {\n        spaceAfterMarker = true;\n\n        if ((state.bsCount[nextLine] + offset) % 4 === 3) {\n          // '  >\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++;\n          initial++;\n          offset++;\n          adjustTab = false;\n        } else {\n          // ' >\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true;\n        }\n      } else {\n        spaceAfterMarker = false;\n      }\n\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n\n      while (pos < max) {\n        ch = state.src.charCodeAt(pos);\n\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;\n          } else {\n            offset++;\n          }\n        } else {\n          break;\n        }\n\n        pos++;\n      }\n\n      lastLineEmpty = pos >= max;\n      oldBSCount.push(state.bsCount[nextLine]);\n      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);\n      oldSCount.push(state.sCount[nextLine]);\n      state.sCount[nextLine] = offset - initial;\n      oldTShift.push(state.tShift[nextLine]);\n      state.tShift[nextLine] = pos - state.bMarks[nextLine];\n      continue;\n    } // Case 2: line is not inside the blockquote, and the last line was empty.\n\n\n    if (lastLineEmpty) {\n      break;\n    } // Case 3: another tag found.\n\n\n    terminate = false;\n\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      // Quirk to enforce \"hard termination mode\" for paragraphs;\n      // normally if you call `tokenize(state, startLine, nextLine)`,\n      // paragraphs will look below nextLine for paragraph continuation,\n      // but if blockquote is terminated by another tag, they shouldn't\n      state.lineMax = nextLine;\n\n      if (state.blkIndent !== 0) {\n        // state.blkIndent was non-zero, we now set it to zero,\n        // so we need to re-calculate all offsets to appear as\n        // if indent wasn't changed\n        oldBMarks.push(state.bMarks[nextLine]);\n        oldBSCount.push(state.bsCount[nextLine]);\n        oldTShift.push(state.tShift[nextLine]);\n        oldSCount.push(state.sCount[nextLine]);\n        state.sCount[nextLine] -= state.blkIndent;\n      }\n\n      break;\n    }\n\n    oldBMarks.push(state.bMarks[nextLine]);\n    oldBSCount.push(state.bsCount[nextLine]);\n    oldTShift.push(state.tShift[nextLine]);\n    oldSCount.push(state.sCount[nextLine]); // A negative indentation means that this is a paragraph continuation\n    //\n\n    state.sCount[nextLine] = -1;\n  }\n\n  oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n  token = state.push('blockquote_open', 'blockquote', 1);\n  token.markup = '>';\n  token.map = lines = [startLine, 0];\n  state.md.block.tokenize(state, startLine, nextLine);\n  token = state.push('blockquote_close', 'blockquote', -1);\n  token.markup = '>';\n  state.lineMax = oldLineMax;\n  state.parentType = oldParentType;\n  lines[1] = state.line; // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n\n  for (i = 0; i < oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i];\n    state.tShift[i + startLine] = oldTShift[i];\n    state.sCount[i + startLine] = oldSCount[i];\n    state.bsCount[i + startLine] = oldBSCount[i];\n  }\n\n  state.blkIndent = oldIndent;\n  return true;\n};","// Horizontal rule\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nmodule.exports = function hr(state, startLine, endLine, silent) {\n  var marker,\n      cnt,\n      ch,\n      token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  marker = state.src.charCodeAt(pos++); // Check hr marker\n\n  if (marker !== 0x2A\n  /* * */\n  && marker !== 0x2D\n  /* - */\n  && marker !== 0x5F\n  /* _ */\n  ) {\n    return false;\n  } // markers can be mixed with spaces, but there should be at least 3 of them\n\n\n  cnt = 1;\n\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch !== marker && !isSpace(ch)) {\n      return false;\n    }\n\n    if (ch === marker) {\n      cnt++;\n    }\n  }\n\n  if (cnt < 3) {\n    return false;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  state.line = startLine + 1;\n  token = state.push('hr', 'hr', 0);\n  token.map = [startLine, state.line];\n  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));\n  return true;\n};","// Lists\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace; // Search `[-+*][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\n\n\nfunction skipBulletListMarker(state, startLine) {\n  var marker, pos, max, ch;\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  max = state.eMarks[startLine];\n  marker = state.src.charCodeAt(pos++); // Check bullet\n\n  if (marker !== 0x2A\n  /* * */\n  && marker !== 0x2D\n  /* - */\n  && marker !== 0x2B\n  /* + */\n  ) {\n    return -1;\n  }\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      // \" -test \" - is not a list item\n      return -1;\n    }\n  }\n\n  return pos;\n} // Search `\\d+[.)][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\n\n\nfunction skipOrderedListMarker(state, startLine) {\n  var ch,\n      start = state.bMarks[startLine] + state.tShift[startLine],\n      pos = start,\n      max = state.eMarks[startLine]; // List marker should have at least 2 chars (digit + dot)\n\n  if (pos + 1 >= max) {\n    return -1;\n  }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch < 0x30\n  /* 0 */\n  || ch > 0x39\n  /* 9 */\n  ) {\n    return -1;\n  }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) {\n      return -1;\n    }\n\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch >= 0x30\n    /* 0 */\n    && ch <= 0x39\n    /* 9 */\n    ) {\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start >= 10) {\n        return -1;\n      }\n\n      continue;\n    } // found valid marker\n\n\n    if (ch === 0x29\n    /* ) */\n    || ch === 0x2e\n    /* . */\n    ) {\n      break;\n    }\n\n    return -1;\n  }\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      // \" 1.test \" - is not a list item\n      return -1;\n    }\n  }\n\n  return pos;\n}\n\nfunction markTightParagraphs(state, idx) {\n  var i,\n      l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true;\n      state.tokens[i].hidden = true;\n      i += 2;\n    }\n  }\n}\n\nmodule.exports = function list(state, startLine, endLine, silent) {\n  var ch,\n      contentStart,\n      i,\n      indent,\n      indentAfterMarker,\n      initial,\n      isOrdered,\n      itemLines,\n      l,\n      listLines,\n      listTokIdx,\n      markerCharCode,\n      markerValue,\n      max,\n      nextLine,\n      offset,\n      oldListIndent,\n      oldParentType,\n      oldSCount,\n      oldTShift,\n      oldTight,\n      pos,\n      posAfterMarker,\n      prevEmptyEnd,\n      start,\n      terminate,\n      terminatorRules,\n      token,\n      isTerminatingParagraph = false,\n      tight = true; // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  } // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n\n\n  if (state.listIndent >= 0 && state.sCount[startLine] - state.listIndent >= 4 && state.sCount[startLine] < state.blkIndent) {\n    return false;\n  } // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n\n\n  if (silent && state.parentType === 'paragraph') {\n    // Next list item should still terminate previous list item;\n    //\n    // This code can fail if plugins use blkIndent as well as lists,\n    // but I hope the spec gets fixed long before that happens.\n    //\n    if (state.tShift[startLine] >= state.blkIndent) {\n      isTerminatingParagraph = true;\n    }\n  } // Detect list type and position after marker\n\n\n  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {\n    isOrdered = true;\n    start = state.bMarks[startLine] + state.tShift[startLine];\n    markerValue = Number(state.src.substr(start, posAfterMarker - start - 1)); // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n\n    if (isTerminatingParagraph && markerValue !== 1) return false;\n  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {\n    isOrdered = false;\n  } else {\n    return false;\n  } // If we're starting a new unordered list right after\n  // a paragraph, first line should not be empty.\n\n\n  if (isTerminatingParagraph) {\n    if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine]) return false;\n  } // We should terminate list on style change. Remember first one to compare.\n\n\n  markerCharCode = state.src.charCodeAt(posAfterMarker - 1); // For validation mode we can terminate immediately\n\n  if (silent) {\n    return true;\n  } // Start list\n\n\n  listTokIdx = state.tokens.length;\n\n  if (isOrdered) {\n    token = state.push('ordered_list_open', 'ol', 1);\n\n    if (markerValue !== 1) {\n      token.attrs = [['start', markerValue]];\n    }\n  } else {\n    token = state.push('bullet_list_open', 'ul', 1);\n  }\n\n  token.map = listLines = [startLine, 0];\n  token.markup = String.fromCharCode(markerCharCode); //\n  // Iterate list items\n  //\n\n  nextLine = startLine;\n  prevEmptyEnd = false;\n  terminatorRules = state.md.block.ruler.getRules('list');\n  oldParentType = state.parentType;\n  state.parentType = 'list';\n\n  while (nextLine < endLine) {\n    pos = posAfterMarker;\n    max = state.eMarks[nextLine];\n    initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);\n\n    while (pos < max) {\n      ch = state.src.charCodeAt(pos);\n\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[nextLine]) % 4;\n      } else if (ch === 0x20) {\n        offset++;\n      } else {\n        break;\n      }\n\n      pos++;\n    }\n\n    contentStart = pos;\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = offset - initial;\n    } // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n\n\n    if (indentAfterMarker > 4) {\n      indentAfterMarker = 1;\n    } // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n\n\n    indent = initial + indentAfterMarker; // Run subparser & write tokens\n\n    token = state.push('list_item_open', 'li', 1);\n    token.markup = String.fromCharCode(markerCharCode);\n    token.map = itemLines = [startLine, 0]; // change current state, then restore it after parser subcall\n\n    oldTight = state.tight;\n    oldTShift = state.tShift[startLine];\n    oldSCount = state.sCount[startLine]; //  - example list\n    // ^ listIndent position will be here\n    //   ^ blkIndent position will be here\n    //\n\n    oldListIndent = state.listIndent;\n    state.listIndent = state.blkIndent;\n    state.blkIndent = indent;\n    state.tight = true;\n    state.tShift[startLine] = contentStart - state.bMarks[startLine];\n    state.sCount[startLine] = offset;\n\n    if (contentStart >= max && state.isEmpty(startLine + 1)) {\n      // workaround for this case\n      // (list item is empty, list terminates before \"foo\"):\n      // ~~~~~~~~\n      //   -\n      //\n      //     foo\n      // ~~~~~~~~\n      state.line = Math.min(state.line + 2, endLine);\n    } else {\n      state.md.block.tokenize(state, startLine, endLine, true);\n    } // If any of list item is tight, mark list as tight\n\n\n    if (!state.tight || prevEmptyEnd) {\n      tight = false;\n    } // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n\n\n    prevEmptyEnd = state.line - startLine > 1 && state.isEmpty(state.line - 1);\n    state.blkIndent = state.listIndent;\n    state.listIndent = oldListIndent;\n    state.tShift[startLine] = oldTShift;\n    state.sCount[startLine] = oldSCount;\n    state.tight = oldTight;\n    token = state.push('list_item_close', 'li', -1);\n    token.markup = String.fromCharCode(markerCharCode);\n    nextLine = startLine = state.line;\n    itemLines[1] = nextLine;\n    contentStart = state.bMarks[startLine];\n\n    if (nextLine >= endLine) {\n      break;\n    } //\n    // Try to check if list is terminated or continued.\n    //\n\n\n    if (state.sCount[nextLine] < state.blkIndent) {\n      break;\n    } // if it's indented more than 3 spaces, it should be a code block\n\n\n    if (state.sCount[startLine] - state.blkIndent >= 4) {\n      break;\n    } // fail if terminating block found\n\n\n    terminate = false;\n\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      break;\n    } // fail if list has another type\n\n\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n\n      if (posAfterMarker < 0) {\n        break;\n      }\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n\n      if (posAfterMarker < 0) {\n        break;\n      }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {\n      break;\n    }\n  } // Finalize list\n\n\n  if (isOrdered) {\n    token = state.push('ordered_list_close', 'ol', -1);\n  } else {\n    token = state.push('bullet_list_close', 'ul', -1);\n  }\n\n  token.markup = String.fromCharCode(markerCharCode);\n  listLines[1] = nextLine;\n  state.line = nextLine;\n  state.parentType = oldParentType; // mark paragraphs tight if needed\n\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n};","'use strict';\n\nvar normalizeReference = require('../common/utils').normalizeReference;\n\nvar isSpace = require('../common/utils').isSpace;\n\nmodule.exports = function reference(state, startLine, _endLine, silent) {\n  var ch,\n      destEndPos,\n      destEndLineNo,\n      endLine,\n      href,\n      i,\n      l,\n      label,\n      labelEnd,\n      oldParentType,\n      res,\n      start,\n      str,\n      terminate,\n      terminatorRules,\n      title,\n      lines = 0,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine],\n      nextLine = startLine + 1; // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(pos) !== 0x5B\n  /* [ */\n  ) {\n    return false;\n  } // Simple check to quickly interrupt scan on [link](url) at the start of line.\n  // Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54\n\n\n  while (++pos < max) {\n    if (state.src.charCodeAt(pos) === 0x5D\n    /* ] */\n    && state.src.charCodeAt(pos - 1) !== 0x5C\n    /* \\ */\n    ) {\n      if (pos + 1 === max) {\n        return false;\n      }\n\n      if (state.src.charCodeAt(pos + 1) !== 0x3A\n      /* : */\n      ) {\n        return false;\n      }\n\n      break;\n    }\n  }\n\n  endLine = state.lineMax; // jump line-by-line until empty one or EOF\n\n  terminatorRules = state.md.block.ruler.getRules('reference');\n  oldParentType = state.parentType;\n  state.parentType = 'reference';\n\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) {\n      continue;\n    } // quirk for blockquotes, this line should already be checked by that rule\n\n\n    if (state.sCount[nextLine] < 0) {\n      continue;\n    } // Some tags can terminate paragraph without empty line.\n\n\n    terminate = false;\n\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      break;\n    }\n  }\n\n  str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  max = str.length;\n\n  for (pos = 1; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n\n    if (ch === 0x5B\n    /* [ */\n    ) {\n      return false;\n    } else if (ch === 0x5D\n    /* ] */\n    ) {\n      labelEnd = pos;\n      break;\n    } else if (ch === 0x0A\n    /* \\n */\n    ) {\n      lines++;\n    } else if (ch === 0x5C\n    /* \\ */\n    ) {\n      pos++;\n\n      if (pos < max && str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n  }\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A\n  /* : */\n  ) {\n    return false;\n  } // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n\n\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  } // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n\n\n  res = state.md.helpers.parseLinkDestination(str, pos, max);\n\n  if (!res.ok) {\n    return false;\n  }\n\n  href = state.md.normalizeLink(res.str);\n\n  if (!state.md.validateLink(href)) {\n    return false;\n  }\n\n  pos = res.pos;\n  lines += res.lines; // save cursor state, we could require to rollback later\n\n  destEndPos = pos;\n  destEndLineNo = lines; // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n\n  start = pos;\n\n  for (; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  } // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n\n\n  res = state.md.helpers.parseLinkTitle(str, pos, max);\n\n  if (pos < max && start !== pos && res.ok) {\n    title = res.str;\n    pos = res.pos;\n    lines += res.lines;\n  } else {\n    title = '';\n    pos = destEndPos;\n    lines = destEndLineNo;\n  } // skip trailing spaces until the rest of the line\n\n\n  while (pos < max) {\n    ch = str.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      break;\n    }\n\n    pos++;\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = '';\n      pos = destEndPos;\n      lines = destEndLineNo;\n\n      while (pos < max) {\n        ch = str.charCodeAt(pos);\n\n        if (!isSpace(ch)) {\n          break;\n        }\n\n        pos++;\n      }\n    }\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false;\n  }\n\n  label = normalizeReference(str.slice(1, labelEnd));\n\n  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false;\n  } // Reference can not terminate anything. This check is for safety only.\n\n  /*istanbul ignore if*/\n\n\n  if (silent) {\n    return true;\n  }\n\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {};\n  }\n\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = {\n      title: title,\n      href: href\n    };\n  }\n\n  state.parentType = oldParentType;\n  state.line = startLine + lines + 1;\n  return true;\n};","// heading (#, ##, ...)\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nmodule.exports = function heading(state, startLine, endLine, silent) {\n  var ch,\n      level,\n      tmp,\n      token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x23\n  /* # */\n  || pos >= max) {\n    return false;\n  } // count heading level\n\n\n  level = 1;\n  ch = state.src.charCodeAt(++pos);\n\n  while (ch === 0x23\n  /* # */\n  && pos < max && level <= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n\n  if (level > 6 || pos < max && !isSpace(ch)) {\n    return false;\n  }\n\n  if (silent) {\n    return true;\n  } // Let's cut tails like '    ###  ' from the end of string\n\n\n  max = state.skipSpacesBack(max, pos);\n  tmp = state.skipCharsBack(max, 0x23, pos); // #\n\n  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp;\n  }\n\n  state.line = startLine + 1;\n  token = state.push('heading_open', 'h' + String(level), 1);\n  token.markup = '########'.slice(0, level);\n  token.map = [startLine, state.line];\n  token = state.push('inline', '', 0);\n  token.content = state.src.slice(pos, max).trim();\n  token.map = [startLine, state.line];\n  token.children = [];\n  token = state.push('heading_close', 'h' + String(level), -1);\n  token.markup = '########'.slice(0, level);\n  return true;\n};","// lheading (---, ===)\n'use strict';\n\nmodule.exports = function lheading(state, startLine, endLine\n/*, silent*/\n) {\n  var content,\n      terminate,\n      i,\n      l,\n      token,\n      pos,\n      max,\n      level,\n      marker,\n      nextLine = startLine + 1,\n      oldParentType,\n      terminatorRules = state.md.block.ruler.getRules('paragraph'); // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph'; // use paragraph to match terminatorRules\n  // jump line-by-line until empty one or EOF\n\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) {\n      continue;\n    } //\n    // Check for underline in setext header\n    //\n\n\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n\n      if (pos < max) {\n        marker = state.src.charCodeAt(pos);\n\n        if (marker === 0x2D\n        /* - */\n        || marker === 0x3D\n        /* = */\n        ) {\n          pos = state.skipChars(pos, marker);\n          pos = state.skipSpaces(pos);\n\n          if (pos >= max) {\n            level = marker === 0x3D\n            /* = */\n            ? 1 : 2;\n            break;\n          }\n        }\n      }\n    } // quirk for blockquotes, this line should already be checked by that rule\n\n\n    if (state.sCount[nextLine] < 0) {\n      continue;\n    } // Some tags can terminate paragraph without empty line.\n\n\n    terminate = false;\n\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      break;\n    }\n  }\n\n  if (!level) {\n    // Didn't find valid underline\n    return false;\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  state.line = nextLine + 1;\n  token = state.push('heading_open', 'h' + String(level), 1);\n  token.markup = String.fromCharCode(marker);\n  token.map = [startLine, state.line];\n  token = state.push('inline', '', 0);\n  token.content = content;\n  token.map = [startLine, state.line - 1];\n  token.children = [];\n  token = state.push('heading_close', 'h' + String(level), -1);\n  token.markup = String.fromCharCode(marker);\n  state.parentType = oldParentType;\n  return true;\n};","// HTML block\n'use strict';\n\nvar block_names = require('../common/html_blocks');\n\nvar HTML_OPEN_CLOSE_TAG_RE = require('../common/html_re').HTML_OPEN_CLOSE_TAG_RE; // An array of opening and corresponding closing sequences for html tags,\n// last argument defines whether it can terminate a paragraph or not\n//\n\n\nvar HTML_SEQUENCES = [[/^<(script|pre|style)(?=(\\s|>|$))/i, /<\\/(script|pre|style)>/i, true], [/^<!--/, /-->/, true], [/^<\\?/, /\\?>/, true], [/^<![A-Z]/, />/, true], [/^<!\\[CDATA\\[/, /\\]\\]>/, true], [new RegExp('^</?(' + block_names.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true], [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\\\s*$'), /^$/, false]];\n\nmodule.exports = function html_block(state, startLine, endLine, silent) {\n  var i,\n      nextLine,\n      token,\n      lineText,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine]; // if it's indented more than 3 spaces, it should be a code block\n\n  if (state.sCount[startLine] - state.blkIndent >= 4) {\n    return false;\n  }\n\n  if (!state.md.options.html) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(pos) !== 0x3C\n  /* < */\n  ) {\n    return false;\n  }\n\n  lineText = state.src.slice(pos, max);\n\n  for (i = 0; i < HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) {\n      break;\n    }\n  }\n\n  if (i === HTML_SEQUENCES.length) {\n    return false;\n  }\n\n  if (silent) {\n    // true if this sequence can be a terminator, false otherwise\n    return HTML_SEQUENCES[i][2];\n  }\n\n  nextLine = startLine + 1; // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine < endLine; nextLine++) {\n      if (state.sCount[nextLine] < state.blkIndent) {\n        break;\n      }\n\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n      lineText = state.src.slice(pos, max);\n\n      if (HTML_SEQUENCES[i][1].test(lineText)) {\n        if (lineText.length !== 0) {\n          nextLine++;\n        }\n\n        break;\n      }\n    }\n  }\n\n  state.line = nextLine;\n  token = state.push('html_block', '', 0);\n  token.map = [startLine, nextLine];\n  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);\n  return true;\n};","// List of valid html blocks names, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#html-blocks\n'use strict';\n\nmodule.exports = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'meta', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];","// Paragraph\n'use strict';\n\nmodule.exports = function paragraph(state, startLine\n/*, endLine*/\n) {\n  var content,\n      terminate,\n      i,\n      l,\n      token,\n      oldParentType,\n      nextLine = startLine + 1,\n      terminatorRules = state.md.block.ruler.getRules('paragraph'),\n      endLine = state.lineMax;\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph'; // jump line-by-line until empty one or EOF\n\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) {\n      continue;\n    } // quirk for blockquotes, this line should already be checked by that rule\n\n\n    if (state.sCount[nextLine] < 0) {\n      continue;\n    } // Some tags can terminate paragraph without empty line.\n\n\n    terminate = false;\n\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      break;\n    }\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  state.line = nextLine;\n  token = state.push('paragraph_open', 'p', 1);\n  token.map = [startLine, state.line];\n  token = state.push('inline', '', 0);\n  token.content = content;\n  token.map = [startLine, state.line];\n  token.children = [];\n  token = state.push('paragraph_close', 'p', -1);\n  state.parentType = oldParentType;\n  return true;\n};","// Parser state class\n'use strict';\n\nvar Token = require('../token');\n\nvar isSpace = require('../common/utils').isSpace;\n\nfunction StateBlock(src, md, env, tokens) {\n  var ch, s, start, pos, len, indent, offset, indent_found;\n  this.src = src; // link to parser instance\n\n  this.md = md;\n  this.env = env; //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens;\n  this.bMarks = []; // line begin offsets for fast jumps\n\n  this.eMarks = []; // line end offsets for fast jumps\n\n  this.tShift = []; // offsets of the first non-space characters (tabs not expanded)\n\n  this.sCount = []; // indents for each line (tabs expanded)\n  // An amount of virtual spaces (tabs expanded) between beginning\n  // of each line (bMarks) and real beginning of that line.\n  //\n  // It exists only as a hack because blockquotes override bMarks\n  // losing information in the process.\n  //\n  // It's used only when expanding tabs, you can think about it as\n  // an initial tab length, e.g. bsCount=21 applied to string `\\t123`\n  // means first tab should be expanded to 4-21%4 === 3 spaces.\n  //\n\n  this.bsCount = []; // block parser variables\n\n  this.blkIndent = 0; // required block content indent (for example, if we are\n  // inside a list, it would be positioned after list marker)\n\n  this.line = 0; // line index in src\n\n  this.lineMax = 0; // lines count\n\n  this.tight = false; // loose/tight mode for lists\n\n  this.ddIndent = -1; // indent of the current dd block (-1 if there isn't any)\n\n  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)\n  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'\n  // used in lists to determine if they interrupt a paragraph\n\n  this.parentType = 'root';\n  this.level = 0; // renderer\n\n  this.result = ''; // Create caches\n  // Generate markers.\n\n  s = this.src;\n  indent_found = false;\n\n  for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {\n    ch = s.charCodeAt(pos);\n\n    if (!indent_found) {\n      if (isSpace(ch)) {\n        indent++;\n\n        if (ch === 0x09) {\n          offset += 4 - offset % 4;\n        } else {\n          offset++;\n        }\n\n        continue;\n      } else {\n        indent_found = true;\n      }\n    }\n\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) {\n        pos++;\n      }\n\n      this.bMarks.push(start);\n      this.eMarks.push(pos);\n      this.tShift.push(indent);\n      this.sCount.push(offset);\n      this.bsCount.push(0);\n      indent_found = false;\n      indent = 0;\n      offset = 0;\n      start = pos + 1;\n    }\n  } // Push fake entry to simplify cache bounds checks\n\n\n  this.bMarks.push(s.length);\n  this.eMarks.push(s.length);\n  this.tShift.push(0);\n  this.sCount.push(0);\n  this.bsCount.push(0);\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\n} // Push new token to \"stream\".\n//\n\n\nStateBlock.prototype.push = function (type, tag, nesting) {\n  var token = new Token(type, tag, nesting);\n  token.block = true;\n  if (nesting < 0) this.level--; // closing tag\n\n  token.level = this.level;\n  if (nesting > 0) this.level++; // opening tag\n\n  this.tokens.push(token);\n  return token;\n};\n\nStateBlock.prototype.isEmpty = function isEmpty(line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];\n};\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (var max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break;\n    }\n  }\n\n  return from;\n}; // Skip spaces from given position.\n\n\nStateBlock.prototype.skipSpaces = function skipSpaces(pos) {\n  var ch;\n\n  for (var max = this.src.length; pos < max; pos++) {\n    ch = this.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      break;\n    }\n  }\n\n  return pos;\n}; // Skip spaces from given position in reverse.\n\n\nStateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {\n  if (pos <= min) {\n    return pos;\n  }\n\n  while (pos > min) {\n    if (!isSpace(this.src.charCodeAt(--pos))) {\n      return pos + 1;\n    }\n  }\n\n  return pos;\n}; // Skip char codes from given position\n\n\nStateBlock.prototype.skipChars = function skipChars(pos, code) {\n  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) {\n      break;\n    }\n  }\n\n  return pos;\n}; // Skip char codes reverse from given position - 1\n\n\nStateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {\n  if (pos <= min) {\n    return pos;\n  }\n\n  while (pos > min) {\n    if (code !== this.src.charCodeAt(--pos)) {\n      return pos + 1;\n    }\n  }\n\n  return pos;\n}; // cut lines range from source.\n\n\nStateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {\n  var i,\n      lineIndent,\n      ch,\n      first,\n      last,\n      queue,\n      lineStart,\n      line = begin;\n\n  if (begin >= end) {\n    return '';\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line < end; line++, i++) {\n    lineIndent = 0;\n    lineStart = first = this.bMarks[line];\n\n    if (line + 1 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1;\n    } else {\n      last = this.eMarks[line];\n    }\n\n    while (first < last && lineIndent < indent) {\n      ch = this.src.charCodeAt(first);\n\n      if (isSpace(ch)) {\n        if (ch === 0x09) {\n          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;\n        } else {\n          lineIndent++;\n        }\n      } else if (first - lineStart < this.tShift[line]) {\n        // patched tShift masked characters to look like spaces (blockquotes, list markers)\n        lineIndent++;\n      } else {\n        break;\n      }\n\n      first++;\n    }\n\n    if (lineIndent > indent) {\n      // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n      // with indent=2 becomes '  \\tfoobar'\n      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);\n    } else {\n      queue[i] = this.src.slice(first, last);\n    }\n  }\n\n  return queue.join('');\n}; // re-export Token class to use in block rules\n\n\nStateBlock.prototype.Token = Token;\nmodule.exports = StateBlock;","/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n'use strict';\n\nvar Ruler = require('./ruler'); ////////////////////////////////////////////////////////////////////////////////\n// Parser rules\n\n\nvar _rules = [['text', require('./rules_inline/text')], ['newline', require('./rules_inline/newline')], ['escape', require('./rules_inline/escape')], ['backticks', require('./rules_inline/backticks')], ['strikethrough', require('./rules_inline/strikethrough').tokenize], ['emphasis', require('./rules_inline/emphasis').tokenize], ['link', require('./rules_inline/link')], ['image', require('./rules_inline/image')], ['autolink', require('./rules_inline/autolink')], ['html_inline', require('./rules_inline/html_inline')], ['entity', require('./rules_inline/entity')]];\nvar _rules2 = [['balance_pairs', require('./rules_inline/balance_pairs')], ['strikethrough', require('./rules_inline/strikethrough').postProcess], ['emphasis', require('./rules_inline/emphasis').postProcess], ['text_collapse', require('./rules_inline/text_collapse')]];\n/**\n * new ParserInline()\n **/\n\nfunction ParserInline() {\n  var i;\n  /**\n   * ParserInline#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\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   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n\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} // Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\n\n\nParserInline.prototype.skipToken = function (state) {\n  var ok,\n      i,\n      pos = state.pos,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      maxNesting = state.md.options.maxNesting,\n      cache = state.cache;\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) {\n        break;\n      }\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) {\n    state.pos++;\n  }\n\n  cache[pos] = state.pos;\n}; // Generate tokens for input range\n//\n\n\nParserInline.prototype.tokenize = function (state) {\n  var ok,\n      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    if (state.level < maxNesting) {\n      for (i = 0; i < len; i++) {\n        ok = rules[i](state, false);\n\n        if (ok) {\n          break;\n        }\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) {\n        break;\n      }\n\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\n\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  this.tokenize(state);\n  rules = this.ruler2.getRules('');\n  len = rules.length;\n\n  for (i = 0; i < len; i++) {\n    rules[i](state);\n  }\n};\n\nParserInline.prototype.State = require('./rules_inline/state_inline');\nmodule.exports = ParserInline;","// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n'use strict'; // Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\n\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A\n    /* \\n */\n    :\n    case 0x21\n    /* ! */\n    :\n    case 0x23\n    /* # */\n    :\n    case 0x24\n    /* $ */\n    :\n    case 0x25\n    /* % */\n    :\n    case 0x26\n    /* & */\n    :\n    case 0x2A\n    /* * */\n    :\n    case 0x2B\n    /* + */\n    :\n    case 0x2D\n    /* - */\n    :\n    case 0x3A\n    /* : */\n    :\n    case 0x3C\n    /* < */\n    :\n    case 0x3D\n    /* = */\n    :\n    case 0x3E\n    /* > */\n    :\n    case 0x40\n    /* @ */\n    :\n    case 0x5B\n    /* [ */\n    :\n    case 0x5C\n    /* \\ */\n    :\n    case 0x5D\n    /* ] */\n    :\n    case 0x5E\n    /* ^ */\n    :\n    case 0x5F\n    /* _ */\n    :\n    case 0x60\n    /* ` */\n    :\n    case 0x7B\n    /* { */\n    :\n    case 0x7D\n    /* } */\n    :\n    case 0x7E\n    /* ~ */\n    :\n      return true;\n\n    default:\n      return false;\n  }\n}\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos;\n\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n\n  if (pos === state.pos) {\n    return false;\n  }\n\n  if (!silent) {\n    state.pending += state.src.slice(state.pos, pos);\n  }\n\n  state.pos = pos;\n  return true;\n}; // Alternative implementation, for memory.\n//\n// It costs 10% of performance, but allows extend terminators list, if place it\n// to `ParcerInline` property. Probably, will switch to it sometime, such\n// flexibility required.\n\n/*\nvar TERMINATOR_RE = /[\\n!#$%&*+\\-:<=>@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -> empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -> text till end of string\n  if (idx < 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n};*/","// Proceess '\\n'\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nmodule.exports = function newline(state, silent) {\n  var pmax,\n      max,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x0A\n  /* \\n */\n  ) {\n    return false;\n  }\n\n  pmax = state.pending.length - 1;\n  max = state.posMax; // '  \\n' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        state.pending = state.pending.replace(/ +$/, '');\n        state.push('hardbreak', 'br', 0);\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push('softbreak', 'br', 0);\n      }\n    } else {\n      state.push('softbreak', 'br', 0);\n    }\n  }\n\n  pos++; // skip heading spaces for next line\n\n  while (pos < max && isSpace(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n\n  state.pos = pos;\n  return true;\n};","// Process escaped chars and hardbreaks\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nvar ESCAPED = [];\n\nfor (var i = 0; i < 256; i++) {\n  ESCAPED.push(0);\n}\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'.split('').forEach(function (ch) {\n  ESCAPED[ch.charCodeAt(0)] = 1;\n});\n\nmodule.exports = function escape(state, silent) {\n  var ch,\n      pos = state.pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x5C\n  /* \\ */\n  ) {\n    return false;\n  }\n\n  pos++;\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch < 256 && ESCAPED[ch] !== 0) {\n      if (!silent) {\n        state.pending += state.src[pos];\n      }\n\n      state.pos += 2;\n      return true;\n    }\n\n    if (ch === 0x0A) {\n      if (!silent) {\n        state.push('hardbreak', 'br', 0);\n      }\n\n      pos++; // skip leading whitespaces from next line\n\n      while (pos < max) {\n        ch = state.src.charCodeAt(pos);\n\n        if (!isSpace(ch)) {\n          break;\n        }\n\n        pos++;\n      }\n\n      state.pos = pos;\n      return true;\n    }\n  }\n\n  if (!silent) {\n    state.pending += '\\\\';\n  }\n\n  state.pos++;\n  return true;\n};","// Parse backticks\n'use strict';\n\nmodule.exports = function backtick(state, silent) {\n  var start,\n      max,\n      marker,\n      matchStart,\n      matchEnd,\n      token,\n      pos = state.pos,\n      ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x60\n  /* ` */\n  ) {\n    return false;\n  }\n\n  start = pos;\n  pos++;\n  max = state.posMax;\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x60\n  /* ` */\n  ) {\n    pos++;\n  }\n\n  marker = state.src.slice(start, pos);\n  matchStart = matchEnd = pos;\n\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60\n    /* ` */\n    ) {\n      matchEnd++;\n    }\n\n    if (matchEnd - matchStart === marker.length) {\n      if (!silent) {\n        token = state.push('code_inline', 'code', 0);\n        token.markup = marker;\n        token.content = state.src.slice(pos, matchStart).replace(/\\n/g, ' ').replace(/^ (.+) $/, '$1');\n      }\n\n      state.pos = matchEnd;\n      return true;\n    }\n  }\n\n  if (!silent) {\n    state.pending += marker;\n  }\n\n  state.pos += marker.length;\n  return true;\n};","// Process [link](<to> \"stuff\")\n'use strict';\n\nvar normalizeReference = require('../common/utils').normalizeReference;\n\nvar isSpace = require('../common/utils').isSpace;\n\nmodule.exports = function link(state, silent) {\n  var attrs,\n      code,\n      label,\n      labelEnd,\n      labelStart,\n      pos,\n      res,\n      ref,\n      title,\n      token,\n      href = '',\n      oldPos = state.pos,\n      max = state.posMax,\n      start = state.pos,\n      parseReference = true;\n\n  if (state.src.charCodeAt(state.pos) !== 0x5B\n  /* [ */\n  ) {\n    return false;\n  }\n\n  labelStart = state.pos + 1;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true); // parser failed to find ']', so it's not a valid link\n\n  if (labelEnd < 0) {\n    return false;\n  }\n\n  pos = labelEnd + 1;\n\n  if (pos < max && state.src.charCodeAt(pos) === 0x28\n  /* ( */\n  ) {\n    //\n    // Inline link\n    //\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false; // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n\n    pos++;\n\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n\n      if (!isSpace(code) && code !== 0x0A) {\n        break;\n      }\n    }\n\n    if (pos >= max) {\n      return false;\n    } // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n\n\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n    } // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n\n\n    start = pos;\n\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n\n      if (!isSpace(code) && code !== 0x0A) {\n        break;\n      }\n    } // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n\n\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos; // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n\n        if (!isSpace(code) && code !== 0x0A) {\n          break;\n        }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29\n    /* ) */\n    ) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true;\n    }\n\n    pos++;\n  }\n\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') {\n      return false;\n    }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B\n    /* [ */\n    ) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    } // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n\n\n    if (!label) {\n      label = state.src.slice(labelStart, labelEnd);\n    }\n\n    ref = state.env.references[normalizeReference(label)];\n\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n\n    href = ref.href;\n    title = ref.title;\n  } //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n\n\n  if (!silent) {\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n    token = state.push('link_open', 'a', 1);\n    token.attrs = attrs = [['href', href]];\n\n    if (title) {\n      attrs.push(['title', title]);\n    }\n\n    state.md.inline.tokenize(state);\n    token = state.push('link_close', 'a', -1);\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};","// Process ![image](<src> \"title\")\n'use strict';\n\nvar normalizeReference = require('../common/utils').normalizeReference;\n\nvar isSpace = require('../common/utils').isSpace;\n\nmodule.exports = function image(state, silent) {\n  var attrs,\n      code,\n      content,\n      label,\n      labelEnd,\n      labelStart,\n      pos,\n      ref,\n      res,\n      title,\n      token,\n      tokens,\n      start,\n      href = '',\n      oldPos = state.pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(state.pos) !== 0x21\n  /* ! */\n  ) {\n    return false;\n  }\n\n  if (state.src.charCodeAt(state.pos + 1) !== 0x5B\n  /* [ */\n  ) {\n    return false;\n  }\n\n  labelStart = state.pos + 2;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false); // parser failed to find ']', so it's not a valid link\n\n  if (labelEnd < 0) {\n    return false;\n  }\n\n  pos = labelEnd + 1;\n\n  if (pos < max && state.src.charCodeAt(pos) === 0x28\n  /* ( */\n  ) {\n    //\n    // Inline link\n    //\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n\n      if (!isSpace(code) && code !== 0x0A) {\n        break;\n      }\n    }\n\n    if (pos >= max) {\n      return false;\n    } // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n\n\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n    } // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n\n\n    start = pos;\n\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n\n      if (!isSpace(code) && code !== 0x0A) {\n        break;\n      }\n    } // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n\n\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos; // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n\n        if (!isSpace(code) && code !== 0x0A) {\n          break;\n        }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29\n    /* ) */\n    ) {\n      state.pos = oldPos;\n      return false;\n    }\n\n    pos++;\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') {\n      return false;\n    }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B\n    /* [ */\n    ) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    } // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n\n\n    if (!label) {\n      label = state.src.slice(labelStart, labelEnd);\n    }\n\n    ref = state.env.references[normalizeReference(label)];\n\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n\n    href = ref.href;\n    title = ref.title;\n  } //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n\n\n  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd);\n    state.md.inline.parse(content, state.md, state.env, tokens = []);\n    token = state.push('image', 'img', 0);\n    token.attrs = attrs = [['src', href], ['alt', '']];\n    token.children = tokens;\n    token.content = content;\n\n    if (title) {\n      attrs.push(['title', title]);\n    }\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};","// Process autolinks '<protocol:...>'\n'use strict';\n/*eslint max-len:0*/\n\nvar EMAIL_RE = /^<([a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;\nvar AUTOLINK_RE = /^<([a-zA-Z][a-zA-Z0-9+.\\-]{1,31}):([^<>\\x00-\\x20]*)>/;\n\nmodule.exports = function autolink(state, silent) {\n  var tail,\n      linkMatch,\n      emailMatch,\n      url,\n      fullUrl,\n      token,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x3C\n  /* < */\n  ) {\n    return false;\n  }\n\n  tail = state.src.slice(pos);\n\n  if (tail.indexOf('>') < 0) {\n    return false;\n  }\n\n  if (AUTOLINK_RE.test(tail)) {\n    linkMatch = tail.match(AUTOLINK_RE);\n    url = linkMatch[0].slice(1, -1);\n    fullUrl = state.md.normalizeLink(url);\n\n    if (!state.md.validateLink(fullUrl)) {\n      return false;\n    }\n\n    if (!silent) {\n      token = state.push('link_open', 'a', 1);\n      token.attrs = [['href', fullUrl]];\n      token.markup = 'autolink';\n      token.info = 'auto';\n      token = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n      token = state.push('link_close', 'a', -1);\n      token.markup = 'autolink';\n      token.info = 'auto';\n    }\n\n    state.pos += linkMatch[0].length;\n    return true;\n  }\n\n  if (EMAIL_RE.test(tail)) {\n    emailMatch = tail.match(EMAIL_RE);\n    url = emailMatch[0].slice(1, -1);\n    fullUrl = state.md.normalizeLink('mailto:' + url);\n\n    if (!state.md.validateLink(fullUrl)) {\n      return false;\n    }\n\n    if (!silent) {\n      token = state.push('link_open', 'a', 1);\n      token.attrs = [['href', fullUrl]];\n      token.markup = 'autolink';\n      token.info = 'auto';\n      token = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n      token = state.push('link_close', 'a', -1);\n      token.markup = 'autolink';\n      token.info = 'auto';\n    }\n\n    state.pos += emailMatch[0].length;\n    return true;\n  }\n\n  return false;\n};","// Process html tags\n'use strict';\n\nvar HTML_TAG_RE = require('../common/html_re').HTML_TAG_RE;\n\nfunction isLetter(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n\n  return lc >= 0x61\n  /* a */\n  && lc <= 0x7a\n  /* z */\n  ;\n}\n\nmodule.exports = function html_inline(state, silent) {\n  var ch,\n      match,\n      max,\n      token,\n      pos = state.pos;\n\n  if (!state.md.options.html) {\n    return false;\n  } // Check start\n\n\n  max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x3C\n  /* < */\n  || pos + 2 >= max) {\n    return false;\n  } // Quick fail on second char\n\n\n  ch = state.src.charCodeAt(pos + 1);\n\n  if (ch !== 0x21\n  /* ! */\n  && ch !== 0x3F\n  /* ? */\n  && ch !== 0x2F\n  /* / */\n  && !isLetter(ch)) {\n    return false;\n  }\n\n  match = state.src.slice(pos).match(HTML_TAG_RE);\n\n  if (!match) {\n    return false;\n  }\n\n  if (!silent) {\n    token = state.push('html_inline', '', 0);\n    token.content = state.src.slice(pos, pos + match[0].length);\n  }\n\n  state.pos += match[0].length;\n  return true;\n};","// Process html entity - &#123;, &#xAF;, &quot;, ...\n'use strict';\n\nvar entities = require('../common/entities');\n\nvar has = require('../common/utils').has;\n\nvar isValidEntityCode = require('../common/utils').isValidEntityCode;\n\nvar fromCodePoint = require('../common/utils').fromCodePoint;\n\nvar DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;\nvar NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;\n\nmodule.exports = function entity(state, silent) {\n  var ch,\n      code,\n      match,\n      pos = state.pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x26\n  /* & */\n  ) {\n    return false;\n  }\n\n  if (pos + 1 < max) {\n    ch = state.src.charCodeAt(pos + 1);\n\n    if (ch === 0x23\n    /* # */\n    ) {\n      match = state.src.slice(pos).match(DIGITAL_RE);\n\n      if (match) {\n        if (!silent) {\n          code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);\n          state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\n        }\n\n        state.pos += match[0].length;\n        return true;\n      }\n    } else {\n      match = state.src.slice(pos).match(NAMED_RE);\n\n      if (match) {\n        if (has(entities, match[1])) {\n          if (!silent) {\n            state.pending += entities[match[1]];\n          }\n\n          state.pos += match[0].length;\n          return true;\n        }\n      }\n    }\n  }\n\n  if (!silent) {\n    state.pending += '&';\n  }\n\n  state.pos++;\n  return true;\n};","// For each opening emphasis-like marker find a matching closing one\n//\n'use strict';\n\nfunction processDelimiters(state, delimiters) {\n  var closerIdx,\n      openerIdx,\n      closer,\n      opener,\n      minOpenerIdx,\n      newMinOpenerIdx,\n      isOddMatch,\n      lastJump,\n      openersBottom = {},\n      max = delimiters.length;\n\n  for (closerIdx = 0; closerIdx < max; closerIdx++) {\n    closer = delimiters[closerIdx]; // Length is only used for emphasis-specific \"rule of 3\",\n    // if it's not defined (in strikethrough or 3rd party plugins),\n    // we can default it to 0 to disable those checks.\n    //\n\n    closer.length = closer.length || 0;\n    if (!closer.close) continue; // Previously calculated lower bounds (previous fails)\n    // for each marker and each delimiter length modulo 3.\n\n    if (!openersBottom.hasOwnProperty(closer.marker)) {\n      openersBottom[closer.marker] = [-1, -1, -1];\n    }\n\n    minOpenerIdx = openersBottom[closer.marker][closer.length % 3];\n    newMinOpenerIdx = -1;\n    openerIdx = closerIdx - closer.jump - 1;\n\n    for (; openerIdx > minOpenerIdx; openerIdx -= opener.jump + 1) {\n      opener = delimiters[openerIdx];\n      if (opener.marker !== closer.marker) continue;\n      if (newMinOpenerIdx === -1) newMinOpenerIdx = openerIdx;\n\n      if (opener.open && opener.end < 0 && opener.level === closer.level) {\n        isOddMatch = false; // from spec:\n        //\n        // If one of the delimiters can both open and close emphasis, then the\n        // sum of the lengths of the delimiter runs containing the opening and\n        // closing delimiters must not be a multiple of 3 unless both lengths\n        // are multiples of 3.\n        //\n\n        if (opener.close || closer.open) {\n          if ((opener.length + closer.length) % 3 === 0) {\n            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {\n              isOddMatch = true;\n            }\n          }\n        }\n\n        if (!isOddMatch) {\n          // If previous delimiter cannot be an opener, we can safely skip\n          // the entire sequence in future checks. This is required to make\n          // sure algorithm has linear complexity (see *_*_*_*_*_... case).\n          //\n          lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? delimiters[openerIdx - 1].jump + 1 : 0;\n          closer.jump = closerIdx - openerIdx + lastJump;\n          closer.open = false;\n          opener.end = closerIdx;\n          opener.jump = lastJump;\n          opener.close = false;\n          newMinOpenerIdx = -1;\n          break;\n        }\n      }\n    }\n\n    if (newMinOpenerIdx !== -1) {\n      // If match for this delimiter run failed, we want to set lower bound for\n      // future lookups. This is required to make sure algorithm has linear\n      // complexity.\n      //\n      // See details here:\n      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442\n      //\n      openersBottom[closer.marker][(closer.length || 0) % 3] = newMinOpenerIdx;\n    }\n  }\n}\n\nmodule.exports = function link_pairs(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n  processDelimiters(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      processDelimiters(state, tokens_meta[curr].delimiters);\n    }\n  }\n};","// Clean up tokens after emphasis and strikethrough postprocessing:\n// merge adjacent text nodes into one and re-calculate all token levels\n//\n// This is necessary because initially emphasis delimiter markers (*, _, ~)\n// are treated as their own separate text tokens. Then emphasis rule either\n// leaves them as text (needed to merge with adjacent text) or turns them\n// into opening/closing tags (which messes up levels inside).\n//\n'use strict';\n\nmodule.exports = function text_collapse(state) {\n  var curr,\n      last,\n      level = 0,\n      tokens = state.tokens,\n      max = state.tokens.length;\n\n  for (curr = last = 0; curr < max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting < 0) level--; // closing tag\n\n    tokens[curr].level = level;\n    if (tokens[curr].nesting > 0) level++; // opening tag\n\n    if (tokens[curr].type === 'text' && curr + 1 < max && tokens[curr + 1].type === 'text') {\n      // collapse two adjacent text nodes\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n    } else {\n      if (curr !== last) {\n        tokens[last] = tokens[curr];\n      }\n\n      last++;\n    }\n  }\n\n  if (curr !== last) {\n    tokens.length = last;\n  }\n};","// Inline parser state\n'use strict';\n\nvar Token = require('../token');\n\nvar isWhiteSpace = require('../common/utils').isWhiteSpace;\n\nvar isPunctChar = require('../common/utils').isPunctChar;\n\nvar isMdAsciiPunct = require('../common/utils').isMdAsciiPunct;\n\nfunction StateInline(src, md, env, outTokens) {\n  this.src = src;\n  this.env = env;\n  this.md = md;\n  this.tokens = outTokens;\n  this.tokens_meta = Array(outTokens.length);\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0; // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n\n  this.cache = {}; // List of emphasis-like delimiters for current tag\n\n  this.delimiters = []; // Stack of delimiter lists for upper level tags\n\n  this._prev_delimiters = [];\n} // Flush pending text\n//\n\n\nStateInline.prototype.pushPending = function () {\n  var token = new Token('text', '', 0);\n  token.content = this.pending;\n  token.level = this.pendingLevel;\n  this.tokens.push(token);\n  this.pending = '';\n  return token;\n}; // Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\n\n\nStateInline.prototype.push = function (type, tag, nesting) {\n  if (this.pending) {\n    this.pushPending();\n  }\n\n  var token = new Token(type, tag, nesting);\n  var token_meta = null;\n\n  if (nesting < 0) {\n    // closing tag\n    this.level--;\n    this.delimiters = this._prev_delimiters.pop();\n  }\n\n  token.level = this.level;\n\n  if (nesting > 0) {\n    // opening tag\n    this.level++;\n\n    this._prev_delimiters.push(this.delimiters);\n\n    this.delimiters = [];\n    token_meta = {\n      delimiters: this.delimiters\n    };\n  }\n\n  this.pendingLevel = this.level;\n  this.tokens.push(token);\n  this.tokens_meta.push(token_meta);\n  return token;\n}; // Scan a sequence of emphasis-like markers, and determine whether\n// it can start an emphasis sequence or end an emphasis sequence.\n//\n//  - start - position to scan from (it should point at a valid marker);\n//  - canSplitWord - determine if these markers can be found inside a word\n//\n\n\nStateInline.prototype.scanDelims = function (start, canSplitWord) {\n  var pos = start,\n      lastChar,\n      nextChar,\n      count,\n      can_open,\n      can_close,\n      isLastWhiteSpace,\n      isLastPunctChar,\n      isNextWhiteSpace,\n      isNextPunctChar,\n      left_flanking = true,\n      right_flanking = true,\n      max = this.posMax,\n      marker = this.src.charCodeAt(start); // treat beginning of the line as a whitespace\n\n  lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20;\n\n  while (pos < max && this.src.charCodeAt(pos) === marker) {\n    pos++;\n  }\n\n  count = pos - start; // treat end of the line as a whitespace\n\n  nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;\n  isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n  isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n  isLastWhiteSpace = isWhiteSpace(lastChar);\n  isNextWhiteSpace = isWhiteSpace(nextChar);\n\n  if (isNextWhiteSpace) {\n    left_flanking = false;\n  } else if (isNextPunctChar) {\n    if (!(isLastWhiteSpace || isLastPunctChar)) {\n      left_flanking = false;\n    }\n  }\n\n  if (isLastWhiteSpace) {\n    right_flanking = false;\n  } else if (isLastPunctChar) {\n    if (!(isNextWhiteSpace || isNextPunctChar)) {\n      right_flanking = false;\n    }\n  }\n\n  if (!canSplitWord) {\n    can_open = left_flanking && (!right_flanking || isLastPunctChar);\n    can_close = right_flanking && (!left_flanking || isNextPunctChar);\n  } else {\n    can_open = left_flanking;\n    can_close = right_flanking;\n  }\n\n  return {\n    can_open: can_open,\n    can_close: can_close,\n    length: count\n  };\n}; // re-export Token class to use in block rules\n\n\nStateInline.prototype.Token = Token;\nmodule.exports = StateInline;","'use strict'; ////////////////////////////////////////////////////////////////////////////////\n// Helpers\n// Merge objects\n//\n\nfunction assign(obj\n/*from1, from2, from3, ...*/\n) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n  sources.forEach(function (source) {\n    if (!source) {\n      return;\n    }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n  return obj;\n}\n\nfunction _class(obj) {\n  return Object.prototype.toString.call(obj);\n}\n\nfunction isString(obj) {\n  return _class(obj) === '[object String]';\n}\n\nfunction isObject(obj) {\n  return _class(obj) === '[object Object]';\n}\n\nfunction isRegExp(obj) {\n  return _class(obj) === '[object RegExp]';\n}\n\nfunction isFunction(obj) {\n  return _class(obj) === '[object Function]';\n}\n\nfunction escapeRE(str) {\n  return str.replace(/[.?*+^$[\\]\\\\(){}|-]/g, '\\\\$&');\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nvar defaultOptions = {\n  fuzzyLink: true,\n  fuzzyEmail: true,\n  fuzzyIP: false\n};\n\nfunction isOptionsObj(obj) {\n  return Object.keys(obj || {}).reduce(function (acc, k) {\n    return acc || defaultOptions.hasOwnProperty(k);\n  }, false);\n}\n\nvar defaultSchemas = {\n  'http:': {\n    validate: function validate(text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.http) {\n        // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.http = new RegExp('^\\\\/\\\\/' + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, 'i');\n      }\n\n      if (self.re.http.test(tail)) {\n        return tail.match(self.re.http)[0].length;\n      }\n\n      return 0;\n    }\n  },\n  'https:': 'http:',\n  'ftp:': 'http:',\n  '//': {\n    validate: function validate(text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.no_http) {\n        // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.no_http = new RegExp('^' + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'\n        // with code comments\n        '(?:localhost|(?:(?:' + self.re.src_domain + ')\\\\.)+' + self.re.src_domain_root + ')' + self.re.src_port + self.re.src_host_terminator + self.re.src_path, 'i');\n      }\n\n      if (self.re.no_http.test(tail)) {\n        // should not be `://` & `///`, that protects from errors in protocol name\n        if (pos >= 3 && text[pos - 3] === ':') {\n          return 0;\n        }\n\n        if (pos >= 3 && text[pos - 3] === '/') {\n          return 0;\n        }\n\n        return tail.match(self.re.no_http)[0].length;\n      }\n\n      return 0;\n    }\n  },\n  'mailto:': {\n    validate: function validate(text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.mailto) {\n        self.re.mailto = new RegExp('^' + self.re.src_email_name + '@' + self.re.src_host_strict, 'i');\n      }\n\n      if (self.re.mailto.test(tail)) {\n        return tail.match(self.re.mailto)[0].length;\n      }\n\n      return 0;\n    }\n  }\n};\n/*eslint-disable max-len*/\n// RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)\n\nvar tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]'; // DON'T try to make PRs with changes. Extend TLDs with LinkifyIt.tlds() instead\n\nvar tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');\n/*eslint-enable max-len*/\n////////////////////////////////////////////////////////////////////////////////\n\nfunction resetScanCache(self) {\n  self.__index__ = -1;\n  self.__text_cache__ = '';\n}\n\nfunction createValidator(re) {\n  return function (text, pos) {\n    var tail = text.slice(pos);\n\n    if (re.test(tail)) {\n      return tail.match(re)[0].length;\n    }\n\n    return 0;\n  };\n}\n\nfunction createNormalizer() {\n  return function (match, self) {\n    self.normalize(match);\n  };\n} // Schemas compiler. Build regexps.\n//\n\n\nfunction compile(self) {\n  // Load & clone RE patterns.\n  var re = self.re = require('./lib/re')(self.__opts__); // Define dynamic patterns\n\n\n  var tlds = self.__tlds__.slice();\n\n  self.onCompile();\n\n  if (!self.__tlds_replaced__) {\n    tlds.push(tlds_2ch_src_re);\n  }\n\n  tlds.push(re.src_xn);\n  re.src_tlds = tlds.join('|');\n\n  function untpl(tpl) {\n    return tpl.replace('%TLDS%', re.src_tlds);\n  }\n\n  re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), 'i');\n  re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), 'i');\n  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), 'i');\n  re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), 'i'); //\n  // Compile each schema\n  //\n\n  var aliases = [];\n  self.__compiled__ = {}; // Reset compiled data\n\n  function schemaError(name, val) {\n    throw new Error('(LinkifyIt) Invalid schema \"' + name + '\": ' + val);\n  }\n\n  Object.keys(self.__schemas__).forEach(function (name) {\n    var val = self.__schemas__[name]; // skip disabled methods\n\n    if (val === null) {\n      return;\n    }\n\n    var compiled = {\n      validate: null,\n      link: null\n    };\n    self.__compiled__[name] = compiled;\n\n    if (isObject(val)) {\n      if (isRegExp(val.validate)) {\n        compiled.validate = createValidator(val.validate);\n      } else if (isFunction(val.validate)) {\n        compiled.validate = val.validate;\n      } else {\n        schemaError(name, val);\n      }\n\n      if (isFunction(val.normalize)) {\n        compiled.normalize = val.normalize;\n      } else if (!val.normalize) {\n        compiled.normalize = createNormalizer();\n      } else {\n        schemaError(name, val);\n      }\n\n      return;\n    }\n\n    if (isString(val)) {\n      aliases.push(name);\n      return;\n    }\n\n    schemaError(name, val);\n  }); //\n  // Compile postponed aliases\n  //\n\n  aliases.forEach(function (alias) {\n    if (!self.__compiled__[self.__schemas__[alias]]) {\n      // Silently fail on missed schemas to avoid errons on disable.\n      // schemaError(alias, self.__schemas__[alias]);\n      return;\n    }\n\n    self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;\n    self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;\n  }); //\n  // Fake record for guessed links\n  //\n\n  self.__compiled__[''] = {\n    validate: null,\n    normalize: createNormalizer()\n  }; //\n  // Build schema condition\n  //\n\n  var slist = Object.keys(self.__compiled__).filter(function (name) {\n    // Filter disabled & fake schemas\n    return name.length > 0 && self.__compiled__[name];\n  }).map(escapeRE).join('|'); // (?!_) cause 1.5x slowdown\n\n  self.re.schema_test = RegExp(\"(^|(?!_)(?:[><\\uFF5C]|\" + re.src_ZPCc + '))(' + slist + ')', 'i');\n  self.re.schema_search = RegExp(\"(^|(?!_)(?:[><\\uFF5C]|\" + re.src_ZPCc + '))(' + slist + ')', 'ig');\n  self.re.pretest = RegExp('(' + self.re.schema_test.source + ')|(' + self.re.host_fuzzy_test.source + ')|@', 'i'); //\n  // Cleanup\n  //\n\n  resetScanCache(self);\n}\n/**\n * class Match\n *\n * Match result. Single element of array, returned by [[LinkifyIt#match]]\n **/\n\n\nfunction Match(self, shift) {\n  var start = self.__index__,\n      end = self.__last_index__,\n      text = self.__text_cache__.slice(start, end);\n  /**\n   * Match#schema -> String\n   *\n   * Prefix (protocol) for matched string.\n   **/\n\n\n  this.schema = self.__schema__.toLowerCase();\n  /**\n   * Match#index -> Number\n   *\n   * First position of matched string.\n   **/\n\n  this.index = start + shift;\n  /**\n   * Match#lastIndex -> Number\n   *\n   * Next position after matched string.\n   **/\n\n  this.lastIndex = end + shift;\n  /**\n   * Match#raw -> String\n   *\n   * Matched string.\n   **/\n\n  this.raw = text;\n  /**\n   * Match#text -> String\n   *\n   * Notmalized text of matched string.\n   **/\n\n  this.text = text;\n  /**\n   * Match#url -> String\n   *\n   * Normalized url of matched string.\n   **/\n\n  this.url = text;\n}\n\nfunction createMatch(self, shift) {\n  var match = new Match(self, shift);\n\n  self.__compiled__[match.schema].normalize(match, self);\n\n  return match;\n}\n/**\n * class LinkifyIt\n **/\n\n/**\n * new LinkifyIt(schemas, options)\n * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Creates new linkifier instance with optional additional schemas.\n * Can be called without `new` keyword for convenience.\n *\n * By default understands:\n *\n * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links\n * - \"fuzzy\" links and emails (example.com, foo@bar.com).\n *\n * `schemas` is an object, where each key/value describes protocol/rule:\n *\n * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`\n *   for example). `linkify-it` makes shure that prefix is not preceeded with\n *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.\n * - __value__ - rule to check tail after link prefix\n *   - _String_ - just alias to existing rule\n *   - _Object_\n *     - _validate_ - validator function (should return matched length on success),\n *       or `RegExp`.\n *     - _normalize_ - optional function to normalize text & url of matched result\n *       (for example, for @twitter mentions).\n *\n * `options`:\n *\n * - __fuzzyLink__ - recognige URL-s without `http(s):` prefix. Default `true`.\n * - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts\n *   like version numbers. Default `false`.\n * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.\n *\n **/\n\n\nfunction LinkifyIt(schemas, options) {\n  if (!(this instanceof LinkifyIt)) {\n    return new LinkifyIt(schemas, options);\n  }\n\n  if (!options) {\n    if (isOptionsObj(schemas)) {\n      options = schemas;\n      schemas = {};\n    }\n  }\n\n  this.__opts__ = assign({}, defaultOptions, options); // Cache last tested result. Used to skip repeating steps on next `match` call.\n\n  this.__index__ = -1;\n  this.__last_index__ = -1; // Next scan position\n\n  this.__schema__ = '';\n  this.__text_cache__ = '';\n  this.__schemas__ = assign({}, defaultSchemas, schemas);\n  this.__compiled__ = {};\n  this.__tlds__ = tlds_default;\n  this.__tlds_replaced__ = false;\n  this.re = {};\n  compile(this);\n}\n/** chainable\n * LinkifyIt#add(schema, definition)\n * - schema (String): rule name (fixed pattern prefix)\n * - definition (String|RegExp|Object): schema definition\n *\n * Add new rule definition. See constructor description for details.\n **/\n\n\nLinkifyIt.prototype.add = function add(schema, definition) {\n  this.__schemas__[schema] = definition;\n  compile(this);\n  return this;\n};\n/** chainable\n * LinkifyIt#set(options)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Set recognition options for links without schema.\n **/\n\n\nLinkifyIt.prototype.set = function set(options) {\n  this.__opts__ = assign(this.__opts__, options);\n  return this;\n};\n/**\n * LinkifyIt#test(text) -> Boolean\n *\n * Searches linkifiable pattern and returns `true` on success or `false` on fail.\n **/\n\n\nLinkifyIt.prototype.test = function test(text) {\n  // Reset scan cache\n  this.__text_cache__ = text;\n  this.__index__ = -1;\n\n  if (!text.length) {\n    return false;\n  }\n\n  var m, ml, me, len, shift, next, re, tld_pos, at_pos; // try to scan for link with schema - that's the most simple rule\n\n  if (this.re.schema_test.test(text)) {\n    re = this.re.schema_search;\n    re.lastIndex = 0;\n\n    while ((m = re.exec(text)) !== null) {\n      len = this.testSchemaAt(text, m[2], re.lastIndex);\n\n      if (len) {\n        this.__schema__ = m[2];\n        this.__index__ = m.index + m[1].length;\n        this.__last_index__ = m.index + m[0].length + len;\n        break;\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyLink && this.__compiled__['http:']) {\n    // guess schemaless links\n    tld_pos = text.search(this.re.host_fuzzy_test);\n\n    if (tld_pos >= 0) {\n      // if tld is located after found link - no need to check fuzzy pattern\n      if (this.__index__ < 0 || tld_pos < this.__index__) {\n        if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {\n          shift = ml.index + ml[1].length;\n\n          if (this.__index__ < 0 || shift < this.__index__) {\n            this.__schema__ = '';\n            this.__index__ = shift;\n            this.__last_index__ = ml.index + ml[0].length;\n          }\n        }\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyEmail && this.__compiled__['mailto:']) {\n    // guess schemaless emails\n    at_pos = text.indexOf('@');\n\n    if (at_pos >= 0) {\n      // We can't skip this check, because this cases are possible:\n      // 192.168.1.1@gmail.com, my.in@example.com\n      if ((me = text.match(this.re.email_fuzzy)) !== null) {\n        shift = me.index + me[1].length;\n        next = me.index + me[0].length;\n\n        if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {\n          this.__schema__ = 'mailto:';\n          this.__index__ = shift;\n          this.__last_index__ = next;\n        }\n      }\n    }\n  }\n\n  return this.__index__ >= 0;\n};\n/**\n * LinkifyIt#pretest(text) -> Boolean\n *\n * Very quick check, that can give false positives. Returns true if link MAY BE\n * can exists. Can be used for speed optimization, when you need to check that\n * link NOT exists.\n **/\n\n\nLinkifyIt.prototype.pretest = function pretest(text) {\n  return this.re.pretest.test(text);\n};\n/**\n * LinkifyIt#testSchemaAt(text, name, position) -> Number\n * - text (String): text to scan\n * - name (String): rule (schema) name\n * - position (Number): text offset to check from\n *\n * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly\n * at given position. Returns length of found pattern (0 on fail).\n **/\n\n\nLinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {\n  // If not supported schema check requested - terminate\n  if (!this.__compiled__[schema.toLowerCase()]) {\n    return 0;\n  }\n\n  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);\n};\n/**\n * LinkifyIt#match(text) -> Array|null\n *\n * Returns array of found link descriptions or `null` on fail. We strongly\n * recommend to use [[LinkifyIt#test]] first, for best speed.\n *\n * ##### Result match description\n *\n * - __schema__ - link schema, can be empty for fuzzy links, or `//` for\n *   protocol-neutral  links.\n * - __index__ - offset of matched text\n * - __lastIndex__ - index of next char after mathch end\n * - __raw__ - matched text\n * - __text__ - normalized text\n * - __url__ - link, generated from matched text\n **/\n\n\nLinkifyIt.prototype.match = function match(text) {\n  var shift = 0,\n      result = []; // Try to take previous element from cache, if .test() called before\n\n  if (this.__index__ >= 0 && this.__text_cache__ === text) {\n    result.push(createMatch(this, shift));\n    shift = this.__last_index__;\n  } // Cut head if cache was used\n\n\n  var tail = shift ? text.slice(shift) : text; // Scan string until end reached\n\n  while (this.test(tail)) {\n    result.push(createMatch(this, shift));\n    tail = tail.slice(this.__last_index__);\n    shift += this.__last_index__;\n  }\n\n  if (result.length) {\n    return result;\n  }\n\n  return null;\n};\n/** chainable\n * LinkifyIt#tlds(list [, keepOld]) -> this\n * - list (Array): list of tlds\n * - keepOld (Boolean): merge with current list if `true` (`false` by default)\n *\n * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)\n * to avoid false positives. By default this algorythm used:\n *\n * - hostname with any 2-letter root zones are ok.\n * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф\n *   are ok.\n * - encoded (`xn--...`) root zones are ok.\n *\n * If list is replaced, then exact match for 2-chars root zones will be checked.\n **/\n\n\nLinkifyIt.prototype.tlds = function tlds(list, keepOld) {\n  list = Array.isArray(list) ? list : [list];\n\n  if (!keepOld) {\n    this.__tlds__ = list.slice();\n    this.__tlds_replaced__ = true;\n    compile(this);\n    return this;\n  }\n\n  this.__tlds__ = this.__tlds__.concat(list).sort().filter(function (el, idx, arr) {\n    return el !== arr[idx - 1];\n  }).reverse();\n  compile(this);\n  return this;\n};\n/**\n * LinkifyIt#normalize(match)\n *\n * Default normalizer (if schema does not define it's own).\n **/\n\n\nLinkifyIt.prototype.normalize = function normalize(match) {\n  // Do minimal possible changes by default. Need to collect feedback prior\n  // to move forward https://github.com/markdown-it/linkify-it/issues/1\n  if (!match.schema) {\n    match.url = 'http://' + match.url;\n  }\n\n  if (match.schema === 'mailto:' && !/^mailto:/i.test(match.url)) {\n    match.url = 'mailto:' + match.url;\n  }\n};\n/**\n * LinkifyIt#onCompile()\n *\n * Override to modify basic RegExp-s.\n **/\n\n\nLinkifyIt.prototype.onCompile = function onCompile() {};\n\nmodule.exports = LinkifyIt;","'use strict';\n\nmodule.exports = function (opts) {\n  var re = {}; // Use direct extract instead of `regenerate` to reduse browserified size\n\n  re.src_Any = require('uc.micro/properties/Any/regex').source;\n  re.src_Cc = require('uc.micro/categories/Cc/regex').source;\n  re.src_Z = require('uc.micro/categories/Z/regex').source;\n  re.src_P = require('uc.micro/categories/P/regex').source; // \\p{\\Z\\P\\Cc\\CF} (white spaces + control + format + punctuation)\n\n  re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join('|'); // \\p{\\Z\\Cc} (white spaces + control)\n\n  re.src_ZCc = [re.src_Z, re.src_Cc].join('|'); // Experimental. List of chars, completely prohibited in links\n  // because can separate it from other part of text\n\n  var text_separators = \"[><\\uFF5C]\"; // All possible word characters (everything without punctuation, spaces & controls)\n  // Defined via punctuation & spaces to save space\n  // Should be something like \\p{\\L\\N\\S\\M} (\\w but without `_`)\n\n  re.src_pseudo_letter = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')'; // The same as abothe but without [0-9]\n  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';\n  ////////////////////////////////////////////////////////////////////////////////\n\n  re.src_ip4 = '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)'; // Prohibit any of \"@/[]()\" in user/pass to avoid wrong domain fetch.\n\n  re.src_auth = '(?:(?:(?!' + re.src_ZCc + '|[@/\\\\[\\\\]()]).)+@)?';\n  re.src_port = '(?::(?:6(?:[0-4]\\\\d{3}|5(?:[0-4]\\\\d{2}|5(?:[0-2]\\\\d|3[0-5])))|[1-5]?\\\\d{1,4}))?';\n  re.src_host_terminator = '(?=$|' + text_separators + '|' + re.src_ZPCc + ')(?!-|_|:\\\\d|\\\\.-|\\\\.(?!$|' + re.src_ZPCc + '))';\n  re.src_path = '(?:' + '[/?#]' + '(?:' + '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\\\]{}.,\"\\'?!\\\\-]).|' + '\\\\[(?:(?!' + re.src_ZCc + '|\\\\]).)*\\\\]|' + '\\\\((?:(?!' + re.src_ZCc + '|[)]).)*\\\\)|' + '\\\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\\\}|' + '\\\\\"(?:(?!' + re.src_ZCc + '|[\"]).)+\\\\\"|' + \"\\\\'(?:(?!\" + re.src_ZCc + \"|[']).)+\\\\'|\" + \"\\\\'(?=\" + re.src_pseudo_letter + '|[-]).|' + // allow `I'm_king` if no pair found\n  '\\\\.{2,4}[a-zA-Z0-9%/]|' + // github has ... in commit range links,\n  // google has .... in links (issue #66)\n  // Restrict to\n  // - english\n  // - percent-encoded\n  // - parts of file path\n  // until more examples found.\n  '\\\\.(?!' + re.src_ZCc + '|[.]).|' + (opts && opts['---'] ? '\\\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate\n  : '\\\\-+|') + '\\\\,(?!' + re.src_ZCc + ').|' + // allow `,,,` in paths\n  '\\\\!(?!' + re.src_ZCc + '|[!]).|' + '\\\\?(?!' + re.src_ZCc + '|[?]).' + ')+' + '|\\\\/' + ')?'; // Allow anything in markdown spec, forbid quote (\") at the first position\n  // because emails enclosed in quotes are far more common\n\n  re.src_email_name = '[\\\\-;:&=\\\\+\\\\$,\\\\.a-zA-Z0-9_][\\\\-;:&=\\\\+\\\\$,\\\\\"\\\\.a-zA-Z0-9_]*';\n  re.src_xn = 'xn--[a-z0-9\\\\-]{1,59}'; // More to read about domain names\n  // http://serverfault.com/questions/638260/\n\n  re.src_domain_root = // Allow letters & digits (http://test1)\n  '(?:' + re.src_xn + '|' + re.src_pseudo_letter + '{1,63}' + ')';\n  re.src_domain = '(?:' + re.src_xn + '|' + '(?:' + re.src_pseudo_letter + ')' + '|' + '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' + ')';\n  re.src_host = '(?:' + // Don't need IP check, because digits are already allowed in normal domain names\n  //   src_ip4 +\n  // '|' +\n  '(?:(?:(?:' + re.src_domain + ')\\\\.)*' + re.src_domain\n  /*_root*/\n  + ')' + ')';\n  re.tpl_host_fuzzy = '(?:' + re.src_ip4 + '|' + '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))' + ')';\n  re.tpl_host_no_ip_fuzzy = '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))';\n  re.src_host_strict = re.src_host + re.src_host_terminator;\n  re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;\n  re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;\n  re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;\n  re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator; ////////////////////////////////////////////////////////////////////////////////\n  // Main rules\n  // Rude test fuzzy links by host, for quick deny\n\n  re.tpl_host_fuzzy_test = 'localhost|www\\\\.|\\\\.\\\\d{1,3}\\\\.|(?:\\\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';\n  re.tpl_email_fuzzy = '(^|' + text_separators + '|\"|\\\\(|' + re.src_ZCc + ')' + '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';\n  re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n  // but can start with > (markdown blockquote)\n  \"(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uFF5C]|\" + re.src_ZPCc + '))' + \"((?![$+<=>^`|\\uFF5C])\" + re.tpl_host_port_fuzzy_strict + re.src_path + ')';\n  re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n  // but can start with > (markdown blockquote)\n  \"(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uFF5C]|\" + re.src_ZPCc + '))' + \"((?![$+<=>^`|\\uFF5C])\" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';\n  return re;\n};","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\n/*! https://mths.be/punycode v1.4.1 by @mathias */\n;\n\n(function (root) {\n  /** Detect free variables */\n  var freeExports = (typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) == 'object' && exports && !exports.nodeType && exports;\n  var freeModule = (typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) == 'object' && module && !module.nodeType && module;\n  var freeGlobal = (typeof global === \"undefined\" ? \"undefined\" : _typeof(global)) == 'object' && global;\n\n  if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {\n    root = freeGlobal;\n  }\n  /**\n   * The `punycode` object.\n   * @name punycode\n   * @type Object\n   */\n\n\n  var punycode,\n\n  /** Highest positive signed 32-bit float value */\n  maxInt = 2147483647,\n      // aka. 0x7FFFFFFF or 2^31-1\n\n  /** Bootstring parameters */\n  base = 36,\n      tMin = 1,\n      tMax = 26,\n      skew = 38,\n      damp = 700,\n      initialBias = 72,\n      initialN = 128,\n      // 0x80\n  delimiter = '-',\n      // '\\x2D'\n\n  /** Regular expressions */\n  regexPunycode = /^xn--/,\n      regexNonASCII = /[^\\x20-\\x7E]/,\n      // unprintable ASCII chars + non-ASCII chars\n  regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g,\n      // RFC 3490 separators\n\n  /** Error messages */\n  errors = {\n    'overflow': 'Overflow: input needs wider integers to process',\n    'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n    'invalid-input': 'Invalid input'\n  },\n\n  /** Convenience shortcuts */\n  baseMinusTMin = base - tMin,\n      floor = Math.floor,\n      stringFromCharCode = String.fromCharCode,\n\n  /** Temporary variable */\n  key;\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * A generic error utility function.\n   * @private\n   * @param {String} type The error type.\n   * @returns {Error} Throws a `RangeError` with the applicable error message.\n   */\n\n  function error(type) {\n    throw new RangeError(errors[type]);\n  }\n  /**\n   * A generic `Array#map` utility function.\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} callback The function that gets called for every array\n   * item.\n   * @returns {Array} A new array of values returned by the callback function.\n   */\n\n\n  function map(array, fn) {\n    var length = array.length;\n    var result = [];\n\n    while (length--) {\n      result[length] = fn(array[length]);\n    }\n\n    return result;\n  }\n  /**\n   * A simple `Array#map`-like wrapper to work with domain name strings or email\n   * addresses.\n   * @private\n   * @param {String} domain The domain name or email address.\n   * @param {Function} callback The function that gets called for every\n   * character.\n   * @returns {Array} A new string of characters returned by the callback\n   * function.\n   */\n\n\n  function mapDomain(string, fn) {\n    var parts = string.split('@');\n    var result = '';\n\n    if (parts.length > 1) {\n      // In email addresses, only the domain name should be punycoded. Leave\n      // the local part (i.e. everything up to `@`) intact.\n      result = parts[0] + '@';\n      string = parts[1];\n    } // Avoid `split(regex)` for IE8 compatibility. See #17.\n\n\n    string = string.replace(regexSeparators, '\\x2E');\n    var labels = string.split('.');\n    var encoded = map(labels, fn).join('.');\n    return result + encoded;\n  }\n  /**\n   * Creates an array containing the numeric code points of each Unicode\n   * character in the string. While JavaScript uses UCS-2 internally,\n   * this function will convert a pair of surrogate halves (each of which\n   * UCS-2 exposes as separate characters) into a single code point,\n   * matching UTF-16.\n   * @see `punycode.ucs2.encode`\n   * @see <https://mathiasbynens.be/notes/javascript-encoding>\n   * @memberOf punycode.ucs2\n   * @name decode\n   * @param {String} string The Unicode input string (UCS-2).\n   * @returns {Array} The new array of code points.\n   */\n\n\n  function ucs2decode(string) {\n    var output = [],\n        counter = 0,\n        length = string.length,\n        value,\n        extra;\n\n    while (counter < length) {\n      value = string.charCodeAt(counter++);\n\n      if (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n        // high surrogate, and there is a next character\n        extra = string.charCodeAt(counter++);\n\n        if ((extra & 0xFC00) == 0xDC00) {\n          // low surrogate\n          output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n        } else {\n          // unmatched surrogate; only append this code unit, in case the next\n          // code unit is the high surrogate of a surrogate pair\n          output.push(value);\n          counter--;\n        }\n      } else {\n        output.push(value);\n      }\n    }\n\n    return output;\n  }\n  /**\n   * Creates a string based on an array of numeric code points.\n   * @see `punycode.ucs2.decode`\n   * @memberOf punycode.ucs2\n   * @name encode\n   * @param {Array} codePoints The array of numeric code points.\n   * @returns {String} The new Unicode string (UCS-2).\n   */\n\n\n  function ucs2encode(array) {\n    return map(array, function (value) {\n      var output = '';\n\n      if (value > 0xFFFF) {\n        value -= 0x10000;\n        output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n        value = 0xDC00 | value & 0x3FF;\n      }\n\n      output += stringFromCharCode(value);\n      return output;\n    }).join('');\n  }\n  /**\n   * Converts a basic code point into a digit/integer.\n   * @see `digitToBasic()`\n   * @private\n   * @param {Number} codePoint The basic numeric code point value.\n   * @returns {Number} The numeric value of a basic code point (for use in\n   * representing integers) in the range `0` to `base - 1`, or `base` if\n   * the code point does not represent a value.\n   */\n\n\n  function basicToDigit(codePoint) {\n    if (codePoint - 48 < 10) {\n      return codePoint - 22;\n    }\n\n    if (codePoint - 65 < 26) {\n      return codePoint - 65;\n    }\n\n    if (codePoint - 97 < 26) {\n      return codePoint - 97;\n    }\n\n    return base;\n  }\n  /**\n   * Converts a digit/integer into a basic code point.\n   * @see `basicToDigit()`\n   * @private\n   * @param {Number} digit The numeric value of a basic code point.\n   * @returns {Number} The basic code point whose value (when used for\n   * representing integers) is `digit`, which needs to be in the range\n   * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n   * used; else, the lowercase form is used. The behavior is undefined\n   * if `flag` is non-zero and `digit` has no uppercase form.\n   */\n\n\n  function digitToBasic(digit, flag) {\n    //  0..25 map to ASCII a..z or A..Z\n    // 26..35 map to ASCII 0..9\n    return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n  }\n  /**\n   * Bias adaptation function as per section 3.4 of RFC 3492.\n   * https://tools.ietf.org/html/rfc3492#section-3.4\n   * @private\n   */\n\n\n  function adapt(delta, numPoints, firstTime) {\n    var k = 0;\n    delta = firstTime ? floor(delta / damp) : delta >> 1;\n    delta += floor(delta / numPoints);\n\n    for (; delta > baseMinusTMin * tMax >> 1; k += base) {\n      delta = floor(delta / baseMinusTMin);\n    }\n\n    return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n  }\n  /**\n   * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n   * symbols.\n   * @memberOf punycode\n   * @param {String} input The Punycode string of ASCII-only symbols.\n   * @returns {String} The resulting string of Unicode symbols.\n   */\n\n\n  function decode(input) {\n    // Don't use UCS-2\n    var output = [],\n        inputLength = input.length,\n        out,\n        i = 0,\n        n = initialN,\n        bias = initialBias,\n        basic,\n        j,\n        index,\n        oldi,\n        w,\n        k,\n        digit,\n        t,\n\n    /** Cached calculation results */\n    baseMinusT; // Handle the basic code points: let `basic` be the number of input code\n    // points before the last delimiter, or `0` if there is none, then copy\n    // the first basic code points to the output.\n\n    basic = input.lastIndexOf(delimiter);\n\n    if (basic < 0) {\n      basic = 0;\n    }\n\n    for (j = 0; j < basic; ++j) {\n      // if it's not a basic code point\n      if (input.charCodeAt(j) >= 0x80) {\n        error('not-basic');\n      }\n\n      output.push(input.charCodeAt(j));\n    } // Main decoding loop: start just after the last delimiter if any basic code\n    // points were copied; start at the beginning otherwise.\n\n\n    for (index = basic > 0 ? basic + 1 : 0; index < inputLength;) {\n      // `index` is the index of the next character to be consumed.\n      // Decode a generalized variable-length integer into `delta`,\n      // which gets added to `i`. The overflow checking is easier\n      // if we increase `i` as we go, then subtract off its starting\n      // value at the end to obtain `delta`.\n      for (oldi = i, w = 1, k = base;; k += base) {\n        if (index >= inputLength) {\n          error('invalid-input');\n        }\n\n        digit = basicToDigit(input.charCodeAt(index++));\n\n        if (digit >= base || digit > floor((maxInt - i) / w)) {\n          error('overflow');\n        }\n\n        i += digit * w;\n        t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\n        if (digit < t) {\n          break;\n        }\n\n        baseMinusT = base - t;\n\n        if (w > floor(maxInt / baseMinusT)) {\n          error('overflow');\n        }\n\n        w *= baseMinusT;\n      }\n\n      out = output.length + 1;\n      bias = adapt(i - oldi, out, oldi == 0); // `i` was supposed to wrap around from `out` to `0`,\n      // incrementing `n` each time, so we'll fix that now:\n\n      if (floor(i / out) > maxInt - n) {\n        error('overflow');\n      }\n\n      n += floor(i / out);\n      i %= out; // Insert `n` at position `i` of the output\n\n      output.splice(i++, 0, n);\n    }\n\n    return ucs2encode(output);\n  }\n  /**\n   * Converts a string of Unicode symbols (e.g. a domain name label) to a\n   * Punycode string of ASCII-only symbols.\n   * @memberOf punycode\n   * @param {String} input The string of Unicode symbols.\n   * @returns {String} The resulting Punycode string of ASCII-only symbols.\n   */\n\n\n  function encode(input) {\n    var n,\n        delta,\n        handledCPCount,\n        basicLength,\n        bias,\n        j,\n        m,\n        q,\n        k,\n        t,\n        currentValue,\n        output = [],\n\n    /** `inputLength` will hold the number of code points in `input`. */\n    inputLength,\n\n    /** Cached calculation results */\n    handledCPCountPlusOne,\n        baseMinusT,\n        qMinusT; // Convert the input in UCS-2 to Unicode\n\n    input = ucs2decode(input); // Cache the length\n\n    inputLength = input.length; // Initialize the state\n\n    n = initialN;\n    delta = 0;\n    bias = initialBias; // Handle the basic code points\n\n    for (j = 0; j < inputLength; ++j) {\n      currentValue = input[j];\n\n      if (currentValue < 0x80) {\n        output.push(stringFromCharCode(currentValue));\n      }\n    }\n\n    handledCPCount = basicLength = output.length; // `handledCPCount` is the number of code points that have been handled;\n    // `basicLength` is the number of basic code points.\n    // Finish the basic string - if it is not empty - with a delimiter\n\n    if (basicLength) {\n      output.push(delimiter);\n    } // Main encoding loop:\n\n\n    while (handledCPCount < inputLength) {\n      // All non-basic code points < n have been handled already. Find the next\n      // larger one:\n      for (m = maxInt, j = 0; j < inputLength; ++j) {\n        currentValue = input[j];\n\n        if (currentValue >= n && currentValue < m) {\n          m = currentValue;\n        }\n      } // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n      // but guard against overflow\n\n\n      handledCPCountPlusOne = handledCPCount + 1;\n\n      if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n        error('overflow');\n      }\n\n      delta += (m - n) * handledCPCountPlusOne;\n      n = m;\n\n      for (j = 0; j < inputLength; ++j) {\n        currentValue = input[j];\n\n        if (currentValue < n && ++delta > maxInt) {\n          error('overflow');\n        }\n\n        if (currentValue == n) {\n          // Represent delta as a generalized variable-length integer\n          for (q = delta, k = base;; k += base) {\n            t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\n            if (q < t) {\n              break;\n            }\n\n            qMinusT = q - t;\n            baseMinusT = base - t;\n            output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));\n            q = floor(qMinusT / baseMinusT);\n          }\n\n          output.push(stringFromCharCode(digitToBasic(q, 0)));\n          bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n          delta = 0;\n          ++handledCPCount;\n        }\n      }\n\n      ++delta;\n      ++n;\n    }\n\n    return output.join('');\n  }\n  /**\n   * Converts a Punycode string representing a domain name or an email address\n   * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n   * it doesn't matter if you call it on a string that has already been\n   * converted to Unicode.\n   * @memberOf punycode\n   * @param {String} input The Punycoded domain name or email address to\n   * convert to Unicode.\n   * @returns {String} The Unicode representation of the given Punycode\n   * string.\n   */\n\n\n  function toUnicode(input) {\n    return mapDomain(input, function (string) {\n      return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;\n    });\n  }\n  /**\n   * Converts a Unicode string representing a domain name or an email address to\n   * Punycode. Only the non-ASCII parts of the domain name will be converted,\n   * i.e. it doesn't matter if you call it with a domain that's already in\n   * ASCII.\n   * @memberOf punycode\n   * @param {String} input The domain name or email address to convert, as a\n   * Unicode string.\n   * @returns {String} The Punycode representation of the given domain name or\n   * email address.\n   */\n\n\n  function toASCII(input) {\n    return mapDomain(input, function (string) {\n      return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;\n    });\n  }\n  /*--------------------------------------------------------------------------*/\n\n  /** Define the public API */\n\n\n  punycode = {\n    /**\n     * A string representing the current Punycode.js version number.\n     * @memberOf punycode\n     * @type String\n     */\n    'version': '1.4.1',\n\n    /**\n     * An object of methods to convert from JavaScript's internal character\n     * representation (UCS-2) to Unicode code points, and back.\n     * @see <https://mathiasbynens.be/notes/javascript-encoding>\n     * @memberOf punycode\n     * @type Object\n     */\n    'ucs2': {\n      'decode': ucs2decode,\n      'encode': ucs2encode\n    },\n    'decode': decode,\n    'encode': encode,\n    'toASCII': toASCII,\n    'toUnicode': toUnicode\n  };\n  /** Expose `punycode` */\n  // Some AMD build optimizers, like r.js, check for specific condition patterns\n  // like the following:\n\n  if (typeof define == 'function' && _typeof(define.amd) == 'object' && define.amd) {\n    define('punycode', function () {\n      return punycode;\n    });\n  } else if (freeExports && freeModule) {\n    if (module.exports == freeExports) {\n      // in Node.js, io.js, or RingoJS v0.8.0+\n      freeModule.exports = punycode;\n    } else {\n      // in Narwhal or RingoJS v0.7.0-\n      for (key in punycode) {\n        punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n      }\n    }\n  } else {\n    // in Rhino or a web browser\n    root.punycode = punycode;\n  }\n})(this);","// markdown-it default options\n'use strict';\n\nmodule.exports = {\n  options: {\n    html: false,\n    // Enable HTML tags in source\n    xhtmlOut: false,\n    // Use '/' to close single tags (<br />)\n    breaks: false,\n    // Convert '\\n' in paragraphs into <br>\n    langPrefix: 'language-',\n    // CSS language prefix for fenced blocks\n    linkify: false,\n    // autoconvert URL-like texts to links\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\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    /* “”‘’ */\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    maxNesting: 100 // Internal protection, recursion limit\n\n  },\n  components: {\n    core: {},\n    block: {},\n    inline: {}\n  }\n};","// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n'use strict';\n\nmodule.exports = {\n  options: {\n    html: false,\n    // Enable HTML tags in source\n    xhtmlOut: false,\n    // Use '/' to close single tags (<br />)\n    breaks: false,\n    // Convert '\\n' in paragraphs into <br>\n    langPrefix: 'language-',\n    // CSS language prefix for fenced blocks\n    linkify: false,\n    // autoconvert URL-like texts to links\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\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    /* “”‘’ */\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    maxNesting: 20 // Internal protection, recursion limit\n\n  },\n  components: {\n    core: {\n      rules: ['normalize', 'block', 'inline']\n    },\n    block: {\n      rules: ['paragraph']\n    },\n    inline: {\n      rules: ['text'],\n      rules2: ['balance_pairs', 'text_collapse']\n    }\n  }\n};","// Commonmark default options\n'use strict';\n\nmodule.exports = {\n  options: {\n    html: true,\n    // Enable HTML tags in source\n    xhtmlOut: true,\n    // Use '/' to close single tags (<br />)\n    breaks: false,\n    // Convert '\\n' in paragraphs into <br>\n    langPrefix: 'language-',\n    // CSS language prefix for fenced blocks\n    linkify: false,\n    // autoconvert URL-like texts to links\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\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    /* “”‘’ */\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    maxNesting: 20 // Internal protection, recursion limit\n\n  },\n  components: {\n    core: {\n      rules: ['normalize', 'block', 'inline']\n    },\n    block: {\n      rules: ['blockquote', 'code', 'fence', 'heading', 'hr', 'html_block', 'lheading', 'list', 'reference', 'paragraph']\n    },\n    inline: {\n      rules: ['autolink', 'backticks', 'emphasis', 'entity', 'escape', 'html_inline', 'image', 'link', 'newline', 'text'],\n      rules2: ['balance_pairs', 'emphasis', 'text_collapse']\n    }\n  }\n};","'use strict'; // mime files data\n\nvar db = require('mime-db'); // Merge objects\n//\n\n\nfunction assign(obj\n/*from1, from2, from3, ...*/\n) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n  sources.forEach(function (source) {\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n  return obj;\n} // leaves only extension from the given string\n//   normalize('foo/bar.js')  // -> '.js'\n//   normalize('bar.js')      // -> '.js'\n//   normalize('.js')         // -> '.js'\n//   normalize('js')          // -> '.js'\n\n\nfunction normalize(path) {\n  // edge case: '/txt' & '\\txt' are not resolveable\n  if (/[\\\\/][^\\\\/.]+$/.test(path)) {\n    return '';\n  }\n\n  return '.' + path.replace(/.*[\\.\\/\\\\]/, '').toLowerCase();\n} // Remove charset/types/spaces, convenent for external data check\n// \" tExt/htMl ; charset=UTF-8 ; type=foo \" -> \"text/html\"\n\n\nfunction clearMime(mimeType) {\n  if (!mimeType || String(mimeType) !== mimeType) {\n    return '';\n  }\n\n  return mimeType.split(';')[0].trim().toLowerCase();\n}\n/**\n * class Mimoza\n **/\n\n/**\n *  new Mimoza([options])\n *\n *  Initiates new instance of Mimoza.\n *\n *  ##### Options\n *\n *  - **defaultType** _(String):_ Default mime type used as last-resort\n *    for [[Mimoza#getMimeType]]. By default: `undefined`.\n *  - **preloaded** _(Boolean):_ Init instance with default mime rules\n **/\n\n\nvar Mimoza = module.exports = function Mimoza(options) {\n  options = options || {}; // Map of `extension -> mimeType` pairs.\n\n  Object.defineProperty(this, 'types', {\n    value: Object.create(null)\n  }); // Map of `mimeType -> extensions` pairs.\n\n  Object.defineProperty(this, 'extensions', {\n    value: Object.create(null)\n  }); // Used as last-resort for [[Mimoza#getMimeType]].\n\n  Object.defineProperty(this, 'defaultType', {\n    value: options.defaultType\n  });\n\n  if (options.preloaded) {\n    Object.keys(db).forEach(function (mime) {\n      var val = db[mime];\n\n      if (val.extensions) {\n        this.register(mime, val.extensions);\n      }\n    }, this);\n  }\n};\n/**\n *  Mimoza#clone() -> Object\n *\n *  Creates copy of current Mimoza instanse\n **/\n\n\nMimoza.prototype.clone = function clone() {\n  var m = new Mimoza({\n    defaultType: this.defaultType\n  });\n  assign(m.types, this.types);\n  assign(m.extensions, this.extensions);\n  return m;\n};\n/**\n *  Mimoza#register(mimeType, extensions[, overrideDefault = false]) -> Void\n *  - mimeType (String):\n *  - extensions (String|Array):\n *  - overrideDefault (Boolean):\n *\n *  Register given `extensions` as representatives of `mimeType` and register\n *  first element of `extensions` as default extension for the `mimeType`.\n *\n *\n *  ##### Example\n *\n *  ```javascript\n *  mime.register('audio/ogg', ['oga', 'ogg', 'spx']);\n *\n *  mime.getMimeType('.oga');       // -> 'audio/ogg'\n *  mime.getMimeType('.ogg');       // -> 'audio/ogg'\n *  mime.getExtension('audio/ogg'); // -> '.oga'\n *  ```\n *\n *  ##### Overriding default extension\n *\n *  `mimeType -> extension` is set only once, if you wnt to override it,\n *  pass `overrideDefault` flag as true. See example below:\n *\n *  ```javascript\n *  mime.register('audio/ogg', ['oga']);\n *  mime.getExtension('audio/ogg');\n *  // -> '.oga'\n *\n *  mime.register('audio/ogg', ['spx']);\n *  mime.getExtension('audio/ogg');\n *  // -> '.oga'\n *\n *  mime.register('audio/ogg', ['ogg'], true);\n *  mime.getExtension('audio/ogg');\n *  // -> '.ogg'\n *  ```\n **/\n\n\nMimoza.prototype.register = function register(mimeType, extensions, overrideDefault) {\n  extensions = Array.isArray(extensions) ? extensions : [extensions]; // pollute `extension -> mimeType` map\n\n  extensions.forEach(function (ext) {\n    this.types[normalize(ext)] = mimeType;\n  }, this); // use case insensitive mime types for extention resolve\n\n  if (overrideDefault || typeof this.extensions[mimeType.toLowerCase()] === 'undefined') {\n    this.extensions[mimeType.toLowerCase()] = normalize(extensions[0]);\n  }\n};\n/**\n *  Mimoza#getMimeType(path[, fallback]) -> String\n *\n *  Lookup a mime type based on extension\n **/\n\n\nMimoza.prototype.getMimeType = function getMimeType(path, fallback) {\n  return this.types[normalize(path)] || fallback || this.defaultType;\n};\n/**\n *  Mimoza#getExtension(mimeType) -> String\n *\n *  Return file extension associated with a mime type.\n **/\n\n\nMimoza.prototype.getExtension = function getExtension(mimeType) {\n  return this.extensions[clearMime(mimeType)];\n}; // Returns whenever an asset is text or not\n\n\nvar TEXT_MIME_RE = new RegExp(['^text/', '/json$', '/javascript$'].join('|'));\n/**\n *  Mimoza#isText(mimeType) -> Boolean\n *\n *  Check if mime type provides text content. Can be used to add encoding.\n **/\n\nMimoza.prototype.isText = function isText(mimeType) {\n  return TEXT_MIME_RE.test(clearMime(mimeType));\n}; ////////////////////////////////////////////////////////////////////////////////\n//\n// Public methods to work with module without creating new instance, if default\n// configs are ok for you.\n//\n// builtin instance of mimoza\n\n\nvar builtin = new Mimoza({\n  preloaded: true\n});\n/**\n *  Mimoza.getMimeType(path, fallback) -> String\n *\n *  Proxy to [[Mimoza#getMimeType]] of internal, built-in instance of [[Mimoza]]\n *  filled with some default types.\n **/\n\nMimoza.getMimeType = function _getMimeType(path, fallback) {\n  return builtin.getMimeType(path, fallback);\n};\n/**\n *  Mimoza.getExtension(mimeType) -> String\n *\n *  Proxy to [[Mimoza#getExtension]] of internal, built-in instance of [[Mimoza]]\n *  filled with some default types.\n **/\n\n\nMimoza.getExtension = function _getExtension(mimeType) {\n  return builtin.getExtension(mimeType);\n};\n/**\n *  Mimoza.isText(mimeType) -> Boolean\n *\n *  Proxy to [[Mimoza#isText]] of internal, built-in instance\n *  of [[Mimoza]].\n **/\n\n\nMimoza.isText = function _isText(mimeType) {\n  return builtin.isText(mimeType);\n};","/*!\n * mime-db\n * Copyright(c) 2014 Jonathan Ong\n * MIT Licensed\n */\n\n/**\n * Module exports.\n */\nmodule.exports = require('./db.json');","import \"markdown-it\";\nimport \"markdown-it-html5-embed\";\n\nimport \"../stylesheets/markdown_editor\";\n\nwindow.addEventListener(\"load\", function() {\n\nconst md = require(\"markdown-it\")({ breaks: true }).use(require(\"markdown-it-html5-embed\"), {\n  html5embed: {\n    useImageSyntax: true, // Enables video/audio embed with ![]() syntax (default)\n    useLinkSyntax: true,\n    isAllowedHttp: true\n  }\n});\n\nconst styles = '<style>body { font-family: sans-serif; }</style>';\n\n\n  const source = document.getElementById('markdown-source');\n  const markdown_target = document.getElementById('markdown-target');\n  markdown_target.innerHTML = md.render(source.innerHTML);\n});\n"],"sourceRoot":""}