src.83c48796.js.map

{"version":3,"sources":["../node_modules/remarkable/dist/esm/index.browser.js","index.js","../node_modules/parcel-bundler/src/builtins/bundle-url.js","../node_modules/parcel-bundler/src/builtins/bundle-loader.js","../node_modules/parcel-bundler/src/builtins/loaders/browser/html-loader.js"],"names":["textarea","decodeEntity","name","document","createElement","innerHTML","value","typeOf","obj","Object","prototype","toString","call","isString","hasOwn","hasOwnProperty","has","object","key","assign","slice","arguments","forEach","source","TypeError","keys","UNESCAPE_MD_RE","unescapeMd","str","indexOf","replace","isValidEntityCode","c","fromCodePoint","surrogate1","surrogate2","String","fromCharCode","NAMED_ENTITY_RE","DIGITAL_ENTITY_TEST_RE","replaceEntityPattern","match","code","decoded","charCodeAt","test","toLowerCase","parseInt","replaceEntities","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","ch","escapeHtml","utils","freeze","rules","nextToken","tokens","idx","length","type","tight","content","blockquote_open","blockquote_close","getBreak","block","fence","options","env","instance","token","fences","fenceName","langClass","langPrefix","params","split","join","fence_custom","highlight","apply","concat","heading_open","hLevel","heading_close","hr","xhtmlOut","bullet_list_open","bullet_list_close","list_item_open","list_item_close","ordered_list_open","order","ordered_list_close","paragraph_open","paragraph_close","addBreak","link_open","title","target","linkTarget","href","link_close","image","src","alt","table_open","table_close","thead_open","thead_close","tbody_open","tbody_close","tr_open","tr_close","th_open","align","th_close","td_open","td_close","strong_open","strong_close","em_open","em_close","del_open","del_close","ins_open","ins_close","mark_open","mark_close","sub","sup","hardbreak","softbreak","breaks","text","htmlblock","htmltag","abbr_open","abbr_close","footnote_ref","n","Number","id","subId","footnote_block_open","footnote_block_close","footnote_open","footnote_close","footnote_anchor","dl_open","dt_open","dd_open","dl_close","dt_close","dd_close","Renderer","Ruler","__rules__","__cache__","state","inlineMode","push","trim","level","lines","children","parse","StateInline","parserInline","outTokens","parser","pos","posMax","pending","pendingLevel","cache","isInLabel","linkLevel","linkContent","labelUnmatchedScopes","parseLinkLabel","start","found","marker","labelEnd","max","oldPos","oldFlag","skipToken","parseAbbr","label","abbreviations","abbr","i","l","inline","normalizeLink","url","normalized","decodeURI","err","encodeURI","parseLinkDestination","link","validateLink","parseLinkTitle","normalizeReference","toUpperCase","parseReference","references","tok","footnote_block","j","t","lastParagraph","list","current","currentLabel","insideRef","refTokens","footnotes","filter","pop","count","renderInline","len","_rules","result","render","__find__","__compile__","self","chains","rule","enabled","altName","chain","fn","at","opt","Error","before","beforeName","ruleName","splice","after","afterName","enable","strict","Array","isArray","disable","getRules","chainName","pushPending","cacheSet","val","cacheGet","PUNCT_CHARS","regEscape","s","abbr2","nodes","reg","m","regText","blockTokens","abbrRegExp","map","x","substr","sort","a","b","RegExp","lastIndex","exec","index","RARE_RE","SCOPED_ABBR_RE","SCOPED_ABBR","replaceScopedAbbr","inlineTokens","blkIdx","typographer","QUOTE_TEST_RE","QUOTE_RE","PUNCT_RE","APOSTROPHE","isLetter","replaceAt","smartquotes","thisLevel","lastSpace","nextSpace","item","canOpen","canClose","isSingle","stack","OUTER","single","quotes","Core","ruler","StateBlock","indent","indent_found","bMarks","eMarks","tShift","blkIndent","line","lineMax","parentType","ddIndent","startLine","endLine","nextLine","last","isEmpty","getLines","silent","mem","haveEndMarker","skipChars","skipSpaces","blockquote","lastLineEmpty","oldTShift","oldBMarks","oldIndent","oldParentType","terminatorRules","terminate","maxNesting","tokenize","cnt","skipBulletListMarker","skipOrderedListMarker","markTightParagraphs","oldTight","posAfterMarker","indentAfterMarker","markerValue","markerCharCode","isOrdered","contentStart","listTokIdx","prevEmptyEnd","listLines","itemLines","footnote","oldBMark","refs","heading","tmp","skipCharsBack","lheading","next","process","skipEmptyLines","from","min","begin","end","keepLastLF","first","queue","shift","Math","html_blocks","HTML_TAG_OPEN_RE","HTML_TAG_CLOSE_RE","isLetter$1","lc","html","getLine","table","lineText","rows","cell","aligns","tableLines","tbodyLines","substring","skipMarker","markTightParagraphs$1","deflist","ddLine","dtLine","oldDDIndent","paragraph","_rules$1","ParserBlock","hasEmptyLines","TABS_SCAN_RE","NEWLINES_RE","SPACES_RE","isTerminatorChar","newline","pmax","lineStart","lastTabPos","offset","ESCAPED","escape","backticks","matchStart","matchEnd","del","lastChar","nextChar","ins","mark","isAlphaNum","scanDelims","can_open","can_close","delims","emphasis","startCount","oldCount","newCount","res","UNESCAPE_RE","UNESCAPE_RE$1","links","labelStart","ref","isImage","footnote_inline","footnoteId","oldLength","footnoteSubId","url_schemas","EMAIL_RE","AUTOLINK_RE","autolink","tail","linkMatch","emailMatch","fullUrl","replace$1","regex","attr_name","unquoted","single_quoted","double_quoted","attr_value","attribute","open_tag","close_tag","comment","processing","declaration","cdata","HTML_TAG_RE","isLetter$2","DIGITAL_RE","NAMED_RE","entity","_rules$2","ParserInline","BAD_PROTOCOLS","cached_pos","ok","defaultConfig","components","core","fullConfig","commonmarkConfig","config","StateCore","renderer","Remarkable","preset","linkify","console","warn","configure","set","presets","use","plugin","parseInline","resume_content","getElementById","querySelector","addEventListener","e","preventDefault","scrollIntoView","md","resume","bundleURL","getBundleURLCached","getBundleURL","matches","getBaseURL","exports","require","loadBundlesLazy","bundles","Promise","resolve","LazyPromise","reject","loadBundles","then","all","loadBundle","bundleLoaders","registerBundleLoader","loader","module","load","register","bundle","lastIndexOf","bundleLoader","resolved","catch","executor","promise","onSuccess","onError","fetch"],"mappings":"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MACA,OACA,OACA,MACA,OACA,MACA,OACA,MACA,MACA,KACA,SACA,OACA,OACA,QACA,MACA,OACA,KACA,OACA,OACA,MACA,OACA,YACA,WACA,YACA,WACA,OACA,SACA,MACA,OACA,QACA,OACA,UACA,OACA,MACA,KACA,MACA,OACA,kBACA,MACA,OACA,OACA,UACA,UACA,QACA,QACA,MACA,OACA,MACA,OACA,YACA,aACA,MACA,MACA,SACA,OACA,cACA,SACA,MACA,KACA,MACA,QACA,KACA,MACA,OACA,cACA,cACA,eACA,OACA,UACA,UACA,YACA,MACA,MACA,MACA,MACA,aACA,KACA,UACA,UACA,OACA,SACA,SACA,mBACA,0BACA,UACA,MACA,kBACA,qBACA,MACA,MACA,OACA,WACA,OACA,SACA,OACA,KACA,MACA,eACA,QACA,MACA,OACA,MACA,MACA,OACA,OACA,OACA,MACA,MACA,UACA,SACA,QACA,SACA,OACA,SACA,UACA,MACA,UACA,QACA,SACA,MACA,QACA,MACA,OACA,YACA,WACA,QACA,OACA,QACA,MACA,WACA,MACA,QACA,OACA,aACA,OACA,MACA,QACA,MACA,SACA,UACA,MACA,QACA,MACA,YACA,SACA,MACA,SACA,SACA,WACA,cACA,SACA,OACA,UACA,QACA,MACA,SAOEC,GAAc,2IACdC,GAAc,2CAGlB,SAASC,GAASvR,EAAOmK,GACnBqH,IAAAA,EAAMC,EAAWC,EAAYpP,EAAKqP,EAAS/Q,EAAMZ,EAAMY,IAEvDZ,OAA8B,KAA9BA,EAAMvD,IAAI/D,WAAWkI,QAEzB4Q,EAAOxR,EAAMvD,IAAIvF,MAAM0J,IAEdjJ,QAAQ,KAAO,MAExB8Z,EAAYD,EAAKjZ,MAAM+Y,OAGjBF,GAAYzZ,QAAQ8Z,EAAU,GAAG7Y,eAAiB,KAGtD+Y,EAAUtP,EADVC,EAAMmP,EAAU,GAAGva,MAAM,GAAI,MAExB8I,EAAMW,OAAOkC,aAAaP,KAE1B6H,IACHnK,EAAME,KAAK,CACTtG,KAAM,YACN0C,KAAMqV,EACNvR,MAAOJ,EAAMI,QA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","file":"src.83c48796.js","sourceRoot":"../src","sourcesContent":["var textarea;\n\nfunction decodeEntity(name) {\n  textarea = textarea || document.createElement('textarea');\n  textarea.innerHTML = '&' + name;\n  return textarea.value;\n}\n\n/**\n * Utility functions\n */\n\nfunction typeOf(obj) {\n  return Object.prototype.toString.call(obj);\n}\n\nfunction isString(obj) {\n  return typeOf(obj) === '[object String]';\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty;\n\nfunction has(object, key) {\n  return object\n    ? hasOwn.call(object, key)\n    : false;\n}\n\n// Extend objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = [].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////////////////////////////////////////////////////////////////////////////////\n\nvar UNESCAPE_MD_RE = /\\\\([\\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) { return str; }\n  return str.replace(UNESCAPE_MD_RE, '$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\nvar NAMED_ENTITY_RE   = /&([a-z#][a-z0-9]{1,31});/gi;\nvar DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;\n\nfunction replaceEntityPattern(match, name) {\n  var code = 0;\n  var decoded = decodeEntity(name);\n\n  if (name !== decoded) {\n    return decoded;\n  } else if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    code = name[1].toLowerCase() === 'x' ?\n      parseInt(name.slice(2), 16)\n    :\n      parseInt(name.slice(1), 10);\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code);\n    }\n  }\n  return match;\n}\n\nfunction replaceEntities(str) {\n  if (str.indexOf('&') < 0) { return str; }\n\n  return str.replace(NAMED_ENTITY_RE, replaceEntityPattern);\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\nvar utils = /*#__PURE__*/Object.freeze({\n  isString: isString,\n  has: has,\n  assign: assign,\n  unescapeMd: unescapeMd,\n  isValidEntityCode: isValidEntityCode,\n  fromCodePoint: fromCodePoint,\n  replaceEntities: replaceEntities,\n  escapeHtml: escapeHtml\n});\n\n/**\n * Renderer rules cache\n */\n\nvar rules = {};\n\n/**\n * Blockquotes\n */\n\nrules.blockquote_open = function(/* tokens, idx, options, env */) {\n  return '<blockquote>\\n';\n};\n\nrules.blockquote_close = function(tokens, idx /*, options, env */) {\n  return '</blockquote>' + getBreak(tokens, idx);\n};\n\n/**\n * Code\n */\n\nrules.code = function(tokens, idx /*, options, env */) {\n  if (tokens[idx].block) {\n    return '<pre><code>' + escapeHtml(tokens[idx].content) + '</code></pre>' + getBreak(tokens, idx);\n  }\n  return '<code>' + escapeHtml(tokens[idx].content) + '</code>';\n};\n\n/**\n * Fenced code blocks\n */\n\nrules.fence = function(tokens, idx, options, env, instance) {\n  var token = tokens[idx];\n  var langClass = '';\n  var langPrefix = options.langPrefix;\n  var langName = '', fences, fenceName;\n  var highlighted;\n\n  if (token.params) {\n\n    //\n    // ```foo bar\n    //\n    // Try custom renderer \"foo\" first. That will simplify overwrite\n    // for diagrams, latex, and any other fenced block with custom look\n    //\n\n    fences = token.params.split(/\\s+/g);\n    fenceName = fences.join(' ');\n\n    if (has(instance.rules.fence_custom, fences[0])) {\n      return instance.rules.fence_custom[fences[0]](tokens, idx, options, env, instance);\n    }\n\n    langName = escapeHtml(replaceEntities(unescapeMd(fenceName)));\n    langClass = ' class=\"' + langPrefix + langName + '\"';\n  }\n\n  if (options.highlight) {\n    highlighted = options.highlight.apply(options.highlight, [ token.content ].concat(fences))\n      || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n\n  return '<pre><code' + langClass + '>'\n        + highlighted\n        + '</code></pre>'\n        + getBreak(tokens, idx);\n};\n\nrules.fence_custom = {};\n\n/**\n * Headings\n */\n\nrules.heading_open = function(tokens, idx /*, options, env */) {\n  return '<h' + tokens[idx].hLevel + '>';\n};\nrules.heading_close = function(tokens, idx /*, options, env */) {\n  return '</h' + tokens[idx].hLevel + '>\\n';\n};\n\n/**\n * Horizontal rules\n */\n\nrules.hr = function(tokens, idx, options /*, env */) {\n  return (options.xhtmlOut ? '<hr />' : '<hr>') + getBreak(tokens, idx);\n};\n\n/**\n * Bullets\n */\n\nrules.bullet_list_open = function(/* tokens, idx, options, env */) {\n  return '<ul>\\n';\n};\nrules.bullet_list_close = function(tokens, idx /*, options, env */) {\n  return '</ul>' + getBreak(tokens, idx);\n};\n\n/**\n * List items\n */\n\nrules.list_item_open = function(/* tokens, idx, options, env */) {\n  return '<li>';\n};\nrules.list_item_close = function(/* tokens, idx, options, env */) {\n  return '</li>\\n';\n};\n\n/**\n * Ordered list items\n */\n\nrules.ordered_list_open = function(tokens, idx /*, options, env */) {\n  var token = tokens[idx];\n  var order = token.order > 1 ? ' start=\"' + token.order + '\"' : '';\n  return '<ol' + order + '>\\n';\n};\nrules.ordered_list_close = function(tokens, idx /*, options, env */) {\n  return '</ol>' + getBreak(tokens, idx);\n};\n\n/**\n * Paragraphs\n */\n\nrules.paragraph_open = function(tokens, idx /*, options, env */) {\n  return tokens[idx].tight ? '' : '<p>';\n};\nrules.paragraph_close = function(tokens, idx /*, options, env */) {\n  var addBreak = !(tokens[idx].tight && idx && tokens[idx - 1].type === 'inline' && !tokens[idx - 1].content);\n  return (tokens[idx].tight ? '' : '</p>') + (addBreak ? getBreak(tokens, idx) : '');\n};\n\n/**\n * Links\n */\n\nrules.link_open = function(tokens, idx, options /* env */) {\n  var title = tokens[idx].title ? (' title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\"') : '';\n  var target = options.linkTarget ? (' target=\"' + options.linkTarget + '\"') : '';\n  return '<a href=\"' + escapeHtml(tokens[idx].href) + '\"' + title + target + '>';\n};\nrules.link_close = function(/* tokens, idx, options, env */) {\n  return '</a>';\n};\n\n/**\n * Images\n */\n\nrules.image = function(tokens, idx, options /*, env */) {\n  var src = ' src=\"' + escapeHtml(tokens[idx].src) + '\"';\n  var title = tokens[idx].title ? (' title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\"') : '';\n  var alt = ' alt=\"' + (tokens[idx].alt ? escapeHtml(replaceEntities(unescapeMd(tokens[idx].alt))) : '') + '\"';\n  var suffix = options.xhtmlOut ? ' /' : '';\n  return '<img' + src + alt + title + suffix + '>';\n};\n\n/**\n * Tables\n */\n\nrules.table_open = function(/* tokens, idx, options, env */) {\n  return '<table>\\n';\n};\nrules.table_close = function(/* tokens, idx, options, env */) {\n  return '</table>\\n';\n};\nrules.thead_open = function(/* tokens, idx, options, env */) {\n  return '<thead>\\n';\n};\nrules.thead_close = function(/* tokens, idx, options, env */) {\n  return '</thead>\\n';\n};\nrules.tbody_open = function(/* tokens, idx, options, env */) {\n  return '<tbody>\\n';\n};\nrules.tbody_close = function(/* tokens, idx, options, env */) {\n  return '</tbody>\\n';\n};\nrules.tr_open = function(/* tokens, idx, options, env */) {\n  return '<tr>';\n};\nrules.tr_close = function(/* tokens, idx, options, env */) {\n  return '</tr>\\n';\n};\nrules.th_open = function(tokens, idx /*, options, env */) {\n  var token = tokens[idx];\n  return '<th'\n    + (token.align ? ' style=\"text-align:' + token.align + '\"' : '')\n    + '>';\n};\nrules.th_close = function(/* tokens, idx, options, env */) {\n  return '</th>';\n};\nrules.td_open = function(tokens, idx /*, options, env */) {\n  var token = tokens[idx];\n  return '<td'\n    + (token.align ? ' style=\"text-align:' + token.align + '\"' : '')\n    + '>';\n};\nrules.td_close = function(/* tokens, idx, options, env */) {\n  return '</td>';\n};\n\n/**\n * Bold\n */\n\nrules.strong_open = function(/* tokens, idx, options, env */) {\n  return '<strong>';\n};\nrules.strong_close = function(/* tokens, idx, options, env */) {\n  return '</strong>';\n};\n\n/**\n * Italicize\n */\n\nrules.em_open = function(/* tokens, idx, options, env */) {\n  return '<em>';\n};\nrules.em_close = function(/* tokens, idx, options, env */) {\n  return '</em>';\n};\n\n/**\n * Strikethrough\n */\n\nrules.del_open = function(/* tokens, idx, options, env */) {\n  return '<del>';\n};\nrules.del_close = function(/* tokens, idx, options, env */) {\n  return '</del>';\n};\n\n/**\n * Insert\n */\n\nrules.ins_open = function(/* tokens, idx, options, env */) {\n  return '<ins>';\n};\nrules.ins_close = function(/* tokens, idx, options, env */) {\n  return '</ins>';\n};\n\n/**\n * Highlight\n */\n\nrules.mark_open = function(/* tokens, idx, options, env */) {\n  return '<mark>';\n};\nrules.mark_close = function(/* tokens, idx, options, env */) {\n  return '</mark>';\n};\n\n/**\n * Super- and sub-script\n */\n\nrules.sub = function(tokens, idx /*, options, env */) {\n  return '<sub>' + escapeHtml(tokens[idx].content) + '</sub>';\n};\nrules.sup = function(tokens, idx /*, options, env */) {\n  return '<sup>' + escapeHtml(tokens[idx].content) + '</sup>';\n};\n\n/**\n * Breaks\n */\n\nrules.hardbreak = function(tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\nrules.softbreak = function(tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n';\n};\n\n/**\n * Text\n */\n\nrules.text = function(tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\n\n/**\n * Content\n */\n\nrules.htmlblock = function(tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\nrules.htmltag = function(tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n/**\n * Abbreviations, initialism\n */\n\nrules.abbr_open = function(tokens, idx /*, options, env */) {\n  return '<abbr title=\"' + escapeHtml(replaceEntities(tokens[idx].title)) + '\">';\n};\nrules.abbr_close = function(/* tokens, idx, options, env */) {\n  return '</abbr>';\n};\n\n/**\n * Footnotes\n */\n\nrules.footnote_ref = function(tokens, idx) {\n  var n = Number(tokens[idx].id + 1).toString();\n  var id = 'fnref' + n;\n  if (tokens[idx].subId > 0) {\n    id += ':' + tokens[idx].subId;\n  }\n  return '<sup class=\"footnote-ref\"><a href=\"#fn' + n + '\" id=\"' + id + '\">[' + n + ']</a></sup>';\n};\nrules.footnote_block_open = function(tokens, idx, options) {\n  var hr = options.xhtmlOut\n    ? '<hr class=\"footnotes-sep\" />\\n'\n    : '<hr class=\"footnotes-sep\">\\n';\n  return hr + '<section class=\"footnotes\">\\n<ol class=\"footnotes-list\">\\n';\n};\nrules.footnote_block_close = function() {\n  return '</ol>\\n</section>\\n';\n};\nrules.footnote_open = function(tokens, idx) {\n  var id = Number(tokens[idx].id + 1).toString();\n  return '<li id=\"fn' + id + '\"  class=\"footnote-item\">';\n};\nrules.footnote_close = function() {\n  return '</li>\\n';\n};\nrules.footnote_anchor = function(tokens, idx) {\n  var n = Number(tokens[idx].id + 1).toString();\n  var id = 'fnref' + n;\n  if (tokens[idx].subId > 0) {\n    id += ':' + tokens[idx].subId;\n  }\n  return ' <a href=\"#' + id + '\" class=\"footnote-backref\">↩</a>';\n};\n\n/**\n * Definition lists\n */\n\nrules.dl_open = function() {\n  return '<dl>\\n';\n};\nrules.dt_open = function() {\n  return '<dt>';\n};\nrules.dd_open = function() {\n  return '<dd>';\n};\nrules.dl_close = function() {\n  return '</dl>\\n';\n};\nrules.dt_close = function() {\n  return '</dt>\\n';\n};\nrules.dd_close = function() {\n  return '</dd>\\n';\n};\n\n/**\n * Helper functions\n */\n\nfunction nextToken(tokens, idx) {\n  if (++idx >= tokens.length - 2) {\n    return idx;\n  }\n  if ((tokens[idx].type === 'paragraph_open' && tokens[idx].tight) &&\n      (tokens[idx + 1].type === 'inline' && tokens[idx + 1].content.length === 0) &&\n      (tokens[idx + 2].type === 'paragraph_close' && tokens[idx + 2].tight)) {\n    return nextToken(tokens, idx + 2);\n  }\n  return idx;\n}\n\n/**\n * Check to see if `\\n` is needed before the next token.\n *\n * @param  {Array} `tokens`\n * @param  {Number} `idx`\n * @return {String} Empty string or newline\n * @api private\n */\n\nvar getBreak = rules.getBreak = function getBreak(tokens, idx) {\n  idx = nextToken(tokens, idx);\n  if (idx < tokens.length && tokens[idx].type === 'list_item_close') {\n    return '';\n  }\n  return '\\n';\n};\n\n/**\n * Renderer class. Renders HTML and exposes `rules` to allow\n * local modifications.\n */\n\nfunction Renderer() {\n  this.rules = assign({}, rules);\n\n  // exported helper, for custom rules only\n  this.getBreak = rules.getBreak;\n}\n\n/**\n * Render a string of inline HTML with the given `tokens` and\n * `options`.\n *\n * @param  {Array} `tokens`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @return {String}\n * @api public\n */\n\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  var _rules = this.rules;\n  var len = tokens.length, i = 0;\n  var result = '';\n\n  while (len--) {\n    result += _rules[tokens[i].type](tokens, i++, options, env, this);\n  }\n\n  return result;\n};\n\n/**\n * Render a string of HTML with the given `tokens` and\n * `options`.\n *\n * @param  {Array} `tokens`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @return {String}\n * @api public\n */\n\nRenderer.prototype.render = function (tokens, options, env) {\n  var _rules = this.rules;\n  var len = tokens.length, i = -1;\n  var result = '';\n\n  while (++i < len) {\n    if (tokens[i].type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else {\n      result += _rules[tokens[i].type](tokens, i, options, env, this);\n    }\n  }\n  return result;\n};\n\n/**\n * Ruler is a helper class for building responsibility chains from\n * parse rules. It allows:\n *\n *   - easy stack rules chains\n *   - getting main chain and named chains content (as arrays of functions)\n *\n * Helper methods, should not be used directly.\n * @api private\n */\n\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // { name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ] }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - digital anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n/**\n * Find the index of a rule by `name`.\n *\n * @param  {String} `name`\n * @return {Number} Index of the given `name`\n * @api private\n */\n\nRuler.prototype.__find__ = function (name) {\n  var len = this.__rules__.length;\n  var i = -1;\n\n  while (len--) {\n    if (this.__rules__[++i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n/**\n * Build the rules lookup cache\n *\n * @api private\n */\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) {\n      return;\n    }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) {\n        return;\n      }\n\n      if (chain && rule.alt.indexOf(chain) < 0) {\n        return;\n      }\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n/**\n * Ruler public methods\n * ------------------------------------------------\n */\n\n/**\n * Replace rule function\n *\n * @param  {String} `name` Rule name\n * @param  {Function `fn`\n * @param  {Object} `options`\n * @api private\n */\n\nRuler.prototype.at = function (name, fn, options) {\n  var idx = this.__find__(name);\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + name);\n  }\n\n  this.__rules__[idx].fn = fn;\n  this.__rules__[idx].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n\n/**\n * Add a rule to the chain before given the `ruleName`.\n *\n * @param  {String}   `beforeName`\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @api private\n */\n\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var idx = this.__find__(beforeName);\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + beforeName);\n  }\n\n  this.__rules__.splice(idx, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Add a rule to the chain after the given `ruleName`.\n *\n * @param  {String}   `afterName`\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @api private\n */\n\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var idx = this.__find__(afterName);\n  var opt = options || {};\n\n  if (idx === -1) {\n    throw new Error('Parser rule not found: ' + afterName);\n  }\n\n  this.__rules__.splice(idx + 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 * Add a rule to the end of chain.\n *\n * @param  {String}   `ruleName`\n * @param  {Function} `fn`\n * @param  {Object}   `options`\n * @return {String}\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 * Enable a rule or list of rules.\n *\n * @param  {String|Array} `list` Name or array of rule names to enable\n * @param  {Boolean} `strict` If `true`, all non listed rules will be disabled.\n * @api private\n */\n\nRuler.prototype.enable = function (list, strict) {\n  list = !Array.isArray(list)\n    ? [ list ]\n    : list;\n\n  // In strict mode disable all existing rules first\n  if (strict) {\n    this.__rules__.forEach(function (rule) {\n      rule.enabled = false;\n    });\n  }\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n    if (idx < 0) {\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n  }, this);\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Disable a rule or list of rules.\n *\n * @param  {String|Array} `list` Name or array of rule names to disable\n * @api private\n */\n\nRuler.prototype.disable = function (list) {\n  list = !Array.isArray(list)\n    ? [ list ]\n    : list;\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n    if (idx < 0) {\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n  }, this);\n\n  this.__cache__ = null;\n};\n\n/**\n * Get a rules list as an array of functions.\n *\n * @param  {String} `chainName`\n * @return {Object}\n * @api private\n */\n\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n  return this.__cache__[chainName] || [];\n};\n\nfunction block(state) {\n\n  if (state.inlineMode) {\n    state.tokens.push({\n      type: 'inline',\n      content: state.src.replace(/\\n/g, ' ').trim(),\n      level: 0,\n      lines: [ 0, 1 ],\n      children: []\n    });\n\n  } else {\n    state.block.parse(state.src, state.options, state.env, state.tokens);\n  }\n}\n\n// Inline parser state\n\nfunction StateInline(src, parserInline, options, env, outTokens) {\n  this.src = src;\n  this.env = env;\n  this.options = options;\n  this.parser = parserInline;\n  this.tokens = outTokens;\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0;\n\n  this.cache = [];        // Stores { start: end } pairs. Useful for backtrack\n                          // optimization of pairs parse (emphasis, strikes).\n\n  // Link parser state vars\n\n  this.isInLabel = false; // Set true when seek link label - we should disable\n                          // \"paired\" rules (emphasis, strikes) to not skip\n                          // tailing `]`\n\n  this.linkLevel = 0;     // Increment for each nesting link. Used to prevent\n                          // nesting in definitions\n\n  this.linkContent = '';  // Temporary storage for link url\n\n  this.labelUnmatchedScopes = 0; // Track unpaired `[` for link labels\n                                 // (backtrack optimization)\n}\n\n// Flush pending text\n//\nStateInline.prototype.pushPending = function () {\n  this.tokens.push({\n    type: 'text',\n    content: this.pending,\n    level: this.pendingLevel\n  });\n  this.pending = '';\n};\n\n// Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\nStateInline.prototype.push = function (token) {\n  if (this.pending) {\n    this.pushPending();\n  }\n\n  this.tokens.push(token);\n  this.pendingLevel = this.level;\n};\n\n// Store value to cache.\n// !!! Implementation has parser-specific optimizations\n// !!! keys MUST be integer, >= 0; values MUST be integer, > 0\n//\nStateInline.prototype.cacheSet = function (key, val) {\n  for (var i = this.cache.length; i <= key; i++) {\n    this.cache.push(0);\n  }\n\n  this.cache[key] = val;\n};\n\n// Get cache value\n//\nStateInline.prototype.cacheGet = function (key) {\n  return key < this.cache.length ? this.cache[key] : 0;\n};\n\n/**\n * Parse link labels\n *\n * This function assumes that first character (`[`) already matches;\n * returns the end of the label.\n *\n * @param  {Object} state\n * @param  {Number} start\n * @api private\n */\n\nfunction parseLinkLabel(state, start) {\n  var level, found, marker,\n      labelEnd = -1,\n      max = state.posMax,\n      oldPos = state.pos,\n      oldFlag = state.isInLabel;\n\n  if (state.isInLabel) { return -1; }\n\n  if (state.labelUnmatchedScopes) {\n    state.labelUnmatchedScopes--;\n    return -1;\n  }\n\n  state.pos = start + 1;\n  state.isInLabel = true;\n  level = 1;\n\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos);\n    if (marker === 0x5B /* [ */) {\n      level++;\n    } else if (marker === 0x5D /* ] */) {\n      level--;\n      if (level === 0) {\n        found = true;\n        break;\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (found) {\n    labelEnd = state.pos;\n    state.labelUnmatchedScopes = 0;\n  } else {\n    state.labelUnmatchedScopes = level - 1;\n  }\n\n  // restore old state\n  state.pos = oldPos;\n  state.isInLabel = oldFlag;\n\n  return labelEnd;\n}\n\n// Parse abbreviation definitions, i.e. `*[abbr]: description`\n\n\nfunction parseAbbr(str, parserInline, options, env) {\n  var state, labelEnd, pos, max, label, title;\n\n  if (str.charCodeAt(0) !== 0x2A/* * */) { return -1; }\n  if (str.charCodeAt(1) !== 0x5B/* [ */) { return -1; }\n\n  if (str.indexOf(']:') === -1) { return -1; }\n\n  state = new StateInline(str, parserInline, options, env, []);\n  labelEnd = parseLinkLabel(state, 1);\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return -1; }\n\n  max = state.posMax;\n\n  // abbr title is always one line, so looking for ending \"\\n\" here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x0A) { break; }\n  }\n\n  label = str.slice(2, labelEnd);\n  title = str.slice(labelEnd + 2, pos).trim();\n  if (title.length === 0) { return -1; }\n  if (!env.abbreviations) { env.abbreviations = {}; }\n  // prepend ':' to avoid conflict with Object.prototype members\n  if (typeof env.abbreviations[':' + label] === 'undefined') {\n    env.abbreviations[':' + label] = title;\n  }\n\n  return pos;\n}\n\nfunction abbr(state) {\n  var tokens = state.tokens, i, l, content, pos;\n\n  if (state.inlineMode) {\n    return;\n  }\n\n  // Parse inlines\n  for (i = 1, l = tokens.length - 1; i < l; i++) {\n    if (tokens[i - 1].type === 'paragraph_open' &&\n        tokens[i].type === 'inline' &&\n        tokens[i + 1].type === 'paragraph_close') {\n\n      content = tokens[i].content;\n      while (content.length) {\n        pos = parseAbbr(content, state.inline, state.options, state.env);\n        if (pos < 0) { break; }\n        content = content.slice(pos).trim();\n      }\n\n      tokens[i].content = content;\n      if (!content.length) {\n        tokens[i - 1].tight = true;\n        tokens[i + 1].tight = true;\n      }\n    }\n  }\n}\n\nfunction normalizeLink(url) {\n  var normalized = replaceEntities(url);\n  // We shouldn't care about the result of malformed URIs,\n  // and should not throw an exception.\n  try {\n    normalized = decodeURI(normalized);\n  } catch (err) {}\n  return encodeURI(normalized);\n}\n\n/**\n * Parse link destination\n *\n *   - on success it returns a string and updates state.pos;\n *   - on failure it returns null\n *\n * @param  {Object} state\n * @param  {Number} pos\n * @api private\n */\n\nfunction parseLinkDestination(state, pos) {\n  var code, level, link,\n      start = pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(pos) === 0x3C /* < */) {\n    pos++;\n    while (pos < max) {\n      code = state.src.charCodeAt(pos);\n      if (code === 0x0A /* \\n */) { return false; }\n      if (code === 0x3E /* > */) {\n        link = normalizeLink(unescapeMd(state.src.slice(start + 1, pos)));\n        if (!state.parser.validateLink(link)) { return false; }\n        state.pos = pos + 1;\n        state.linkContent = link;\n        return true;\n      }\n      if (code === 0x5C /* \\ */ && pos + 1 < max) {\n        pos += 2;\n        continue;\n      }\n\n      pos++;\n    }\n\n    // no closing '>'\n    return false;\n  }\n\n  // this should be ... } else { ... branch\n\n  level = 0;\n  while (pos < max) {\n    code = state.src.charCodeAt(pos);\n\n    if (code === 0x20) { break; }\n\n    // ascii control chars\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      if (level > 1) { break; }\n    }\n\n    if (code === 0x29 /* ) */) {\n      level--;\n      if (level < 0) { break; }\n    }\n\n    pos++;\n  }\n\n  if (start === pos) { return false; }\n\n  link = unescapeMd(state.src.slice(start, pos));\n  if (!state.parser.validateLink(link)) { return false; }\n\n  state.linkContent = link;\n  state.pos = pos;\n  return true;\n}\n\n/**\n * Parse link title\n *\n *   - on success it returns a string and updates state.pos;\n *   - on failure it returns null\n *\n * @param  {Object} state\n * @param  {Number} pos\n * @api private\n */\n\nfunction parseLinkTitle(state, pos) {\n  var code,\n      start = pos,\n      max = state.posMax,\n      marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return false; }\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 = state.src.charCodeAt(pos);\n    if (code === marker) {\n      state.pos = pos + 1;\n      state.linkContent = unescapeMd(state.src.slice(start + 1, pos));\n      return true;\n    }\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    pos++;\n  }\n\n  return false;\n}\n\nfunction normalizeReference(str) {\n  // use .toUpperCase() instead of .toLowerCase()\n  // here to avoid a conflict with Object.prototype\n  // members (most notably, `__proto__`)\n  return str.trim().replace(/\\s+/g, ' ').toUpperCase();\n}\n\nfunction parseReference(str, parser, options, env) {\n  var state, labelEnd, pos, max, code, start, href, title, label;\n\n  if (str.charCodeAt(0) !== 0x5B/* [ */) { return -1; }\n\n  if (str.indexOf(']:') === -1) { return -1; }\n\n  state = new StateInline(str, parser, options, env, []);\n  labelEnd = parseLinkLabel(state, 0);\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return -1; }\n\n  max = state.posMax;\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    code = state.src.charCodeAt(pos);\n    if (code !== 0x20 && code !== 0x0A) { break; }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  if (!parseLinkDestination(state, pos)) { return -1; }\n  href = state.linkContent;\n  pos = state.pos;\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  start = pos;\n  for (pos = pos + 1; pos < max; pos++) {\n    code = state.src.charCodeAt(pos);\n    if (code !== 0x20 && code !== 0x0A) { break; }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  if (pos < max && start !== pos && parseLinkTitle(state, pos)) {\n    title = state.linkContent;\n    pos = state.pos;\n  } else {\n    title = '';\n    pos = start;\n  }\n\n  // ensure that the end of the line is empty\n  while (pos < max && state.src.charCodeAt(pos) === 0x20/* space */) { pos++; }\n  if (pos < max && state.src.charCodeAt(pos) !== 0x0A) { return -1; }\n\n  label = normalizeReference(str.slice(1, labelEnd));\n  if (typeof env.references[label] === 'undefined') {\n    env.references[label] = { title: title, href: href };\n  }\n\n  return pos;\n}\n\n\nfunction references(state) {\n  var tokens = state.tokens, i, l, content, pos;\n\n  state.env.references = state.env.references || {};\n\n  if (state.inlineMode) {\n    return;\n  }\n\n  // Scan definitions in paragraph inlines\n  for (i = 1, l = tokens.length - 1; i < l; i++) {\n    if (tokens[i].type === 'inline' &&\n        tokens[i - 1].type === 'paragraph_open' &&\n        tokens[i + 1].type === 'paragraph_close') {\n\n      content = tokens[i].content;\n      while (content.length) {\n        pos = parseReference(content, state.inline, state.options, state.env);\n        if (pos < 0) { break; }\n        content = content.slice(pos).trim();\n      }\n\n      tokens[i].content = content;\n      if (!content.length) {\n        tokens[i - 1].tight = true;\n        tokens[i + 1].tight = true;\n      }\n    }\n  }\n}\n\nfunction 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.inline.parse(tok.content, state.options, state.env, tok.children);\n    }\n  }\n}\n\nfunction footnote_block(state) {\n  var i, l, j, t, lastParagraph, list, tokens, current, currentLabel,\n      level = 0,\n      insideRef = false,\n      refTokens = {};\n\n  if (!state.env.footnotes) { return; }\n\n  state.tokens = state.tokens.filter(function(tok) {\n    if (tok.type === 'footnote_reference_open') {\n      insideRef = true;\n      current = [];\n      currentLabel = tok.label;\n      return false;\n    }\n    if (tok.type === 'footnote_reference_close') {\n      insideRef = false;\n      // prepend ':' to avoid conflict with Object.prototype members\n      refTokens[':' + currentLabel] = current;\n      return false;\n    }\n    if (insideRef) { current.push(tok); }\n    return !insideRef;\n  });\n\n  if (!state.env.footnotes.list) { return; }\n  list = state.env.footnotes.list;\n\n  state.tokens.push({\n    type: 'footnote_block_open',\n    level: level++\n  });\n  for (i = 0, l = list.length; i < l; i++) {\n    state.tokens.push({\n      type: 'footnote_open',\n      id: i,\n      level: level++\n    });\n\n    if (list[i].tokens) {\n      tokens = [];\n      tokens.push({\n        type: 'paragraph_open',\n        tight: false,\n        level: level++\n      });\n      tokens.push({\n        type: 'inline',\n        content: '',\n        level: level,\n        children: list[i].tokens\n      });\n      tokens.push({\n        type: 'paragraph_close',\n        tight: false,\n        level: --level\n      });\n    } else if (list[i].label) {\n      tokens = refTokens[':' + list[i].label];\n    }\n\n    state.tokens = state.tokens.concat(tokens);\n    if (state.tokens[state.tokens.length - 1].type === 'paragraph_close') {\n      lastParagraph = state.tokens.pop();\n    } else {\n      lastParagraph = null;\n    }\n\n    t = list[i].count > 0 ? list[i].count : 1;\n    for (j = 0; j < t; j++) {\n      state.tokens.push({\n        type: 'footnote_anchor',\n        id: i,\n        subId: j,\n        level: level\n      });\n    }\n\n    if (lastParagraph) {\n      state.tokens.push(lastParagraph);\n    }\n\n    state.tokens.push({\n      type: 'footnote_close',\n      level: --level\n    });\n  }\n  state.tokens.push({\n    type: 'footnote_block_close',\n    level: --level\n  });\n}\n\n// Enclose abbreviations in <abbr> tags\n//\n\nvar PUNCT_CHARS = ' \\n()[]\\'\".,!?-';\n\n\n// from Google closure library\n// http://closure-library.googlecode.com/git-history/docs/local_closure_goog_string_string.js.source.html#line1021\nfunction regEscape(s) {\n  return s.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g, '\\\\$1');\n}\n\n\nfunction abbr2(state) {\n  var i, j, l, tokens, token, text, nodes, pos, level, reg, m, regText,\n      blockTokens = state.tokens;\n\n  if (!state.env.abbreviations) { return; }\n  if (!state.env.abbrRegExp) {\n    regText = '(^|[' + PUNCT_CHARS.split('').map(regEscape).join('') + '])'\n            + '(' + Object.keys(state.env.abbreviations).map(function (x) {\n                      return x.substr(1);\n                    }).sort(function (a, b) {\n                      return b.length - a.length;\n                    }).map(regEscape).join('|') + ')'\n            + '($|[' + PUNCT_CHARS.split('').map(regEscape).join('') + '])';\n    state.env.abbrRegExp = new RegExp(regText, 'g');\n  }\n  reg = state.env.abbrRegExp;\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline') { continue; }\n    tokens = blockTokens[j].children;\n\n    // We scan from the end, to keep position when new tags added.\n    for (i = tokens.length - 1; i >= 0; i--) {\n      token = tokens[i];\n      if (token.type !== 'text') { continue; }\n\n      pos = 0;\n      text = token.content;\n      reg.lastIndex = 0;\n      level = token.level;\n      nodes = [];\n\n      while ((m = reg.exec(text))) {\n        if (reg.lastIndex > pos) {\n          nodes.push({\n            type: 'text',\n            content: text.slice(pos, m.index + m[1].length),\n            level: level\n          });\n        }\n\n        nodes.push({\n          type: 'abbr_open',\n          title: state.env.abbreviations[':' + m[2]],\n          level: level++\n        });\n        nodes.push({\n          type: 'text',\n          content: m[2],\n          level: level\n        });\n        nodes.push({\n          type: 'abbr_close',\n          level: --level\n        });\n        pos = reg.lastIndex - m[3].length;\n      }\n\n      if (!nodes.length) { continue; }\n\n      if (pos < text.length) {\n        nodes.push({\n          type: 'text',\n          content: text.slice(pos),\n          level: level\n        });\n      }\n\n      // replace current node\n      blockTokens[j].children = tokens = [].concat(tokens.slice(0, i), nodes, tokens.slice(i + 1));\n    }\n  }\n}\n\n// Simple typographical replacements\n//\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - miltiplication 2 x 4 -> 2 × 4\n\nvar RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/;\n\nvar SCOPED_ABBR_RE = /\\((c|tm|r|p)\\)/ig;\nvar SCOPED_ABBR = {\n  'c': '©',\n  'r': '®',\n  'p': '§',\n  'tm': '™'\n};\n\nfunction replaceScopedAbbr(str) {\n  if (str.indexOf('(') < 0) { return str; }\n\n  return str.replace(SCOPED_ABBR_RE, function(match, name) {\n    return SCOPED_ABBR[name.toLowerCase()];\n  });\n}\n\n\nfunction replace(state) {\n  var i, token, text, inlineTokens, blkIdx;\n\n  if (!state.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    inlineTokens = state.tokens[blkIdx].children;\n\n    for (i = inlineTokens.length - 1; i >= 0; i--) {\n      token = inlineTokens[i];\n      if (token.type === 'text') {\n        text = token.content;\n\n        text = replaceScopedAbbr(text);\n\n        if (RARE_RE.test(text)) {\n          text = text\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$2')\n            // en-dash\n            .replace(/(^|\\s)--(\\s|$)/mg, '$1\\u2013$2')\n            .replace(/(^|[^-\\s])--([^-\\s]|$)/mg, '$1\\u2013$2');\n        }\n\n        token.content = text;\n      }\n    }\n  }\n}\n\n// Convert straight quotation marks to typographic ones\n//\n\nvar QUOTE_TEST_RE = /['\"]/;\nvar QUOTE_RE = /['\"]/g;\nvar PUNCT_RE = /[-\\s()\\[\\]]/;\nvar APOSTROPHE = '’';\n\n// This function returns true if the character at `pos`\n// could be inside a word.\nfunction isLetter(str, pos) {\n  if (pos < 0 || pos >= str.length) { return false; }\n  return !PUNCT_RE.test(str[pos]);\n}\n\n\nfunction replaceAt(str, index, ch) {\n  return str.substr(0, index) + ch + str.substr(index + 1);\n}\n\n\nfunction smartquotes(state) {\n  /*eslint max-depth:0*/\n  var i, token, text, t, pos, max, thisLevel, lastSpace, nextSpace, item,\n      canOpen, canClose, j, isSingle, blkIdx, tokens,\n      stack;\n\n  if (!state.options.typographer) { return; }\n\n  stack = [];\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline') { continue; }\n\n    tokens = state.tokens[blkIdx].children;\n    stack.length = 0;\n\n    for (i = 0; i < tokens.length; i++) {\n      token = tokens[i];\n\n      if (token.type !== 'text' || QUOTE_TEST_RE.test(token.text)) { continue; }\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      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        lastSpace = !isLetter(text, t.index - 1);\n        pos = t.index + 1;\n        isSingle = (t[0] === \"'\");\n        nextSpace = !isLetter(text, pos);\n\n        if (!nextSpace && !lastSpace) {\n          // middle of word\n          if (isSingle) {\n            token.content = replaceAt(token.content, t.index, APOSTROPHE);\n          }\n          continue;\n        }\n\n        canOpen = !nextSpace;\n        canClose = !lastSpace;\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              if (isSingle) {\n                tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[2]);\n                token.content = replaceAt(token.content, t.index, state.options.quotes[3]);\n              } else {\n                tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[0]);\n                token.content = replaceAt(token.content, t.index, state.options.quotes[1]);\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\n/**\n * Core parser `rules`\n */\n\nvar _rules = [\n  [ 'block',          block          ],\n  [ 'abbr',           abbr           ],\n  [ 'references',     references     ],\n  [ 'inline',         inline         ],\n  [ 'footnote_tail',  footnote_block  ],\n  [ 'abbr2',          abbr2          ],\n  [ 'replacements',   replace   ],\n  [ 'smartquotes',    smartquotes    ],\n];\n\n/**\n * Class for top level (`core`) parser rules\n *\n * @api private\n */\n\nfunction Core() {\n  this.options = {};\n  this.ruler = new Ruler();\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n\n/**\n * Process rules with the given `state`\n *\n * @param  {Object} `state`\n * @api private\n */\n\nCore.prototype.process = function (state) {\n  var i, l, rules;\n  rules = this.ruler.getRules('');\n  for (i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\n\n// Parser state class\n\nfunction StateBlock(src, parser, options, env, tokens) {\n  var ch, s, start, pos, len, indent, indent_found;\n\n  this.src = src;\n\n  // Shortcuts to simplify nested calls\n  this.parser = parser;\n\n  this.options = options;\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 = [];  // indent for each line\n\n  // block parser variables\n  this.blkIndent  = 0; // required block content indent\n                       // (for example, if we are in list)\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.parentType = 'root'; // if `list`, block parser stops on two newlines\n  this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)\n\n  this.level = 0;\n\n  // renderer\n  this.result = '';\n\n  // Create caches\n  // Generate markers.\n  s = this.src;\n  indent = 0;\n  indent_found = false;\n\n  for (start = pos = indent = 0, len = s.length; pos < len; pos++) {\n    ch = s.charCodeAt(pos);\n\n    if (!indent_found) {\n      if (ch === 0x20/* space */) {\n        indent++;\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\n      indent_found = false;\n      indent = 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\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\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  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== 0x20/* space */) { break; }\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, first, last, queue, shift,\n      line = begin;\n\n  if (begin >= end) {\n    return '';\n  }\n\n  // Opt: don't use push queue for single line;\n  if (line + 1 === end) {\n    first = this.bMarks[line] + Math.min(this.tShift[line], indent);\n    last = keepLastLF ? this.eMarks[line] + 1 : this.eMarks[line];\n    return this.src.slice(first, last);\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line < end; line++, i++) {\n    shift = this.tShift[line];\n    if (shift > indent) { shift = indent; }\n    if (shift < 0) { shift = 0; }\n\n    first = this.bMarks[line] + shift;\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    queue[i] = this.src.slice(first, last);\n  }\n\n  return queue.join('');\n};\n\n// Code block (4 spaces padded)\n\nfunction code(state, startLine, endLine/*, silent*/) {\n  var nextLine, last;\n\n  if (state.tShift[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    if (state.tShift[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n    break;\n  }\n\n  state.line = nextLine;\n  state.tokens.push({\n    type: 'code',\n    content: state.getLines(startLine, last, 4 + state.blkIndent, true),\n    block: true,\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  return true;\n}\n\n// fences (``` lang, ~~~ lang)\n\nfunction fences(state, startLine, endLine, silent) {\n  var marker, len, params, nextLine, mem,\n      haveEndMarker = false,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\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  params = state.src.slice(pos, max).trim();\n\n  if (params.indexOf('`') >= 0) { return false; }\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.tShift[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.tShift[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.tShift[startLine];\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n  state.tokens.push({\n    type: 'fence',\n    params: params,\n    content: state.getLines(startLine + 1, nextLine, len, true),\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  return true;\n}\n\n// Block quotes\n\nfunction blockquote(state, startLine, endLine, silent) {\n  var nextLine, lastLineEmpty, oldTShift, oldBMarks, oldIndent, oldParentType, lines,\n      terminatorRules,\n      i, l, terminate,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos > max) { return false; }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos++) !== 0x3E/* > */) { return false; }\n\n  if (state.level >= state.options.maxNesting) { 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  // skip one optional space after '>'\n  if (state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n  oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n\n  oldBMarks = [ state.bMarks[startLine] ];\n  state.bMarks[startLine] = pos;\n\n  // check if we have an empty blockquote\n  pos = pos < max ? state.skipSpaces(pos) : pos;\n  lastLineEmpty = pos >= max;\n\n  oldTShift = [ state.tShift[startLine] ];\n  state.tShift[startLine] = pos - state.bMarks[startLine];\n\n  terminatorRules = state.parser.ruler.getRules('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    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* > */) {\n      // This line is inside the blockquote.\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n\n      pos = pos < max ? state.skipSpaces(pos) : pos;\n      lastLineEmpty = pos >= max;\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    if (terminate) { break; }\n\n    oldBMarks.push(state.bMarks[nextLine]);\n    oldTShift.push(state.tShift[nextLine]);\n\n    // A negative number means that this is a paragraph continuation;\n    //\n    // Any negative number will do the job here, but it's better for it\n    // to be large enough to make any bugs obvious.\n    state.tShift[nextLine] = -1337;\n  }\n\n  oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n  state.tokens.push({\n    type: 'blockquote_open',\n    lines: lines = [ startLine, 0 ],\n    level: state.level++\n  });\n  state.parser.tokenize(state, startLine, nextLine);\n  state.tokens.push({\n    type: 'blockquote_close',\n    level: --state.level\n  });\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  }\n  state.blkIndent = oldIndent;\n\n  return true;\n}\n\n// Horizontal rule\n\nfunction hr(state, startLine, endLine, silent) {\n  var marker, cnt, ch,\n      pos = state.bMarks[startLine],\n      max = state.eMarks[startLine];\n\n  pos += state.tShift[startLine];\n\n  if (pos > max) { 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 one\n\n  cnt = 1;\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos++);\n    if (ch !== marker && ch !== 0x20/* space */) { 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  state.tokens.push({\n    type: 'hr',\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  return true;\n}\n\n// Lists\n\n// Search `[-+*][\\n ]`, returns next pos arter marker on success\n// or -1 on fail.\nfunction skipBulletListMarker(state, startLine) {\n  var marker, pos, max;\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  max = state.eMarks[startLine];\n\n  if (pos >= max) { return -1; }\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 && state.src.charCodeAt(pos) !== 0x20) {\n    // \" 1.test \" - is not a list item\n    return -1;\n  }\n\n  return pos;\n}\n\n// Search `\\d+[.)][\\n ]`, returns next pos arter marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker(state, startLine) {\n  var ch,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\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      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 && state.src.charCodeAt(pos) !== 0x20/* space */) {\n    // \" 1.test \" - is not a list item\n    return -1;\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].tight = true;\n      state.tokens[i].tight = true;\n      i += 2;\n    }\n  }\n}\n\n\nfunction list(state, startLine, endLine, silent) {\n  var nextLine,\n      indent,\n      oldTShift,\n      oldIndent,\n      oldTight,\n      oldParentType,\n      start,\n      posAfterMarker,\n      max,\n      indentAfterMarker,\n      markerValue,\n      markerCharCode,\n      isOrdered,\n      contentStart,\n      listTokIdx,\n      prevEmptyEnd,\n      listLines,\n      itemLines,\n      tight = true,\n      terminatorRules,\n      i, l, terminate;\n\n  // Detect list type and position after marker\n  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {\n    isOrdered = true;\n  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {\n    isOrdered = false;\n  } else {\n    return false;\n  }\n\n  if (state.level >= state.options.maxNesting) { return false; }\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    start = state.bMarks[startLine] + state.tShift[startLine];\n    markerValue = Number(state.src.substr(start, posAfterMarker - start - 1));\n\n    state.tokens.push({\n      type: 'ordered_list_open',\n      order: markerValue,\n      lines: listLines = [ startLine, 0 ],\n      level: state.level++\n    });\n\n  } else {\n    state.tokens.push({\n      type: 'bullet_list_open',\n      lines: listLines = [ startLine, 0 ],\n      level: state.level++\n    });\n  }\n\n  //\n  // Iterate list items\n  //\n\n  nextLine = startLine;\n  prevEmptyEnd = false;\n  terminatorRules = state.parser.ruler.getRules('list');\n\n  while (nextLine < endLine) {\n    contentStart = state.skipSpaces(posAfterMarker);\n    max = state.eMarks[nextLine];\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = contentStart - posAfterMarker;\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    // If indent is less than 1, assume that it's one, example:\n    //  \"-\\n  test\"\n    if (indentAfterMarker < 1) { indentAfterMarker = 1; }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    indent = (posAfterMarker - state.bMarks[nextLine]) + indentAfterMarker;\n\n    // Run subparser & write tokens\n    state.tokens.push({\n      type: 'list_item_open',\n      lines: itemLines = [ startLine, 0 ],\n      level: state.level++\n    });\n\n    oldIndent = state.blkIndent;\n    oldTight = state.tight;\n    oldTShift = state.tShift[startLine];\n    oldParentType = state.parentType;\n    state.tShift[startLine] = contentStart - state.bMarks[startLine];\n    state.blkIndent = indent;\n    state.tight = true;\n    state.parentType = 'list';\n\n    state.parser.tokenize(state, startLine, endLine, true);\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 = oldIndent;\n    state.tShift[startLine] = oldTShift;\n    state.tight = oldTight;\n    state.parentType = oldParentType;\n\n    state.tokens.push({\n      type: 'list_item_close',\n      level: --state.level\n    });\n\n    nextLine = startLine = state.line;\n    itemLines[1] = nextLine;\n    contentStart = state.bMarks[startLine];\n\n    if (nextLine >= endLine) { break; }\n\n    if (state.isEmpty(nextLine)) {\n      break;\n    }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.tShift[nextLine] < state.blkIndent) { 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  // Finilize list\n  state.tokens.push({\n    type: isOrdered ? 'ordered_list_close' : 'bullet_list_close',\n    level: --state.level\n  });\n  listLines[1] = nextLine;\n\n  state.line = nextLine;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n}\n\n// Process footnote reference list\n\nfunction footnote(state, startLine, endLine, silent) {\n  var oldBMark, oldTShift, oldParentType, pos, label,\n      start = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // line should be at least 5 chars - \"[^x]:\"\n  if (start + 4 > max) { return false; }\n\n  if (state.src.charCodeAt(start) !== 0x5B/* [ */) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x5E/* ^ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  for (pos = start + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x20) { return false; }\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */) {\n      break;\n    }\n  }\n\n  if (pos === start + 2) { return false; } // no empty footnote labels\n  if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 0x3A /* : */) { return false; }\n  if (silent) { return true; }\n  pos++;\n\n  if (!state.env.footnotes) { state.env.footnotes = {}; }\n  if (!state.env.footnotes.refs) { state.env.footnotes.refs = {}; }\n  label = state.src.slice(start + 2, pos - 2);\n  state.env.footnotes.refs[':' + label] = -1;\n\n  state.tokens.push({\n    type: 'footnote_reference_open',\n    label: label,\n    level: state.level++\n  });\n\n  oldBMark = state.bMarks[startLine];\n  oldTShift = state.tShift[startLine];\n  oldParentType = state.parentType;\n  state.tShift[startLine] = state.skipSpaces(pos) - pos;\n  state.bMarks[startLine] = pos;\n  state.blkIndent += 4;\n  state.parentType = 'footnote';\n\n  if (state.tShift[startLine] < state.blkIndent) {\n    state.tShift[startLine] += state.blkIndent;\n    state.bMarks[startLine] -= state.blkIndent;\n  }\n\n  state.parser.tokenize(state, startLine, endLine, true);\n\n  state.parentType = oldParentType;\n  state.blkIndent -= 4;\n  state.tShift[startLine] = oldTShift;\n  state.bMarks[startLine] = oldBMark;\n\n  state.tokens.push({\n    type: 'footnote_reference_close',\n    level: --state.level\n  });\n\n  return true;\n}\n\n// heading (#, ##, ...)\n\nfunction heading(state, startLine, endLine, silent) {\n  var ch, level, tmp,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  if (pos >= max) { 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 && ch !== 0x20/* space */)) { return false; }\n\n  if (silent) { return true; }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipCharsBack(max, 0x20, pos); // space\n  tmp = state.skipCharsBack(max, 0x23, pos); // #\n  if (tmp > pos && state.src.charCodeAt(tmp - 1) === 0x20/* space */) {\n    max = tmp;\n  }\n\n  state.line = startLine + 1;\n\n  state.tokens.push({ type: 'heading_open',\n    hLevel: level,\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n\n  // only if header is not empty\n  if (pos < max) {\n    state.tokens.push({\n      type: 'inline',\n      content: state.src.slice(pos, max).trim(),\n      level: state.level + 1,\n      lines: [ startLine, state.line ],\n      children: []\n    });\n  }\n  state.tokens.push({ type: 'heading_close', hLevel: level, level: state.level });\n\n  return true;\n}\n\n// lheading (---, ===)\n\nfunction lheading(state, startLine, endLine/*, silent*/) {\n  var marker, pos, max,\n      next = startLine + 1;\n\n  if (next >= endLine) { return false; }\n  if (state.tShift[next] < state.blkIndent) { return false; }\n\n  // Scan next line\n\n  if (state.tShift[next] - state.blkIndent > 3) { return false; }\n\n  pos = state.bMarks[next] + state.tShift[next];\n  max = state.eMarks[next];\n\n  if (pos >= max) { return false; }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x2D/* - */ && marker !== 0x3D/* = */) { return false; }\n\n  pos = state.skipChars(pos, marker);\n\n  pos = state.skipSpaces(pos);\n\n  if (pos < max) { return false; }\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n\n  state.line = next + 1;\n  state.tokens.push({\n    type: 'heading_open',\n    hLevel: marker === 0x3D/* = */ ? 1 : 2,\n    lines: [ startLine, state.line ],\n    level: state.level\n  });\n  state.tokens.push({\n    type: 'inline',\n    content: state.src.slice(pos, state.eMarks[startLine]).trim(),\n    level: state.level + 1,\n    lines: [ startLine, state.line - 1 ],\n    children: []\n  });\n  state.tokens.push({\n    type: 'heading_close',\n    hLevel: marker === 0x3D/* = */ ? 1 : 2,\n    level: state.level\n  });\n\n  return true;\n}\n\n// List of valid html blocks names, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#html-blocks\n\nvar html_blocks = {};\n\n[\n  'article',\n  'aside',\n  'button',\n  'blockquote',\n  'body',\n  'canvas',\n  'caption',\n  'col',\n  'colgroup',\n  'dd',\n  'div',\n  'dl',\n  'dt',\n  'embed',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'header',\n  'hgroup',\n  'hr',\n  'iframe',\n  'li',\n  'map',\n  'object',\n  'ol',\n  'output',\n  'p',\n  'pre',\n  'progress',\n  'script',\n  'section',\n  'style',\n  'table',\n  'tbody',\n  'td',\n  'textarea',\n  'tfoot',\n  'th',\n  'tr',\n  'thead',\n  'ul',\n  'video'\n].forEach(function (name) { html_blocks[name] = true; });\n\n// HTML block\n\n\nvar HTML_TAG_OPEN_RE = /^<([a-zA-Z]{1,15})[\\s\\/>]/;\nvar HTML_TAG_CLOSE_RE = /^<\\/([a-zA-Z]{1,15})[\\s>]/;\n\nfunction isLetter$1(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */);\n}\n\nfunction htmlblock(state, startLine, endLine, silent) {\n  var ch, match, nextLine,\n      pos = state.bMarks[startLine],\n      max = state.eMarks[startLine],\n      shift = state.tShift[startLine];\n\n  pos += shift;\n\n  if (!state.options.html) { return false; }\n\n  if (shift > 3 || pos + 2 >= max) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  ch = state.src.charCodeAt(pos + 1);\n\n  if (ch === 0x21/* ! */ || ch === 0x3F/* ? */) {\n    // Directive start / comment start / processing instruction start\n    if (silent) { return true; }\n\n  } else if (ch === 0x2F/* / */ || isLetter$1(ch)) {\n\n    // Probably start or end of tag\n    if (ch === 0x2F/* \\ */) {\n      // closing tag\n      match = state.src.slice(pos, max).match(HTML_TAG_CLOSE_RE);\n      if (!match) { return false; }\n    } else {\n      // opening tag\n      match = state.src.slice(pos, max).match(HTML_TAG_OPEN_RE);\n      if (!match) { return false; }\n    }\n    // Make sure tag name is valid\n    if (html_blocks[match[1].toLowerCase()] !== true) { return false; }\n    if (silent) { return true; }\n\n  } else {\n    return false;\n  }\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till empty line (block end).\n  nextLine = startLine + 1;\n  while (nextLine < state.lineMax && !state.isEmpty(nextLine)) {\n    nextLine++;\n  }\n\n  state.line = nextLine;\n  state.tokens.push({\n    type: 'htmlblock',\n    level: state.level,\n    lines: [ startLine, state.line ],\n    content: state.getLines(startLine, nextLine, 0, true)\n  });\n\n  return true;\n}\n\n// GFM table, non-standard\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 table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, nextLine, rows, cell,\n      aligns, t, tableLines, tbodyLines;\n\n  // should have at least three lines\n  if (startLine + 2 > endLine) { return false; }\n\n  nextLine = startLine + 1;\n\n  if (state.tShift[nextLine] < state.blkIndent) { return false; }\n\n  // first character of the second line should be '|' or '-'\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  lineText = getLine(state, startLine + 1);\n  if (!/^[-:| ]+$/.test(lineText)) { return false; }\n\n  rows = lineText.split('|');\n  if (rows <= 2) { return false; }\n  aligns = [];\n  for (i = 0; i < rows.length; i++) {\n    t = rows[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 === rows.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  rows = lineText.replace(/^\\||\\|$/g, '').split('|');\n  if (aligns.length !== rows.length) { return false; }\n  if (silent) { return true; }\n\n  state.tokens.push({\n    type: 'table_open',\n    lines: tableLines = [ startLine, 0 ],\n    level: state.level++\n  });\n  state.tokens.push({\n    type: 'thead_open',\n    lines: [ startLine, startLine + 1 ],\n    level: state.level++\n  });\n\n  state.tokens.push({\n    type: 'tr_open',\n    lines: [ startLine, startLine + 1 ],\n    level: state.level++\n  });\n  for (i = 0; i < rows.length; i++) {\n    state.tokens.push({\n      type: 'th_open',\n      align: aligns[i],\n      lines: [ startLine, startLine + 1 ],\n      level: state.level++\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: rows[i].trim(),\n      lines: [ startLine, startLine + 1 ],\n      level: state.level,\n      children: []\n    });\n    state.tokens.push({ type: 'th_close', level: --state.level });\n  }\n  state.tokens.push({ type: 'tr_close', level: --state.level });\n  state.tokens.push({ type: 'thead_close', level: --state.level });\n\n  state.tokens.push({\n    type: 'tbody_open',\n    lines: tbodyLines = [ startLine + 2, 0 ],\n    level: state.level++\n  });\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.tShift[nextLine] < state.blkIndent) { break; }\n\n    lineText = getLine(state, nextLine).trim();\n    if (lineText.indexOf('|') === -1) { break; }\n    rows = lineText.replace(/^\\||\\|$/g, '').split('|');\n\n    state.tokens.push({ type: 'tr_open', level: state.level++ });\n    for (i = 0; i < rows.length; i++) {\n      state.tokens.push({ type: 'td_open', align: aligns[i], level: state.level++ });\n      // 0x7c === '|'\n      cell = rows[i].substring(\n          rows[i].charCodeAt(0) === 0x7c ? 1 : 0,\n          rows[i].charCodeAt(rows[i].length - 1) === 0x7c ? rows[i].length - 1 : rows[i].length\n      ).trim();\n      state.tokens.push({\n        type: 'inline',\n        content: cell,\n        level: state.level,\n        children: []\n      });\n      state.tokens.push({ type: 'td_close', level: --state.level });\n    }\n    state.tokens.push({ type: 'tr_close', level: --state.level });\n  }\n  state.tokens.push({ type: 'tbody_close', level: --state.level });\n  state.tokens.push({ type: 'table_close', level: --state.level });\n\n  tableLines[1] = tbodyLines[1] = nextLine;\n  state.line = nextLine;\n  return true;\n}\n\n// Definition lists\n\n// Search `[:~][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipMarker(state, line) {\n  var pos, marker,\n      start = state.bMarks[line] + state.tShift[line],\n      max = state.eMarks[line];\n\n  if (start >= max) { return -1; }\n\n  // Check bullet\n  marker = state.src.charCodeAt(start++);\n  if (marker !== 0x7E/* ~ */ && marker !== 0x3A/* : */) { return -1; }\n\n  pos = state.skipSpaces(start);\n\n  // require space after \":\"\n  if (start === pos) { return -1; }\n\n  // no empty definitions, e.g. \"  : \"\n  if (pos >= max) { return -1; }\n\n  return pos;\n}\n\nfunction markTightParagraphs$1(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].tight = true;\n      state.tokens[i].tight = true;\n      i += 2;\n    }\n  }\n}\n\nfunction deflist(state, startLine, endLine, silent) {\n  var contentStart,\n      ddLine,\n      dtLine,\n      itemLines,\n      listLines,\n      listTokIdx,\n      nextLine,\n      oldIndent,\n      oldDDIndent,\n      oldParentType,\n      oldTShift,\n      oldTight,\n      prevEmptyEnd,\n      tight;\n\n  if (silent) {\n    // quirk: validation mode validates a dd block only, not a whole deflist\n    if (state.ddIndent < 0) { return false; }\n    return skipMarker(state, startLine) >= 0;\n  }\n\n  nextLine = startLine + 1;\n  if (state.isEmpty(nextLine)) {\n    if (++nextLine > endLine) { return false; }\n  }\n\n  if (state.tShift[nextLine] < state.blkIndent) { return false; }\n  contentStart = skipMarker(state, nextLine);\n  if (contentStart < 0) { return false; }\n\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  // Start list\n  listTokIdx = state.tokens.length;\n\n  state.tokens.push({\n    type: 'dl_open',\n    lines: listLines = [ startLine, 0 ],\n    level: state.level++\n  });\n\n  //\n  // Iterate list items\n  //\n\n  dtLine = startLine;\n  ddLine = nextLine;\n\n  // One definition list can contain multiple DTs,\n  // and one DT can be followed by multiple DDs.\n  //\n  // Thus, there is two loops here, and label is\n  // needed to break out of the second one\n  //\n  /*eslint no-labels:0,block-scoped-var:0*/\n  OUTER:\n  for (;;) {\n    tight = true;\n    prevEmptyEnd = false;\n\n    state.tokens.push({\n      type: 'dt_open',\n      lines: [ dtLine, dtLine ],\n      level: state.level++\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: state.getLines(dtLine, dtLine + 1, state.blkIndent, false).trim(),\n      level: state.level + 1,\n      lines: [ dtLine, dtLine ],\n      children: []\n    });\n    state.tokens.push({\n      type: 'dt_close',\n      level: --state.level\n    });\n\n    for (;;) {\n      state.tokens.push({\n        type: 'dd_open',\n        lines: itemLines = [ nextLine, 0 ],\n        level: state.level++\n      });\n\n      oldTight = state.tight;\n      oldDDIndent = state.ddIndent;\n      oldIndent = state.blkIndent;\n      oldTShift = state.tShift[ddLine];\n      oldParentType = state.parentType;\n      state.blkIndent = state.ddIndent = state.tShift[ddLine] + 2;\n      state.tShift[ddLine] = contentStart - state.bMarks[ddLine];\n      state.tight = true;\n      state.parentType = 'deflist';\n\n      state.parser.tokenize(state, ddLine, endLine, true);\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 - ddLine) > 1 && state.isEmpty(state.line - 1);\n\n      state.tShift[ddLine] = oldTShift;\n      state.tight = oldTight;\n      state.parentType = oldParentType;\n      state.blkIndent = oldIndent;\n      state.ddIndent = oldDDIndent;\n\n      state.tokens.push({\n        type: 'dd_close',\n        level: --state.level\n      });\n\n      itemLines[1] = nextLine = state.line;\n\n      if (nextLine >= endLine) { break OUTER; }\n\n      if (state.tShift[nextLine] < state.blkIndent) { break OUTER; }\n      contentStart = skipMarker(state, nextLine);\n      if (contentStart < 0) { break; }\n\n      ddLine = nextLine;\n\n      // go to the next loop iteration:\n      // insert DD tag and repeat checking\n    }\n\n    if (nextLine >= endLine) { break; }\n    dtLine = nextLine;\n\n    if (state.isEmpty(dtLine)) { break; }\n    if (state.tShift[dtLine] < state.blkIndent) { break; }\n\n    ddLine = dtLine + 1;\n    if (ddLine >= endLine) { break; }\n    if (state.isEmpty(ddLine)) { ddLine++; }\n    if (ddLine >= endLine) { break; }\n\n    if (state.tShift[ddLine] < state.blkIndent) { break; }\n    contentStart = skipMarker(state, ddLine);\n    if (contentStart < 0) { break; }\n\n    // go to the next loop iteration:\n    // insert DT and DD tags and repeat checking\n  }\n\n  // Finilize list\n  state.tokens.push({\n    type: 'dl_close',\n    level: --state.level\n  });\n  listLines[1] = nextLine;\n\n  state.line = nextLine;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs$1(state, listTokIdx);\n  }\n\n  return true;\n}\n\n// Paragraph\n\nfunction paragraph(state, startLine/*, endLine*/) {\n  var endLine, content, terminate, i, l,\n      nextLine = startLine + 1,\n      terminatorRules;\n\n  endLine = state.lineMax;\n\n  // jump line-by-line until empty one or EOF\n  if (nextLine < endLine && !state.isEmpty(nextLine)) {\n    terminatorRules = state.parser.ruler.getRules('paragraph');\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.tShift[nextLine] - state.blkIndent > 3) { 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\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n\n  state.line = nextLine;\n  if (content.length) {\n    state.tokens.push({\n      type: 'paragraph_open',\n      tight: false,\n      lines: [ startLine, state.line ],\n      level: state.level\n    });\n    state.tokens.push({\n      type: 'inline',\n      content: content,\n      level: state.level + 1,\n      lines: [ startLine, state.line ],\n      children: []\n    });\n    state.tokens.push({\n      type: 'paragraph_close',\n      tight: false,\n      level: state.level\n    });\n  }\n\n  return true;\n}\n\n/**\n * Parser rules\n */\n\nvar _rules$1 = [\n  [ 'code',       code ],\n  [ 'fences',     fences,     [ 'paragraph', 'blockquote', 'list' ] ],\n  [ 'blockquote', blockquote, [ 'paragraph', 'blockquote', 'list' ] ],\n  [ 'hr',         hr,         [ 'paragraph', 'blockquote', 'list' ] ],\n  [ 'list',       list,       [ 'paragraph', 'blockquote' ] ],\n  [ 'footnote',   footnote,   [ 'paragraph' ] ],\n  [ 'heading',    heading,    [ 'paragraph', 'blockquote' ] ],\n  [ 'lheading',   lheading ],\n  [ 'htmlblock',  htmlblock,  [ 'paragraph', 'blockquote' ] ],\n  [ 'table',      table,      [ 'paragraph' ] ],\n  [ 'deflist',    deflist,    [ 'paragraph' ] ],\n  [ 'paragraph',  paragraph ]\n];\n\n/**\n * Block Parser class\n *\n * @api private\n */\n\nfunction ParserBlock() {\n  this.ruler = new Ruler();\n  for (var i = 0; i < _rules$1.length; i++) {\n    this.ruler.push(_rules$1[i][0], _rules$1[i][1], {\n      alt: (_rules$1[i][2] || []).slice()\n    });\n  }\n}\n\n/**\n * Generate tokens for the given input range.\n *\n * @param  {Object} `state` Has properties like `src`, `parser`, `options` etc\n * @param  {Number} `startLine`\n * @param  {Number} `endLine`\n * @api private\n */\n\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var line = startLine;\n  var hasEmptyLines = false;\n  var ok, i;\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line >= endLine) {\n      break;\n    }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.tShift[line] < state.blkIndent) {\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) {\n        break;\n      }\n    }\n\n    // set state.tight iff we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines;\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n\n    line = state.line;\n\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++;\n\n      // two empty lines should stop the parser in list mode\n      if (line < endLine && state.parentType === 'list' && state.isEmpty(line)) { break; }\n      state.line = line;\n    }\n  }\n};\n\nvar TABS_SCAN_RE = /[\\n\\t]/g;\nvar NEWLINES_RE  = /\\r[\\n\\u0085]|[\\u2424\\u2028\\u0085]/g;\nvar SPACES_RE    = /\\u00a0/g;\n\n/**\n * Tokenize the given `str`.\n *\n * @param  {String} `str` Source string\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @param  {Array} `outTokens`\n * @api private\n */\n\nParserBlock.prototype.parse = function (str, options, env, outTokens) {\n  var state, lineStart = 0, lastTabPos = 0;\n  if (!str) { return []; }\n\n  // Normalize spaces\n  str = str.replace(SPACES_RE, ' ');\n\n  // Normalize newlines\n  str = str.replace(NEWLINES_RE, '\\n');\n\n  // Replace tabs with proper number of spaces (1..4)\n  if (str.indexOf('\\t') >= 0) {\n    str = str.replace(TABS_SCAN_RE, function (match, offset) {\n      var result;\n      if (str.charCodeAt(offset) === 0x0A) {\n        lineStart = offset + 1;\n        lastTabPos = 0;\n        return match;\n      }\n      result = '    '.slice((offset - lineStart - lastTabPos) % 4);\n      lastTabPos = offset - lineStart + 1;\n      return result;\n    });\n  }\n\n  state = new StateBlock(str, this, options, env, outTokens);\n  this.tokenize(state, state.line, state.lineMax);\n};\n\n// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n\n// Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x5C/* \\ */:\n    case 0x60/* ` */:\n    case 0x2A/* * */:\n    case 0x5F/* _ */:\n    case 0x5E/* ^ */:\n    case 0x5B/* [ */:\n    case 0x5D/* ] */:\n    case 0x21/* ! */:\n    case 0x26/* & */:\n    case 0x3C/* < */:\n    case 0x3E/* > */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x40/* @ */:\n    case 0x7E/* ~ */:\n    case 0x2B/* + */:\n    case 0x3D/* = */:\n    case 0x3A/* : */:\n      return true;\n    default:\n      return false;\n  }\n}\n\nfunction 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// Proceess '\\n'\n\nfunction 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        // Strip out all trailing spaces on this line.\n        for (var i = pmax - 2; i >= 0; i--) {\n          if (state.pending.charCodeAt(i) !== 0x20) {\n            state.pending = state.pending.substring(0, i + 1);\n            break;\n          }\n        }\n        state.push({\n          type: 'hardbreak',\n          level: state.level\n        });\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push({\n          type: 'softbreak',\n          level: state.level\n        });\n      }\n\n    } else {\n      state.push({\n        type: 'softbreak',\n        level: state.level\n      });\n    }\n  }\n\n  pos++;\n\n  // skip heading spaces for next line\n  while (pos < max && state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n  state.pos = pos;\n  return true;\n}\n\n// Proceess escaped chars and hardbreaks\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\nfunction 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({\n          type: 'hardbreak',\n          level: state.level\n        });\n      }\n\n      pos++;\n      // skip leading whitespaces from next line\n      while (pos < max && state.src.charCodeAt(pos) === 0x20) { pos++; }\n\n      state.pos = pos;\n      return true;\n    }\n  }\n\n  if (!silent) { state.pending += '\\\\'; }\n  state.pos++;\n  return true;\n}\n\n// Parse backticks\n\nfunction backticks(state, silent) {\n  var start, max, marker, matchStart, matchEnd,\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        state.push({\n          type: 'code',\n          content: state.src.slice(pos, matchStart)\n                              .replace(/[ \\n]+/g, ' ')\n                              .trim(),\n          block: false,\n          level: state.level\n        });\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\n// Process ~~deleted text~~\n\nfunction del(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x7E/* ~ */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 4 >= max) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x7E/* ~ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x7E/* ~ */) { return false; }\n  if (nextChar === 0x7E/* ~ */) { return false; }\n  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }\n\n  pos = start + 2;\n  while (pos < max && state.src.charCodeAt(pos) === 0x7E/* ~ */) { pos++; }\n  if (pos > start + 3) {\n    // sequence of 4+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n    if (!silent) { state.pending += state.src.slice(start, pos); }\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x7E/* ~ */) {\n      if (state.src.charCodeAt(state.pos + 1) === 0x7E/* ~ */) {\n        lastChar = state.src.charCodeAt(state.pos - 1);\n        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n        if (nextChar !== 0x7E/* ~ */ && lastChar !== 0x7E/* ~ */) {\n          if (lastChar !== 0x20 && lastChar !== 0x0A) {\n            // closing '~~'\n            stack--;\n          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n            // opening '~~'\n            stack++;\n          } // else {\n            //  // standalone ' ~~ ' indented with spaces\n            // }\n          if (stack <= 0) {\n            found = true;\n            break;\n          }\n        }\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({ type: 'del_open', level: state.level++ });\n    state.parser.tokenize(state);\n    state.push({ type: 'del_close', level: --state.level });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n}\n\n// Process ++inserted text++\n\nfunction ins(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x2B/* + */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 4 >= max) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x2B/* + */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x2B/* + */) { return false; }\n  if (nextChar === 0x2B/* + */) { return false; }\n  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }\n\n  pos = start + 2;\n  while (pos < max && state.src.charCodeAt(pos) === 0x2B/* + */) { pos++; }\n  if (pos !== start + 2) {\n    // sequence of 3+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n    if (!silent) { state.pending += state.src.slice(start, pos); }\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x2B/* + */) {\n      if (state.src.charCodeAt(state.pos + 1) === 0x2B/* + */) {\n        lastChar = state.src.charCodeAt(state.pos - 1);\n        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n        if (nextChar !== 0x2B/* + */ && lastChar !== 0x2B/* + */) {\n          if (lastChar !== 0x20 && lastChar !== 0x0A) {\n            // closing '++'\n            stack--;\n          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n            // opening '++'\n            stack++;\n          } // else {\n            //  // standalone ' ++ ' indented with spaces\n            // }\n          if (stack <= 0) {\n            found = true;\n            break;\n          }\n        }\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({ type: 'ins_open', level: state.level++ });\n    state.parser.tokenize(state);\n    state.push({ type: 'ins_close', level: --state.level });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n}\n\n// Process ==highlighted text==\n\nfunction mark(state, silent) {\n  var found,\n      pos,\n      stack,\n      max = state.posMax,\n      start = state.pos,\n      lastChar,\n      nextChar;\n\n  if (state.src.charCodeAt(start) !== 0x3D/* = */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 4 >= max) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x3D/* = */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n  nextChar = state.src.charCodeAt(start + 2);\n\n  if (lastChar === 0x3D/* = */) { return false; }\n  if (nextChar === 0x3D/* = */) { return false; }\n  if (nextChar === 0x20 || nextChar === 0x0A) { return false; }\n\n  pos = start + 2;\n  while (pos < max && state.src.charCodeAt(pos) === 0x3D/* = */) { pos++; }\n  if (pos !== start + 2) {\n    // sequence of 3+ markers taking as literal, same as in a emphasis\n    state.pos += pos - start;\n    if (!silent) { state.pending += state.src.slice(start, pos); }\n    return true;\n  }\n\n  state.pos = start + 2;\n  stack = 1;\n\n  while (state.pos + 1 < max) {\n    if (state.src.charCodeAt(state.pos) === 0x3D/* = */) {\n      if (state.src.charCodeAt(state.pos + 1) === 0x3D/* = */) {\n        lastChar = state.src.charCodeAt(state.pos - 1);\n        nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1;\n        if (nextChar !== 0x3D/* = */ && lastChar !== 0x3D/* = */) {\n          if (lastChar !== 0x20 && lastChar !== 0x0A) {\n            // closing '=='\n            stack--;\n          } else if (nextChar !== 0x20 && nextChar !== 0x0A) {\n            // opening '=='\n            stack++;\n          } // else {\n            //  // standalone ' == ' indented with spaces\n            // }\n          if (stack <= 0) {\n            found = true;\n            break;\n          }\n        }\n      }\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 2;\n\n  if (!silent) {\n    state.push({ type: 'mark_open', level: state.level++ });\n    state.parser.tokenize(state);\n    state.push({ type: 'mark_close', level: --state.level });\n  }\n\n  state.pos = state.posMax + 2;\n  state.posMax = max;\n  return true;\n}\n\n// Process *this* and _that_\n\nfunction isAlphaNum(code) {\n  return (code >= 0x30 /* 0 */ && code <= 0x39 /* 9 */) ||\n         (code >= 0x41 /* A */ && code <= 0x5A /* Z */) ||\n         (code >= 0x61 /* a */ && code <= 0x7A /* z */);\n}\n\n// parse sequence of emphasis markers,\n// \"start\" should point at a valid marker\nfunction scanDelims(state, start) {\n  var pos = start, lastChar, nextChar, count,\n      can_open = true,\n      can_close = true,\n      max = state.posMax,\n      marker = state.src.charCodeAt(start);\n\n  lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1;\n\n  while (pos < max && state.src.charCodeAt(pos) === marker) { pos++; }\n  if (pos >= max) { can_open = false; }\n  count = pos - start;\n\n  if (count >= 4) {\n    // sequence of four or more unescaped markers can't start/end an emphasis\n    can_open = can_close = false;\n  } else {\n    nextChar = pos < max ? state.src.charCodeAt(pos) : -1;\n\n    // check whitespace conditions\n    if (nextChar === 0x20 || nextChar === 0x0A) { can_open = false; }\n    if (lastChar === 0x20 || lastChar === 0x0A) { can_close = false; }\n\n    if (marker === 0x5F /* _ */) {\n      // check if we aren't inside the word\n      if (isAlphaNum(lastChar)) { can_open = false; }\n      if (isAlphaNum(nextChar)) { can_close = false; }\n    }\n  }\n\n  return {\n    can_open: can_open,\n    can_close: can_close,\n    delims: count\n  };\n}\n\nfunction emphasis(state, silent) {\n  var startCount,\n      count,\n      found,\n      oldCount,\n      newCount,\n      stack,\n      res,\n      max = state.posMax,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (marker !== 0x5F/* _ */ && marker !== 0x2A /* * */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n\n  res = scanDelims(state, start);\n  startCount = res.delims;\n  if (!res.can_open) {\n    state.pos += startCount;\n    if (!silent) { state.pending += state.src.slice(start, state.pos); }\n    return true;\n  }\n\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  state.pos = start + startCount;\n  stack = [ startCount ];\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === marker) {\n      res = scanDelims(state, state.pos);\n      count = res.delims;\n      if (res.can_close) {\n        oldCount = stack.pop();\n        newCount = count;\n\n        while (oldCount !== newCount) {\n          if (newCount < oldCount) {\n            stack.push(oldCount - newCount);\n            break;\n          }\n\n          // assert(newCount > oldCount)\n          newCount -= oldCount;\n\n          if (stack.length === 0) { break; }\n          state.pos += oldCount;\n          oldCount = stack.pop();\n        }\n\n        if (stack.length === 0) {\n          startCount = oldCount;\n          found = true;\n          break;\n        }\n        state.pos += count;\n        continue;\n      }\n\n      if (res.can_open) { stack.push(count); }\n      state.pos += count;\n      continue;\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found) {\n    // parser failed to find ending tag, so it's not valid emphasis\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + startCount;\n\n  if (!silent) {\n    if (startCount === 2 || startCount === 3) {\n      state.push({ type: 'strong_open', level: state.level++ });\n    }\n    if (startCount === 1 || startCount === 3) {\n      state.push({ type: 'em_open', level: state.level++ });\n    }\n\n    state.parser.tokenize(state);\n\n    if (startCount === 1 || startCount === 3) {\n      state.push({ type: 'em_close', level: --state.level });\n    }\n    if (startCount === 2 || startCount === 3) {\n      state.push({ type: 'strong_close', level: --state.level });\n    }\n  }\n\n  state.pos = state.posMax + startCount;\n  state.posMax = max;\n  return true;\n}\n\n// Process ~subscript~\n\n// same as UNESCAPE_MD_RE plus a space\nvar UNESCAPE_RE = /\\\\([ \\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nfunction sub(state, silent) {\n  var found,\n      content,\n      max = state.posMax,\n      start = state.pos;\n\n  if (state.src.charCodeAt(start) !== 0x7E/* ~ */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 2 >= max) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  state.pos = start + 1;\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === 0x7E/* ~ */) {\n      found = true;\n      break;\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found || start + 1 === state.pos) {\n    state.pos = start;\n    return false;\n  }\n\n  content = state.src.slice(start + 1, state.pos);\n\n  // don't allow unescaped spaces/newlines inside\n  if (content.match(/(^|[^\\\\])(\\\\\\\\)*\\s/)) {\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 1;\n\n  if (!silent) {\n    state.push({\n      type: 'sub',\n      level: state.level,\n      content: content.replace(UNESCAPE_RE, '$1')\n    });\n  }\n\n  state.pos = state.posMax + 1;\n  state.posMax = max;\n  return true;\n}\n\n// Process ^superscript^\n\n// same as UNESCAPE_MD_RE plus a space\nvar UNESCAPE_RE$1 = /\\\\([ \\\\!\"#$%&'()*+,.\\/:;<=>?@[\\]^_`{|}~-])/g;\n\nfunction sup(state, silent) {\n  var found,\n      content,\n      max = state.posMax,\n      start = state.pos;\n\n  if (state.src.charCodeAt(start) !== 0x5E/* ^ */) { return false; }\n  if (silent) { return false; } // don't run any pairs in validation mode\n  if (start + 2 >= max) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  state.pos = start + 1;\n\n  while (state.pos < max) {\n    if (state.src.charCodeAt(state.pos) === 0x5E/* ^ */) {\n      found = true;\n      break;\n    }\n\n    state.parser.skipToken(state);\n  }\n\n  if (!found || start + 1 === state.pos) {\n    state.pos = start;\n    return false;\n  }\n\n  content = state.src.slice(start + 1, state.pos);\n\n  // don't allow unescaped spaces/newlines inside\n  if (content.match(/(^|[^\\\\])(\\\\\\\\)*\\s/)) {\n    state.pos = start;\n    return false;\n  }\n\n  // found!\n  state.posMax = state.pos;\n  state.pos = start + 1;\n\n  if (!silent) {\n    state.push({\n      type: 'sup',\n      level: state.level,\n      content: content.replace(UNESCAPE_RE$1, '$1')\n    });\n  }\n\n  state.pos = state.posMax + 1;\n  state.posMax = max;\n  return true;\n}\n\n// Process [links](<to> \"stuff\")\n\n\nfunction links(state, silent) {\n  var labelStart,\n      labelEnd,\n      label,\n      href,\n      title,\n      pos,\n      ref,\n      code,\n      isImage = false,\n      oldPos = state.pos,\n      max = state.posMax,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (marker === 0x21/* ! */) {\n    isImage = true;\n    marker = state.src.charCodeAt(++start);\n  }\n\n  if (marker !== 0x5B/* [ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  labelStart = start + 1;\n  labelEnd = parseLinkLabel(state, start);\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 (code !== 0x20 && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    if (parseLinkDestination(state, pos)) {\n      href = state.linkContent;\n      pos = state.pos;\n    } else {\n      href = '';\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 (code !== 0x20 && code !== 0x0A) { break; }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    if (pos < max && start !== pos && parseLinkTitle(state, pos)) {\n      title = state.linkContent;\n      pos = state.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (code !== 0x20 && 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\n    // do not allow nested reference links\n    if (state.linkLevel > 0) { return false; }\n\n    // [foo]  [bar]\n    //      ^^ optional whitespace (can include newlines)\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (code !== 0x20 && code !== 0x0A) { break; }\n    }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = start - 1;\n      }\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) {\n      if (typeof label === 'undefined') {\n        pos = labelEnd + 1;\n      }\n      label = state.src.slice(labelStart, labelEnd);\n    }\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    if (isImage) {\n      state.push({\n        type: 'image',\n        src: href,\n        title: title,\n        alt: state.src.substr(labelStart, labelEnd - labelStart),\n        level: state.level\n      });\n    } else {\n      state.push({\n        type: 'link_open',\n        href: href,\n        title: title,\n        level: state.level++\n      });\n      state.linkLevel++;\n      state.parser.tokenize(state);\n      state.linkLevel--;\n      state.push({ type: 'link_close', level: --state.level });\n    }\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n}\n\n// Process inline footnotes (^[...])\n\n\nfunction footnote_inline(state, silent) {\n  var labelStart,\n      labelEnd,\n      footnoteId,\n      oldLength,\n      max = state.posMax,\n      start = state.pos;\n\n  if (start + 2 >= max) { return false; }\n  if (state.src.charCodeAt(start) !== 0x5E/* ^ */) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x5B/* [ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  labelStart = start + 2;\n  labelEnd = parseLinkLabel(state, start + 1);\n\n  // parser failed to find ']', so it's not a valid note\n  if (labelEnd < 0) { return false; }\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    if (!state.env.footnotes) { state.env.footnotes = {}; }\n    if (!state.env.footnotes.list) { state.env.footnotes.list = []; }\n    footnoteId = state.env.footnotes.list.length;\n\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n\n    state.push({\n      type: 'footnote_ref',\n      id: footnoteId,\n      level: state.level\n    });\n    state.linkLevel++;\n    oldLength = state.tokens.length;\n    state.parser.tokenize(state);\n    state.env.footnotes.list[footnoteId] = { tokens: state.tokens.splice(oldLength) };\n    state.linkLevel--;\n  }\n\n  state.pos = labelEnd + 1;\n  state.posMax = max;\n  return true;\n}\n\n// Process footnote references ([^...])\n\nfunction footnote_ref(state, silent) {\n  var label,\n      pos,\n      footnoteId,\n      footnoteSubId,\n      max = state.posMax,\n      start = state.pos;\n\n  // should be at least 4 chars - \"[^x]\"\n  if (start + 3 > max) { return false; }\n\n  if (!state.env.footnotes || !state.env.footnotes.refs) { return false; }\n  if (state.src.charCodeAt(start) !== 0x5B/* [ */) { return false; }\n  if (state.src.charCodeAt(start + 1) !== 0x5E/* ^ */) { return false; }\n  if (state.level >= state.options.maxNesting) { return false; }\n\n  for (pos = start + 2; pos < max; pos++) {\n    if (state.src.charCodeAt(pos) === 0x20) { return false; }\n    if (state.src.charCodeAt(pos) === 0x0A) { return false; }\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */) {\n      break;\n    }\n  }\n\n  if (pos === start + 2) { return false; } // no empty footnote labels\n  if (pos >= max) { return false; }\n  pos++;\n\n  label = state.src.slice(start + 2, pos - 1);\n  if (typeof state.env.footnotes.refs[':' + label] === 'undefined') { return false; }\n\n  if (!silent) {\n    if (!state.env.footnotes.list) { state.env.footnotes.list = []; }\n\n    if (state.env.footnotes.refs[':' + label] < 0) {\n      footnoteId = state.env.footnotes.list.length;\n      state.env.footnotes.list[footnoteId] = { label: label, count: 0 };\n      state.env.footnotes.refs[':' + label] = footnoteId;\n    } else {\n      footnoteId = state.env.footnotes.refs[':' + label];\n    }\n\n    footnoteSubId = state.env.footnotes.list[footnoteId].count;\n    state.env.footnotes.list[footnoteId].count++;\n\n    state.push({\n      type: 'footnote_ref',\n      id: footnoteId,\n      subId: footnoteSubId,\n      level: state.level\n    });\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n}\n\n// List of valid url schemas, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#autolinks\n\nvar url_schemas = [\n  'coap',\n  'doi',\n  'javascript',\n  'aaa',\n  'aaas',\n  'about',\n  'acap',\n  'cap',\n  'cid',\n  'crid',\n  'data',\n  'dav',\n  'dict',\n  'dns',\n  'file',\n  'ftp',\n  'geo',\n  'go',\n  'gopher',\n  'h323',\n  'http',\n  'https',\n  'iax',\n  'icap',\n  'im',\n  'imap',\n  'info',\n  'ipp',\n  'iris',\n  'iris.beep',\n  'iris.xpc',\n  'iris.xpcs',\n  'iris.lwz',\n  'ldap',\n  'mailto',\n  'mid',\n  'msrp',\n  'msrps',\n  'mtqp',\n  'mupdate',\n  'news',\n  'nfs',\n  'ni',\n  'nih',\n  'nntp',\n  'opaquelocktoken',\n  'pop',\n  'pres',\n  'rtsp',\n  'service',\n  'session',\n  'shttp',\n  'sieve',\n  'sip',\n  'sips',\n  'sms',\n  'snmp',\n  'soap.beep',\n  'soap.beeps',\n  'tag',\n  'tel',\n  'telnet',\n  'tftp',\n  'thismessage',\n  'tn3270',\n  'tip',\n  'tv',\n  'urn',\n  'vemmi',\n  'ws',\n  'wss',\n  'xcon',\n  'xcon-userid',\n  'xmlrpc.beep',\n  'xmlrpc.beeps',\n  'xmpp',\n  'z39.50r',\n  'z39.50s',\n  'adiumxtra',\n  'afp',\n  'afs',\n  'aim',\n  'apt',\n  'attachment',\n  'aw',\n  'beshare',\n  'bitcoin',\n  'bolo',\n  'callto',\n  'chrome',\n  'chrome-extension',\n  'com-eventbrite-attendee',\n  'content',\n  'cvs',\n  'dlna-playsingle',\n  'dlna-playcontainer',\n  'dtn',\n  'dvb',\n  'ed2k',\n  'facetime',\n  'feed',\n  'finger',\n  'fish',\n  'gg',\n  'git',\n  'gizmoproject',\n  'gtalk',\n  'hcp',\n  'icon',\n  'ipn',\n  'irc',\n  'irc6',\n  'ircs',\n  'itms',\n  'jar',\n  'jms',\n  'keyparc',\n  'lastfm',\n  'ldaps',\n  'magnet',\n  'maps',\n  'market',\n  'message',\n  'mms',\n  'ms-help',\n  'msnim',\n  'mumble',\n  'mvn',\n  'notes',\n  'oid',\n  'palm',\n  'paparazzi',\n  'platform',\n  'proxy',\n  'psyc',\n  'query',\n  'res',\n  'resource',\n  'rmi',\n  'rsync',\n  'rtmp',\n  'secondlife',\n  'sftp',\n  'sgn',\n  'skype',\n  'smb',\n  'soldat',\n  'spotify',\n  'ssh',\n  'steam',\n  'svn',\n  'teamspeak',\n  'things',\n  'udp',\n  'unreal',\n  'ut2004',\n  'ventrilo',\n  'view-source',\n  'webcal',\n  'wtai',\n  'wyciwyg',\n  'xfire',\n  'xri',\n  'ymsgr'\n];\n\n// Process autolinks '<protocol:...>'\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.\\-]{1,25}):([^<>\\x00-\\x20]*)>/;\n\n\nfunction autolink(state, silent) {\n  var tail, linkMatch, emailMatch, url, fullUrl, 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  linkMatch = tail.match(AUTOLINK_RE);\n\n  if (linkMatch) {\n    if (url_schemas.indexOf(linkMatch[1].toLowerCase()) < 0) { return false; }\n\n    url = linkMatch[0].slice(1, -1);\n    fullUrl = normalizeLink(url);\n    if (!state.parser.validateLink(url)) { return false; }\n\n    if (!silent) {\n      state.push({\n        type: 'link_open',\n        href: fullUrl,\n        level: state.level\n      });\n      state.push({\n        type: 'text',\n        content: url,\n        level: state.level + 1\n      });\n      state.push({ type: 'link_close', level: state.level });\n    }\n\n    state.pos += linkMatch[0].length;\n    return true;\n  }\n\n  emailMatch = tail.match(EMAIL_RE);\n\n  if (emailMatch) {\n\n    url = emailMatch[0].slice(1, -1);\n\n    fullUrl = normalizeLink('mailto:' + url);\n    if (!state.parser.validateLink(fullUrl)) { return false; }\n\n    if (!silent) {\n      state.push({\n        type: 'link_open',\n        href: fullUrl,\n        level: state.level\n      });\n      state.push({\n        type: 'text',\n        content: url,\n        level: state.level + 1\n      });\n      state.push({ type: 'link_close', level: state.level });\n    }\n\n    state.pos += emailMatch[0].length;\n    return true;\n  }\n\n  return false;\n}\n\n// Regexps to match html elements\n\nfunction replace$1(regex, options) {\n  regex = regex.source;\n  options = options || '';\n\n  return function self(name, val) {\n    if (!name) {\n      return new RegExp(regex, options);\n    }\n    val = val.source || val;\n    regex = regex.replace(name, val);\n    return self;\n  };\n}\n\n\nvar attr_name     = /[a-zA-Z_:][a-zA-Z0-9:._-]*/;\n\nvar unquoted      = /[^\"'=<>`\\x00-\\x20]+/;\nvar single_quoted = /'[^']*'/;\nvar double_quoted = /\"[^\"]*\"/;\n\n/*eslint no-spaced-func:0*/\nvar attr_value  = replace$1(/(?:unquoted|single_quoted|double_quoted)/)\n                    ('unquoted', unquoted)\n                    ('single_quoted', single_quoted)\n                    ('double_quoted', double_quoted)\n                    ();\n\nvar attribute   = replace$1(/(?:\\s+attr_name(?:\\s*=\\s*attr_value)?)/)\n                    ('attr_name', attr_name)\n                    ('attr_value', attr_value)\n                    ();\n\nvar open_tag    = replace$1(/<[A-Za-z][A-Za-z0-9]*attribute*\\s*\\/?>/)\n                    ('attribute', attribute)\n                    ();\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 = replace$1(/^(?:open_tag|close_tag|comment|processing|declaration|cdata)/)\n  ('open_tag', open_tag)\n  ('close_tag', close_tag)\n  ('comment', comment)\n  ('processing', processing)\n  ('declaration', declaration)\n  ('cdata', cdata)\n  ();\n\n// Process html tags\n\n\nfunction isLetter$2(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\nfunction htmltag(state, silent) {\n  var ch, match, max, pos = state.pos;\n\n  if (!state.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$2(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    state.push({\n      type: 'htmltag',\n      content: state.src.slice(pos, pos + match[0].length),\n      level: state.level\n    });\n  }\n  state.pos += match[0].length;\n  return true;\n}\n\n// Process html entity - &#123;, &#xAF;, &quot;, ...\n\n\nvar DIGITAL_RE = /^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/i;\nvar NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i;\n\n\nfunction 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        var decoded = decodeEntity(match[1]);\n        if (match[1] !== decoded) {\n          if (!silent) { state.pending += decoded; }\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\n/**\n * Inline Parser `rules`\n */\n\nvar _rules$2 = [\n  [ 'text',            text ],\n  [ 'newline',         newline ],\n  [ 'escape',          escape ],\n  [ 'backticks',       backticks ],\n  [ 'del',             del ],\n  [ 'ins',             ins ],\n  [ 'mark',            mark ],\n  [ 'emphasis',        emphasis ],\n  [ 'sub',             sub ],\n  [ 'sup',             sup ],\n  [ 'links',           links ],\n  [ 'footnote_inline', footnote_inline ],\n  [ 'footnote_ref',    footnote_ref ],\n  [ 'autolink',        autolink ],\n  [ 'htmltag',         htmltag ],\n  [ 'entity',          entity ]\n];\n\n/**\n * Inline Parser class. Note that link validation is stricter\n * in Remarkable than what is specified by CommonMark. If you\n * want to change this you can use a custom validator.\n *\n * @api private\n */\n\nfunction ParserInline() {\n  this.ruler = new Ruler();\n  for (var i = 0; i < _rules$2.length; i++) {\n    this.ruler.push(_rules$2[i][0], _rules$2[i][1]);\n  }\n\n  // Can be overridden with a custom validator\n  this.validateLink = validateLink;\n}\n\n/**\n * Skip a single token by running all rules in validation mode.\n * Returns `true` if any rule reports success.\n *\n * @param  {Object} `state`\n * @api privage\n */\n\nParserInline.prototype.skipToken = function (state) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var pos = state.pos;\n  var i, cached_pos;\n\n  if ((cached_pos = state.cacheGet(pos)) > 0) {\n    state.pos = cached_pos;\n    return;\n  }\n\n  for (i = 0; i < len; i++) {\n    if (rules[i](state, true)) {\n      state.cacheSet(pos, state.pos);\n      return;\n    }\n  }\n\n  state.pos++;\n  state.cacheSet(pos, state.pos);\n};\n\n/**\n * Generate tokens for the given input range.\n *\n * @param  {Object} `state`\n * @api private\n */\n\nParserInline.prototype.tokenize = function (state) {\n  var rules = this.ruler.getRules('');\n  var len = rules.length;\n  var end = state.posMax;\n  var ok, i;\n\n  while (state.pos < end) {\n\n    // Try all possible rules.\n    // On success, the rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, false);\n\n      if (ok) {\n        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 * Parse the given input string.\n *\n * @param  {String} `str`\n * @param  {Object} `options`\n * @param  {Object} `env`\n * @param  {Array} `outTokens`\n * @api private\n */\n\nParserInline.prototype.parse = function (str, options, env, outTokens) {\n  var state = new StateInline(str, this, options, env, outTokens);\n  this.tokenize(state);\n};\n\n/**\n * Validate the given `url` by checking for bad protocols.\n *\n * @param  {String} `url`\n * @return {Boolean}\n */\n\nfunction validateLink(url) {\n  var BAD_PROTOCOLS = [ 'vbscript', 'javascript', 'file', 'data' ];\n  var str = url.trim().toLowerCase();\n  // Care about digital entities \"javascript&#x3A;alert(1)\"\n  str = replaceEntities(str);\n  if (str.indexOf(':') !== -1 && BAD_PROTOCOLS.indexOf(str.split(':')[0]) !== -1) {\n    return false;\n  }\n  return true;\n}\n\n// Remarkable default options\n\nvar defaultConfig = {\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    linkTarget:   '',           // set target to open link in\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. Set doubles to '«»' for Russian, '„“' for German.\n    quotes: '“”‘’',\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\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        'block',\n        'inline',\n        'references',\n        'replacements',\n        'smartquotes',\n        'references',\n        'abbr2',\n        'footnote_tail'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fences',\n        'footnote',\n        'heading',\n        'hr',\n        'htmlblock',\n        'lheading',\n        'list',\n        'paragraph',\n        'table'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'del',\n        'emphasis',\n        'entity',\n        'escape',\n        'footnote_ref',\n        'htmltag',\n        'links',\n        'newline',\n        'text'\n      ]\n    }\n  }\n};\n\n// Remarkable default options\n\nvar fullConfig = {\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    linkTarget:   '',           // set target to open link in\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. Set doubles to '«»' for Russian, '„“' for German.\n    quotes:       '“”‘’',\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight:     null,\n\n    maxNesting:    20            // Internal protection, recursion limit\n  },\n\n  components: {\n    // Don't restrict core/block/inline rules\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n\n// Commonmark default options\n\nvar commonmarkConfig = {\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    linkTarget:   '',           // set target to open link in\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. Set doubles to '«»' for Russian, '„“' for German.\n    quotes: '“”‘’',\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if input not changed\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        'block',\n        'inline',\n        'references',\n        'abbr2'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fences',\n        'heading',\n        'hr',\n        'htmlblock',\n        'lheading',\n        'list',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'htmltag',\n        'links',\n        'newline',\n        'text'\n      ]\n    }\n  }\n};\n\n/**\n * Preset configs\n */\n\nvar config = {\n  'default': defaultConfig,\n  'full': fullConfig,\n  'commonmark': commonmarkConfig\n};\n\n/**\n * The `StateCore` class manages state.\n *\n * @param {Object} `instance` Remarkable instance\n * @param {String} `str` Markdown string\n * @param {Object} `env`\n */\n\nfunction StateCore(instance, str, env) {\n  this.src = str;\n  this.env = env;\n  this.options = instance.options;\n  this.tokens = [];\n  this.inlineMode = false;\n\n  this.inline = instance.inline;\n  this.block = instance.block;\n  this.renderer = instance.renderer;\n  this.typographer = instance.typographer;\n}\n\n/**\n * The main `Remarkable` class. Create an instance of\n * `Remarkable` with a `preset` and/or `options`.\n *\n * @param {String} `preset` If no preset is given, `default` is used.\n * @param {Object} `options`\n */\n\nfunction Remarkable(preset, options) {\n  if (typeof preset !== 'string') {\n    options = preset;\n    preset = 'default';\n  }\n\n  if (options && options.linkify != null) {\n    console.warn(\n      'linkify option is removed. Use linkify plugin instead:\\n\\n' +\n      'import Remarkable from \\'remarkable\\';\\n' +\n      'import linkify from \\'remarkable/linkify\\';\\n' +\n      'new Remarkable().use(linkify)\\n'\n    );\n  }\n\n  this.inline   = new ParserInline();\n  this.block    = new ParserBlock();\n  this.core     = new Core();\n  this.renderer = new Renderer();\n  this.ruler    = new Ruler();\n\n  this.options  = {};\n  this.configure(config[preset]);\n  this.set(options || {});\n}\n\n/**\n * Set options as an alternative to passing them\n * to the constructor.\n *\n * ```js\n * md.set({typographer: true});\n * ```\n * @param {Object} `options`\n * @api public\n */\n\nRemarkable.prototype.set = function (options) {\n  assign(this.options, options);\n};\n\n/**\n * Batch loader for components rules states, and options\n *\n * @param  {Object} `presets`\n */\n\nRemarkable.prototype.configure = function (presets) {\n  var self = this;\n\n  if (!presets) { throw new Error('Wrong `remarkable` preset, check name/content'); }\n  if (presets.options) { self.set(presets.options); }\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enable(presets.components[name].rules, true);\n      }\n    });\n  }\n};\n\n/**\n * Use a plugin.\n *\n * ```js\n * var md = new Remarkable();\n *\n * md.use(plugin1)\n *   .use(plugin2, opts)\n *   .use(plugin3);\n * ```\n *\n * @param  {Function} `plugin`\n * @param  {Object} `options`\n * @return {Object} `Remarkable` for chaining\n */\n\nRemarkable.prototype.use = function (plugin, options) {\n  plugin(this, options);\n  return this;\n};\n\n\n/**\n * Parse the input `string` and return a tokens array.\n * Modifies `env` with definitions data.\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {Array} Array of tokens\n */\n\nRemarkable.prototype.parse = function (str, env) {\n  var state = new StateCore(this, str, env);\n  this.core.process(state);\n  return state.tokens;\n};\n\n/**\n * The main `.render()` method that does all the magic :)\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {String} Rendered HTML.\n */\n\nRemarkable.prototype.render = function (str, env) {\n  env = env || {};\n  return this.renderer.render(this.parse(str, env), this.options, env);\n};\n\n/**\n * Parse the given content `string` as a single string.\n *\n * @param  {String} `string`\n * @param  {Object} `env`\n * @return {Array} Array of tokens\n */\n\nRemarkable.prototype.parseInline = function (str, env) {\n  var state = new StateCore(this, str, env);\n  state.inlineMode = true;\n  this.core.process(state);\n  return state.tokens;\n};\n\n/**\n * Render a single content `string`, without wrapping it\n * to paragraphs\n *\n * @param  {String} `str`\n * @param  {Object} `env`\n * @return {String}\n */\n\nRemarkable.prototype.renderInline = function (str, env) {\n  env = env || {};\n  return this.renderer.render(this.parseInline(str, env), this.options, env);\n};\n\nexport { Remarkable, utils };\n","import { Remarkable } from 'remarkable';\nimport resume from './assets/cv.md';\nimport './styles/site.scss';\n\nconst resume_content = document.getElementById('resume');\n\n// Link scroll to resume\ndocument.querySelector('#link__resume').addEventListener('click', e => {\n\te.preventDefault();\n\tresume_content.scrollIntoView();\n});\n\n// Render Resume\nconst md = new Remarkable('default', { html: true });\nresume_content.querySelector('.content').innerHTML = md.render(resume);\n","var bundleURL = null;\nfunction getBundleURLCached() {\n  if (!bundleURL) {\n    bundleURL = getBundleURL();\n  }\n\n  return bundleURL;\n}\n\nfunction getBundleURL() {\n  // Attempt to find the URL of the current script and use that as the base URL\n  try {\n    throw new Error;\n  } catch (err) {\n    var matches = ('' + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\\/\\/[^)\\n]+/g);\n    if (matches) {\n      return getBaseURL(matches[0]);\n    }\n  }\n\n  return '/';\n}\n\nfunction getBaseURL(url) {\n  return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\\/\\/.+)\\/[^/]+$/, '$1') + '/';\n}\n\nexports.getBundleURL = getBundleURLCached;\nexports.getBaseURL = getBaseURL;\n","var getBundleURL = require('./bundle-url').getBundleURL;\n\nfunction loadBundlesLazy(bundles) {\n  if (!Array.isArray(bundles)) {\n    bundles = [bundles]\n  }\n\n  var id = bundles[bundles.length - 1];\n\n  try {\n    return Promise.resolve(require(id));\n  } catch (err) {\n    if (err.code === 'MODULE_NOT_FOUND') {\n      return new LazyPromise(function (resolve, reject) {\n        loadBundles(bundles.slice(0, -1))\n          .then(function () {\n            return require(id);\n          })\n          .then(resolve, reject);\n      });\n    }\n\n    throw err;\n  }\n}\n\nfunction loadBundles(bundles) {\n  return Promise.all(bundles.map(loadBundle));\n}\n\nvar bundleLoaders = {};\nfunction registerBundleLoader(type, loader) {\n  bundleLoaders[type] = loader;\n}\n\nmodule.exports = exports = loadBundlesLazy;\nexports.load = loadBundles;\nexports.register = registerBundleLoader;\n\nvar bundles = {};\nfunction loadBundle(bundle) {\n  var id;\n  if (Array.isArray(bundle)) {\n    id = bundle[1];\n    bundle = bundle[0];\n  }\n\n  if (bundles[bundle]) {\n    return bundles[bundle];\n  }\n\n  var type = (bundle.substring(bundle.lastIndexOf('.') + 1, bundle.length) || bundle).toLowerCase();\n  var bundleLoader = bundleLoaders[type];\n  if (bundleLoader) {\n    return bundles[bundle] = bundleLoader(getBundleURL() + bundle)\n      .then(function (resolved) {\n        if (resolved) {\n          module.bundle.register(id, resolved);\n        }\n\n        return resolved;\n      }).catch(function(e) {\n        delete bundles[bundle];\n        \n        throw e;\n      });\n  }\n}\n\nfunction LazyPromise(executor) {\n  this.executor = executor;\n  this.promise = null;\n}\n\nLazyPromise.prototype.then = function (onSuccess, onError) {\n  if (this.promise === null) this.promise = new Promise(this.executor)\n  return this.promise.then(onSuccess, onError)\n};\n\nLazyPromise.prototype.catch = function (onError) {\n  if (this.promise === null) this.promise = new Promise(this.executor)\n  return this.promise.catch(onError)\n};\n","module.exports = function loadHTMLBundle(bundle) {\n  return fetch(bundle).then(function (res) {\n    return res.text();\n  });\n};\n"]}