{"version":3,"sources":["webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/linkify-it/lib/re.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/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/text_join.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/html_block.js","webpack:///./node_modules/markdown-it/lib/common/html_blocks.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/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/linkify.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/fragments_join.js","webpack:///./node_modules/markdown-it/lib/rules_inline/state_inline.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/uc.micro/categories/P/regex.js","webpack:///./node_modules/markdown-it/index.js","webpack:///./node_modules/mdurl/index.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./node_modules/markdown-it/lib/ruler.js","webpack:///./node_modules/markdown-it/lib/token.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/linkify-it/index.js","webpack:///./node_modules/core-js/modules/es.regexp.constructor.js","webpack:///./node_modules/markdown-it/lib/common/entities.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:///./node_modules/markdown-it-link-attributes/index.js","webpack:///./node_modules/uc.micro/index.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/markdown-it/lib/common/utils.js"],"names":["module","exports","webpackPolyfill","deprecate","paths","children","Object","defineProperty","enumerable","get","l","i","opts","re","src_Any","source","src_Cc","src_Z","src_P","src_ZPCc","join","src_ZCc","src_pseudo_letter","src_ip4","src_auth","src_port","src_host_terminator","src_path","src_email_name","src_xn","src_domain_root","src_domain","src_host","tpl_host_fuzzy","tpl_host_no_ip_fuzzy","src_host_strict","tpl_host_fuzzy_strict","src_host_port_strict","tpl_host_port_fuzzy_strict","tpl_host_port_no_ip_fuzzy_strict","tpl_host_fuzzy_test","tpl_email_fuzzy","tpl_link_fuzzy","tpl_link_no_ip_fuzzy","utils","helpers","Renderer","ParserCore","ParserBlock","ParserInline","LinkifyIt","mdurl","punycode","config","default","zero","commonmark","BAD_PROTO_RE","GOOD_DATA_RE","validateLink","url","str","trim","toLowerCase","test","RECODE_HOSTNAME_FOR","normalizeLink","parsed","parse","hostname","protocol","indexOf","toASCII","er","encode","format","normalizeLinkText","toUnicode","decode","defaultChars","MarkdownIt","presetName","options","this","isString","inline","block","core","renderer","linkify","assign","configure","set","prototype","presets","self","Error","components","keys","forEach","name","rules","ruler","enableOnly","rules2","ruler2","enable","list","ignoreInvalid","result","Array","isArray","chain","concat","missed","filter","length","disable","use","plugin","args","slice","call","arguments","apply","src","env","state","State","process","tokens","render","parseInline","inlineMode","renderInline","encodeCache","string","exclude","keepEscaped","code","nextCode","cache","ch","String","fromCharCode","push","toString","toUpperCase","charCodeAt","getEncodeCache","encodeURIComponent","componentChars","decodeCache","getDecodeCache","replace","seq","b1","b2","b3","b4","chr","parseInt","slashes","auth","port","pathname","search","hash","Url","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","hostlessProtocol","slashedProtocol","slashesDenoteHost","lowerProto","hec","rest","split","simplePath","exec","proto","substr","match","atSign","hostEnd","lastIndexOf","host","parseHost","ipv6Hostname","hostparts","part","newpart","j","k","validParts","notHost","bit","unshift","qm","u","parseLinkLabel","parseLinkDestination","parseLinkTitle","start","disableNested","level","found","marker","prevPos","labelEnd","max","posMax","oldPos","pos","md","skipToken","unescapeAll","ok","lines","escapeHtml","default_rules","code_inline","idx","slf","token","renderAttrs","content","code_block","fence","highlighted","arr","tmpAttrs","tmpToken","info","langName","langAttrs","highlight","attrIndex","attrs","langPrefix","image","renderInlineAsText","renderToken","hardbreak","xhtmlOut","softbreak","breaks","text","html_block","html_inline","nextToken","needLf","hidden","nesting","tag","type","len","Ruler","_rules","Core","getRules","NEWLINES_RE","NULL_RE","Token","map","tok","arrayReplaceAt","isLinkClose","currentToken","nodes","ln","lastPos","htmlLinkLevel","fullUrl","urlText","links","blockTokens","pretest","index","schema","markup","lastIndex","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","c","r","tm","replaceFn","replace_scoped","inlineTokens","inside_autolink","replace_rare","blkIdx","typographer","isWhiteSpace","isPunctChar","isMdAsciiPunct","QUOTE_TEST_RE","QUOTE_RE","replaceAt","process_inlines","t","thisLevel","item","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","canOpen","canClose","isSingle","stack","openQuote","closeQuote","OUTER","single","quotes","curr","last","StateCore","alt","tokenize","startLine","endLine","line","hasEmptyLines","maxNesting","skipEmptyLines","sCount","blkIndent","tight","isEmpty","outTokens","lineMax","isSpace","getLine","bMarks","tShift","eMarks","escapedSplit","isEscaped","current","substring","silent","lineText","nextLine","columns","columnCount","aligns","tableLines","tbodyLines","oldParentType","terminate","terminatorRules","firstCh","secondCh","shift","pop","parentType","getLines","params","mem","haveEndMarker","skipChars","skipSpaces","adjustTab","initial","lastLineEmpty","offset","oldBMarks","oldBSCount","oldIndent","oldSCount","oldTShift","spaceAfterMarker","isOutdented","oldLineMax","bsCount","cnt","skipBulletListMarker","skipOrderedListMarker","contentStart","indent","indentAfterMarker","isOrdered","itemLines","listLines","listTokIdx","markerCharCode","markerValue","oldListIndent","oldTight","posAfterMarker","prevEmptyEnd","isTerminatingParagraph","listIndent","Number","Math","min","markTightParagraphs","normalizeReference","_endLine","destEndPos","destEndLineNo","href","label","res","title","references","block_names","HTML_OPEN_CLOSE_TAG_RE","HTML_SEQUENCES","RegExp","html","tmp","skipSpacesBack","skipCharsBack","StateBlock","s","indent_found","ddIndent","from","begin","end","keepLastLF","lineIndent","first","queue","lineStart","_rules2","postProcess","pending","pushPending","isTerminatorChar","SCHEME_RE","link","linkLevel","matchAtStart","pmax","ws","ESCAPED","ch1","ch2","origStr","escapedStr","matchStart","matchEnd","openerLength","closerLength","backticksScanned","backticks","labelStart","ref","parseReference","EMAIL_RE","AUTOLINK_RE","HTML_TAG_RE","lc","isLetter","entities","has","isValidEntityCode","fromCodePoint","DIGITAL_RE","NAMED_RE","processDelimiters","delimiters","closerIdx","openerIdx","closer","opener","minOpenerIdx","newMinOpenerIdx","isOddMatch","lastJump","openersBottom","headerIdx","lastTokenIdx","jumps","close","hasOwnProperty","open","tokens_meta","StateInline","pendingLevel","_prev_delimiters","token_meta","scanDelims","canSplitWord","count","can_open","can_close","left_flanking","right_flanking","__webpack_amd_options__","__rules__","__cache__","__find__","__compile__","chains","rule","enabled","altName","fn","at","opt","before","beforeName","ruleName","splice","after","afterName","chainName","meta","attrPush","attrData","attrSet","value","attrGet","attrJoin","obj","sources","key","_class","isFunction","escapeRE","defaultOptions","fuzzyLink","fuzzyEmail","fuzzyIP","defaultSchemas","validate","tail","http","no_http","mailto","tlds_default","compile","__opts__","tlds","__tlds__","untpl","tpl","src_tlds","onCompile","__tlds_replaced__","email_fuzzy","link_fuzzy","link_no_ip_fuzzy","host_fuzzy_test","aliases","schemaError","val","__compiled__","__schemas__","compiled","isRegExp","createValidator","normalize","alias","slist","schema_test","schema_search","schema_at_start","__index__","__text_cache__","resetScanCache","Match","__last_index__","__schema__","raw","createMatch","schemas","reduce","acc","add","definition","m","ml","me","next","tld_pos","testSchemaAt","keepOld","sort","el","reverse","DESCRIPTORS","global","isForced","inheritIfRequired","f","getOwnPropertyNames","getFlags","stickyHelpers","redefine","fails","enforceInternalState","enforce","setSpecies","MATCH","wellKnownSymbol","NativeRegExp","RegExpPrototype","re1","re2","CORRECT_NEW","UNSUPPORTED_Y","RegExpWrapper","pattern","flags","sticky","thisIsRegExp","patternIsRegExp","flagsAreUndefined","undefined","constructor","proxy","configurable","it","open_tag","close_tag","startDelim","endDelim","loneMarkers","scanned","isStrong","markdownitLinkAttributes","configs","freeze","defaultRender","link_open","matcher","findFirstMatchingConfig","attributes","attr","applyAttributes","Any","Cc","Cf","P","Z","_typeof","Symbol","iterator","root","freeExports","nodeType","freeModule","freeGlobal","window","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","n","bias","handledCPCount","basicLength","q","currentValue","handledCPCountPlusOne","qMinusT","_hasOwnProperty","object","surrogate1","surrogate2","UNESCAPE_MD_RE","UNESCAPE_ALL_RE","DIGITAL_ENTITY_TEST_RE","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","REGEXP_ESCAPE_RE","UNICODE_PUNCT_RE","lib","ucmicro","TypeError","unescapeMd","escaped","entity","replaceEntityPattern","newElements"],"mappings":"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","file":"js/0-11c00c4921f4e9f74c64.chunk.js","sourcesContent":["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};","'use strict';\n\nmodule.exports = function (opts) {\n var re = {};\n opts = opts || {}; // 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 + ')' + '(?!' + (opts['---'] ? '-(?!--)|' : '-|') + '_|:\\\\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,}[a-zA-Z0-9%/&]|' + // google has many dots in \"google search\" links (#66, #81).\n // github has ... in commit range links,\n // Restrict to\n // - english\n // - percent-encoded\n // - parts of file path\n // - params separator\n // until more examples found.\n '\\\\.(?!' + re.src_ZCc + '|[.]|$)|' + (opts['---'] ? '\\\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate\n : '\\\\-+|') + ',(?!' + re.src_ZCc + '|$)|' + // allow `,,,` in paths\n ';(?!' + re.src_ZCc + '|$)|' + // allow `;` if not followed by space-like char\n '\\\\!+(?!' + re.src_ZCc + '|[!]|$)|' + // allow `!!!` in paths, but not at the end\n '\\\\?(?!' + 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};","// 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 } // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720\n\n\n return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%');\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 * (`
`). 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 `
`.\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 `):\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 '
' +\n *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n *                '
';\n * } catch (__) {}\n * }\n *\n * return '
' + md.utils.escapeHtml(str) + '
';\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 will - 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 return 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 `

` 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;","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 === 0x3C\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 if (str.charCodeAt(pos + 1) === 0x20) {\n break;\n }\n\n pos += 2;\n continue;\n }\n\n if (code === 0x28\n /* ( */\n ) {\n level++;\n\n if (level > 32) {\n return result;\n }\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 === 0x28\n /* ( */\n && marker === 0x29\n /* ) */\n ) {\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 '' + escapeHtml(tokens[idx].content) + '';\n};\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n var token = tokens[idx];\n return '' + escapeHtml(tokens[idx].content) + '\\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 langAttrs = '',\n highlighted,\n i,\n arr,\n tmpAttrs,\n tmpToken;\n\n if (info) {\n arr = info.split(/(\\s+)/g);\n langName = arr[0];\n langAttrs = arr.slice(2).join('');\n }\n\n if (options.highlight) {\n highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);\n } else {\n highlighted = escapeHtml(token.content);\n }\n\n if (highlighted.indexOf('' + highlighted + '\\n';\n }\n\n return '

' + highlighted + '
\\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 ? '
\\n' : '
\\n';\n};\n\ndefault_rules.softbreak = function (tokens, idx, options\n/*, env */\n) {\n return options.breaks ? options.xhtmlOut ? '
\\n' : '
\\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 ''; };\n * md.renderer.rules.strong_close = function () { return ''; };\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. ``.\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 render\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 render\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 } else if (tokens[i].type === 'softbreak') {\n result += '\\n';\n }\n }\n\n return result;\n};\n/**\n * Renderer.render(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\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')], // `text_join` finds `text_special` tokens (for escape sequences)\n// and joins them with the rest of the text\n['text_join', require('./rules_core/text_join')]];\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 /^\\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; // forbid escape sequence at the start of the string,\n // this avoids http\\://example.com/ from being linkified as\n // http://example.com/\n\n if (links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === 'text_special') {\n links = links.slice(1);\n }\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// -- → –, --- → —\n//\n'use strict'; // TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - multiplications 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)\\)/i;\nvar SCOPED_ABBR_RE = /\\((c|tm|r)\\)/ig;\nvar SCOPED_ABBR = {\n c: '©',\n r: '®',\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\") // en-dash\n .replace(/(^|\\s)--(?=\\s|$)/mg, \"$1\\u2013\").replace(/(^|[^-\\s])--(?=[^-\\s]|$)/mg, \"$1\\u2013\");\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.slice(0, index) + ch + str.slice(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].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\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].content) continue; // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\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 // Replace quotes in the middle of punctuation sequence, but not\n // in the middle of the words, i.e.:\n //\n // 1. foo \" bar \" baz - not replaced\n // 2. foo-\"-bar-\"-baz - replaced\n // 3. foo\"bar\"baz - not replaced\n //\n canOpen = isLastPunctChar;\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};","// Join raw text tokens with the rest of the text\n//\n// This is set as a separate rule to provide an opportunity for plugins\n// to run text replacements after text join, but before escape join.\n//\n// For example, `\\:)` shouldn't be replaced with an emoji.\n//\n'use strict';\n\nmodule.exports = function text_join(state) {\n var j,\n l,\n tokens,\n curr,\n max,\n last,\n blockTokens = state.tokens;\n\n for (j = 0, l = blockTokens.length; j < l; j++) {\n if (blockTokens[j].type !== 'inline') continue;\n tokens = blockTokens[j].children;\n max = tokens.length;\n\n for (curr = 0; curr < max; curr++) {\n if (tokens[curr].type === 'text_special') {\n tokens[curr].type = 'text';\n }\n }\n\n for (curr = last = 0; curr < max; curr++) {\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 }\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')], ['html_block', require('./rules_block/html_block'), ['paragraph', 'reference', 'blockquote']], ['heading', require('./rules_block/heading'), ['paragraph', 'reference', 'blockquote']], ['lheading', require('./rules_block/lheading')], ['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, https://github.github.com/gfm/#tables-extension-\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nfunction getLine(state, line) {\n var pos = state.bMarks[line] + state.tShift[line],\n max = state.eMarks[line];\n return state.src.slice(pos, max);\n}\n\nfunction escapedSplit(str) {\n var result = [],\n pos = 0,\n max = str.length,\n ch,\n isEscaped = false,\n lastPos = 0,\n current = '';\n ch = str.charCodeAt(pos);\n\n while (pos < max) {\n if (ch === 0x7c\n /* | */\n ) {\n if (!isEscaped) {\n // pipe separating cells, '|'\n result.push(current + str.substring(lastPos, pos));\n current = '';\n lastPos = pos + 1;\n } else {\n // escaped pipe, '\\|'\n current += str.substring(lastPos, pos - 1);\n lastPos = pos;\n }\n }\n\n isEscaped = ch === 0x5c\n /* \\ */\n ;\n pos++;\n ch = str.charCodeAt(pos);\n }\n\n result.push(current + str.substring(lastPos));\n return result;\n}\n\nmodule.exports = function table(state, startLine, endLine, silent) {\n var ch, lineText, pos, i, l, nextLine, columns, columnCount, token, aligns, t, tableLines, tbodyLines, oldParentType, terminate, terminatorRules, firstCh, secondCh; // 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 firstCh = state.src.charCodeAt(pos++);\n\n if (firstCh !== 0x7C\n /* | */\n && firstCh !== 0x2D\n /* - */\n && firstCh !== 0x3A\n /* : */\n ) {\n return false;\n }\n\n if (pos >= state.eMarks[nextLine]) {\n return false;\n }\n\n secondCh = state.src.charCodeAt(pos++);\n\n if (secondCh !== 0x7C\n /* | */\n && secondCh !== 0x2D\n /* - */\n && secondCh !== 0x3A\n /* : */\n && !isSpace(secondCh)) {\n return false;\n } // if first character is '-', then second character must not be a space\n // (due to parsing ambiguity with list)\n\n\n if (firstCh === 0x2D\n /* - */\n && isSpace(secondCh)) {\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);\n if (columns.length && columns[0] === '') columns.shift();\n if (columns.length && columns[columns.length - 1] === '') columns.pop(); // header row will define an amount of columns in the entire table,\n // and align row should be exactly the same (the rest of the rows can differ)\n\n columnCount = columns.length;\n\n if (columnCount === 0 || columnCount !== aligns.length) {\n return false;\n }\n\n if (silent) {\n return true;\n }\n\n oldParentType = state.parentType;\n state.parentType = 'table'; // use 'blockquote' lists for termination because it's\n // the most similar to tables\n\n terminatorRules = state.md.block.ruler.getRules('blockquote');\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\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.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\n for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n if (state.sCount[nextLine] < state.blkIndent) {\n break;\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 lineText = getLine(state, nextLine).trim();\n\n if (!lineText) {\n break;\n }\n\n if (state.sCount[nextLine] - state.blkIndent >= 4) {\n break;\n }\n\n columns = escapedSplit(lineText);\n if (columns.length && columns[0] === '') columns.shift();\n if (columns.length && columns[columns.length - 1] === '') columns.pop();\n\n if (nextLine === startLine + 2) {\n token = state.push('tbody_open', 'tbody', 1);\n token.map = tbodyLines = [startLine + 2, 0];\n }\n\n token = state.push('tr_open', 'tr', 1);\n token.map = [nextLine, nextLine + 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 if (tbodyLines) {\n token = state.push('tbody_close', 'tbody', -1);\n tbodyLines[1] = nextLine;\n }\n\n token = state.push('table_close', 'table', -1);\n tableLines[1] = nextLine;\n state.parentType = oldParentType;\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, false) + '\\n';\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 isOutdented,\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 } // set offset past spaces and \">\"\n\n\n initial = offset = state.sCount[startLine] + 1; // 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'; // 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 isOutdented = state.sCount[nextLine] < state.blkIndent;\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 && !isOutdented) {\n // This line is inside the blockquote.\n // set offset past spaces and \">\"\n initial = offset = state.sCount[nextLine] + 1; // 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.sCount[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.slice(start, posAfterMarker - 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];\n\n if (isOrdered) {\n token.info = state.src.slice(start, posAfterMarker - 1);\n } // change current state, then restore it after parser subcall\n\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\n start = state.bMarks[nextLine] + state.tShift[nextLine];\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};","// 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|textarea)(?=(\\s|>|$))/i, /<\\/(script|pre|style|textarea)>/i, true], [/^/, true], [/^<\\?/, /\\?>/, true], [/^/, true], [/^/, true], [new RegExp('^|$))', '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', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];","// 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};","// 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')], ['linkify', require('./rules_inline/linkify')], ['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')]]; // `rule2` ruleset was created specifically for emphasis/strikethrough\n// post-processing and may be changed in the future.\n//\n// Don't use this for anything except pairs (plugins working with `balance_pairs`).\n//\n\nvar _rules2 = [['balance_pairs', require('./rules_inline/balance_pairs')], ['strikethrough', require('./rules_inline/strikethrough').postProcess], ['emphasis', require('./rules_inline/emphasis').postProcess], // rules for pairs separate '**' into its own text tokens, which may be left unused,\n// rule below merges unused segments back with the rest of the text\n['fragments_join', require('./rules_inline/fragments_join')]];\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};*/","// Process links like https://example.org/\n'use strict'; // RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n\nvar SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;\n\nmodule.exports = function linkify(state, silent) {\n var pos, max, match, proto, link, url, fullUrl, token;\n if (!state.md.options.linkify) return false;\n if (state.linkLevel > 0) return false;\n pos = state.pos;\n max = state.posMax;\n if (pos + 3 > max) return false;\n if (state.src.charCodeAt(pos) !== 0x3A\n /* : */\n ) return false;\n if (state.src.charCodeAt(pos + 1) !== 0x2F\n /* / */\n ) return false;\n if (state.src.charCodeAt(pos + 2) !== 0x2F\n /* / */\n ) return false;\n match = state.pending.match(SCHEME_RE);\n if (!match) return false;\n proto = match[1];\n link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));\n if (!link) return false;\n url = link.url; // disallow '*' at the end of the link (conflicts with emphasis)\n\n url = url.replace(/\\*+$/, '');\n fullUrl = state.md.normalizeLink(url);\n if (!state.md.validateLink(fullUrl)) return false;\n\n if (!silent) {\n state.pending = state.pending.slice(0, -proto.length);\n token = state.push('link_open', 'a', 1);\n token.attrs = [['href', fullUrl]];\n token.markup = 'linkify';\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 = 'linkify';\n token.info = 'auto';\n }\n\n state.pos += url.length - proto.length;\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 ws,\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 // Find whitespaces tail of pending chars.\n ws = pmax - 1;\n\n while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) {\n ws--;\n }\n\n state.pending = state.pending.slice(0, ws);\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 ch1,\n ch2,\n origStr,\n escapedStr,\n token,\n pos = state.pos,\n max = state.posMax;\n if (state.src.charCodeAt(pos) !== 0x5C\n /* \\ */\n ) return false;\n pos++; // '\\' at the end of the inline block\n\n if (pos >= max) return false;\n ch1 = state.src.charCodeAt(pos);\n\n if (ch1 === 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 ch1 = state.src.charCodeAt(pos);\n if (!isSpace(ch1)) break;\n pos++;\n }\n\n state.pos = pos;\n return true;\n }\n\n escapedStr = state.src[pos];\n\n if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {\n ch2 = state.src.charCodeAt(pos + 1);\n\n if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {\n escapedStr += state.src[pos + 1];\n pos++;\n }\n }\n\n origStr = '\\\\' + escapedStr;\n\n if (!silent) {\n token = state.push('text_special', '', 0);\n\n if (ch1 < 256 && ESCAPED[ch1] !== 0) {\n token.content = escapedStr;\n } else {\n token.content = origStr;\n }\n\n token.markup = origStr;\n token.info = 'escape';\n }\n\n state.pos = pos + 1;\n return true;\n};","// Parse backticks\n'use strict';\n\nmodule.exports = function backtick(state, silent) {\n var start,\n max,\n marker,\n token,\n matchStart,\n matchEnd,\n openerLength,\n closerLength,\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; // scan marker length\n\n while (pos < max && state.src.charCodeAt(pos) === 0x60\n /* ` */\n ) {\n pos++;\n }\n\n marker = state.src.slice(start, pos);\n openerLength = marker.length;\n\n if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {\n if (!silent) state.pending += marker;\n state.pos += openerLength;\n return true;\n }\n\n matchStart = matchEnd = pos; // Nothing found in the cache, scan until the end of the line (or until marker is found)\n\n while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n matchEnd = matchStart + 1; // scan marker length\n\n while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60\n /* ` */\n ) {\n matchEnd++;\n }\n\n closerLength = matchEnd - matchStart;\n\n if (closerLength === openerLength) {\n // Found matching closer 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 } // Some different length found, put it in cache as upper limit of where closer can be found\n\n\n state.backticks[closerLength] = matchStart;\n } // Scanned through the end, didn't find anything\n\n\n state.backticksScanned = true;\n if (!silent) state.pending += marker;\n state.pos += openerLength;\n return true;\n};","// Process [link]( \"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 token,\n href = '',\n title = '',\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]( \"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]( \"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 } // [link]( \"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]( \"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]( \"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 }\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.linkLevel++;\n state.md.inline.tokenize(state);\n state.linkLevel--;\n token = state.push('link_close', 'a', -1);\n }\n\n state.pos = pos;\n state.posMax = max;\n return true;\n};","// Process ![image]( \"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]( \"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]( \"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]( \"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]( \"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]( \"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 ''\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 url,\n fullUrl,\n token,\n ch,\n start,\n max,\n pos = state.pos;\n\n if (state.src.charCodeAt(pos) !== 0x3C\n /* < */\n ) {\n return false;\n }\n\n start = state.pos;\n max = state.posMax;\n\n for (;;) {\n if (++pos >= max) return false;\n ch = state.src.charCodeAt(pos);\n if (ch === 0x3C\n /* < */\n ) return false;\n if (ch === 0x3E\n /* > */\n ) break;\n }\n\n url = state.src.slice(start + 1, pos);\n\n if (AUTOLINK_RE.test(url)) {\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 += url.length + 2;\n return true;\n }\n\n if (EMAIL_RE.test(url)) {\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 += url.length + 2;\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 isLinkOpen(str) {\n return /^\\s]/i.test(str);\n}\n\nfunction isLinkClose(str) {\n return /^<\\/a\\s*>/i.test(str);\n}\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 if (isLinkOpen(token.content)) state.linkLevel++;\n if (isLinkClose(token.content)) state.linkLevel--;\n }\n\n state.pos += match[0].length;\n return true;\n};","// Process html entity - {, ¯, ", ...\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 token,\n pos = state.pos,\n max = state.posMax;\n if (state.src.charCodeAt(pos) !== 0x26\n /* & */\n ) return false;\n if (pos + 1 >= max) return false;\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 token = state.push('text_special', '', 0);\n token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\n token.markup = match[0];\n token.info = 'entity';\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 token = state.push('text_special', '', 0);\n token.content = entities[match[1]];\n token.markup = match[0];\n token.info = 'entity';\n }\n\n state.pos += match[0].length;\n return true;\n }\n }\n }\n\n return false;\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 if (!max) return; // headerIdx is the first delimiter of the current (where closer is) delimiter run\n\n var headerIdx = 0;\n var lastTokenIdx = -2; // needs any value lower than -1\n\n var jumps = [];\n\n for (closerIdx = 0; closerIdx < max; closerIdx++) {\n closer = delimiters[closerIdx];\n jumps.push(0); // markers belong to same delimiter run if:\n // - they have adjacent tokens\n // - AND markers are the same\n //\n\n if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {\n headerIdx = closerIdx;\n }\n\n lastTokenIdx = closer.token; // 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, each delimiter length modulo 3,\n // and for whether this closer can be an opener;\n // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460\n\n if (!openersBottom.hasOwnProperty(closer.marker)) {\n openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];\n }\n\n minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + closer.length % 3];\n openerIdx = headerIdx - jumps[headerIdx] - 1;\n newMinOpenerIdx = openerIdx;\n\n for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {\n opener = delimiters[openerIdx];\n if (opener.marker !== closer.marker) continue;\n\n if (opener.open && opener.end < 0) {\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 ? jumps[openerIdx - 1] + 1 : 0;\n jumps[closerIdx] = closerIdx - openerIdx + lastJump;\n jumps[openerIdx] = lastJump;\n closer.open = false;\n opener.end = closerIdx;\n opener.close = false;\n newMinOpenerIdx = -1; // treat next token as start of run,\n // it optimizes skips in **<...>**a**<...>** pathological case\n\n lastTokenIdx = -2;\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.open ? 3 : 0) + (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 fragments_join(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 = []; // backtick length => last seen position\n\n this.backticks = {};\n this.backticksScanned = false; // Counter used to disable inline linkify-it execution\n // inside and markdown links\n\n this.linkLevel = 0;\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;","// 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 (
)\n breaks: false,\n // Convert '\\n' in paragraphs into
\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 )\n breaks: false,\n // Convert '\\n' in paragraphs into
\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 )\n breaks: false,\n // Convert '\\n' in paragraphs into
\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 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 * Additional information:\n *\n * - Info string for \"fence\" tokens\n * - The value \"auto\" for autolink \"link_open\" and \"link_close\" tokens\n * - The string value of the item marker for ordered-list \"list_item_open\" tokens\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;","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]/;","'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.schema_at_start = RegExp('^' + self.re.schema_search.source, 'i');\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/**\n * LinkifyIt#matchAtStart(text) -> Match|null\n *\n * Returns fully-formed (not fuzzy) link if it starts at the beginning\n * of the string, and null otherwise.\n **/\n\n\nLinkifyIt.prototype.matchAtStart = function matchAtStart(text) {\n // Reset scan cache\n this.__text_cache__ = text;\n this.__index__ = -1;\n if (!text.length) return null;\n var m = this.re.schema_at_start.exec(text);\n if (!m) return null;\n var len = this.testSchemaAt(text, m[2], m[0].length);\n if (!len) return null;\n this.__schema__ = m[2];\n this.__index__ = m.index + m[1].length;\n this.__last_index__ = m.index + m[0].length + len;\n return createMatch(this, 0);\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;","var DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar isForced = require('../internals/is-forced');\nvar inheritIfRequired = require('../internals/inherit-if-required');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar isRegExp = require('../internals/is-regexp');\nvar getFlags = require('../internals/regexp-flags');\nvar stickyHelpers = require('../internals/regexp-sticky-helpers');\nvar redefine = require('../internals/redefine');\nvar fails = require('../internals/fails');\nvar enforceInternalState = require('../internals/internal-state').enforce;\nvar setSpecies = require('../internals/set-species');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\nvar NativeRegExp = global.RegExp;\nvar RegExpPrototype = NativeRegExp.prototype;\nvar re1 = /a/g;\nvar re2 = /a/g;\n\n// \"new\" should create a new object, old webkit bug\nvar CORRECT_NEW = new NativeRegExp(re1) !== re1;\n\nvar UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;\n\nvar FORCED = DESCRIPTORS && isForced('RegExp', (!CORRECT_NEW || UNSUPPORTED_Y || fails(function () {\n re2[MATCH] = false;\n // RegExp constructor can alter flags and IsRegExp works correct with @@match\n return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';\n})));\n\n// `RegExp` constructor\n// https://tc39.es/ecma262/#sec-regexp-constructor\nif (FORCED) {\n var RegExpWrapper = function RegExp(pattern, flags) {\n var thisIsRegExp = this instanceof RegExpWrapper;\n var patternIsRegExp = isRegExp(pattern);\n var flagsAreUndefined = flags === undefined;\n var sticky;\n\n if (!thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined) {\n return pattern;\n }\n\n if (CORRECT_NEW) {\n if (patternIsRegExp && !flagsAreUndefined) pattern = pattern.source;\n } else if (pattern instanceof RegExpWrapper) {\n if (flagsAreUndefined) flags = getFlags.call(pattern);\n pattern = pattern.source;\n }\n\n if (UNSUPPORTED_Y) {\n sticky = !!flags && flags.indexOf('y') > -1;\n if (sticky) flags = flags.replace(/y/g, '');\n }\n\n var result = inheritIfRequired(\n CORRECT_NEW ? new NativeRegExp(pattern, flags) : NativeRegExp(pattern, flags),\n thisIsRegExp ? this : RegExpPrototype,\n RegExpWrapper\n );\n\n if (UNSUPPORTED_Y && sticky) {\n var state = enforceInternalState(result);\n state.sticky = true;\n }\n\n return result;\n };\n var proxy = function (key) {\n key in RegExpWrapper || defineProperty(RegExpWrapper, key, {\n configurable: true,\n get: function () { return NativeRegExp[key]; },\n set: function (it) { NativeRegExp[key] = it; }\n });\n };\n var keys = getOwnPropertyNames(NativeRegExp);\n var index = 0;\n while (keys.length > index) proxy(keys[index++]);\n RegExpPrototype.constructor = RegExpWrapper;\n RegExpWrapper.prototype = RegExpPrototype;\n redefine(global, 'RegExp', RegExpWrapper);\n}\n\n// https://tc39.es/ecma262/#sec-get-regexp-@@species\nsetSpecies('RegExp');\n","// HTML5 entities map: { name -> utf16string }\n//\n'use strict';\n/*eslint quotes:0*/\n\nmodule.exports = require('entities/lib/maps/entities.json');","// 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 = '<[?][\\\\s\\\\S]*?[?]>';\nvar declaration = ']*>';\nvar cdata = '';\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 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 // 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 // `whatever` -> `whatever`\n //\n\n isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && // check that first two markers match and adjacent\n delimiters[i - 1].marker === startDelim.marker && delimiters[i - 1].token === startDelim.token - 1 && // check that last two markers are adjacent (we can safely assume they match)\n delimiters[startDelim.end + 1].token === endDelim.token + 1;\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};","\"use strict\"; // Adapted from https://github.com/markdown-it/markdown-it/blob/fbc6b0fed563ba7c00557ab638fd19752f8e759d/docs/architecture.md\n\nfunction findFirstMatchingConfig(link, configs) {\n var i, config;\n var href = link.attrs[link.attrIndex(\"href\")][1];\n\n for (i = 0; i < configs.length; ++i) {\n config = configs[i]; // If there is a matcher function defined then call it\n // Matcher Function should return a boolean indicating\n // whether or not it matched. If it matched, use that\n // configuration, otherwise, try the next one.\n\n if (typeof config.matcher === \"function\") {\n if (config.matcher(href, config)) {\n return config;\n } else {\n continue;\n }\n }\n\n return config;\n }\n}\n\nfunction applyAttributes(idx, tokens, attributes) {\n Object.keys(attributes).forEach(function (attr) {\n var attrIndex;\n var value = attributes[attr];\n\n if (attr === \"className\") {\n // when dealing with applying classes\n // programatically, some programmers\n // may prefer to use the className syntax\n attr = \"class\";\n }\n\n attrIndex = tokens[idx].attrIndex(attr);\n\n if (attrIndex < 0) {\n // attr doesn't exist, add new attribute\n tokens[idx].attrPush([attr, value]);\n } else {\n // attr already exists, overwrite it\n tokens[idx].attrs[attrIndex][1] = value; // replace value of existing attr\n }\n });\n}\n\nfunction markdownitLinkAttributes(md, configs) {\n if (!configs) {\n configs = [];\n } else {\n configs = Array.isArray(configs) ? configs : [configs];\n }\n\n Object.freeze(configs);\n var defaultRender = md.renderer.rules.link_open || this.defaultRender;\n\n md.renderer.rules.link_open = function (tokens, idx, options, env, self) {\n var config = findFirstMatchingConfig(tokens[idx], configs);\n var attributes = config && config.attrs;\n\n if (attributes) {\n applyAttributes(idx, tokens, attributes);\n } // pass token to default renderer.\n\n\n return defaultRender(tokens, idx, options, env, self);\n };\n}\n\nmarkdownitLinkAttributes.defaultRender = function (tokens, idx, options, env, self) {\n return self.renderToken(tokens, idx, options);\n};\n\nmodule.exports = markdownitLinkAttributes;","'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');","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _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 \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 (;\n /* no initialization */\n 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 /* no final expression */\n {\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;;\n /* no condition */\n 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 state to ,\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;;\n /* no condition */\n 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 \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);","// Utilities\n//\n'use strict';\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _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 '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"'\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; 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L; 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;"],"sourceRoot":""}