{"version":3,"file":"9101.chunk.7e438.js","mappings":"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","sources":["webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/reference.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/fence.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/lheading.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/hr.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/code.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/image.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_core/state_core.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/newline.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_core/smartquotes.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/ruler.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/list.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/parser_inline.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/parser_block.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/emphasis.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/helpers/parse_link_title.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/helpers/parse_link_label.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/autolink.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/common/html_blocks.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/common/entities.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/token.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_core/inline.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/presets/default.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_core/linkify.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/strikethrough.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_core/replacements.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/escape.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/backticks.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/balance_pairs.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/heading.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/index.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/html_block.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/blockquote.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/text_collapse.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/state_inline.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/common/html_re.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/text.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/entity.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/state_block.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/paragraph.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/html_inline.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_block/table.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/parser_core.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/helpers/parse_link_destination.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_core/block.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/index.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/common/utils.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/helpers/index.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/presets/commonmark.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_inline/link.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/rules_core/normalize.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/presets/zero.js","webpack://@rocket.chat/livechat/./node_modules/markdown-it/lib/renderer.js"],"sourcesContent":["'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 >= 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 < max) {\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */ &&\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 < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    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 < 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 < max && str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n  }\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false; }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < 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 < 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 < max && start !== pos && res.ok) {\n    title = res.str;\n    pos = res.pos;\n    lines += res.lines;\n  } else {\n    title = '';\n    pos = destEndPos;\n    lines = destEndLineNo;\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos < max) {\n    ch = str.charCodeAt(pos);\n    if (!isSpace(ch)) { break; }\n    pos++;\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = '';\n      pos = destEndPos;\n      lines = destEndLineNo;\n      while (pos < max) {\n        ch = str.charCodeAt(pos);\n        if (!isSpace(ch)) { break; }\n        pos++;\n      }\n    }\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false;\n  }\n\n  label = normalizeReference(str.slice(1, labelEnd));\n  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","// 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 >= 4) { return false; }\n\n  if (pos + 3 > max) { return false; }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x7E/* ~ */ && 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 < 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)) >= 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 >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break;\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos < max && state.sCount[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break;\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) { continue; }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n\n    pos = state.skipChars(pos, marker);\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem < len) { continue; }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos);\n\n    if (pos < 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","// 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 >= 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 < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n\n      if (pos < max) {\n        marker = state.src.charCodeAt(pos);\n\n        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {\n          pos = state.skipChars(pos, marker);\n          pos = state.skipSpaces(pos);\n\n          if (pos >= 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] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    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","// 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 >= 4) { return false; }\n\n  marker = state.src.charCodeAt(pos++);\n\n  // Check hr marker\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\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 < max) {\n    ch = state.src.charCodeAt(pos++);\n    if (ch !== marker && !isSpace(ch)) { return false; }\n    if (ch === marker) { cnt++; }\n  }\n\n  if (cnt < 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","// 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 < 4) { return false; }\n\n  last = nextLine = startLine + 1;\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n    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, true);\n  token.map     = [ startLine, state.line ];\n\n  return true;\n};\n","// Process ![image](<src> \"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 < 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"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](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) { break; }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= 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 < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\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","// 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","// 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, 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' -> 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 >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        state.pending = state.pending.replace(/ +$/, '');\n        state.push('hardbreak', 'br', 0);\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push('softbreak', 'br', 0);\n      }\n\n    } else {\n      state.push('softbreak', 'br', 0);\n    }\n  }\n\n  pos++;\n\n  // skip heading spaces for next line\n  while (pos < max && isSpace(state.src.charCodeAt(pos))) { pos++; }\n\n  state.pos = pos;\n  return true;\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.substr(0, index) + ch + str.substr(index + 1);\n}\n\nfunction process_inlines(tokens, state) {\n  var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar,\n      isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace,\n      canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;\n\n  stack = [];\n\n  for (i = 0; i < tokens.length; i++) {\n    token = tokens[i];\n\n    thisLevel = tokens[i].level;\n\n    for (j = stack.length - 1; j >= 0; j--) {\n      if (stack[j].level <= 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 < 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 >= 0) {\n        lastChar = text.charCodeAt(t.index - 1);\n      } else {\n        for (j = i - 1; j >= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20\n          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 < max) {\n        nextChar = text.charCodeAt(pos);\n      } else {\n        for (j = i + 1; j < tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20\n          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 /* \" */ && t[0] === '\"') {\n        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false;\n        }\n      }\n\n      if (canOpen && canClose) {\n        // Replace quotes in the middle of punctuation sequence, but not\n        // in the middle of the words, i.e.:\n        //\n        // 1. foo \" bar \" baz - not replaced\n        // 2. foo-\"-bar-\"-baz - replaced\n        // 3. foo\"bar\"baz     - not replaced\n        //\n        canOpen = isLastPunctChar;\n        canClose = isNextPunctChar;\n      }\n\n      if (!canOpen && !canClose) {\n        // middle of word\n        if (isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\n        }\n        continue;\n      }\n\n      if (canClose) {\n        // this could be a closing quote, rewind the stack to get a match\n        for (j = stack.length - 1; j >= 0; j--) {\n          item = stack[j];\n          if (stack[j].level < thisLevel) { break; }\n          if (item.single === isSingle && stack[j].level === thisLevel) {\n            item = stack[j];\n\n            if (isSingle) {\n              openQuote = state.md.options.quotes[2];\n              closeQuote = state.md.options.quotes[3];\n            } else {\n              openQuote = state.md.options.quotes[0];\n              closeQuote = state.md.options.quotes[1];\n            }\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 && 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 >= 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","/**\n * class Ruler\n *\n * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and\n * [[MarkdownIt#inline]] to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and\n * [[MarkdownIt.use]].\n **/\n'use strict';\n\n\n/**\n * new Ruler()\n **/\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Helper methods, should not be used directly\n\n\n// Find rule index by name\n//\nRuler.prototype.__find__ = function (name) {\n  for (var i = 0; i < this.__rules__.length; i++) {\n    if (this.__rules__[i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n\n// Build rules lookup cache\n//\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = [ '' ];\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) { return; }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) { return; }\n\n      if (chain && rule.alt.indexOf(chain) < 0) { return; }\n\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function & options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing 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]) -> Array\n * - list (String|Array): list of rule names to enable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.disable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.enableOnly(list [, ignoreInvalid])\n * - list (String|Array): list of rule names to enable (whitelist).\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names, and disable everything else. If any rule name\n * not found - throw Error. Errors can be disabled by second param.\n *\n * See also [[Ruler.disable]], [[Ruler.enable]].\n **/\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  this.__rules__.forEach(function (rule) { rule.enabled = false; });\n\n  this.enable(list, ignoreInvalid);\n};\n\n\n/**\n * Ruler.disable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Disable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.enable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.getRules(chainName) -> Array\n *\n * Return array of active functions (rules) for given chain name. It analyzes\n * rules configuration, compiles caches if not exists and returns result.\n *\n * Default chain name is `''` (empty string). It can't be skipped. That's\n * done intentionally, to keep signature monomorphic for high speed.\n **/\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n\n  // Chain can be empty, if rules disabled. But we still have to return Array.\n  return this.__cache__[chainName] || [];\n};\n\nmodule.exports = Ruler;\n","// 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/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x2B/* + */) {\n    return -1;\n  }\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      // \" -test \" - is not a list item\n      return -1;\n    }\n  }\n\n  return pos;\n}\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 >= max) { return -1; }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1; }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) { return -1; }\n\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {\n\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start >= 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 < 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 < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true;\n      state.tokens[i].hidden = true;\n      i += 2;\n    }\n  }\n}\n\n\nmodule.exports = function list(state, startLine, endLine, silent) {\n  var ch,\n      contentStart,\n      i,\n      indent,\n      indentAfterMarker,\n      initial,\n      isOrdered,\n      itemLines,\n      l,\n      listLines,\n      listTokIdx,\n      markerCharCode,\n      markerValue,\n      max,\n      nextLine,\n      offset,\n      oldListIndent,\n      oldParentType,\n      oldSCount,\n      oldTShift,\n      oldTight,\n      pos,\n      posAfterMarker,\n      prevEmptyEnd,\n      start,\n      terminate,\n      terminatorRules,\n      token,\n      isTerminatingParagraph = false,\n      tight = true;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 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 >= 0 &&\n      state.sCount[startLine] - state.listIndent >= 4 &&\n      state.sCount[startLine] < state.blkIndent) {\n    return false;\n  }\n\n  // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n  if (silent && state.parentType === 'paragraph') {\n    // Next list item should still terminate previous list item;\n    //\n    // This code can fail if plugins use blkIndent as well as lists,\n    // but I hope the spec gets fixed long before that happens.\n    //\n    if (state.tShift[startLine] >= state.blkIndent) {\n      isTerminatingParagraph = true;\n    }\n  }\n\n  // Detect list type and position after marker\n  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {\n    isOrdered = true;\n    start = state.bMarks[startLine] + state.tShift[startLine];\n    markerValue = Number(state.src.substr(start, posAfterMarker - start - 1));\n\n    // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n    if (isTerminatingParagraph && markerValue !== 1) return false;\n\n  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 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) >= state.eMarks[startLine]) return false;\n  }\n\n  // We should terminate list on style change. Remember first one to compare.\n  markerCharCode = state.src.charCodeAt(posAfterMarker - 1);\n\n  // For validation mode we can terminate immediately\n  if (silent) { return true; }\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 = [ startLine, 0 ];\n  token.markup = String.fromCharCode(markerCharCode);\n\n  //\n  // Iterate list items\n  //\n\n  nextLine = startLine;\n  prevEmptyEnd = false;\n  terminatorRules = state.md.block.ruler.getRules('list');\n\n  oldParentType = state.parentType;\n  state.parentType = 'list';\n\n  while (nextLine < endLine) {\n    pos = posAfterMarker;\n    max = state.eMarks[nextLine];\n\n    initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);\n\n    while (pos < max) {\n      ch = state.src.charCodeAt(pos);\n\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[nextLine]) % 4;\n      } else if (ch === 0x20) {\n        offset++;\n      } else {\n        break;\n      }\n\n      pos++;\n    }\n\n    contentStart = pos;\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = offset - initial;\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker > 4) { indentAfterMarker = 1; }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    indent = initial + indentAfterMarker;\n\n    // Run subparser & write tokens\n    token        = state.push('list_item_open', 'li', 1);\n    token.markup = String.fromCharCode(markerCharCode);\n    token.map    = itemLines = [ startLine, 0 ];\n\n    // change current state, then restore it after parser subcall\n    oldTight = state.tight;\n    oldTShift = state.tShift[startLine];\n    oldSCount = state.sCount[startLine];\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[startLine] = contentStart - state.bMarks[startLine];\n    state.sCount[startLine] = offset;\n\n    if (contentStart >= max && state.isEmpty(startLine + 1)) {\n      // workaround for this case\n      // (list item is empty, list terminates before \"foo\"):\n      // ~~~~~~~~\n      //   -\n      //\n      //     foo\n      // ~~~~~~~~\n      state.line = Math.min(state.line + 2, endLine);\n    } else {\n      state.md.block.tokenize(state, startLine, endLine, true);\n    }\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 - startLine) > 1 && state.isEmpty(state.line - 1);\n\n    state.blkIndent = state.listIndent;\n    state.listIndent = oldListIndent;\n    state.tShift[startLine] = oldTShift;\n    state.sCount[startLine] = oldSCount;\n    state.tight = oldTight;\n\n    token        = state.push('list_item_close', 'li', -1);\n    token.markup = String.fromCharCode(markerCharCode);\n\n    nextLine = startLine = state.line;\n    itemLines[1] = nextLine;\n    contentStart = state.bMarks[startLine];\n\n    if (nextLine >= endLine) { break; }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[startLine] - state.blkIndent >= 4) { break; }\n\n    // fail if terminating block found\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n      if (posAfterMarker < 0) { break; }\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n      if (posAfterMarker < 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","/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Parser rules\n\nvar _rules = [\n  [ 'text',            require('./rules_inline/text') ],\n  [ 'newline',         require('./rules_inline/newline') ],\n  [ 'escape',          require('./rules_inline/escape') ],\n  [ 'backticks',       require('./rules_inline/backticks') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').tokenize ],\n  [ 'emphasis',        require('./rules_inline/emphasis').tokenize ],\n  [ 'link',            require('./rules_inline/link') ],\n  [ 'image',           require('./rules_inline/image') ],\n  [ 'autolink',        require('./rules_inline/autolink') ],\n  [ 'html_inline',     require('./rules_inline/html_inline') ],\n  [ 'entity',          require('./rules_inline/entity') ]\n];\n\nvar _rules2 = [\n  [ 'balance_pairs',   require('./rules_inline/balance_pairs') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').postProcess ],\n  [ 'emphasis',        require('./rules_inline/emphasis').postProcess ],\n  [ 'text_collapse',   require('./rules_inline/text_collapse') ]\n];\n\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline() {\n  var i;\n\n  /**\n   * ParserInline#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n\n  /**\n   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler();\n\n  for (i = 0; i < _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1]);\n  }\n}\n\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  var ok, i, pos = state.pos,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      maxNesting = state.md.options.maxNesting,\n      cache = state.cache;\n\n\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos];\n    return;\n  }\n\n  if (state.level < maxNesting) {\n    for (i = 0; i < len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++;\n      ok = rules[i](state, true);\n      state.level--;\n\n      if (ok) { break; }\n    }\n  } else {\n    // Too much nesting, just skip until the end of the paragraph.\n    //\n    // NOTE: this will cause links to behave incorrectly in the following case,\n    //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n    //\n    //       [[[[[[[[[[[[[[[[[[[[[foo]()\n    //\n    // TODO: remove this workaround when CM standard will allow nested links\n    //       (we can replace it by preventing links from being parsed in\n    //       validation mode)\n    //\n    state.pos = state.posMax;\n  }\n\n  if (!ok) { state.pos++; }\n  cache[pos] = state.pos;\n};\n\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      end = state.posMax,\n      maxNesting = state.md.options.maxNesting;\n\n  while (state.pos < end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n\n    if (state.level < maxNesting) {\n      for (i = 0; i < len; i++) {\n        ok = rules[i](state, false);\n        if (ok) { break; }\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) { break; }\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  var i, rules, len;\n  var state = new this.State(str, md, env, outTokens);\n\n  this.tokenize(state);\n\n  rules = this.ruler2.getRules('');\n  len = rules.length;\n\n  for (i = 0; i < len; i++) {\n    rules[i](state);\n  }\n};\n\n\nParserInline.prototype.State = require('./rules_inline/state_inline');\n\n\nmodule.exports = ParserInline;\n","/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\nvar _rules = [\n  // First 2 params - rule name & source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  [ 'table',      require('./rules_block/table'),      [ 'paragraph', 'reference' ] ],\n  [ 'code',       require('./rules_block/code') ],\n  [ 'fence',      require('./rules_block/fence'),      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'blockquote', require('./rules_block/blockquote'), [ 'paragraph', 'reference', '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  [ 'heading',    require('./rules_block/heading'),    [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'lheading',   require('./rules_block/lheading') ],\n  [ 'html_block', require('./rules_block/html_block'), [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'paragraph',  require('./rules_block/paragraph') ]\n];\n\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock() {\n  /**\n   * ParserBlock#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });\n  }\n}\n\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      line = startLine,\n      hasEmptyLines = false,\n      maxNesting = state.md.options.maxNesting;\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line >= endLine) { break; }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.sCount[line] < state.blkIndent) { break; }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level >= maxNesting) {\n      state.line = endLine;\n      break;\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n      if (ok) { break; }\n    }\n\n    // set state.tight 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 < endLine && 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","// 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 /* _ */ && marker !== 0x2A /* * */) { return false; }\n\n  scanned = state.scanDelims(state.pos, marker === 0x2A);\n\n  for (i = 0; i < scanned.length; i++) {\n    token         = state.push('text', '', 0);\n    token.content = String.fromCharCode(marker);\n\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      // An amount of characters before this one that's equivalent to\n      // current one. In plain English: if this delimiter does not open\n      // an emphasis, neither do previous `jump` characters.\n      //\n      // Used to skip sequences like \"*****\" in one step, for 1st asterisk\n      // value will be 0, for 2nd it's 1 and so on.\n      //\n      jump:   i,\n\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 >= 0; i--) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x5F/* _ */ && 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    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`\n    //\n    isStrong = i > 0 &&\n               delimiters[i - 1].end === startDelim.end + 1 &&\n               delimiters[i - 1].token === startDelim.token - 1 &&\n               delimiters[startDelim.end + 1].token === endDelim.token + 1 &&\n               delimiters[i - 1].marker === startDelim.marker;\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 < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n","// Parse link title\n//\n'use strict';\n\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\n\nmodule.exports = function parseLinkTitle(str, pos, max) {\n  var code,\n      marker,\n      lines = 0,\n      start = pos,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (pos >= max) { return result; }\n\n  marker = str.charCodeAt(pos);\n\n  if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && 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 < 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 === 0x0A) {\n      lines++;\n    } else if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos++;\n      if (str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n\n    pos++;\n  }\n\n  return result;\n};\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 < 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","// Process autolinks '<protocol:...>'\n\n'use strict';\n\n\n/*eslint max-len:0*/\nvar EMAIL_RE    = /^<([a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;\nvar AUTOLINK_RE = /^<([a-zA-Z][a-zA-Z0-9+.\\-]{1,31}):([^<>\\x00-\\x20]*)>/;\n\n\nmodule.exports = function autolink(state, silent) {\n  var tail, linkMatch, emailMatch, url, fullUrl, token,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  tail = state.src.slice(pos);\n\n  if (tail.indexOf('>') < 0) { return false; }\n\n  if (AUTOLINK_RE.test(tail)) {\n    linkMatch = tail.match(AUTOLINK_RE);\n\n    url = linkMatch[0].slice(1, -1);\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 += linkMatch[0].length;\n    return true;\n  }\n\n  if (EMAIL_RE.test(tail)) {\n    emailMatch = tail.match(EMAIL_RE);\n\n    url = emailMatch[0].slice(1, -1);\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 += emailMatch[0].length;\n    return true;\n  }\n\n  return false;\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  'meta',\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","// HTML5 entities map: { name -> utf16string }\n//\n'use strict';\n\n/*eslint quotes:0*/\nmodule.exports = require('entities/lib/maps/entities.json');\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 -> String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type     = type;\n\n  /**\n   * Token#tag -> String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag      = tag;\n\n  /**\n   * Token#attrs -> Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs    = null;\n\n  /**\n   * Token#map -> Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map      = null;\n\n  /**\n   * Token#nesting -> Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n  this.nesting  = nesting;\n\n  /**\n   * Token#level -> Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level    = 0;\n\n  /**\n   * Token#children -> Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null;\n\n  /**\n   * Token#content -> String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content  = '';\n\n  /**\n   * Token#markup -> String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup   = '';\n\n  /**\n   * Token#info -> String\n   *\n   * fence infostring\n   **/\n  this.info     = '';\n\n  /**\n   * Token#meta -> Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta     = null;\n\n  /**\n   * Token#block -> Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block    = false;\n\n  /**\n   * Token#hidden -> Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden   = false;\n}\n\n\n/**\n * Token.attrIndex(name) -> 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 < 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 < 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 >= 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 < 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","'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 < 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","// markdown-it default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   100            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n","// 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 /^<a[>\\s]/i.test(str);\n}\nfunction isLinkClose(str) {\n  return /^<\\/a\\s*>/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 < 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 >= 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 && 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) && htmlLinkLevel > 0) {\n          htmlLinkLevel--;\n        }\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++;\n        }\n      }\n      if (htmlLinkLevel > 0) { continue; }\n\n      if (currentToken.type === 'text' && 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        for (ln = 0; ln < links.length; ln++) {\n\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:' && !/^mailto:/i.test(urlText)) {\n            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');\n          } else {\n            urlText = state.md.normalizeLinkText(urlText);\n          }\n\n          pos = links[ln].index;\n\n          if (pos > lastPos) {\n            token         = new state.Token('text', '', 0);\n            token.content = text.slice(lastPos, pos);\n            token.level   = level;\n            nodes.push(token);\n          }\n\n          token         = new state.Token('link_open', 'a', 1);\n          token.attrs   = [ [ 'href', fullUrl ] ];\n          token.level   = level++;\n          token.markup  = 'linkify';\n          token.info    = 'auto';\n          nodes.push(token);\n\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 < 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","// ~~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 < 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 < 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      jump:   i,\n      token:  state.tokens.length - 1,\n      end:    -1,\n      open:   scanned.can_open,\n      close:  scanned.can_close\n    });\n  }\n\n  state.pos += scanned.length;\n\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 < 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' &&\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: `~~~~~` -> `~` + `~~` + `~~`, 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 < state.tokens.length && state.tokens[j].type === 's_close') {\n      j++;\n    }\n\n    j--;\n\n    if (i !== j) {\n      token = state.tokens[j];\n      state.tokens[j] = state.tokens[i];\n      state.tokens[i] = token;\n    }\n  }\n}\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 < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n","// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// (p) (P) -> §\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → &ndash;, --- → &mdash;\n//\n'use strict';\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - miltiplication 2 x 4 -> 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|p)\\)/i;\n\nvar SCOPED_ABBR_RE = /\\((c|tm|r|p)\\)/ig;\nvar SCOPED_ABBR = {\n  c: '©',\n  r: '®',\n  p: '§',\n  tm: '™'\n};\n\nfunction replaceFn(match, name) {\n  return SCOPED_ABBR[name.toLowerCase()];\n}\n\nfunction replace_scoped(inlineTokens) {\n  var i, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\nfunction replace_rare(inlineTokens) {\n  var i, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content\n          .replace(/\\+-/g, '±')\n          // .., ..., ....... -> …\n          // but ?..... & !..... -> ?.. & !..\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' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && 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 >= 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","// 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 < 256; i++) { ESCAPED.push(0); }\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'\n  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1; });\n\n\nmodule.exports = function escape(state, silent) {\n  var ch, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x5C/* \\ */) { return false; }\n\n  pos++;\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch < 256 && ESCAPED[ch] !== 0) {\n      if (!silent) { state.pending += state.src[pos]; }\n      state.pos += 2;\n      return true;\n    }\n\n    if (ch === 0x0A) {\n      if (!silent) {\n        state.push('hardbreak', 'br', 0);\n      }\n\n      pos++;\n      // skip leading whitespaces from next line\n      while (pos < max) {\n        ch = state.src.charCodeAt(pos);\n        if (!isSpace(ch)) { break; }\n        pos++;\n      }\n\n      state.pos = pos;\n      return true;\n    }\n  }\n\n  if (!silent) { state.pending += '\\\\'; }\n  state.pos++;\n  return true;\n};\n","// Parse backticks\n\n'use strict';\n\nmodule.exports = function backtick(state, silent) {\n  var start, max, marker, matchStart, matchEnd, token,\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  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++; }\n\n  marker = state.src.slice(start, pos);\n\n  matchStart = matchEnd = pos;\n\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++; }\n\n    if (matchEnd - matchStart === marker.length) {\n      if (!silent) {\n        token         = state.push('code_inline', 'code', 0);\n        token.markup  = marker;\n        token.content = state.src.slice(pos, matchStart)\n          .replace(/\\n/g, ' ')\n          .replace(/^ (.+) $/, '$1');\n      }\n      state.pos = matchEnd;\n      return true;\n    }\n  }\n\n  if (!silent) { state.pending += marker; }\n  state.pos += marker.length;\n  return true;\n};\n","// For each opening emphasis-like marker find a matching closing one\n//\n'use strict';\n\n\nfunction processDelimiters(state, delimiters) {\n  var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx,\n      isOddMatch, lastJump,\n      openersBottom = {},\n      max = delimiters.length;\n\n  for (closerIdx = 0; closerIdx < max; closerIdx++) {\n    closer = delimiters[closerIdx];\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 and each delimiter length modulo 3.\n    if (!openersBottom.hasOwnProperty(closer.marker)) {\n      openersBottom[closer.marker] = [ -1, -1, -1 ];\n    }\n\n    minOpenerIdx = openersBottom[closer.marker][closer.length % 3];\n    newMinOpenerIdx = -1;\n\n    openerIdx = closerIdx - closer.jump - 1;\n\n    for (; openerIdx > minOpenerIdx; openerIdx -= opener.jump + 1) {\n      opener = delimiters[openerIdx];\n\n      if (opener.marker !== closer.marker) continue;\n\n      if (newMinOpenerIdx === -1) newMinOpenerIdx = openerIdx;\n\n      if (opener.open && opener.end < 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 > 0 && !delimiters[openerIdx - 1].open ?\n            delimiters[openerIdx - 1].jump + 1 :\n            0;\n\n          closer.jump  = closerIdx - openerIdx + lastJump;\n          closer.open  = false;\n          opener.end   = closerIdx;\n          opener.jump  = lastJump;\n          opener.close = false;\n          newMinOpenerIdx = -1;\n          break;\n        }\n      }\n    }\n\n    if (newMinOpenerIdx !== -1) {\n      // If match for this delimiter run failed, we want to set lower bound for\n      // future lookups. This is required to make sure algorithm has linear\n      // complexity.\n      //\n      // See details here:\n      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442\n      //\n      openersBottom[closer.marker][(closer.length || 0) % 3] = newMinOpenerIdx;\n    }\n  }\n}\n\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, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      processDelimiters(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\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 >= 4) { return false; }\n\n  ch  = state.src.charCodeAt(pos);\n\n  if (ch !== 0x23/* # */ || pos >= max) { return false; }\n\n  // count heading level\n  level = 1;\n  ch = state.src.charCodeAt(++pos);\n  while (ch === 0x23/* # */ && pos < max && level <= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n\n  if (level > 6 || (pos < max && !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 > pos && 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","'use strict';\n\n\nmodule.exports = require('./lib/');\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  [ /^<(script|pre|style)(?=(\\s|>|$))/i, /<\\/(script|pre|style)>/i, true ],\n  [ /^<!--/,        /-->/,   true ],\n  [ /^<\\?/,         /\\?>/,   true ],\n  [ /^<![A-Z]/,     />/,     true ],\n  [ /^<!\\[CDATA\\[/, /\\]\\]>/, true ],\n  [ new RegExp('^</?(' + block_names.join('|') + ')(?=(\\\\s|/?>|$))', '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 >= 4) { return false; }\n\n  if (!state.md.options.html) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  lineText = state.src.slice(pos, max);\n\n  for (i = 0; i < HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) { 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 < endLine; nextLine++) {\n      if (state.sCount[nextLine] < 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","// 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 >= 4) { return false; }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos++) !== 0x3E/* > */) { 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  // set offset past spaces and \">\"\n  initial = offset = state.sCount[startLine] + 1;\n\n  // skip one optional space after '>'\n  if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n    // ' >   test '\n    //     ^ -- position start of line here:\n    pos++;\n    initial++;\n    offset++;\n    adjustTab = false;\n    spaceAfterMarker = true;\n  } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n    spaceAfterMarker = true;\n\n    if ((state.bsCount[startLine] + offset) % 4 === 3) {\n      // '  >\\t  test '\n      //       ^ -- position start of line here (tab has width===1)\n      pos++;\n      initial++;\n      offset++;\n      adjustTab = false;\n    } else {\n      // ' >\\t  test '\n      //    ^ -- position start of line here + shift bsCount slightly\n      //         to make extra space appear\n      adjustTab = true;\n    }\n  } else {\n    spaceAfterMarker = false;\n  }\n\n  oldBMarks = [ state.bMarks[startLine] ];\n  state.bMarks[startLine] = pos;\n\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (isSpace(ch)) {\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;\n      } else {\n        offset++;\n      }\n    } else {\n      break;\n    }\n\n    pos++;\n  }\n\n  oldBSCount = [ state.bsCount[startLine] ];\n  state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);\n\n  lastLineEmpty = pos >= max;\n\n  oldSCount = [ state.sCount[startLine] ];\n  state.sCount[startLine] = offset - initial;\n\n  oldTShift = [ state.tShift[startLine] ];\n  state.tShift[startLine] = pos - state.bMarks[startLine];\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  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    > current blockquote\n    // 2. checking this line\n    // ```\n    isOutdented = state.sCount[nextLine] < state.blkIndent;\n\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !isOutdented) {\n      // This line is inside the blockquote.\n\n      // set offset past spaces and \">\"\n      initial = offset = state.sCount[nextLine] + 1;\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' >   test '\n        //     ^ -- position start of line here:\n        pos++;\n        initial++;\n        offset++;\n        adjustTab = false;\n        spaceAfterMarker = true;\n      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n        spaceAfterMarker = true;\n\n        if ((state.bsCount[nextLine] + offset) % 4 === 3) {\n          // '  >\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++;\n          initial++;\n          offset++;\n          adjustTab = false;\n        } else {\n          // ' >\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true;\n        }\n      } else {\n        spaceAfterMarker = false;\n      }\n\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n\n      while (pos < max) {\n        ch = state.src.charCodeAt(pos);\n\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;\n          } else {\n            offset++;\n          }\n        } else {\n          break;\n        }\n\n        pos++;\n      }\n\n      lastLineEmpty = pos >= max;\n\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 < 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 = '>';\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 = '>';\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 < 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","// 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 text_collapse(state) {\n  var curr, last,\n      level = 0,\n      tokens = state.tokens,\n      max = state.tokens.length;\n\n  for (curr = last = 0; curr < max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting < 0) level--; // closing tag\n    tokens[curr].level = level;\n    if (tokens[curr].nesting > 0) level++; // opening tag\n\n    if (tokens[curr].type === 'text' &&\n        curr + 1 < max &&\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\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 < 0) {\n    // closing tag\n    this.level--;\n    this.delimiters = this._prev_delimiters.pop();\n  }\n\n  token.level = this.level;\n\n  if (nesting > 0) {\n    // opening tag\n    this.level++;\n    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 > 0 ? this.src.charCodeAt(start - 1) : 0x20;\n\n  while (pos < max && this.src.charCodeAt(pos) === marker) { pos++; }\n\n  count = pos - start;\n\n  // treat end of the line as a whitespace\n  nextChar = pos < 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  && (!right_flanking || isLastPunctChar);\n    can_close = right_flanking && (!left_flanking  || isNextPunctChar);\n  } else {\n    can_open  = left_flanking;\n    can_close = right_flanking;\n  }\n\n  return {\n    can_open:  can_open,\n    can_close: can_close,\n    length:    count\n  };\n};\n\n\n// re-export Token class to use in block rules\nStateInline.prototype.Token = Token;\n\n\nmodule.exports = StateInline;\n","// Regexps to match html elements\n\n'use strict';\n\nvar attr_name     = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\n\nvar unquoted      = '[^\"\\'=<>`\\\\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    = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\n\nvar close_tag   = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nvar comment     = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';\nvar processing  = '<[?].*?[?]>';\nvar declaration = '<![A-Z]+\\\\s+[^>]*>';\nvar cdata       = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\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","// 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// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, 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/* & */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2D/* - */:\n    case 0x3A/* : */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\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 < state.posMax && !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!#$%&*+\\-:<=>@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -> empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -> text till end of string\n  if (idx < 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n};*/\n","// Process html entity - &#123;, &#xAF;, &quot;, ...\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 = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;\nvar NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i;\n\n\nmodule.exports = function entity(state, silent) {\n  var ch, code, match, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x26/* & */) { return false; }\n\n  if (pos + 1 < max) {\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          state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\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) { state.pending += entities[match[1]]; }\n          state.pos += match[0].length;\n          return true;\n        }\n      }\n    }\n  }\n\n  if (!silent) { state.pending += '&'; }\n  state.pos++;\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 < 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 < 0) this.level--; // closing tag\n  token.level = this.level;\n  if (nesting > 0) this.level++; // opening tag\n\n  this.tokens.push(token);\n  return token;\n};\n\nStateBlock.prototype.isEmpty = function isEmpty(line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];\n};\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (var max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break;\n    }\n  }\n  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 < 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 <= min) { return pos; }\n\n  while (pos > 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 < 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 <= min) { return pos; }\n\n  while (pos > 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 >= end) {\n    return '';\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line < end; line++, i++) {\n    lineIndent = 0;\n    lineStart = first = this.bMarks[line];\n\n    if (line + 1 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1;\n    } else {\n      last = this.eMarks[line];\n    }\n\n    while (first < last && lineIndent < indent) {\n      ch = this.src.charCodeAt(first);\n\n      if (isSpace(ch)) {\n        if (ch === 0x09) {\n          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;\n        } else {\n          lineIndent++;\n        }\n      } else if (first - lineStart < this.tShift[line]) {\n        // patched tShift masked characters to look like spaces (blockquotes, list markers)\n        lineIndent++;\n      } else {\n        break;\n      }\n\n      first++;\n    }\n\n    if (lineIndent > indent) {\n      // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n      // with indent=2 becomes '  \\tfoobar'\n      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);\n    } else {\n      queue[i] = this.src.slice(first, last);\n    }\n  }\n\n  return queue.join('');\n};\n\n// re-export Token class to use in block rules\nStateBlock.prototype.Token = Token;\n\n\nmodule.exports = StateBlock;\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      endLine = state.lineMax;\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph';\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    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","// Process html tags\n\n'use strict';\n\n\nvar HTML_TAG_RE = require('../common/html_re').HTML_TAG_RE;\n\n\nfunction isLetter(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 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/* < */ ||\n      pos + 2 >= max) {\n    return false;\n  }\n\n  // Quick fail on second char\n  ch = state.src.charCodeAt(pos + 1);\n  if (ch !== 0x21/* ! */ &&\n      ch !== 0x3F/* ? */ &&\n      ch !== 0x2F/* / */ &&\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 = state.src.slice(pos, pos + match[0].length);\n  }\n  state.pos += match[0].length;\n  return true;\n};\n","// GFM table, non-standard\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nfunction getLine(state, line) {\n  var pos = state.bMarks[line] + state.blkIndent,\n      max = state.eMarks[line];\n\n  return state.src.substr(pos, max - pos);\n}\n\nfunction escapedSplit(str) {\n  var result = [],\n      pos = 0,\n      max = str.length,\n      ch,\n      escapes = 0,\n      lastPos = 0,\n      backTicked = false,\n      lastBackTick = 0;\n\n  ch  = str.charCodeAt(pos);\n\n  while (pos < max) {\n    if (ch === 0x60/* ` */) {\n      if (backTicked) {\n        // make \\` close code sequence, but not open it;\n        // the reason is: `\\` is correct code block\n        backTicked = false;\n        lastBackTick = pos;\n      } else if (escapes % 2 === 0) {\n        backTicked = true;\n        lastBackTick = pos;\n      }\n    } else if (ch === 0x7c/* | */ && (escapes % 2 === 0) && !backTicked) {\n      result.push(str.substring(lastPos, pos));\n      lastPos = pos + 1;\n    }\n\n    if (ch === 0x5c/* \\ */) {\n      escapes++;\n    } else {\n      escapes = 0;\n    }\n\n    pos++;\n\n    // If there was an un-closed backtick, go back to just after\n    // the last backtick, but as if it was a normal character\n    if (pos === max && backTicked) {\n      backTicked = false;\n      pos = lastBackTick + 1;\n    }\n\n    ch = str.charCodeAt(pos);\n  }\n\n  result.push(str.substring(lastPos));\n\n  return result;\n}\n\n\nmodule.exports = function table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, nextLine, columns, columnCount, token,\n      aligns, t, tableLines, tbodyLines;\n\n  // should have at least two lines\n  if (startLine + 2 > endLine) { return false; }\n\n  nextLine = startLine + 1;\n\n  if (state.sCount[nextLine] < 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 >= 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 >= state.eMarks[nextLine]) { return false; }\n\n  ch = state.src.charCodeAt(pos++);\n  if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */) { return false; }\n\n  while (pos < state.eMarks[nextLine]) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !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 < 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 >= 4) { return false; }\n  columns = escapedSplit(lineText.replace(/^\\||\\|$/g, ''));\n\n  // header row will define an amount of columns in the entire table,\n  // and align row shouldn't be smaller than that (the rest of the rows can)\n  columnCount = columns.length;\n  if (columnCount > aligns.length) { return false; }\n\n  if (silent) { return true; }\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 < columns.length; i++) {\n    token          = state.push('th_open', 'th', 1);\n    token.map      = [ startLine, startLine + 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.map      = [ startLine, startLine + 1 ];\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  token     = state.push('tbody_open', 'tbody', 1);\n  token.map = tbodyLines = [ startLine + 2, 0 ];\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n    lineText = getLine(state, nextLine).trim();\n    if (lineText.indexOf('|') === -1) { break; }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) { break; }\n    columns = escapedSplit(lineText.replace(/^\\||\\|$/g, ''));\n\n    token = state.push('tr_open', 'tr', 1);\n    for (i = 0; i < columnCount; i++) {\n      token          = state.push('td_open', 'td', 1);\n      token.map      = [ nextLine, nextLine + 1 ];\n      if (aligns[i]) {\n        token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ];\n      }\n\n      token          = state.push('inline', '', 0);\n      token.map      = [ nextLine, nextLine + 1 ];\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  token = state.push('tbody_close', 'tbody', -1);\n  token = state.push('table_close', 'table', -1);\n\n  tableLines[1] = tbodyLines[1] = nextLine;\n  state.line = nextLine;\n  return true;\n};\n","/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n'use strict';\n\n\nvar Ruler  = require('./ruler');\n\n\nvar _rules = [\n  [ 'normalize',      require('./rules_core/normalize')      ],\n  [ 'block',          require('./rules_core/block')          ],\n  [ 'inline',         require('./rules_core/inline')         ],\n  [ 'linkify',        require('./rules_core/linkify')        ],\n  [ 'replacements',   require('./rules_core/replacements')   ],\n  [ 'smartquotes',    require('./rules_core/smartquotes')    ]\n];\n\n\n/**\n * new Core()\n **/\nfunction Core() {\n  /**\n   * Core#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  var i, l, rules;\n\n  rules = this.ruler.getRules('');\n\n  for (i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\n\nCore.prototype.State = require('./rules_core/state_core');\n\n\nmodule.exports = Core;\n","// Parse link destination\n//\n'use strict';\n\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\n\nmodule.exports = function parseLinkDestination(str, pos, max) {\n  var code, level,\n      lines = 0,\n      start = pos,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (str.charCodeAt(pos) === 0x3C /* < */) {\n    pos++;\n    while (pos < max) {\n      code = str.charCodeAt(pos);\n      if (code === 0x0A /* \\n */) { return result; }\n      if (code === 0x3E /* > */) {\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 /* \\ */ && pos + 1 < max) {\n        pos += 2;\n        continue;\n      }\n\n      pos++;\n    }\n\n    // no closing '>'\n    return result;\n  }\n\n  // this should be ... } else { ... branch\n\n  level = 0;\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n\n    if (code === 0x20) { break; }\n\n    // ascii control characters\n    if (code < 0x20 || code === 0x7F) { break; }\n\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++;\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.lines = lines;\n  result.pos = pos;\n  result.ok = true;\n  return result;\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","// 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) >= 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) >= 0) {\n      try {\n        parsed.hostname = punycode.toUnicode(parsed.hostname);\n      } catch (er) { /**/ }\n    }\n  }\n\n  return mdurl.decode(mdurl.format(parsed));\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 & autolinker.\n * - [\"zero\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -\n *   all rules disabled. Useful to quickly setup your config via `.enable()`.\n *   For example, when you need only `bold` and `italic` markup and nothing else.\n *\n * ##### options:\n *\n * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!\n *   That's not safe! You may need external sanitizer to protect output from XSS.\n *   It's better to extend features via plugins, instead of enabling HTML.\n * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags\n *   (`<br />`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `<br>`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +\n *   quotes beautification (smartquotes).\n * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement\n *   pairs, when typographer enabled and smartquotes on. For example, you can\n *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and\n *   `['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›']` for French (including nbsp).\n * - __highlight__ - `null`. Highlighter function for fenced code blocks.\n *   Highlighter `function (str, lang)` should return escaped HTML. It can also\n *   return empty string if the source was not changed and should be escaped\n *   externaly. If result starts with <pre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(lang, str, true).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `<pre>`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return '<pre class=\"hljs\"><code>' +\n *                hljs.highlight(lang, str, true).value +\n *                '</code></pre>';\n *       } catch (__) {}\n *     }\n *\n *     return '<pre class=\"hljs\"><code>' + md.utils.escapeHtml(str) + '</code></pre>';\n *   }\n * });\n * ```\n *\n **/\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 -> 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 -> 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 -> 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 -> 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 -> 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) -> 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) -> 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) -> String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText;\n\n\n  // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -> utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js).\n   **/\n  this.utils = utils;\n\n  /**\n   * MarkdownIt#helpers -> helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n  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) < 0; });\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);\n  }\n\n  return this;\n};\n\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) < 0; });\n\n  if (missed.length && !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) -> 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]) -> 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) -> 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]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `<p>` tags.\n **/\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","// 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 >= 0xD800 && c <= 0xDFFF) { return false; }\n  // never used\n  if (c >= 0xFDD0 && c <= 0xFDEF) { return false; }\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false; }\n  // control codes\n  if (c >= 0x00 && c <= 0x08) { return false; }\n  if (c === 0x0B) { return false; }\n  if (c >= 0x0E && c <= 0x1F) { return false; }\n  if (c >= 0x7F && c <= 0x9F) { return false; }\n  // out of range\n  if (c > 0x10FFFF) { return false; }\n  return true;\n}\n\nfunction fromCodePoint(c) {\n  /*eslint no-bitwise:0*/\n  if (c > 0xffff) {\n    c -= 0x10000;\n    var surrogate1 = 0xd800 + (c >> 10),\n        surrogate2 = 0xdc00 + (c & 0x3ff);\n\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n  return String.fromCharCode(c);\n}\n\n\nvar UNESCAPE_MD_RE  = /\\\\([!\"#$%&'()*+,\\-.\\/:;<=>?@[\\\\\\]^_`{|}~])/g;\nvar ENTITY_RE       = /&([a-z#][a-z0-9]{1,31});/gi;\nvar UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');\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 = 0;\n\n  if (has(entities, name)) {\n    return entities[name];\n  }\n\n  if (name.charCodeAt(0) === 0x23/* # */ && 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('&') < 0) { return str; }\n\n  return str.replace(ENTITY_RE, replaceEntityPattern);\n}*/\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) { return str; }\n  return str.replace(UNESCAPE_MD_RE, '$1');\n}\n\nfunction unescapeAll(str) {\n  if (str.indexOf('\\\\') < 0 && str.indexOf('&') < 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 = /[&<>\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nvar HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\n\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\n\nfunction escapeHtml(str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n  return str;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g;\n\nfunction escapeRE(str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$&');\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 >= 0x2000 && code <= 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// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, 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/* & */:\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/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\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  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n  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","// 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","// Commonmark default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         true,         // Enable HTML tags in source\n    xhtmlOut:     true,         // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'text_collapse'\n      ]\n    }\n  }\n};\n","// Process [link](<to> \"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      title,\n      token,\n      href = '',\n      oldPos = state.pos,\n      max = state.posMax,\n      start = state.pos,\n      parseReference = true;\n\n  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { 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 < 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos < max && 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](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"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](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) { break; }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= 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 < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\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.md.inline.tokenize(state);\n\n    token        = state.push('link_close', 'a', -1);\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};\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","// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline'\n      ]\n    },\n\n    block: {\n      rules: [\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'text_collapse'\n      ]\n    }\n  }\n};\n","/**\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  '<code' + slf.renderAttrs(token) + '>' +\n          escapeHtml(tokens[idx].content) +\n          '</code>';\n};\n\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  return  '<pre' + slf.renderAttrs(token) + '><code>' +\n          escapeHtml(tokens[idx].content) +\n          '</code></pre>\\n';\n};\n\n\ndefault_rules.fence = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx],\n      info = token.info ? unescapeAll(token.info).trim() : '',\n      langName = '',\n      highlighted, i, tmpAttrs, tmpToken;\n\n  if (info) {\n    langName = info.split(/\\s+/g)[0];\n  }\n\n  if (options.highlight) {\n    highlighted = options.highlight(token.content, langName) || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n\n  if (highlighted.indexOf('<pre') === 0) {\n    return highlighted + '\\n';\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .clone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    i        = token.attrIndex('class');\n    tmpAttrs = token.attrs ? token.attrs.slice() : [];\n\n    if (i < 0) {\n      tmpAttrs.push([ 'class', options.langPrefix + langName ]);\n    } else {\n      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;\n    }\n\n    // Fake token just to render attributes\n    tmpToken = {\n      attrs: tmpAttrs\n    };\n\n    return  '<pre><code' + slf.renderAttrs(tmpToken) + '>'\n          + highlighted\n          + '</code></pre>\\n';\n  }\n\n\n  return  '<pre><code' + slf.renderAttrs(token) + '>'\n        + highlighted\n        + '</code></pre>\\n';\n};\n\n\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs[token.attrIndex('alt')][1] =\n    slf.renderInlineAsText(token.children, options, env);\n\n  return slf.renderToken(tokens, idx, options);\n};\n\n\ndefault_rules.hardbreak = function (tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n';\n};\n\n\ndefault_rules.text = function (tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\n\n\ndefault_rules.html_block = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\ndefault_rules.html_inline = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\nfunction Renderer() {\n\n  /**\n   * Renderer#rules -> Object\n   *\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * md.renderer.rules.strong_open  = function () { return '<b>'; };\n   * md.renderer.rules.strong_close = function () { return '</b>'; };\n   *\n   * var result = md.renderInline(...);\n   * ```\n   *\n   * Each rule is called as 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) -> String\n *\n * Render token attributes to string.\n **/\nRenderer.prototype.renderAttrs = function renderAttrs(token) {\n  var i, l, result;\n\n  if (!token.attrs) { return ''; }\n\n  result = '';\n\n  for (i = 0, l = token.attrs.length; i < l; i++) {\n    result += ' ' + escapeHtml(token.attrs[i][0]) + '=\"' + escapeHtml(token.attrs[i][1]) + '\"';\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.renderToken(tokens, idx, options) -> String\n * - tokens (Array): list of tokens\n * - idx (Numbed): token index to render\n * - options (Object): params of parser instance\n *\n * Default token renderer. Can be overriden by custom function\n * in [[Renderer#rules]].\n **/\nRenderer.prototype.renderToken = function renderToken(tokens, idx, options) {\n  var nextToken,\n      result = '',\n      needLf = false,\n      token = tokens[idx];\n\n  // Tight list paragraphs\n  if (token.hidden) {\n    return '';\n  }\n\n  // Insert a newline between hidden paragraph and subsequent opening\n  // block-level tag.\n  //\n  // For example, here we should insert a newline before blockquote:\n  //  - a\n  //    >\n  //\n  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {\n    result += '\\n';\n  }\n\n  // Add token name, e.g. `<img`\n  result += (token.nesting === -1 ? '</' : '<') + token.tag;\n\n  // Encode attributes, e.g. `<img src=\"foo\"`\n  result += this.renderAttrs(token);\n\n  // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n  if (token.nesting === 0 && options.xhtmlOut) {\n    result += ' /';\n  }\n\n  // Check if we need to add a newline after this tag\n  if (token.block) {\n    needLf = true;\n\n    if (token.nesting === 1) {\n      if (idx + 1 < tokens.length) {\n        nextToken = tokens[idx + 1];\n\n        if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n          needLf = false;\n\n        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `<li></li>`.\n          //\n          needLf = false;\n        }\n      }\n    }\n  }\n\n  result += needLf ? '>\\n' : '>';\n\n  return result;\n};\n\n\n/**\n * Renderer.renderInline(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * The same as [[Renderer.render]], but for single token of `inline` type.\n **/\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  var type,\n      result = '',\n      rules = this.rules;\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options);\n    }\n  }\n\n  return result;\n};\n\n\n/** internal\n * Renderer.renderInlineAsText(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Special kludge for image `alt` attributes to conform CommonMark spec.\n * Don't try to use it! Spec requires to show `alt` content with stripped markup,\n * instead of simple escaping.\n **/\nRenderer.prototype.renderInlineAsText = function (tokens, options, env) {\n  var result = '';\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    if (tokens[i].type === 'text') {\n      result += tokens[i].content;\n    } else if (tokens[i].type === 'image') {\n      result += this.renderInlineAsText(tokens[i].children, options, env);\n    }\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.render(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Takes token stream and generates HTML. Probably, you will never need to call\n * this method directly.\n **/\nRenderer.prototype.render = function (tokens, options, env) {\n  var i, len, type,\n      result = '',\n      rules = this.rules;\n\n  for (i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else if (typeof rules[type] !== 'undefined') {\n      result += rules[tokens[i].type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options, env);\n    }\n  }\n\n  return result;\n};\n\nmodule.exports = Renderer;\n"],"names":["normalizeReference","require","isSpace","module","exports","state","startLine","_endLine","silent","ch","destEndPos","destEndLineNo","endLine","href","i","l","label","labelEnd","oldParentType","res","start","str","terminate","terminatorRules","title","lines","pos","bMarks","tShift","max","eMarks","nextLine","sCount","blkIndent","src","charCodeAt","lineMax","md","block","ruler","getRules","parentType","isEmpty","length","getLines","trim","helpers","parseLinkDestination","ok","normalizeLink","validateLink","parseLinkTitle","slice","env","references","line","marker","len","params","mem","token","markup","haveEndMarker","skipChars","indexOf","String","fromCharCode","skipSpaces","push","info","content","map","level","children","cnt","Array","join","last","attrs","code","labelStart","ref","tokens","oldPos","posMax","parseLinkLabel","inline","parse","Token","StateCore","this","inlineMode","prototype","pmax","pending","replace","isWhiteSpace","isPunctChar","isMdAsciiPunct","QUOTE_TEST_RE","QUOTE_RE","replaceAt","index","substr","process_inlines","text","t","thisLevel","item","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","canOpen","canClose","j","isSingle","stack","openQuote","closeQuote","type","OUTER","lastIndex","exec","single","options","quotes","blkIdx","typographer","test","Ruler","__rules__","__cache__","__find__","name","__compile__","self","chains","forEach","rule","enabled","alt","altName","chain","fn","at","opt","Error","before","beforeName","ruleName","splice","after","afterName","enable","list","ignoreInvalid","isArray","result","idx","enableOnly","disable","chainName","skipBulletListMarker","skipOrderedListMarker","contentStart","indent","indentAfterMarker","initial","isOrdered","itemLines","listLines","listTokIdx","markerCharCode","markerValue","offset","oldListIndent","oldSCount","oldTShift","oldTight","posAfterMarker","prevEmptyEnd","isTerminatingParagraph","tight","listIndent","Number","bsCount","Math","min","tokenize","hidden","markTightParagraphs","_rules","_rules2","ParserInline","ruler2","skipToken","rules","maxNesting","cache","end","pushPending","outTokens","State","ParserBlock","hasEmptyLines","skipEmptyLines","postProcess","delimiters","startDelim","endDelim","isStrong","tag","nesting","scanned","scanDelims","jump","open","can_open","close","can_close","curr","tokens_meta","unescapeAll","disableNested","found","prevPos","EMAIL_RE","AUTOLINK_RE","tail","linkMatch","emailMatch","url","fullUrl","match","normalizeLinkText","meta","attrIndex","attrPush","attrData","attrSet","value","attrGet","attrJoin","tok","html","xhtmlOut","breaks","langPrefix","linkify","highlight","components","core","arrayReplaceAt","isLinkClose","currentToken","nodes","ln","lastPos","htmlLinkLevel","urlText","links","blockTokens","pretest","schema","loneMarkers","pop","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","c","r","p","tm","replaceFn","toLowerCase","replace_scoped","inlineTokens","inside_autolink","replace_rare","ESCAPED","split","matchStart","matchEnd","processDelimiters","closerIdx","openerIdx","closer","opener","minOpenerIdx","newMinOpenerIdx","isOddMatch","lastJump","openersBottom","hasOwnProperty","tmp","skipSpacesBack","skipCharsBack","block_names","HTML_OPEN_CLOSE_TAG_RE","HTML_SEQUENCES","RegExp","source","lineText","adjustTab","lastLineEmpty","oldBMarks","oldBSCount","oldIndent","spaceAfterMarker","isOutdented","oldLineMax","StateInline","pendingLevel","_prev_delimiters","token_meta","canSplitWord","count","left_flanking","right_flanking","open_tag","close_tag","HTML_TAG_RE","isTerminatorChar","entities","has","isValidEntityCode","fromCodePoint","DIGITAL_RE","NAMED_RE","parseInt","StateBlock","s","indent_found","ddIndent","from","begin","keepLastLF","lineIndent","first","queue","lineStart","lc","isLetter","getLine","escapedSplit","escapes","backTicked","lastBackTick","substring","columns","columnCount","aligns","tableLines","tbodyLines","Core","process","utils","Renderer","ParserCore","LinkifyIt","mdurl","punycode","config","zero","commonmark","BAD_PROTO_RE","GOOD_DATA_RE","RECODE_HOSTNAME_FOR","parsed","hostname","protocol","toASCII","er","encode","format","toUnicode","decode","MarkdownIt","presetName","isString","renderer","assign","configure","set","presets","Object","keys","rules2","concat","missed","filter","use","plugin","args","call","arguments","apply","render","parseInline","renderInline","_typeof","o","Symbol","iterator","constructor","_hasOwnProperty","object","key","surrogate1","surrogate2","UNESCAPE_MD_RE","UNESCAPE_ALL_RE","DIGITAL_ENTITY_TEST_RE","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","REGEXP_ESCAPE_RE","UNICODE_PUNCT_RE","lib","ucmicro","obj","TypeError","toString","_class","unescapeMd","escaped","entity","replaceEntityPattern","escapeHtml","newElements","escapeRE","toUpperCase","parseReference","NEWLINES_RE","NULL_RE","default_rules","code_inline","slf","renderAttrs","code_block","fence","highlighted","tmpAttrs","tmpToken","langName","image","renderInlineAsText","renderToken","hardbreak","softbreak","html_block","html_inline","nextToken","needLf"],"sourceRoot":""}