{"mappings":"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","names":["require_entities","__commonJSMin","exports","module","require_utils","__commonJSMin","exports","_class","obj","isString","_hasOwnProperty","has","object","key","assign","sources","source","arrayReplaceAt","src","pos","newElements","isValidEntityCode","c","fromCodePoint","surrogate1","surrogate2","UNESCAPE_MD_RE","ENTITY_RE","UNESCAPE_ALL_RE","DIGITAL_ENTITY_TEST_RE","entities","replaceEntityPattern","match","name","code","unescapeMd","str","unescapeAll","escaped","entity","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","ch","escapeHtml","REGEXP_ESCAPE_RE","escapeRE","isSpace","isWhiteSpace","UNICODE_PUNCT_RE","isPunctChar","isMdAsciiPunct","normalizeReference","require_parse_link_label","__commonJSMin","exports","module","state","start","disableNested","level","found","marker","prevPos","labelEnd","max","oldPos","require_parse_link_destination","__commonJSMin","exports","module","unescapeAll","str","start","max","code","level","pos","result","require_parse_link_title","__commonJSMin","exports","module","unescapeAll","str","start","max","code","marker","lines","pos","result","require_helpers","__commonJSMin","exports","require_renderer","__commonJSMin","exports","module","assign","unescapeAll","escapeHtml","default_rules","tokens","idx","options","env","slf","token","info","langName","langAttrs","highlighted","i","arr","tmpAttrs","tmpToken","Renderer","l","result","nextToken","needLf","type","rules","len","require_ruler","__commonJSMin","exports","module","Ruler","name","i","self","chains","rule","altName","chain","fn","options","index","opt","beforeName","ruleName","afterName","list","ignoreInvalid","result","idx","chainName","require_normalize","__commonJSMin","exports","module","NEWLINES_RE","NULL_RE","state","str","require_block","__commonJSMin","exports","module","state","token","require_inline","__commonJSMin","exports","module","state","tokens","tok","i","l","require_linkify","__commonJSMin","exports","module","arrayReplaceAt","isLinkOpen","str","isLinkClose","state","i","j","l","tokens","token","currentToken","nodes","ln","text","pos","lastPos","level","htmlLinkLevel","url","fullUrl","urlText","blockTokens","links","require_replacements","__commonJSMin","exports","module","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","replaceFn","match","name","replace_scoped","inlineTokens","i","token","inside_autolink","replace_rare","state","blkIdx","require_smartquotes","__commonJSMin","exports","module","isWhiteSpace","isPunctChar","isMdAsciiPunct","QUOTE_TEST_RE","QUOTE_RE","APOSTROPHE","replaceAt","str","index","ch","process_inlines","tokens","state","i","token","text","t","pos","max","thisLevel","item","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","canOpen","canClose","j","isSingle","stack","openQuote","closeQuote","OUTER","blkIdx","require_text_join","__commonJSMin","exports","module","state","j","l","tokens","curr","max","last","blockTokens","require_token","__commonJSMin","exports","module","Token","type","tag","nesting","name","attrs","len","attrData","value","idx","require_state_core","__commonJSMin","exports","module","Token","StateCore","src","md","env","require_parser_core","__commonJSMin","exports","module","Ruler","_rules","Core","i","state","l","rules","require_table","__commonJSMin","exports","module","isSpace","getLine","state","line","pos","max","escapedSplit","str","result","ch","isEscaped","lastPos","current","startLine","endLine","silent","lineText","i","l","nextLine","columns","columnCount","token","aligns","t","tableLines","tbodyLines","oldParentType","terminate","terminatorRules","firstCh","secondCh","require_code","__commonJSMin","exports","module","state","startLine","endLine","nextLine","last","token","require_fence","__commonJSMin","exports","module","state","startLine","endLine","silent","marker","len","params","nextLine","mem","token","markup","haveEndMarker","pos","max","require_blockquote","__commonJSMin","exports","module","isSpace","state","startLine","endLine","silent","adjustTab","ch","i","initial","l","lastLineEmpty","lines","nextLine","offset","oldBMarks","oldBSCount","oldIndent","oldParentType","oldSCount","oldTShift","spaceAfterMarker","terminate","terminatorRules","token","isOutdented","oldLineMax","pos","max","require_hr","__commonJSMin","exports","module","isSpace","state","startLine","endLine","silent","marker","cnt","ch","token","pos","max","require_list","__commonJSMin","exports","module","isSpace","skipBulletListMarker","state","startLine","marker","pos","max","ch","skipOrderedListMarker","start","markTightParagraphs","idx","i","l","level","endLine","silent","contentStart","indent","indentAfterMarker","initial","isOrdered","itemLines","listLines","listTokIdx","markerCharCode","markerValue","offset","oldListIndent","oldParentType","oldSCount","oldTShift","oldTight","posAfterMarker","prevEmptyEnd","terminate","terminatorRules","token","nextLine","isTerminatingParagraph","tight","require_reference","__commonJSMin","exports","module","normalizeReference","isSpace","state","startLine","_endLine","silent","ch","destEndPos","destEndLineNo","endLine","href","i","l","label","labelEnd","oldParentType","res","start","str","terminate","terminatorRules","title","lines","pos","max","nextLine","require_html_blocks","__commonJSMin","exports","module","require_html_re","__commonJSMin","exports","module","attr_name","unquoted","single_quoted","double_quoted","attr_value","attribute","open_tag","close_tag","comment","processing","declaration","cdata","HTML_TAG_RE","HTML_OPEN_CLOSE_TAG_RE","require_html_block","__commonJSMin","exports","module","block_names","HTML_OPEN_CLOSE_TAG_RE","HTML_SEQUENCES","state","startLine","endLine","silent","i","nextLine","token","lineText","pos","max","require_heading","__commonJSMin","exports","module","isSpace","state","startLine","endLine","silent","ch","level","tmp","token","pos","max","require_lheading","__commonJSMin","exports","module","state","startLine","endLine","content","terminate","i","l","token","pos","max","level","marker","nextLine","oldParentType","terminatorRules","require_paragraph","__commonJSMin","exports","module","state","startLine","endLine","content","terminate","i","l","token","oldParentType","nextLine","terminatorRules","require_state_block","__commonJSMin","exports","module","Token","isSpace","StateBlock","src","md","env","tokens","ch","s","start","pos","len","indent","offset","indent_found","type","tag","nesting","token","line","from","max","min","code","begin","end","keepLastLF","i","lineIndent","first","last","queue","lineStart","require_parser_block","__commonJSMin","exports","module","Ruler","_rules","ParserBlock","i","state","startLine","endLine","ok","prevLine","rules","len","line","hasEmptyLines","maxNesting","src","md","env","outTokens","require_text","__commonJSMin","exports","module","isTerminatorChar","ch","state","silent","pos","require_linkify","__commonJSMin","exports","module","SCHEME_RE","state","silent","pos","max","match","proto","link","url","fullUrl","token","require_newline","__commonJSMin","exports","module","isSpace","state","silent","pmax","max","ws","pos","require_escape","__commonJSMin","exports","module","isSpace","ESCAPED","i","ch","state","silent","ch1","ch2","origStr","escapedStr","token","pos","max","require_backticks","__commonJSMin","exports","module","state","silent","start","max","marker","token","matchStart","matchEnd","openerLength","closerLength","pos","ch","require_strikethrough","__commonJSMin","exports","module","state","silent","scanned","token","len","ch","start","marker","postProcess","delimiters","i","j","startDelim","endDelim","loneMarkers","max","curr","tokens_meta","require_emphasis","__commonJSMin","exports","module","state","silent","scanned","token","start","marker","postProcess","delimiters","i","startDelim","endDelim","ch","isStrong","max","curr","tokens_meta","require_link","__commonJSMin","exports","module","normalizeReference","isSpace","state","silent","attrs","code","label","labelEnd","labelStart","pos","res","ref","token","href","title","oldPos","max","start","parseReference","require_image","__commonJSMin","exports","module","normalizeReference","isSpace","state","silent","attrs","code","content","label","labelEnd","labelStart","pos","ref","res","title","token","tokens","start","href","oldPos","max","require_autolink","__commonJSMin","exports","module","EMAIL_RE","AUTOLINK_RE","state","silent","url","fullUrl","token","ch","start","max","pos","require_html_inline","__commonJSMin","exports","module","HTML_TAG_RE","isLinkOpen","str","isLinkClose","isLetter","ch","lc","state","silent","match","max","token","pos","require_entity","__commonJSMin","exports","module","entities","has","isValidEntityCode","fromCodePoint","DIGITAL_RE","NAMED_RE","state","silent","ch","code","match","token","pos","max","require_balance_pairs","__commonJSMin","exports","module","processDelimiters","delimiters","closerIdx","openerIdx","closer","opener","minOpenerIdx","newMinOpenerIdx","isOddMatch","lastJump","openersBottom","max","headerIdx","lastTokenIdx","jumps","state","curr","tokens_meta","require_fragments_join","__commonJSMin","exports","module","state","curr","last","level","tokens","max","require_state_inline","__commonJSMin","exports","module","Token","isWhiteSpace","isPunctChar","isMdAsciiPunct","StateInline","src","md","env","outTokens","token","type","tag","nesting","token_meta","start","canSplitWord","pos","lastChar","nextChar","count","can_open","can_close","isLastWhiteSpace","isLastPunctChar","isNextWhiteSpace","isNextPunctChar","left_flanking","right_flanking","max","marker","require_parser_inline","__commonJSMin","exports","module","Ruler","_rules","_rules2","ParserInline","i","state","ok","pos","rules","len","maxNesting","cache","prevPos","end","str","md","env","outTokens","require_default","__commonJSMin","exports","module","require_zero","__commonJSMin","exports","module","require_commonmark","__commonJSMin","exports","module","require_lib","__commonJSMin","exports","module","utils","helpers","Renderer","ParserCore","ParserBlock","ParserInline","LinkifyIt","mdurl","punycode","config","BAD_PROTO_RE","GOOD_DATA_RE","validateLink","url","str","RECODE_HOSTNAME_FOR","normalizeLink","parsed","er","normalizeLinkText","MarkdownIt","presetName","options","presets","self","name","list","ignoreInvalid","result","chain","missed","plugin","args","src","env","state","require_markdown_it","__commonJSMin","exports","module","cjsm","_a","endpoint_default"],"sources":["../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/common/entities.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/common/utils.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/helpers/parse_link_label.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/helpers/parse_link_destination.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/helpers/parse_link_title.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/helpers/index.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/renderer.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/ruler.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/normalize.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/block.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/inline.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/linkify.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/replacements.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/smartquotes.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/text_join.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/token.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_core/state_core.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/parser_core.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/table.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/code.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/fence.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/blockquote.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/hr.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/list.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/reference.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/common/html_blocks.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/common/html_re.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/html_block.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/heading.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/lheading.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/paragraph.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_block/state_block.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/parser_block.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/text.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/linkify.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/newline.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/escape.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/backticks.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/strikethrough.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/emphasis.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/link.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/image.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/autolink.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/html_inline.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/entity.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/balance_pairs.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/fragments_join.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/rules_inline/state_inline.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/parser_inline.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/presets/default.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/presets/zero.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/presets/commonmark.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/lib/index.js","../esm/npm/markdown-it@13.0.2/node_modules/markdown-it/index.js","endpoint.js"],"sourcesContent":["// HTML5 entities map: { name -\u003e utf16string }\n//\n'use strict';\n\n/*eslint quotes:0*/\nmodule.exports = require('entities/lib/maps/entities.json');\n","// Utilities\n//\n'use strict';\n\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\n\nfunction isString(obj) { return _class(obj) === '[object String]'; }\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction has(object, key) {\n  return _hasOwnProperty.call(object, key);\n}\n\n// Merge objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return; }\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\n  return obj;\n}\n\n// Remove element from array and put another array at those position.\n// Useful for some operations with tokens\nfunction arrayReplaceAt(src, pos, newElements) {\n  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction isValidEntityCode(c) {\n  /*eslint no-bitwise:0*/\n  // broken sequence\n  if (c \u003e= 0xD800 \u0026\u0026 c \u003c= 0xDFFF) { return false; }\n  // never used\n  if (c \u003e= 0xFDD0 \u0026\u0026 c \u003c= 0xFDEF) { return false; }\n  if ((c \u0026 0xFFFF) === 0xFFFF || (c \u0026 0xFFFF) === 0xFFFE) { return false; }\n  // control codes\n  if (c \u003e= 0x00 \u0026\u0026 c \u003c= 0x08) { return false; }\n  if (c === 0x0B) { return false; }\n  if (c \u003e= 0x0E \u0026\u0026 c \u003c= 0x1F) { return false; }\n  if (c \u003e= 0x7F \u0026\u0026 c \u003c= 0x9F) { return false; }\n  // out of range\n  if (c \u003e 0x10FFFF) { return false; }\n  return true;\n}\n\nfunction fromCodePoint(c) {\n  /*eslint no-bitwise:0*/\n  if (c \u003e 0xffff) {\n    c -= 0x10000;\n    var surrogate1 = 0xd800 + (c \u003e\u003e 10),\n        surrogate2 = 0xdc00 + (c \u0026 0x3ff);\n\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n  return String.fromCharCode(c);\n}\n\n\nvar UNESCAPE_MD_RE  = /\\\\([!\"#$%\u0026'()*+,\\-.\\/:;\u003c=\u003e?@[\\\\\\]^_`{|}~])/g;\nvar ENTITY_RE       = /\u0026([a-z#][a-z0-9]{1,31});/gi;\nvar UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');\n\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;\n\n  if (has(entities, name)) {\n    return entities[name];\n  }\n\n  if (name.charCodeAt(0) === 0x23/* # */ \u0026\u0026 DIGITAL_ENTITY_TEST_RE.test(name)) {\n    code = name[1].toLowerCase() === 'x' ?\n      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\n/*function replaceEntities(str) {\n  if (str.indexOf('\u0026') \u003c 0) { return str; }\n\n  return str.replace(ENTITY_RE, replaceEntityPattern);\n}*/\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') \u003c 0) { return str; }\n  return str.replace(UNESCAPE_MD_RE, '$1');\n}\n\nfunction unescapeAll(str) {\n  if (str.indexOf('\\\\') \u003c 0 \u0026\u0026 str.indexOf('\u0026') \u003c 0) { return str; }\n\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) { return escaped; }\n    return replaceEntityPattern(match, entity);\n  });\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar HTML_ESCAPE_TEST_RE = /[\u0026\u003c\u003e\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[\u0026\u003c\u003e\"]/g;\nvar HTML_REPLACEMENTS = {\n  '\u0026': '\u0026amp;',\n  '\u003c': '\u0026lt;',\n  '\u003e': '\u0026gt;',\n  '\"': '\u0026quot;'\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  return str;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g;\n\nfunction escapeRE(str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$\u0026');\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction isSpace(code) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true;\n  }\n  return false;\n}\n\n// Zs (unicode class) || [\\t\\f\\v\\r\\n]\nfunction isWhiteSpace(code) {\n  if (code \u003e= 0x2000 \u0026\u0026 code \u003c= 0x200A) { return true; }\n  switch (code) {\n    case 0x09: // \\t\n    case 0x0A: // \\n\n    case 0x0B: // \\v\n    case 0x0C: // \\f\n    case 0x0D: // \\r\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true;\n  }\n  return false;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n/*eslint-disable max-len*/\nvar UNICODE_PUNCT_RE = require('uc.micro/categories/P/regex');\n\n// Currently without astral characters support.\nfunction isPunctChar(ch) {\n  return UNICODE_PUNCT_RE.test(ch);\n}\n\n\n// Markdown ASCII punctuation characters.\n//\n// !, \", #, $, %, \u0026, ', (, ), *, +, ,, -, ., /, :, ;, \u003c, =, \u003e, ?, @, [, \\, ], ^, _, `, {, |, }, 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//\nfunction isMdAsciiPunct(ch) {\n  switch (ch) {\n    case 0x21/* ! */:\n    case 0x22/* \" */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* \u0026 */:\n    case 0x27/* ' */:\n    case 0x28/* ( */:\n    case 0x29/* ) */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2C/* , */:\n    case 0x2D/* - */:\n    case 0x2E/* . */:\n    case 0x2F/* / */:\n    case 0x3A/* : */:\n    case 0x3B/* ; */:\n    case 0x3C/* \u003c */:\n    case 0x3D/* = */:\n    case 0x3E/* \u003e */:\n    case 0x3F/* ? */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7C/* | */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\n\n// Hepler to unify [reference labels].\n//\nfunction normalizeReference(str) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' ');\n\n  // 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  if ('ẞ'.toLowerCase() === 'Ṿ') {\n    str = str.replace(/ẞ/g, 'ß');\n  }\n\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  // İ, ϴ, ẞ, Ω, K, Å - 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;\u003ccompat\u003e 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;\u003ccompat\u003e 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  return str.toLowerCase().toUpperCase();\n}\n\n////////////////////////////////////////////////////////////////////////////////\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//\nexports.lib                 = {};\nexports.lib.mdurl           = require('mdurl');\nexports.lib.ucmicro         = require('uc.micro');\n\nexports.assign              = assign;\nexports.isString            = isString;\nexports.has                 = has;\nexports.unescapeMd          = unescapeMd;\nexports.unescapeAll         = unescapeAll;\nexports.isValidEntityCode   = isValidEntityCode;\nexports.fromCodePoint       = fromCodePoint;\n// exports.replaceEntities     = replaceEntities;\nexports.escapeHtml          = escapeHtml;\nexports.arrayReplaceAt      = arrayReplaceAt;\nexports.isSpace             = isSpace;\nexports.isWhiteSpace        = isWhiteSpace;\nexports.isMdAsciiPunct      = isMdAsciiPunct;\nexports.isPunctChar         = isPunctChar;\nexports.escapeRE            = escapeRE;\nexports.normalizeReference  = normalizeReference;\n","// 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, found, marker, prevPos,\n      labelEnd = -1,\n      max = state.posMax,\n      oldPos = state.pos;\n\n  state.pos = start + 1;\n  level = 1;\n\n  while (state.pos \u003c max) {\n    marker = state.src.charCodeAt(state.pos);\n    if (marker === 0x5D /* ] */) {\n      level--;\n      if (level === 0) {\n        found = true;\n        break;\n      }\n    }\n\n    prevPos = state.pos;\n    state.md.inline.skipToken(state);\n    if (marker === 0x5B /* [ */) {\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  }\n\n  // restore old state\n  state.pos = oldPos;\n\n  return labelEnd;\n};\n","// Parse link destination\n//\n'use strict';\n\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\n\nmodule.exports = function parseLinkDestination(str, start, max) {\n  var code, level,\n      pos = start,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (str.charCodeAt(pos) === 0x3C /* \u003c */) {\n    pos++;\n    while (pos \u003c max) {\n      code = str.charCodeAt(pos);\n      if (code === 0x0A /* \\n */) { return result; }\n      if (code === 0x3C /* \u003c */) { return result; }\n      if (code === 0x3E /* \u003e */) {\n        result.pos = pos + 1;\n        result.str = unescapeAll(str.slice(start + 1, pos));\n        result.ok = true;\n        return result;\n      }\n      if (code === 0x5C /* \\ */ \u0026\u0026 pos + 1 \u003c max) {\n        pos += 2;\n        continue;\n      }\n\n      pos++;\n    }\n\n    // no closing '\u003e'\n    return result;\n  }\n\n  // this should be ... } else { ... branch\n\n  level = 0;\n  while (pos \u003c max) {\n    code = str.charCodeAt(pos);\n\n    if (code === 0x20) { break; }\n\n    // ascii control characters\n    if (code \u003c 0x20 || code === 0x7F) { break; }\n\n    if (code === 0x5C /* \\ */ \u0026\u0026 pos + 1 \u003c max) {\n      if (str.charCodeAt(pos + 1) === 0x20) { break; }\n      pos += 2;\n      continue;\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++;\n      if (level \u003e 32) { return result; }\n    }\n\n    if (code === 0x29 /* ) */) {\n      if (level === 0) { break; }\n      level--;\n    }\n\n    pos++;\n  }\n\n  if (start === pos) { return result; }\n  if (level !== 0) { return result; }\n\n  result.str = unescapeAll(str.slice(start, pos));\n  result.pos = pos;\n  result.ok = true;\n  return result;\n};\n","// Parse link title\n//\n'use strict';\n\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\n\nmodule.exports = function parseLinkTitle(str, start, max) {\n  var code,\n      marker,\n      lines = 0,\n      pos = start,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (pos \u003e= max) { return result; }\n\n  marker = str.charCodeAt(pos);\n\n  if (marker !== 0x22 /* \" */ \u0026\u0026 marker !== 0x27 /* ' */ \u0026\u0026 marker !== 0x28 /* ( */) { return result; }\n\n  pos++;\n\n  // if opening marker is \"(\", switch it to closing marker \")\"\n  if (marker === 0x28) { marker = 0x29; }\n\n  while (pos \u003c max) {\n    code = str.charCodeAt(pos);\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 /* ( */ \u0026\u0026 marker === 0x29 /* ) */) {\n      return result;\n    } else if (code === 0x0A) {\n      lines++;\n    } else if (code === 0x5C /* \\ */ \u0026\u0026 pos + 1 \u003c max) {\n      pos++;\n      if (str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n\n    pos++;\n  }\n\n  return result;\n};\n","// Just a shortcut for bulk export\n'use strict';\n\n\nexports.parseLinkLabel       = require('./parse_link_label');\nexports.parseLinkDestination = require('./parse_link_destination');\nexports.parseLinkTitle       = require('./parse_link_title');\n","/**\n * class Renderer\n *\n * Generates HTML from parsed token stream. Each instance has independent\n * copy of rules. Those can be rewritten with ease. Also, you can add new\n * rules if you create plugin and adds new token types.\n **/\n'use strict';\n\n\nvar assign          = require('./common/utils').assign;\nvar unescapeAll     = require('./common/utils').unescapeAll;\nvar escapeHtml      = require('./common/utils').escapeHtml;\n\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar default_rules = {};\n\n\ndefault_rules.code_inline = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  return  '\u003ccode' + slf.renderAttrs(token) + '\u003e' +\n          escapeHtml(token.content) +\n          '\u003c/code\u003e';\n};\n\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  return  '\u003cpre' + slf.renderAttrs(token) + '\u003e\u003ccode\u003e' +\n          escapeHtml(tokens[idx].content) +\n          '\u003c/code\u003e\u003c/pre\u003e\\n';\n};\n\n\ndefault_rules.fence = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx],\n      info = token.info ? unescapeAll(token.info).trim() : '',\n      langName = '',\n      langAttrs = '',\n      highlighted, i, arr, tmpAttrs, 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('\u003cpre') === 0) {\n    return highlighted + '\\n';\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .deepClone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    i        = token.attrIndex('class');\n    tmpAttrs = token.attrs ? token.attrs.slice() : [];\n\n    if (i \u003c 0) {\n      tmpAttrs.push([ 'class', options.langPrefix + langName ]);\n    } else {\n      tmpAttrs[i] = tmpAttrs[i].slice();\n      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;\n    }\n\n    // Fake token just to render attributes\n    tmpToken = {\n      attrs: tmpAttrs\n    };\n\n    return  '\u003cpre\u003e\u003ccode' + slf.renderAttrs(tmpToken) + '\u003e'\n          + highlighted\n          + '\u003c/code\u003e\u003c/pre\u003e\\n';\n  }\n\n\n  return  '\u003cpre\u003e\u003ccode' + slf.renderAttrs(token) + '\u003e'\n        + highlighted\n        + '\u003c/code\u003e\u003c/pre\u003e\\n';\n};\n\n\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs[token.attrIndex('alt')][1] =\n    slf.renderInlineAsText(token.children, options, env);\n\n  return slf.renderToken(tokens, idx, options);\n};\n\n\ndefault_rules.hardbreak = function (tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '\u003cbr /\u003e\\n' : '\u003cbr\u003e\\n';\n};\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '\u003cbr /\u003e\\n' : '\u003cbr\u003e\\n') : '\\n';\n};\n\n\ndefault_rules.text = function (tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\n\n\ndefault_rules.html_block = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\ndefault_rules.html_inline = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\nfunction Renderer() {\n\n  /**\n   * Renderer#rules -\u003e 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 '\u003cb\u003e'; };\n   * md.renderer.rules.strong_close = function () { return '\u003c/b\u003e'; };\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\n/**\n * Renderer.renderAttrs(token) -\u003e String\n *\n * Render token attributes to string.\n **/\nRenderer.prototype.renderAttrs = function renderAttrs(token) {\n  var i, l, result;\n\n  if (!token.attrs) { return ''; }\n\n  result = '';\n\n  for (i = 0, l = token.attrs.length; i \u003c l; i++) {\n    result += ' ' + escapeHtml(token.attrs[i][0]) + '=\"' + escapeHtml(token.attrs[i][1]) + '\"';\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.renderToken(tokens, idx, options) -\u003e String\n * - tokens (Array): list of tokens\n * - idx (Numbed): token index to render\n * - options (Object): params of parser instance\n *\n * Default token renderer. Can be overriden by custom function\n * in [[Renderer#rules]].\n **/\nRenderer.prototype.renderToken = function renderToken(tokens, idx, options) {\n  var nextToken,\n      result = '',\n      needLf = false,\n      token = tokens[idx];\n\n  // Tight list paragraphs\n  if (token.hidden) {\n    return '';\n  }\n\n  // Insert a newline between hidden paragraph and subsequent opening\n  // block-level tag.\n  //\n  // For example, here we should insert a newline before blockquote:\n  //  - a\n  //    \u003e\n  //\n  if (token.block \u0026\u0026 token.nesting !== -1 \u0026\u0026 idx \u0026\u0026 tokens[idx - 1].hidden) {\n    result += '\\n';\n  }\n\n  // Add token name, e.g. `\u003cimg`\n  result += (token.nesting === -1 ? '\u003c/' : '\u003c') + token.tag;\n\n  // Encode attributes, e.g. `\u003cimg src=\"foo\"`\n  result += this.renderAttrs(token);\n\n  // Add a slash for self-closing tags, e.g. `\u003cimg src=\"foo\" /`\n  if (token.nesting === 0 \u0026\u0026 options.xhtmlOut) {\n    result += ' /';\n  }\n\n  // Check if we need to add a newline after this tag\n  if (token.block) {\n    needLf = true;\n\n    if (token.nesting === 1) {\n      if (idx + 1 \u003c tokens.length) {\n        nextToken = tokens[idx + 1];\n\n        if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n          needLf = false;\n\n        } else if (nextToken.nesting === -1 \u0026\u0026 nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `\u003cli\u003e\u003c/li\u003e`.\n          //\n          needLf = false;\n        }\n      }\n    }\n  }\n\n  result += needLf ? '\u003e\\n' : '\u003e';\n\n  return result;\n};\n\n\n/**\n * Renderer.renderInline(tokens, options, env) -\u003e 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 **/\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 \u003c len; i++) {\n    type = tokens[i].type;\n\n    if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options);\n    }\n  }\n\n  return result;\n};\n\n\n/** internal\n * Renderer.renderInlineAsText(tokens, options, env) -\u003e 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 **/\nRenderer.prototype.renderInlineAsText = function (tokens, options, env) {\n  var result = '';\n\n  for (var i = 0, len = tokens.length; i \u003c 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\n/**\n * Renderer.render(tokens, options, env) -\u003e 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 **/\nRenderer.prototype.render = function (tokens, options, env) {\n  var i, len, type,\n      result = '',\n      rules = this.rules;\n\n  for (i = 0, len = tokens.length; i \u003c 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[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options, env);\n    }\n  }\n\n  return result;\n};\n\nmodule.exports = Renderer;\n","/**\n * class Ruler\n *\n * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and\n * [[MarkdownIt#inline]] to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and\n * [[MarkdownIt.use]].\n **/\n'use strict';\n\n\n/**\n * new Ruler()\n **/\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Helper methods, should not be used directly\n\n\n// Find rule index by name\n//\nRuler.prototype.__find__ = function (name) {\n  for (var i = 0; i \u003c this.__rules__.length; i++) {\n    if (this.__rules__[i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n\n// Build rules lookup cache\n//\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = [ '' ];\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) { return; }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) \u003c 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) { return; }\n\n      if (chain \u0026\u0026 rule.alt.indexOf(chain) \u003c 0) { return; }\n\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function \u0026 options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing typographer replacement rule with new one:\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.at('replacements', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.at = function (name, fn, options) {\n  var index = this.__find__(name);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + name); }\n\n  this.__rules__[index].fn = fn;\n  this.__rules__[index].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.before(beforeName, ruleName, fn [, options])\n * - beforeName (String): new rule will be added before this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain before one with given name. See also\n * [[Ruler.after]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var index = this.__find__(beforeName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName); }\n\n  this.__rules__.splice(index, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.after(afterName, ruleName, fn [, options])\n * - afterName (String): new rule will be added after this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain after one with given name. See also\n * [[Ruler.before]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.inline.ruler.after('text', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var index = this.__find__(afterName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + afterName); }\n\n  this.__rules__.splice(index + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.push(ruleName, fn [, options])\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Push new rule to the end of chain. See also\n * [[Ruler.before]], [[Ruler.after]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.push('my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.push = function (ruleName, fn, options) {\n  var opt = options || {};\n\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.enable(list [, ignoreInvalid]) -\u003e Array\n * - list (String|Array): list of rule names to enable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.disable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx \u003c 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.enableOnly(list [, ignoreInvalid])\n * - list (String|Array): list of rule names to enable (whitelist).\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names, and disable everything else. If any rule name\n * not found - throw Error. Errors can be disabled by second param.\n *\n * See also [[Ruler.disable]], [[Ruler.enable]].\n **/\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  this.__rules__.forEach(function (rule) { rule.enabled = false; });\n\n  this.enable(list, ignoreInvalid);\n};\n\n\n/**\n * Ruler.disable(list [, ignoreInvalid]) -\u003e Array\n * - list (String|Array): list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Disable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.enable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx \u003c 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.getRules(chainName) -\u003e Array\n *\n * Return array of active functions (rules) for given chain name. It analyzes\n * rules configuration, compiles caches if not exists and returns result.\n *\n * Default chain name is `''` (empty string). It can't be skipped. That's\n * done intentionally, to keep signature monomorphic for high speed.\n **/\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n\n  // Chain can be empty, if rules disabled. But we still have to return Array.\n  return this.__cache__[chainName] || [];\n};\n\nmodule.exports = Ruler;\n","// Normalize input string\n\n'use strict';\n\n\n// https://spec.commonmark.org/0.29/#line-ending\nvar NEWLINES_RE  = /\\r\\n?|\\n/g;\nvar NULL_RE      = /\\0/g;\n\n\nmodule.exports = function normalize(state) {\n  var str;\n\n  // Normalize newlines\n  str = state.src.replace(NEWLINES_RE, '\\n');\n\n  // Replace NULL characters\n  str = str.replace(NULL_RE, '\\uFFFD');\n\n  state.src = str;\n};\n","'use strict';\n\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};\n","'use strict';\n\nmodule.exports = function inline(state) {\n  var tokens = state.tokens, tok, i, l;\n\n  // Parse inlines\n  for (i = 0, l = tokens.length; i \u003c l; i++) {\n    tok = tokens[i];\n    if (tok.type === 'inline') {\n      state.md.inline.parse(tok.content, state.md, state.env, tok.children);\n    }\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\n\nvar arrayReplaceAt = require('../common/utils').arrayReplaceAt;\n\n\nfunction isLinkOpen(str) {\n  return /^\u003ca[\u003e\\s]/i.test(str);\n}\nfunction isLinkClose(str) {\n  return /^\u003c\\/a\\s*\u003e/i.test(str);\n}\n\n\nmodule.exports = function linkify(state) {\n  var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos,\n      level, htmlLinkLevel, url, fullUrl, urlText,\n      blockTokens = state.tokens,\n      links;\n\n  if (!state.md.options.linkify) { return; }\n\n  for (j = 0, l = blockTokens.length; j \u003c l; j++) {\n    if (blockTokens[j].type !== 'inline' ||\n        !state.md.linkify.pretest(blockTokens[j].content)) {\n      continue;\n    }\n\n    tokens = blockTokens[j].children;\n\n    htmlLinkLevel = 0;\n\n    // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n    for (i = tokens.length - 1; i \u003e= 0; i--) {\n      currentToken = tokens[i];\n\n      // Skip content of markdown links\n      if (currentToken.type === 'link_close') {\n        i--;\n        while (tokens[i].level !== currentToken.level \u0026\u0026 tokens[i].type !== 'link_open') {\n          i--;\n        }\n        continue;\n      }\n\n      // Skip content of html tag links\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen(currentToken.content) \u0026\u0026 htmlLinkLevel \u003e 0) {\n          htmlLinkLevel--;\n        }\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++;\n        }\n      }\n      if (htmlLinkLevel \u003e 0) { continue; }\n\n      if (currentToken.type === 'text' \u0026\u0026 state.md.linkify.test(currentToken.content)) {\n\n        text = currentToken.content;\n        links = state.md.linkify.match(text);\n\n        // Now split string to nodes\n        nodes = [];\n        level = currentToken.level;\n        lastPos = 0;\n\n        // forbid escape sequence at the start of the string,\n        // this avoids http\\://example.com/ from being linkified as\n        // http:\u003ca href=\"//example.com/\"\u003e//example.com/\u003c/a\u003e\n        if (links.length \u003e 0 \u0026\u0026\n            links[0].index === 0 \u0026\u0026\n            i \u003e 0 \u0026\u0026\n            tokens[i - 1].type === 'text_special') {\n          links = links.slice(1);\n        }\n\n        for (ln = 0; ln \u003c links.length; ln++) {\n          url = links[ln].url;\n          fullUrl = state.md.normalizeLink(url);\n          if (!state.md.validateLink(fullUrl)) { continue; }\n\n          urlText = links[ln].text;\n\n          // 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          if (!links[ln].schema) {\n            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\\/\\//, '');\n          } else if (links[ln].schema === 'mailto:' \u0026\u0026 !/^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 \u003e 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\n          token         = new state.Token('text', '', 0);\n          token.content = urlText;\n          token.level   = level;\n          nodes.push(token);\n\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\n          lastPos = links[ln].lastIndex;\n        }\n        if (lastPos \u003c text.length) {\n          token         = new state.Token('text', '', 0);\n          token.content = text.slice(lastPos);\n          token.level   = level;\n          nodes.push(token);\n        }\n\n        // replace current node\n        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);\n      }\n    }\n  }\n};\n","// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → \u0026ndash;, --- → \u0026mdash;\n//\n'use strict';\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -\u003e ½, ¼, ¾\n// - multiplications 2 x 4 -\u003e 2 × 4\n\nvar RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/;\n\n// Workaround for phantomjs - need regex without /g flag,\n// or root check will fail every second time\nvar SCOPED_ABBR_TEST_RE = /\\((c|tm|r)\\)/i;\n\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, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i \u003e= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' \u0026\u0026 !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);\n    }\n\n    if (token.type === 'link_open' \u0026\u0026 token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' \u0026\u0026 token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\nfunction replace_rare(inlineTokens) {\n  var i, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i \u003e= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' \u0026\u0026 !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content\n          .replace(/\\+-/g, '±')\n          // .., ..., ....... -\u003e …\n          // but ?..... \u0026 !..... -\u003e ?.. \u0026 !..\n          .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..')\n          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n          // em-dash\n          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\\u2014')\n          // en-dash\n          .replace(/(^|\\s)--(?=\\s|$)/mg, '$1\\u2013')\n          .replace(/(^|[^-\\s])--(?=[^-\\s]|$)/mg, '$1\\u2013');\n      }\n    }\n\n    if (token.type === 'link_open' \u0026\u0026 token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' \u0026\u0026 token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\n\nmodule.exports = function replace(state) {\n  var blkIdx;\n\n  if (!state.md.options.typographer) { return; }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx \u003e= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline') { continue; }\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  }\n};\n","// Convert straight quotation marks to typographic ones\n//\n'use strict';\n\n\nvar isWhiteSpace   = require('../common/utils').isWhiteSpace;\nvar isPunctChar    = require('../common/utils').isPunctChar;\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,\n      isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace,\n      canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;\n\n  stack = [];\n\n  for (i = 0; i \u003c tokens.length; i++) {\n    token = tokens[i];\n\n    thisLevel = tokens[i].level;\n\n    for (j = stack.length - 1; j \u003e= 0; j--) {\n      if (stack[j].level \u003c= thisLevel) { break; }\n    }\n    stack.length = j + 1;\n\n    if (token.type !== 'text') { continue; }\n\n    text = token.content;\n    pos = 0;\n    max = text.length;\n\n    /*eslint no-labels:0,block-scoped-var:0*/\n    OUTER:\n    while (pos \u003c max) {\n      QUOTE_RE.lastIndex = pos;\n      t = QUOTE_RE.exec(text);\n      if (!t) { break; }\n\n      canOpen = canClose = true;\n      pos = t.index + 1;\n      isSingle = (t[0] === \"'\");\n\n      // Find previous character,\n      // default to space if it's the beginning of the line\n      //\n      lastChar = 0x20;\n\n      if (t.index - 1 \u003e= 0) {\n        lastChar = text.charCodeAt(t.index - 1);\n      } else {\n        for (j = i - 1; j \u003e= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20\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      }\n\n      // Find next character,\n      // default to space if it's the end of the line\n      //\n      nextChar = 0x20;\n\n      if (pos \u003c max) {\n        nextChar = text.charCodeAt(pos);\n      } else {\n        for (j = i + 1; j \u003c tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20\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\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 /* \" */ \u0026\u0026 t[0] === '\"') {\n        if (lastChar \u003e= 0x30 /* 0 */ \u0026\u0026 lastChar \u003c= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false;\n        }\n      }\n\n      if (canOpen \u0026\u0026 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 \u0026\u0026 !canClose) {\n        // middle of word\n        if (isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\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 \u003e= 0; j--) {\n          item = stack[j];\n          if (stack[j].level \u003c thisLevel) { break; }\n          if (item.single === isSingle \u0026\u0026 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            }\n\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            token.content = replaceAt(token.content, t.index, closeQuote);\n            tokens[item.token].content = replaceAt(\n              tokens[item.token].content, item.pos, openQuote);\n\n            pos += closeQuote.length - 1;\n            if (item.token === i) { pos += openQuote.length - 1; }\n\n            text = token.content;\n            max = text.length;\n\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 \u0026\u0026 isSingle) {\n        token.content = replaceAt(token.content, t.index, APOSTROPHE);\n      }\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) { return; }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx \u003e= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline' ||\n        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {\n      continue;\n    }\n\n    process_inlines(state.tokens[blkIdx].children, state);\n  }\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\n\nmodule.exports = function text_join(state) {\n  var j, l, tokens, curr, max, last,\n      blockTokens = state.tokens;\n\n  for (j = 0, l = blockTokens.length; j \u003c l; j++) {\n    if (blockTokens[j].type !== 'inline') continue;\n\n    tokens = blockTokens[j].children;\n    max = tokens.length;\n\n    for (curr = 0; curr \u003c max; curr++) {\n      if (tokens[curr].type === 'text_special') {\n        tokens[curr].type = 'text';\n      }\n    }\n\n    for (curr = last = 0; curr \u003c max; curr++) {\n      if (tokens[curr].type === 'text' \u0026\u0026\n          curr + 1 \u003c max \u0026\u0026\n          tokens[curr + 1].type === 'text') {\n\n        // collapse two adjacent text nodes\n        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n      } else {\n        if (curr !== last) { tokens[last] = tokens[curr]; }\n\n        last++;\n      }\n    }\n\n    if (curr !== last) {\n      tokens.length = last;\n    }\n  }\n};\n","// Token class\n\n'use strict';\n\n\n/**\n * class Token\n **/\n\n/**\n * new Token(type, tag, nesting)\n *\n * Create new token and fill passed properties.\n **/\nfunction Token(type, tag, nesting) {\n  /**\n   * Token#type -\u003e String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type     = type;\n\n  /**\n   * Token#tag -\u003e String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag      = tag;\n\n  /**\n   * Token#attrs -\u003e Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs    = null;\n\n  /**\n   * Token#map -\u003e Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map      = null;\n\n  /**\n   * Token#nesting -\u003e 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  this.nesting  = nesting;\n\n  /**\n   * Token#level -\u003e Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level    = 0;\n\n  /**\n   * Token#children -\u003e Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null;\n\n  /**\n   * Token#content -\u003e String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content  = '';\n\n  /**\n   * Token#markup -\u003e String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup   = '';\n\n  /**\n   * Token#info -\u003e 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  this.info     = '';\n\n  /**\n   * Token#meta -\u003e Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta     = null;\n\n  /**\n   * Token#block -\u003e Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block    = false;\n\n  /**\n   * Token#hidden -\u003e Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden   = false;\n}\n\n\n/**\n * Token.attrIndex(name) -\u003e Number\n *\n * Search attribute index by name.\n **/\nToken.prototype.attrIndex = function attrIndex(name) {\n  var attrs, i, len;\n\n  if (!this.attrs) { return -1; }\n\n  attrs = this.attrs;\n\n  for (i = 0, len = attrs.length; i \u003c len; i++) {\n    if (attrs[i][0] === name) { return i; }\n  }\n  return -1;\n};\n\n\n/**\n * Token.attrPush(attrData)\n *\n * Add `[ name, value ]` attribute to list. Init attrs if necessary\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\n/**\n * Token.attrSet(name, value)\n *\n * Set `name` attribute to `value`. Override old value if exists.\n **/\nToken.prototype.attrSet = function attrSet(name, value) {\n  var idx = this.attrIndex(name),\n      attrData = [ name, value ];\n\n  if (idx \u003c 0) {\n    this.attrPush(attrData);\n  } else {\n    this.attrs[idx] = attrData;\n  }\n};\n\n\n/**\n * Token.attrGet(name)\n *\n * Get the value of attribute `name`, or null if it does not exist.\n **/\nToken.prototype.attrGet = function attrGet(name) {\n  var idx = this.attrIndex(name), value = null;\n  if (idx \u003e= 0) {\n    value = this.attrs[idx][1];\n  }\n  return value;\n};\n\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 **/\nToken.prototype.attrJoin = function attrJoin(name, value) {\n  var idx = this.attrIndex(name);\n\n  if (idx \u003c 0) {\n    this.attrPush([ name, value ]);\n  } else {\n    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;\n  }\n};\n\n\nmodule.exports = Token;\n","// Core state object\n//\n'use strict';\n\nvar Token = require('../token');\n\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}\n\n// re-export Token class to use in core rules\nStateCore.prototype.Token = Token;\n\n\nmodule.exports = StateCore;\n","/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n'use strict';\n\n\nvar Ruler  = require('./ruler');\n\n\nvar _rules = [\n  [ 'normalize',      require('./rules_core/normalize')      ],\n  [ 'block',          require('./rules_core/block')          ],\n  [ 'inline',         require('./rules_core/inline')         ],\n  [ 'linkify',        require('./rules_core/linkify')        ],\n  [ 'replacements',   require('./rules_core/replacements')   ],\n  [ 'smartquotes',    require('./rules_core/smartquotes')    ],\n  // `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\n\n/**\n * new Core()\n **/\nfunction Core() {\n  /**\n   * Core#ruler -\u003e Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i \u003c _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  var i, l, rules;\n\n  rules = this.ruler.getRules('');\n\n  for (i = 0, l = rules.length; i \u003c l; i++) {\n    rules[i](state);\n  }\n};\n\nCore.prototype.State = require('./rules_core/state_core');\n\n\nmodule.exports = Core;\n","// GFM table, https://github.github.com/gfm/#tables-extension-\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nfunction getLine(state, line) {\n  var pos = state.bMarks[line] + state.tShift[line],\n      max = state.eMarks[line];\n\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\n  ch  = str.charCodeAt(pos);\n\n  while (pos \u003c max) {\n    if (ch === 0x7c/* | */) {\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    pos++;\n\n    ch = str.charCodeAt(pos);\n  }\n\n  result.push(current + str.substring(lastPos));\n\n  return result;\n}\n\n\nmodule.exports = function table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, l, nextLine, columns, columnCount, token,\n      aligns, t, tableLines, tbodyLines, oldParentType, terminate,\n      terminatorRules, firstCh, secondCh;\n\n  // should have at least two lines\n  if (startLine + 2 \u003e endLine) { return false; }\n\n  nextLine = startLine + 1;\n\n  if (state.sCount[nextLine] \u003c state.blkIndent) { return false; }\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { return false; }\n\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  pos = state.bMarks[nextLine] + state.tShift[nextLine];\n  if (pos \u003e= state.eMarks[nextLine]) { return false; }\n\n  firstCh = state.src.charCodeAt(pos++);\n  if (firstCh !== 0x7C/* | */ \u0026\u0026 firstCh !== 0x2D/* - */ \u0026\u0026 firstCh !== 0x3A/* : */) { return false; }\n\n  if (pos \u003e= state.eMarks[nextLine]) { return false; }\n\n  secondCh = state.src.charCodeAt(pos++);\n  if (secondCh !== 0x7C/* | */ \u0026\u0026 secondCh !== 0x2D/* - */ \u0026\u0026 secondCh !== 0x3A/* : */ \u0026\u0026 !isSpace(secondCh)) {\n    return false;\n  }\n\n  // if first character is '-', then second character must not be a space\n  // (due to parsing ambiguity with list)\n  if (firstCh === 0x2D/* - */ \u0026\u0026 isSpace(secondCh)) { return false; }\n\n  while (pos \u003c state.eMarks[nextLine]) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch !== 0x7C/* | */ \u0026\u0026 ch !== 0x2D/* - */ \u0026\u0026 ch !== 0x3A/* : */ \u0026\u0026 !isSpace(ch)) { return false; }\n\n    pos++;\n  }\n\n  lineText = getLine(state, startLine + 1);\n\n  columns = lineText.split('|');\n  aligns = [];\n  for (i = 0; i \u003c columns.length; i++) {\n    t = columns[i].trim();\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)) { return false; }\n    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {\n      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right');\n    } else if (t.charCodeAt(0) === 0x3A/* : */) {\n      aligns.push('left');\n    } else {\n      aligns.push('');\n    }\n  }\n\n  lineText = getLine(state, startLine).trim();\n  if (lineText.indexOf('|') === -1) { return false; }\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n  columns = escapedSplit(lineText);\n  if (columns.length \u0026\u0026 columns[0] === '') columns.shift();\n  if (columns.length \u0026\u0026 columns[columns.length - 1] === '') columns.pop();\n\n  // 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  columnCount = columns.length;\n  if (columnCount === 0 || columnCount !== aligns.length) { return false; }\n\n  if (silent) { return true; }\n\n  oldParentType = state.parentType;\n  state.parentType = 'table';\n\n  // use 'blockquote' lists for termination because it's\n  // the most similar to tables\n  terminatorRules = state.md.block.ruler.getRules('blockquote');\n\n  token     = state.push('table_open', 'table', 1);\n  token.map = tableLines = [ startLine, 0 ];\n\n  token     = state.push('thead_open', 'thead', 1);\n  token.map = [ startLine, startLine + 1 ];\n\n  token     = state.push('tr_open', 'tr', 1);\n  token.map = [ startLine, startLine + 1 ];\n\n  for (i = 0; i \u003c columns.length; i++) {\n    token          = state.push('th_open', 'th', 1);\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\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 \u003c endLine; nextLine++) {\n    if (state.sCount[nextLine] \u003c state.blkIndent) { break; }\n\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) { break; }\n    lineText = getLine(state, nextLine).trim();\n    if (!lineText) { break; }\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { break; }\n    columns = escapedSplit(lineText);\n    if (columns.length \u0026\u0026 columns[0] === '') columns.shift();\n    if (columns.length \u0026\u0026 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 \u003c columnCount; i++) {\n      token          = state.push('td_open', 'td', 1);\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\n      token          = state.push('td_close', 'td', -1);\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\n  state.parentType = oldParentType;\n  state.line = nextLine;\n  return true;\n};\n","// Code block (4 spaces padded)\n\n'use strict';\n\n\nmodule.exports = function code(state, startLine, endLine/*, silent*/) {\n  var nextLine, last, token;\n\n  if (state.sCount[startLine] - state.blkIndent \u003c 4) { return false; }\n\n  last = nextLine = startLine + 1;\n\n  while (nextLine \u003c endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n    break;\n  }\n\n  state.line = last;\n\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\n  return true;\n};\n","// fences (``` lang, ~~~ lang)\n\n'use strict';\n\n\nmodule.exports = function fence(state, startLine, endLine, silent) {\n  var marker, len, params, nextLine, mem, token, markup,\n      haveEndMarker = false,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n\n  if (pos + 3 \u003e max) { return false; }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x7E/* ~ */ \u0026\u0026 marker !== 0x60 /* ` */) {\n    return false;\n  }\n\n  // scan marker length\n  mem = pos;\n  pos = state.skipChars(pos, marker);\n\n  len = pos - mem;\n\n  if (len \u003c 3) { return false; }\n\n  markup = state.src.slice(mem, pos);\n  params = state.src.slice(pos, max);\n\n  if (marker === 0x60 /* ` */) {\n    if (params.indexOf(String.fromCharCode(marker)) \u003e= 0) {\n      return false;\n    }\n  }\n\n  // Since start is found, we can report success here in validation mode\n  if (silent) { return true; }\n\n  // search end of block\n  nextLine = startLine;\n\n  for (;;) {\n    nextLine++;\n    if (nextLine \u003e= 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 \u003c max \u0026\u0026 state.sCount[nextLine] \u003c 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) { continue; }\n\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n\n    pos = state.skipChars(pos, marker);\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem \u003c len) { continue; }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos);\n\n    if (pos \u003c max) { continue; }\n\n    haveEndMarker = true;\n    // found!\n    break;\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.sCount[startLine];\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n\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\n  return true;\n};\n","// Block quotes\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\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];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos) !== 0x3E/* \u003e */) { return false; }\n\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  if (silent) { return true; }\n\n  oldBMarks  = [];\n  oldBSCount = [];\n  oldSCount  = [];\n  oldTShift  = [];\n\n  terminatorRules = state.md.block.ruler.getRules('blockquote');\n\n  oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n\n  // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     \u003e test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     \u003e\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     \u003e test\n  //      - - -\n  //     ```\n  for (nextLine = startLine; nextLine \u003c 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    //    \u003e current blockquote\n    // 2. checking this line\n    // ```\n    isOutdented = state.sCount[nextLine] \u003c state.blkIndent;\n\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos \u003e= 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/* \u003e */ \u0026\u0026 !isOutdented) {\n      // This line is inside the blockquote.\n\n      // set offset past spaces and \"\u003e\"\n      initial = state.sCount[nextLine] + 1;\n\n      // skip one optional space after '\u003e'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' \u003e   test '\n        //     ^ -- position start of line here:\n        pos++;\n        initial++;\n        adjustTab = false;\n        spaceAfterMarker = true;\n      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n        spaceAfterMarker = true;\n\n        if ((state.bsCount[nextLine] + initial) % 4 === 3) {\n          // '  \u003e\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++;\n          initial++;\n          adjustTab = false;\n        } else {\n          // ' \u003e\\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      offset = initial;\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n\n      while (pos \u003c 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 \u003e= max;\n\n      oldBSCount.push(state.bsCount[nextLine]);\n      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);\n\n      oldSCount.push(state.sCount[nextLine]);\n      state.sCount[nextLine] = offset - initial;\n\n      oldTShift.push(state.tShift[nextLine]);\n      state.tShift[nextLine] = pos - state.bMarks[nextLine];\n      continue;\n    }\n\n    // Case 2: line is not inside the blockquote, and the last line was empty.\n    if (lastLineEmpty) { break; }\n\n    // Case 3: another tag found.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i \u003c 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]);\n\n    // A negative indentation means that this is a paragraph continuation\n    //\n    state.sCount[nextLine] = -1;\n  }\n\n  oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n\n  token        = state.push('blockquote_open', 'blockquote', 1);\n  token.markup = '\u003e';\n  token.map    = lines = [ startLine, 0 ];\n\n  state.md.block.tokenize(state, startLine, nextLine);\n\n  token        = state.push('blockquote_close', 'blockquote', -1);\n  token.markup = '\u003e';\n\n  state.lineMax = oldLineMax;\n  state.parentType = oldParentType;\n  lines[1] = state.line;\n\n  // 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  for (i = 0; i \u003c 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  state.blkIndent = oldIndent;\n\n  return true;\n};\n","// Horizontal rule\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nmodule.exports = function hr(state, startLine, endLine, silent) {\n  var marker, cnt, ch, token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n\n  marker = state.src.charCodeAt(pos++);\n\n  // Check hr marker\n  if (marker !== 0x2A/* * */ \u0026\u0026\n      marker !== 0x2D/* - */ \u0026\u0026\n      marker !== 0x5F/* _ */) {\n    return false;\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 of them\n\n  cnt = 1;\n  while (pos \u003c max) {\n    ch = state.src.charCodeAt(pos++);\n    if (ch !== marker \u0026\u0026 !isSpace(ch)) { return false; }\n    if (ch === marker) { cnt++; }\n  }\n\n  if (cnt \u003c 3) { return false; }\n\n  if (silent) { return true; }\n\n  state.line = startLine + 1;\n\n  token        = state.push('hr', 'hr', 0);\n  token.map    = [ startLine, state.line ];\n  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));\n\n  return true;\n};\n","// Lists\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\n// Search `[-+*][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipBulletListMarker(state, startLine) {\n  var marker, pos, max, ch;\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  max = state.eMarks[startLine];\n\n  marker = state.src.charCodeAt(pos++);\n  // Check bullet\n  if (marker !== 0x2A/* * */ \u0026\u0026\n      marker !== 0x2D/* - */ \u0026\u0026\n      marker !== 0x2B/* + */) {\n    return -1;\n  }\n\n  if (pos \u003c 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}\n\n// Search `\\d+[.)][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker(state, startLine) {\n  var ch,\n      start = state.bMarks[startLine] + state.tShift[startLine],\n      pos = start,\n      max = state.eMarks[startLine];\n\n  // List marker should have at least 2 chars (digit + dot)\n  if (pos + 1 \u003e= max) { return -1; }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch \u003c 0x30/* 0 */ || ch \u003e 0x39/* 9 */) { return -1; }\n\n  for (;;) {\n    // EOL -\u003e fail\n    if (pos \u003e= max) { return -1; }\n\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch \u003e= 0x30/* 0 */ \u0026\u0026 ch \u003c= 0x39/* 9 */) {\n\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start \u003e= 10) { return -1; }\n\n      continue;\n    }\n\n    // found valid marker\n    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {\n      break;\n    }\n\n    return -1;\n  }\n\n\n  if (pos \u003c 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  return pos;\n}\n\nfunction markTightParagraphs(state, idx) {\n  var i, l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i \u003c l; i++) {\n    if (state.tokens[i].level === level \u0026\u0026 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\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      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      nextLine = startLine,\n      isTerminatingParagraph = false,\n      tight = true;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { return false; }\n\n  // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n  if (state.listIndent \u003e= 0 \u0026\u0026\n      state.sCount[nextLine] - state.listIndent \u003e= 4 \u0026\u0026\n      state.sCount[nextLine] \u003c state.blkIndent) {\n    return false;\n  }\n\n  // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n  if (silent \u0026\u0026 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[nextLine] \u003e= state.blkIndent) {\n      isTerminatingParagraph = true;\n    }\n  }\n\n  // Detect list type and position after marker\n  if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) \u003e= 0) {\n    isOrdered = true;\n    start = state.bMarks[nextLine] + state.tShift[nextLine];\n    markerValue = Number(state.src.slice(start, posAfterMarker - 1));\n\n    // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n    if (isTerminatingParagraph \u0026\u0026 markerValue !== 1) return false;\n\n  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) \u003e= 0) {\n    isOrdered = false;\n\n  } else {\n    return false;\n  }\n\n  // If we're starting a new unordered list right after\n  // a paragraph, first line should not be empty.\n  if (isTerminatingParagraph) {\n    if (state.skipSpaces(posAfterMarker) \u003e= state.eMarks[nextLine]) return false;\n  }\n\n  // For validation mode we can terminate immediately\n  if (silent) { return true; }\n\n  // We should terminate list on style change. Remember first one to compare.\n  markerCharCode = state.src.charCodeAt(posAfterMarker - 1);\n\n  // Start list\n  listTokIdx = state.tokens.length;\n\n  if (isOrdered) {\n    token       = state.push('ordered_list_open', 'ol', 1);\n    if (markerValue !== 1) {\n      token.attrs = [ [ 'start', markerValue ] ];\n    }\n\n  } else {\n    token       = state.push('bullet_list_open', 'ul', 1);\n  }\n\n  token.map    = listLines = [ nextLine, 0 ];\n  token.markup = String.fromCharCode(markerCharCode);\n\n  //\n  // Iterate list items\n  //\n\n  prevEmptyEnd = false;\n  terminatorRules = state.md.block.ruler.getRules('list');\n\n  oldParentType = state.parentType;\n  state.parentType = 'list';\n\n  while (nextLine \u003c endLine) {\n    pos = posAfterMarker;\n    max = state.eMarks[nextLine];\n\n    initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine]);\n\n    while (pos \u003c 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 \u003e= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = offset - initial;\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker \u003e 4) { indentAfterMarker = 1; }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    indent = initial + indentAfterMarker;\n\n    // Run subparser \u0026 write tokens\n    token        = state.push('list_item_open', 'li', 1);\n    token.markup = String.fromCharCode(markerCharCode);\n    token.map    = itemLines = [ nextLine, 0 ];\n    if (isOrdered) {\n      token.info = state.src.slice(start, posAfterMarker - 1);\n    }\n\n    // change current state, then restore it after parser subcall\n    oldTight = state.tight;\n    oldTShift = state.tShift[nextLine];\n    oldSCount = state.sCount[nextLine];\n\n    //  - example list\n    // ^ listIndent position will be here\n    //   ^ blkIndent position will be here\n    //\n    oldListIndent = state.listIndent;\n    state.listIndent = state.blkIndent;\n    state.blkIndent = indent;\n\n    state.tight = true;\n    state.tShift[nextLine] = contentStart - state.bMarks[nextLine];\n    state.sCount[nextLine] = offset;\n\n    if (contentStart \u003e= max \u0026\u0026 state.isEmpty(nextLine + 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, nextLine, endLine, true);\n    }\n\n    // If any of list item is tight, mark list as tight\n    if (!state.tight || prevEmptyEnd) {\n      tight = false;\n    }\n    // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n    prevEmptyEnd = (state.line - nextLine) \u003e 1 \u0026\u0026 state.isEmpty(state.line - 1);\n\n    state.blkIndent = state.listIndent;\n    state.listIndent = oldListIndent;\n    state.tShift[nextLine] = oldTShift;\n    state.sCount[nextLine] = oldSCount;\n    state.tight = oldTight;\n\n    token        = state.push('list_item_close', 'li', -1);\n    token.markup = String.fromCharCode(markerCharCode);\n\n    nextLine = state.line;\n    itemLines[1] = nextLine;\n\n    if (nextLine \u003e= endLine) { break; }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] \u003c state.blkIndent) { break; }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { break; }\n\n    // fail if terminating block found\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n      if (posAfterMarker \u003c 0) { break; }\n      start = state.bMarks[nextLine] + state.tShift[nextLine];\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n      if (posAfterMarker \u003c 0) { break; }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break; }\n  }\n\n  // Finalize list\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  token.markup = String.fromCharCode(markerCharCode);\n\n  listLines[1] = nextLine;\n  state.line = nextLine;\n\n  state.parentType = oldParentType;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n};\n","'use strict';\n\n\nvar normalizeReference   = require('../common/utils').normalizeReference;\nvar isSpace              = require('../common/utils').isSpace;\n\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;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false; }\n\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  while (++pos \u003c max) {\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */ \u0026\u0026\n        state.src.charCodeAt(pos - 1) !== 0x5C/* \\ */) {\n      if (pos + 1 === max) { return false; }\n      if (state.src.charCodeAt(pos + 1) !== 0x3A/* : */) { return false; }\n      break;\n    }\n  }\n\n  endLine = state.lineMax;\n\n  // jump line-by-line until empty one or EOF\n  terminatorRules = state.md.block.ruler.getRules('reference');\n\n  oldParentType = state.parentType;\n  state.parentType = 'reference';\n\n  for (; nextLine \u003c endLine \u0026\u0026 !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 \u003e 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] \u003c 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  max = str.length;\n\n  for (pos = 1; pos \u003c max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x5B /* [ */) {\n      return false;\n    } else if (ch === 0x5D /* ] */) {\n      labelEnd = pos;\n      break;\n    } else if (ch === 0x0A /* \\n */) {\n      lines++;\n    } else if (ch === 0x5C /* \\ */) {\n      pos++;\n      if (pos \u003c max \u0026\u0026 str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n  }\n\n  if (labelEnd \u003c 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false; }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos \u003c max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  res = state.md.helpers.parseLinkDestination(str, pos, max);\n  if (!res.ok) { return false; }\n\n  href = state.md.normalizeLink(res.str);\n  if (!state.md.validateLink(href)) { return false; }\n\n  pos = res.pos;\n  lines += res.lines;\n\n  // save cursor state, we could require to rollback later\n  destEndPos = pos;\n  destEndLineNo = lines;\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  start = pos;\n  for (; pos \u003c max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  res = state.md.helpers.parseLinkTitle(str, pos, max);\n  if (pos \u003c max \u0026\u0026 start !== pos \u0026\u0026 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  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos \u003c max) {\n    ch = str.charCodeAt(pos);\n    if (!isSpace(ch)) { break; }\n    pos++;\n  }\n\n  if (pos \u003c max \u0026\u0026 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      while (pos \u003c max) {\n        ch = str.charCodeAt(pos);\n        if (!isSpace(ch)) { break; }\n        pos++;\n      }\n    }\n  }\n\n  if (pos \u003c max \u0026\u0026 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  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false;\n  }\n\n  // Reference can not terminate anything. This check is for safety only.\n  /*istanbul ignore if*/\n  if (silent) { return true; }\n\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {};\n  }\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = { title: title, href: href };\n  }\n\n  state.parentType = oldParentType;\n\n  state.line = startLine + lines + 1;\n  return true;\n};\n","// List of valid html blocks names, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#html-blocks\n\n'use strict';\n\n\nmodule.exports = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'source',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n];\n","// Regexps to match html elements\n\n'use strict';\n\nvar attr_name     = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\n\nvar unquoted      = '[^\"\\'=\u003c\u003e`\\\\x00-\\\\x20]+';\nvar single_quoted = \"'[^']*'\";\nvar double_quoted = '\"[^\"]*\"';\n\nvar attr_value  = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';\n\nvar attribute   = '(?:\\\\s+' + attr_name + '(?:\\\\s*=\\\\s*' + attr_value + ')?)';\n\nvar open_tag    = '\u003c[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?\u003e';\n\nvar close_tag   = '\u003c\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*\u003e';\nvar comment     = '\u003c!----\u003e|\u003c!--(?:-?[^\u003e-])(?:-?[^-])*--\u003e';\nvar processing  = '\u003c[?][\\\\s\\\\S]*?[?]\u003e';\nvar declaration = '\u003c![A-Z]+\\\\s+[^\u003e]*\u003e';\nvar cdata       = '\u003c!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]\u003e';\n\nvar HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +\n                        '|' + processing + '|' + declaration + '|' + cdata + ')');\nvar HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');\n\nmodule.exports.HTML_TAG_RE = HTML_TAG_RE;\nmodule.exports.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE;\n","// HTML block\n\n'use strict';\n\n\nvar block_names = require('../common/html_blocks');\nvar HTML_OPEN_CLOSE_TAG_RE = require('../common/html_re').HTML_OPEN_CLOSE_TAG_RE;\n\n// An array of opening and corresponding closing sequences for html tags,\n// last argument defines whether it can terminate a paragraph or not\n//\nvar HTML_SEQUENCES = [\n  [ /^\u003c(script|pre|style|textarea)(?=(\\s|\u003e|$))/i, /\u003c\\/(script|pre|style|textarea)\u003e/i, true ],\n  [ /^\u003c!--/,        /--\u003e/,   true ],\n  [ /^\u003c\\?/,         /\\?\u003e/,   true ],\n  [ /^\u003c![A-Z]/,     /\u003e/,     true ],\n  [ /^\u003c!\\[CDATA\\[/, /\\]\\]\u003e/, true ],\n  [ new RegExp('^\u003c/?(' + block_names.join('|') + ')(?=(\\\\s|/?\u003e|$))', 'i'), /^$/, true ],\n  [ new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\\\s*$'),  /^$/, false ]\n];\n\n\nmodule.exports = function html_block(state, startLine, endLine, silent) {\n  var i, nextLine, token, lineText,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n\n  if (!state.md.options.html) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* \u003c */) { return false; }\n\n  lineText = state.src.slice(pos, max);\n\n  for (i = 0; i \u003c HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) { break; }\n  }\n\n  if (i === HTML_SEQUENCES.length) { return false; }\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;\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine \u003c endLine; nextLine++) {\n      if (state.sCount[nextLine] \u003c state.blkIndent) { break; }\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) { nextLine++; }\n        break;\n      }\n    }\n  }\n\n  state.line = nextLine;\n\n  token         = state.push('html_block', '', 0);\n  token.map     = [ startLine, nextLine ];\n  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);\n\n  return true;\n};\n","// heading (#, ##, ...)\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nmodule.exports = function heading(state, startLine, endLine, silent) {\n  var ch, level, tmp, token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n\n  ch  = state.src.charCodeAt(pos);\n\n  if (ch !== 0x23/* # */ || pos \u003e= max) { return false; }\n\n  // count heading level\n  level = 1;\n  ch = state.src.charCodeAt(++pos);\n  while (ch === 0x23/* # */ \u0026\u0026 pos \u003c max \u0026\u0026 level \u003c= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n\n  if (level \u003e 6 || (pos \u003c max \u0026\u0026 !isSpace(ch))) { return false; }\n\n  if (silent) { return true; }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipSpacesBack(max, pos);\n  tmp = state.skipCharsBack(max, 0x23, pos); // #\n  if (tmp \u003e pos \u0026\u0026 isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp;\n  }\n\n  state.line = startLine + 1;\n\n  token        = state.push('heading_open', 'h' + String(level), 1);\n  token.markup = '########'.slice(0, level);\n  token.map    = [ startLine, state.line ];\n\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\n  token        = state.push('heading_close', 'h' + String(level), -1);\n  token.markup = '########'.slice(0, level);\n\n  return true;\n};\n","// lheading (---, ===)\n\n'use strict';\n\n\nmodule.exports = function lheading(state, startLine, endLine/*, silent*/) {\n  var content, terminate, i, l, token, pos, max, level, marker,\n      nextLine = startLine + 1, oldParentType,\n      terminatorRules = state.md.block.ruler.getRules('paragraph');\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false; }\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph'; // use paragraph to match terminatorRules\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine \u003c endLine \u0026\u0026 !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 \u003e 3) { continue; }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] \u003e= state.blkIndent) {\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n\n      if (pos \u003c max) {\n        marker = state.src.charCodeAt(pos);\n\n        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {\n          pos = state.skipChars(pos, marker);\n          pos = state.skipSpaces(pos);\n\n          if (pos \u003e= max) {\n            level = (marker === 0x3D/* = */ ? 1 : 2);\n            break;\n          }\n        }\n      }\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] \u003c 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\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\n  state.line = nextLine + 1;\n\n  token          = state.push('heading_open', 'h' + String(level), 1);\n  token.markup   = String.fromCharCode(marker);\n  token.map      = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = content;\n  token.map      = [ startLine, state.line - 1 ];\n  token.children = [];\n\n  token          = state.push('heading_close', 'h' + String(level), -1);\n  token.markup   = String.fromCharCode(marker);\n\n  state.parentType = oldParentType;\n\n  return true;\n};\n","// Paragraph\n\n'use strict';\n\n\nmodule.exports = function paragraph(state, startLine, endLine) {\n  var content, terminate, i, l, token, oldParentType,\n      nextLine = startLine + 1,\n      terminatorRules = state.md.block.ruler.getRules('paragraph');\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph';\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine \u003c endLine \u0026\u0026 !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 \u003e 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] \u003c 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n\n  state.line = nextLine;\n\n  token          = state.push('paragraph_open', 'p', 1);\n  token.map      = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = content;\n  token.map      = [ startLine, state.line ];\n  token.children = [];\n\n  token          = state.push('paragraph_close', 'p', -1);\n\n  state.parentType = oldParentType;\n\n  return true;\n};\n","// Parser state class\n\n'use strict';\n\nvar Token = require('../token');\nvar isSpace = require('../common/utils').isSpace;\n\n\nfunction StateBlock(src, md, env, tokens) {\n  var ch, s, start, pos, len, indent, offset, indent_found;\n\n  this.src = src;\n\n  // link to parser instance\n  this.md     = md;\n\n  this.env = env;\n\n  //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens;\n\n  this.bMarks = [];  // line begin offsets for fast jumps\n  this.eMarks = [];  // line end offsets for fast jumps\n  this.tShift = [];  // offsets of the first non-space characters (tabs not expanded)\n  this.sCount = [];  // indents for each line (tabs expanded)\n\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  this.bsCount = [];\n\n  // block parser variables\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  this.line       = 0; // line index in src\n  this.lineMax    = 0; // lines count\n  this.tight      = false;  // loose/tight mode for lists\n  this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)\n  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)\n\n  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'\n  // used in lists to determine if they interrupt a paragraph\n  this.parentType = 'root';\n\n  this.level = 0;\n\n  // renderer\n  this.result = '';\n\n  // Create caches\n  // Generate markers.\n  s = this.src;\n  indent_found = false;\n\n  for (start = pos = indent = offset = 0, len = s.length; pos \u003c 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        continue;\n      } else {\n        indent_found = true;\n      }\n    }\n\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) { pos++; }\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\n      indent_found = false;\n      indent = 0;\n      offset = 0;\n      start = pos + 1;\n    }\n  }\n\n  // Push fake entry to simplify cache bounds checks\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\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\n}\n\n// Push new token to \"stream\".\n//\nStateBlock.prototype.push = function (type, tag, nesting) {\n  var token = new Token(type, tag, nesting);\n  token.block = true;\n\n  if (nesting \u003c 0) this.level--; // closing tag\n  token.level = this.level;\n  if (nesting \u003e 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] \u003e= this.eMarks[line];\n};\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (var max = this.lineMax; from \u003c max; from++) {\n    if (this.bMarks[from] + this.tShift[from] \u003c this.eMarks[from]) {\n      break;\n    }\n  }\n  return from;\n};\n\n// Skip spaces from given position.\nStateBlock.prototype.skipSpaces = function skipSpaces(pos) {\n  var ch;\n\n  for (var max = this.src.length; pos \u003c max; pos++) {\n    ch = this.src.charCodeAt(pos);\n    if (!isSpace(ch)) { break; }\n  }\n  return pos;\n};\n\n// Skip spaces from given position in reverse.\nStateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {\n  if (pos \u003c= min) { return pos; }\n\n  while (pos \u003e min) {\n    if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1; }\n  }\n  return pos;\n};\n\n// Skip char codes from given position\nStateBlock.prototype.skipChars = function skipChars(pos, code) {\n  for (var max = this.src.length; pos \u003c max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) { break; }\n  }\n  return pos;\n};\n\n// Skip char codes reverse from given position - 1\nStateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {\n  if (pos \u003c= min) { return pos; }\n\n  while (pos \u003e min) {\n    if (code !== this.src.charCodeAt(--pos)) { return pos + 1; }\n  }\n  return pos;\n};\n\n// cut lines range from source.\nStateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {\n  var i, lineIndent, ch, first, last, queue, lineStart,\n      line = begin;\n\n  if (begin \u003e= end) {\n    return '';\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line \u003c end; line++, i++) {\n    lineIndent = 0;\n    lineStart = first = this.bMarks[line];\n\n    if (line + 1 \u003c 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 \u003c last \u0026\u0026 lineIndent \u003c 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 \u003c 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 \u003e 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};\n\n// re-export Token class to use in block rules\nStateBlock.prototype.Token = Token;\n\n\nmodule.exports = StateBlock;\n","/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\nvar _rules = [\n  // First 2 params - rule name \u0026 source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  [ 'table',      require('./rules_block/table'),      [ 'paragraph', 'reference' ] ],\n  [ 'code',       require('./rules_block/code') ],\n  [ 'fence',      require('./rules_block/fence'),      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'blockquote', require('./rules_block/blockquote'), [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'hr',         require('./rules_block/hr'),         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'list',       require('./rules_block/list'),       [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'reference',  require('./rules_block/reference') ],\n  [ 'html_block', require('./rules_block/html_block'), [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'heading',    require('./rules_block/heading'),    [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'lheading',   require('./rules_block/lheading') ],\n  [ 'paragraph',  require('./rules_block/paragraph') ]\n];\n\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock() {\n  /**\n   * ParserBlock#ruler -\u003e Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i \u003c _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });\n  }\n}\n\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var ok, i, prevLine,\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 \u003c endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line \u003e= endLine) { break; }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes \u0026 lists\n    if (state.sCount[line] \u003c state.blkIndent) { break; }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level \u003e= maxNesting) {\n      state.line = endLine;\n      break;\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n    prevLine = state.line;\n\n    for (i = 0; i \u003c len; i++) {\n      ok = rules[i](state, line, endLine, false);\n      if (ok) {\n        if (prevLine \u003e= state.line) {\n          throw new Error(\"block rule didn't increment state.line\");\n        }\n        break;\n      }\n    }\n\n    // this can only happen if user disables paragraph rule\n    if (!ok) throw new Error('none of the block rules matched');\n\n    // set state.tight if we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines;\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n\n    line = state.line;\n\n    if (line \u003c endLine \u0026\u0026 state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++;\n      state.line = line;\n    }\n  }\n};\n\n\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  var state;\n\n  if (!src) { return; }\n\n  state = new this.State(src, md, env, outTokens);\n\n  this.tokenize(state, state.line, state.lineMax);\n};\n\n\nParserBlock.prototype.State = require('./rules_block/state_block');\n\n\nmodule.exports = ParserBlock;\n","// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n\n'use strict';\n\n\n// Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\n// !, \", #, $, %, \u0026, ', (, ), *, +, ,, -, ., /, :, ;, \u003c, =, \u003e, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x21/* ! */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* \u0026 */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2D/* - */:\n    case 0x3A/* : */:\n    case 0x3C/* \u003c */:\n    case 0x3D/* = */:\n    case 0x3E/* \u003e */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos;\n\n  while (pos \u003c state.posMax \u0026\u0026 !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n\n  if (pos === state.pos) { return false; }\n\n  if (!silent) { state.pending += state.src.slice(state.pos, pos); }\n\n  state.pos = pos;\n\n  return true;\n};\n\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!#$%\u0026*+\\-:\u003c=\u003e@[\\\\\\]^_`{}~]/;\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 -\u003e empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -\u003e text till end of string\n  if (idx \u003c 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};*/\n","// Process links like https://example.org/\n\n'use strict';\n\n\n// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\nvar SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;\n\n\nmodule.exports = function linkify(state, silent) {\n  var pos, max, match, proto, link, url, fullUrl, token;\n\n  if (!state.md.options.linkify) return false;\n  if (state.linkLevel \u003e 0) return false;\n\n  pos = state.pos;\n  max = state.posMax;\n\n  if (pos + 3 \u003e max) return false;\n  if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false;\n  if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false;\n  if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false;\n\n  match = state.pending.match(SCHEME_RE);\n  if (!match) return false;\n\n  proto = match[1];\n\n  link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));\n  if (!link) return false;\n\n  url = link.url;\n\n  // invalid link, but still detected by linkify somehow;\n  // need to check to prevent infinite loop below\n  if (url.length \u003c= proto.length) return false;\n\n  // disallow '*' at the end of the link (conflicts with emphasis)\n  url = url.replace(/\\*+$/, '');\n\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\n    token         = state.push('link_open', 'a', 1);\n    token.attrs   = [ [ 'href', fullUrl ] ];\n    token.markup  = 'linkify';\n    token.info    = 'auto';\n\n    token         = state.push('text', '', 0);\n    token.content = state.md.normalizeLinkText(url);\n\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};\n","// Proceess '\\n'\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nmodule.exports = function newline(state, silent) {\n  var pmax, max, ws, pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x0A/* \\n */) { return false; }\n\n  pmax = state.pending.length - 1;\n  max = state.posMax;\n\n  // '  \\n' -\u003e 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  if (!silent) {\n    if (pmax \u003e= 0 \u0026\u0026 state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax \u003e= 1 \u0026\u0026 state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Find whitespaces tail of pending chars.\n        ws = pmax - 1;\n        while (ws \u003e= 1 \u0026\u0026 state.pending.charCodeAt(ws - 1) === 0x20) ws--;\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\n    } else {\n      state.push('softbreak', 'br', 0);\n    }\n  }\n\n  pos++;\n\n  // skip heading spaces for next line\n  while (pos \u003c max \u0026\u0026 isSpace(state.src.charCodeAt(pos))) { pos++; }\n\n  state.pos = pos;\n  return true;\n};\n","// Process escaped chars and hardbreaks\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nvar ESCAPED = [];\n\nfor (var i = 0; i \u003c 256; i++) { ESCAPED.push(0); }\n\n'\\\\!\"#$%\u0026\\'()*+,./:;\u003c=\u003e?@[]^_`{|}~-'\n  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1; });\n\n\nmodule.exports = function escape(state, silent) {\n  var ch1, ch2, origStr, escapedStr, token, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x5C/* \\ */) return false;\n  pos++;\n\n  // '\\' at the end of the inline block\n  if (pos \u003e= max) return false;\n\n  ch1 = state.src.charCodeAt(pos);\n\n  if (ch1 === 0x0A) {\n    if (!silent) {\n      state.push('hardbreak', 'br', 0);\n    }\n\n    pos++;\n    // skip leading whitespaces from next line\n    while (pos \u003c 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 \u003e= 0xD800 \u0026\u0026 ch1 \u003c= 0xDBFF \u0026\u0026 pos + 1 \u003c max) {\n    ch2 = state.src.charCodeAt(pos + 1);\n\n    if (ch2 \u003e= 0xDC00 \u0026\u0026 ch2 \u003c= 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 \u003c 256 \u0026\u0026 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};\n","// Parse backticks\n\n'use strict';\n\n\nmodule.exports = function backtick(state, silent) {\n  var start, max, marker, token, matchStart, matchEnd, openerLength, closerLength,\n      pos = state.pos,\n      ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x60/* ` */) { return false; }\n\n  start = pos;\n  pos++;\n  max = state.posMax;\n\n  // scan marker length\n  while (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x60/* ` */) { pos++; }\n\n  marker = state.src.slice(start, pos);\n  openerLength = marker.length;\n\n  if (state.backticksScanned \u0026\u0026 (state.backticks[openerLength] || 0) \u003c= start) {\n    if (!silent) state.pending += marker;\n    state.pos += openerLength;\n    return true;\n  }\n\n  matchEnd = pos;\n\n  // Nothing found in the cache, scan until the end of the line (or until marker is found)\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    // scan marker length\n    while (matchEnd \u003c max \u0026\u0026 state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++; }\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)\n          .replace(/\\n/g, ' ')\n          .replace(/^ (.+) $/, '$1');\n      }\n      state.pos = matchEnd;\n      return true;\n    }\n\n    // Some different length found, put it in cache as upper limit of where closer can be found\n    state.backticks[closerLength] = matchStart;\n  }\n\n  // Scanned through the end, didn't find anything\n  state.backticksScanned = true;\n\n  if (!silent) state.pending += marker;\n  state.pos += openerLength;\n  return true;\n};\n","// ~~strike through~~\n//\n'use strict';\n\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nmodule.exports.tokenize = function strikethrough(state, silent) {\n  var i, scanned, token, len, ch,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) { return false; }\n\n  if (marker !== 0x7E/* ~ */) { return false; }\n\n  scanned = state.scanDelims(state.pos, true);\n  len = scanned.length;\n  ch = String.fromCharCode(marker);\n\n  if (len \u003c 2) { return false; }\n\n  if (len % 2) {\n    token         = state.push('text', '', 0);\n    token.content = ch;\n    len--;\n  }\n\n  for (i = 0; i \u003c len; i += 2) {\n    token         = state.push('text', '', 0);\n    token.content = ch + ch;\n\n    state.delimiters.push({\n      marker: marker,\n      length: 0,     // 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\n  return true;\n};\n\n\nfunction postProcess(state, delimiters) {\n  var i, j,\n      startDelim,\n      endDelim,\n      token,\n      loneMarkers = [],\n      max = delimiters.length;\n\n  for (i = 0; i \u003c max; i++) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x7E/* ~ */) {\n      continue;\n    }\n\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end];\n\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\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' \u0026\u0026\n        state.tokens[endDelim.token - 1].content === '~') {\n\n      loneMarkers.push(endDelim.token - 1);\n    }\n  }\n\n  // If a marker sequence has an odd number of characters, it's splitted\n  // like this: `~~~~~` -\u003e `~` + `~~` + `~~`, 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  while (loneMarkers.length) {\n    i = loneMarkers.pop();\n    j = i + 1;\n\n    while (j \u003c state.tokens.length \u0026\u0026 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}\n\n\n// Walk through delimiter list and replace text tokens with tags\n//\nmodule.exports.postProcess = function strikethrough(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr \u003c max; curr++) {\n    if (tokens_meta[curr] \u0026\u0026 tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n","// Process *this* and _that_\n//\n'use strict';\n\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nmodule.exports.tokenize = function emphasis(state, silent) {\n  var i, scanned, token,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) { return false; }\n\n  if (marker !== 0x5F /* _ */ \u0026\u0026 marker !== 0x2A /* * */) { return false; }\n\n  scanned = state.scanDelims(state.pos, marker === 0x2A);\n\n  for (i = 0; i \u003c scanned.length; i++) {\n    token         = state.push('text', '', 0);\n    token.content = String.fromCharCode(marker);\n\n    state.delimiters.push({\n      // Char code of the starting marker (number).\n      //\n      marker: marker,\n\n      // Total length of these series of delimiters.\n      //\n      length: scanned.length,\n\n      // A position of the token this delimiter corresponds to.\n      //\n      token:  state.tokens.length - 1,\n\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\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\n  return true;\n};\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 \u003e= 0; i--) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x5F/* _ */ \u0026\u0026 startDelim.marker !== 0x2A/* * */) {\n      continue;\n    }\n\n    // Process only opening markers\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end];\n\n    // If the previous delimiter has the same marker and is adjacent to this one,\n    // merge those into one strong delimiter.\n    //\n    // `\u003cem\u003e\u003cem\u003ewhatever\u003c/em\u003e\u003c/em\u003e` -\u003e `\u003cstrong\u003ewhatever\u003c/strong\u003e`\n    //\n    isStrong = i \u003e 0 \u0026\u0026\n               delimiters[i - 1].end === startDelim.end + 1 \u0026\u0026\n               // check that first two markers match and adjacent\n               delimiters[i - 1].marker === startDelim.marker \u0026\u0026\n               delimiters[i - 1].token === startDelim.token - 1 \u0026\u0026\n               // check that last two markers are adjacent (we can safely assume they match)\n               delimiters[startDelim.end + 1].token === endDelim.token + 1;\n\n    ch = String.fromCharCode(startDelim.marker);\n\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\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}\n\n\n// Walk through delimiter list and replace text tokens with tags\n//\nmodule.exports.postProcess = function emphasis(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr \u003c max; curr++) {\n    if (tokens_meta[curr] \u0026\u0026 tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n","// Process [link](\u003cto\u003e \"stuff\")\n\n'use strict';\n\nvar normalizeReference   = require('../common/utils').normalizeReference;\nvar isSpace              = require('../common/utils').isSpace;\n\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/* [ */) { return false; }\n\n  labelStart = state.pos + 1;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd \u003c 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false;\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos \u003c max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break; }\n    }\n    if (pos \u003e= max) { return false; }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n\n      // [link](  \u003chref\u003e  \"title\"  )\n      //                ^^ skipping these spaces\n      start = pos;\n      for (; pos \u003c max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break; }\n      }\n\n      // [link](  \u003chref\u003e  \"title\"  )\n      //                  ^^^^^^^ parsing link title\n      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n      if (pos \u003c max \u0026\u0026 start !== pos \u0026\u0026 res.ok) {\n        title = res.str;\n        pos = res.pos;\n\n        // [link](  \u003chref\u003e  \"title\"  )\n        //                         ^^ skipping these spaces\n        for (; pos \u003c max; pos++) {\n          code = state.src.charCodeAt(pos);\n          if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break; }\n        }\n      }\n    }\n\n    if (pos \u003e= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true;\n    }\n    pos++;\n  }\n\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false; }\n\n    if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos \u003e= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd); }\n\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\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  if (!silent) {\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n\n    token        = state.push('link_open', 'a', 1);\n    token.attrs  = attrs = [ [ 'href', href ] ];\n    if (title) {\n      attrs.push([ 'title', title ]);\n    }\n\n    state.linkLevel++;\n    state.md.inline.tokenize(state);\n    state.linkLevel--;\n\n    token        = state.push('link_close', 'a', -1);\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};\n","// Process ![image](\u003csrc\u003e \"title\")\n\n'use strict';\n\nvar normalizeReference   = require('../common/utils').normalizeReference;\nvar isSpace              = require('../common/utils').isSpace;\n\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/* ! */) { return false; }\n  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false; }\n\n  labelStart = state.pos + 2;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd \u003c 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos \u003c max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break; }\n    }\n    if (pos \u003e= max) { return false; }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n    }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos \u003c max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break; }\n    }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n    if (pos \u003c max \u0026\u0026 start !== pos \u0026\u0026 res.ok) {\n      title = res.str;\n      pos = res.pos;\n\n      // [link](  \u003chref\u003e  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos \u003c max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break; }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos \u003e= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      state.pos = oldPos;\n      return false;\n    }\n    pos++;\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false; }\n\n    if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos \u003e= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd); }\n\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\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  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd);\n\n    state.md.inline.parse(\n      content,\n      state.md,\n      state.env,\n      tokens = []\n    );\n\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};\n","// Process autolinks '\u003cprotocol:...\u003e'\n\n'use strict';\n\n\n/*eslint max-len:0*/\nvar EMAIL_RE    = /^([a-zA-Z0-9.!#$%\u0026'*+\\/=?^_`{|}~-]+@[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}):([^\u003c\u003e\\x00-\\x20]*)$/;\n\n\nmodule.exports = function autolink(state, silent) {\n  var url, fullUrl, token, ch, start, max,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* \u003c */) { return false; }\n\n  start = state.pos;\n  max = state.posMax;\n\n  for (;;) {\n    if (++pos \u003e= max) return false;\n\n    ch = state.src.charCodeAt(pos);\n\n    if (ch === 0x3C /* \u003c */) return false;\n    if (ch === 0x3E /* \u003e */) 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    if (!state.md.validateLink(fullUrl)) { return false; }\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\n      token         = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n\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    if (!state.md.validateLink(fullUrl)) { return false; }\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\n      token         = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n\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};\n","// Process html tags\n\n'use strict';\n\n\nvar HTML_TAG_RE = require('../common/html_re').HTML_TAG_RE;\n\n\nfunction isLinkOpen(str) {\n  return /^\u003ca[\u003e\\s]/i.test(str);\n}\nfunction isLinkClose(str) {\n  return /^\u003c\\/a\\s*\u003e/i.test(str);\n}\n\n\nfunction isLetter(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n  return (lc \u003e= 0x61/* a */) \u0026\u0026 (lc \u003c= 0x7a/* z */);\n}\n\n\nmodule.exports = function html_inline(state, silent) {\n  var ch, match, max, token,\n      pos = state.pos;\n\n  if (!state.md.options.html) { return false; }\n\n  // Check start\n  max = state.posMax;\n  if (state.src.charCodeAt(pos) !== 0x3C/* \u003c */ ||\n      pos + 2 \u003e= max) {\n    return false;\n  }\n\n  // Quick fail on second char\n  ch = state.src.charCodeAt(pos + 1);\n  if (ch !== 0x21/* ! */ \u0026\u0026\n      ch !== 0x3F/* ? */ \u0026\u0026\n      ch !== 0x2F/* / */ \u0026\u0026\n      !isLetter(ch)) {\n    return false;\n  }\n\n  match = state.src.slice(pos).match(HTML_TAG_RE);\n  if (!match) { return false; }\n\n  if (!silent) {\n    token         = state.push('html_inline', '', 0);\n    token.content = match[0];\n\n    if (isLinkOpen(token.content))  state.linkLevel++;\n    if (isLinkClose(token.content)) state.linkLevel--;\n  }\n  state.pos += match[0].length;\n  return true;\n};\n","// Process html entity - \u0026#123;, \u0026#xAF;, \u0026quot;, ...\n\n'use strict';\n\nvar entities          = require('../common/entities');\nvar has               = require('../common/utils').has;\nvar isValidEntityCode = require('../common/utils').isValidEntityCode;\nvar fromCodePoint     = require('../common/utils').fromCodePoint;\n\n\nvar DIGITAL_RE = /^\u0026#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;\nvar NAMED_RE   = /^\u0026([a-z][a-z0-9]{1,31});/i;\n\n\nmodule.exports = function entity(state, silent) {\n  var ch, code, match, token, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x26/* \u0026 */) return false;\n\n  if (pos + 1 \u003e= max) return false;\n\n  ch = state.src.charCodeAt(pos + 1);\n\n  if (ch === 0x23 /* # */) {\n    match = state.src.slice(pos).match(DIGITAL_RE);\n    if (match) {\n      if (!silent) {\n        code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);\n\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      state.pos += match[0].length;\n      return true;\n    }\n  } else {\n    match = state.src.slice(pos).match(NAMED_RE);\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        state.pos += match[0].length;\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n","// For each opening emphasis-like marker find a matching closing one\n//\n'use strict';\n\n\nfunction processDelimiters(delimiters) {\n  var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx,\n      isOddMatch, lastJump,\n      openersBottom = {},\n      max = delimiters.length;\n\n  if (!max) return;\n\n  // headerIdx is the first delimiter of the current (where closer is) delimiter run\n  var headerIdx = 0;\n  var lastTokenIdx = -2; // needs any value lower than -1\n  var jumps = [];\n\n  for (closerIdx = 0; closerIdx \u003c max; closerIdx++) {\n    closer = delimiters[closerIdx];\n\n    jumps.push(0);\n\n    // markers belong to same delimiter run if:\n    //  - they have adjacent tokens\n    //  - AND markers are the same\n    //\n    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {\n      headerIdx = closerIdx;\n    }\n\n    lastTokenIdx = closer.token;\n\n    // 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    closer.length = closer.length || 0;\n\n    if (!closer.close) continue;\n\n    // 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    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\n    openerIdx = headerIdx - jumps[headerIdx] - 1;\n\n    newMinOpenerIdx = openerIdx;\n\n    for (; openerIdx \u003e minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {\n      opener = delimiters[openerIdx];\n\n      if (opener.marker !== closer.marker) continue;\n\n      if (opener.open \u0026\u0026 opener.end \u003c 0) {\n\n        isOddMatch = false;\n\n        // 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        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 \u003e 0 \u0026\u0026 !delimiters[openerIdx - 1].open ?\n            jumps[openerIdx - 1] + 1 :\n            0;\n\n          jumps[closerIdx] = closerIdx - openerIdx + lastJump;\n          jumps[openerIdx] = lastJump;\n\n          closer.open  = false;\n          opener.end   = closerIdx;\n          opener.close = false;\n          newMinOpenerIdx = -1;\n          // treat next token as start of run,\n          // it optimizes skips in **\u003c...\u003e**a**\u003c...\u003e** pathological case\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\n\nmodule.exports = function link_pairs(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  processDelimiters(state.delimiters);\n\n  for (curr = 0; curr \u003c max; curr++) {\n    if (tokens_meta[curr] \u0026\u0026 tokens_meta[curr].delimiters) {\n      processDelimiters(tokens_meta[curr].delimiters);\n    }\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\n\nmodule.exports = function fragments_join(state) {\n  var curr, last,\n      level = 0,\n      tokens = state.tokens,\n      max = state.tokens.length;\n\n  for (curr = last = 0; curr \u003c max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting \u003c 0) level--; // closing tag\n    tokens[curr].level = level;\n    if (tokens[curr].nesting \u003e 0) level++; // opening tag\n\n    if (tokens[curr].type === 'text' \u0026\u0026\n        curr + 1 \u003c max \u0026\u0026\n        tokens[curr + 1].type === 'text') {\n\n      // collapse two adjacent text nodes\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n    } else {\n      if (curr !== last) { tokens[last] = tokens[curr]; }\n\n      last++;\n    }\n  }\n\n  if (curr !== last) {\n    tokens.length = last;\n  }\n};\n","// Inline parser state\n\n'use strict';\n\n\nvar Token          = require('../token');\nvar isWhiteSpace   = require('../common/utils').isWhiteSpace;\nvar isPunctChar    = require('../common/utils').isPunctChar;\nvar isMdAsciiPunct = require('../common/utils').isMdAsciiPunct;\n\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\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0;\n\n  // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n  this.cache = {};\n\n  // List of emphasis-like delimiters for current tag\n  this.delimiters = [];\n\n  // Stack of delimiter lists for upper level tags\n  this._prev_delimiters = [];\n\n  // backtick length =\u003e last seen position\n  this.backticks = {};\n  this.backticksScanned = false;\n\n  // Counter used to disable inline linkify-it execution\n  // inside \u003ca\u003e and markdown links\n  this.linkLevel = 0;\n}\n\n\n// Flush pending text\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};\n\n\n// Push new token to \"stream\".\n// If pending text exists - flush it as text token\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 \u003c 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 \u003e 0) {\n    // opening tag\n    this.level++;\n    this._prev_delimiters.push(this.delimiters);\n    this.delimiters = [];\n    token_meta = { delimiters: this.delimiters };\n  }\n\n  this.pendingLevel = this.level;\n  this.tokens.push(token);\n  this.tokens_meta.push(token_meta);\n  return token;\n};\n\n\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//\nStateInline.prototype.scanDelims = function (start, canSplitWord) {\n  var pos = start, lastChar, nextChar, count, can_open, can_close,\n      isLastWhiteSpace, isLastPunctChar,\n      isNextWhiteSpace, isNextPunctChar,\n      left_flanking = true,\n      right_flanking = true,\n      max = this.posMax,\n      marker = this.src.charCodeAt(start);\n\n  // treat beginning of the line as a whitespace\n  lastChar = start \u003e 0 ? this.src.charCodeAt(start - 1) : 0x20;\n\n  while (pos \u003c max \u0026\u0026 this.src.charCodeAt(pos) === marker) { pos++; }\n\n  count = pos - start;\n\n  // treat end of the line as a whitespace\n  nextChar = pos \u003c max ? this.src.charCodeAt(pos) : 0x20;\n\n  isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n  isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n\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  \u0026\u0026 (!right_flanking || isLastPunctChar);\n    can_close = right_flanking \u0026\u0026 (!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};\n\n\n// re-export Token class to use in block rules\nStateInline.prototype.Token = Token;\n\n\nmodule.exports = StateInline;\n","/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Parser rules\n\nvar _rules = [\n  [ 'text',            require('./rules_inline/text') ],\n  [ 'linkify',         require('./rules_inline/linkify') ],\n  [ 'newline',         require('./rules_inline/newline') ],\n  [ 'escape',          require('./rules_inline/escape') ],\n  [ 'backticks',       require('./rules_inline/backticks') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').tokenize ],\n  [ 'emphasis',        require('./rules_inline/emphasis').tokenize ],\n  [ 'link',            require('./rules_inline/link') ],\n  [ 'image',           require('./rules_inline/image') ],\n  [ 'autolink',        require('./rules_inline/autolink') ],\n  [ 'html_inline',     require('./rules_inline/html_inline') ],\n  [ 'entity',          require('./rules_inline/entity') ]\n];\n\n// `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//\nvar _rules2 = [\n  [ 'balance_pairs',   require('./rules_inline/balance_pairs') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').postProcess ],\n  [ 'emphasis',        require('./rules_inline/emphasis').postProcess ],\n  // 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\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline() {\n  var i;\n\n  /**\n   * ParserInline#ruler -\u003e Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (i = 0; i \u003c _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n\n  /**\n   * ParserInline#ruler2 -\u003e Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler();\n\n  for (i = 0; i \u003c _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1]);\n  }\n}\n\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  var ok, i, pos = state.pos,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      maxNesting = state.md.options.maxNesting,\n      cache = state.cache;\n\n\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos];\n    return;\n  }\n\n  if (state.level \u003c maxNesting) {\n    for (i = 0; i \u003c 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        if (pos \u003e= state.pos) { throw new Error(\"inline rule didn't increment state.pos\"); }\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) { state.pos++; }\n  cache[pos] = state.pos;\n};\n\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  var ok, i, prevPos,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      end = state.posMax,\n      maxNesting = state.md.options.maxNesting;\n\n  while (state.pos \u003c end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n    prevPos = state.pos;\n\n    if (state.level \u003c maxNesting) {\n      for (i = 0; i \u003c len; i++) {\n        ok = rules[i](state, false);\n        if (ok) {\n          if (prevPos \u003e= state.pos) { throw new Error(\"inline rule didn't increment state.pos\"); }\n          break;\n        }\n      }\n    }\n\n    if (ok) {\n      if (state.pos \u003e= end) { break; }\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  var i, rules, len;\n  var state = new this.State(str, md, env, outTokens);\n\n  this.tokenize(state);\n\n  rules = this.ruler2.getRules('');\n  len = rules.length;\n\n  for (i = 0; i \u003c len; i++) {\n    rules[i](state);\n  }\n};\n\n\nParserInline.prototype.State = require('./rules_inline/state_inline');\n\n\nmodule.exports = ParserInline;\n","// markdown-it default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (\u003cbr /\u003e)\n    breaks:       false,        // Convert '\\n' in paragraphs into \u003cbr\u003e\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with \u003cpre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   100            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n","// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (\u003cbr /\u003e)\n    breaks:       false,        // Convert '\\n' in paragraphs into \u003cbr\u003e\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with \u003cpre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'fragments_join'\n      ]\n    }\n  }\n};\n","// Commonmark default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         true,         // Enable HTML tags in source\n    xhtmlOut:     true,         // Use '/' to close single tags (\u003cbr /\u003e)\n    breaks:       false,        // Convert '\\n' in paragraphs into \u003cbr\u003e\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with \u003cpre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'fragments_join'\n      ]\n    }\n  }\n};\n","// Main parser class\n\n'use strict';\n\n\nvar utils        = require('./common/utils');\nvar helpers      = require('./helpers');\nvar Renderer     = require('./renderer');\nvar ParserCore   = require('./parser_core');\nvar ParserBlock  = require('./parser_block');\nvar ParserInline = require('./parser_inline');\nvar LinkifyIt    = require('linkify-it');\nvar mdurl        = require('mdurl');\nvar punycode     = require('punycode');\n\n\nvar config = {\n  default: require('./presets/default'),\n  zero: require('./presets/zero'),\n  commonmark: require('./presets/commonmark')\n};\n\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\n  return BAD_PROTO_RE.test(str) ? (GOOD_DATA_RE.test(str) ? true : false) : true;\n}\n\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) \u003e= 0) {\n      try {\n        parsed.hostname = punycode.toASCII(parsed.hostname);\n      } catch (er) { /**/ }\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) \u003e= 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  return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%');\n}\n\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 \u0026 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 *   (`\u003cbr /\u003e`). 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 `\u003cbr\u003e`.\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 \u003cpre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang \u0026\u0026 hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `\u003cpre\u003e`):\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 \u0026\u0026 hljs.getLanguage(lang)) {\n *       try {\n *         return '\u003cpre class=\"hljs\"\u003e\u003ccode\u003e' +\n *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n *                '\u003c/code\u003e\u003c/pre\u003e';\n *       } catch (__) {}\n *     }\n *\n *     return '\u003cpre class=\"hljs\"\u003e\u003ccode\u003e' + md.utils.escapeHtml(str) + '\u003c/code\u003e\u003c/pre\u003e';\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  /**\n   * MarkdownIt#inline -\u003e 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  this.inline = new ParserInline();\n\n  /**\n   * MarkdownIt#block -\u003e 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  this.block = new ParserBlock();\n\n  /**\n   * MarkdownIt#core -\u003e 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  this.core = new ParserCore();\n\n  /**\n   * MarkdownIt#renderer -\u003e 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  this.renderer = new Renderer();\n\n  /**\n   * MarkdownIt#linkify -\u003e 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  this.linkify = new LinkifyIt();\n\n  /**\n   * MarkdownIt#validateLink(url) -\u003e 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  this.validateLink = validateLink;\n\n  /**\n   * MarkdownIt#normalizeLink(url) -\u003e String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n  this.normalizeLink = normalizeLink;\n\n  /**\n   * MarkdownIt#normalizeLinkText(url) -\u003e String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText;\n\n\n  // Expose utils \u0026 helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -\u003e 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  this.utils = utils;\n\n  /**\n   * MarkdownIt#helpers -\u003e 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  this.helpers = utils.assign({}, helpers);\n\n\n  this.options = {};\n  this.configure(presetName);\n\n  if (options) { this.set(options); }\n}\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 **/\nMarkdownIt.prototype.set = function (options) {\n  utils.assign(this.options, options);\n  return this;\n};\n\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 **/\nMarkdownIt.prototype.configure = function (presets) {\n  var self = this, presetName;\n\n  if (utils.isString(presets)) {\n    presetName = presets;\n    presets = config[presetName];\n    if (!presets) { throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name'); }\n  }\n\n  if (!presets) { throw new Error('Wrong `markdown-it` preset, can\\'t be empty'); }\n\n  if (presets.options) { self.set(presets.options); }\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      if (presets.components[name].rules2) {\n        self[name].ruler2.enableOnly(presets.components[name].rules2);\n      }\n    });\n  }\n  return this;\n};\n\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 **/\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  [ 'core', 'block', 'inline' ].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.enable(list, true));\n  }, this);\n\n  result = result.concat(this.inline.ruler2.enable(list, true));\n\n  var missed = list.filter(function (name) { return result.indexOf(name) \u003c 0; });\n\n  if (missed.length \u0026\u0026 !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);\n  }\n\n  return this;\n};\n\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 **/\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  [ 'core', 'block', 'inline' ].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.disable(list, true));\n  }, this);\n\n  result = result.concat(this.inline.ruler2.disable(list, true));\n\n  var missed = list.filter(function (name) { return result.indexOf(name) \u003c 0; });\n\n  if (missed.length \u0026\u0026 !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);\n  }\n  return this;\n};\n\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 **/\nMarkdownIt.prototype.use = function (plugin /*, params, ... */) {\n  var args = [ this ].concat(Array.prototype.slice.call(arguments, 1));\n  plugin.apply(plugin, args);\n  return this;\n};\n\n\n/** internal\n * MarkdownIt.parse(src, env) -\u003e 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 **/\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\n  this.core.process(state);\n\n  return state.tokens;\n};\n\n\n/**\n * MarkdownIt.render(src [, env]) -\u003e 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 **/\nMarkdownIt.prototype.render = function (src, env) {\n  env = env || {};\n\n  return this.renderer.render(this.parse(src, env), this.options, env);\n};\n\n\n/** internal\n * MarkdownIt.parseInline(src, env) -\u003e 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 **/\nMarkdownIt.prototype.parseInline = function (src, env) {\n  var state = new this.core.State(src, this, env);\n\n  state.inlineMode = true;\n  this.core.process(state);\n\n  return state.tokens;\n};\n\n\n/**\n * MarkdownIt.renderInline(src [, env]) -\u003e 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 `\u003cp\u003e` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {};\n\n  return this.renderer.render(this.parseInline(src, env), this.options, env);\n};\n\n\nmodule.exports = MarkdownIt;\n","'use strict';\n\n\nmodule.exports = require('./lib/');\n","import * as cjsm from \"markdown-it\";export default cjsm.default ?? cjsm;"],"version":3}
