{"mappings":"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","names":["utils_exports","__export","arrayReplaceAt","asciiTrim","assign","escapeHtml","escapeRE","fromCodePoint","has","isMdAsciiPunct","isPunctChar","isPunctCharCode","isSpace","isString","isValidEntityCode","isWhiteSpace","lib","normalizeReference","unescapeAll","unescapeMd","mdurl","ucmicro","decodeHTML","_class","obj","_hasOwnProperty","object","key","source","src","pos","newElements","c","surrogate1","surrogate2","UNESCAPE_MD_RE","ENTITY_RE","UNESCAPE_ALL_RE","DIGITAL_ENTITY_TEST_RE","replaceEntityPattern","match","name","code","decoded","str","escaped","entity","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","ch","REGEXP_ESCAPE_RE","isAsciiTrimmable","start","end","helpers_exports","__export","parseLinkDestination","parseLinkLabel","parseLinkTitle","parseLinkLabel","state","start","disableNested","level","found","marker","prevPos","max","oldPos","labelEnd","parseLinkDestination","str","start","max","code","pos","result","unescapeAll","level","parseLinkTitle","str","start","max","prev_state","code","pos","state","marker","unescapeAll","default_rules","tokens","idx","options","env","slf","token","escapeHtml","info","unescapeAll","langName","langAttrs","arr","highlighted","i","tmpAttrs","tmpToken","Renderer","assign","l","result","needLf","nextToken","rules","len","type","renderer_default","Ruler","name","i","self","chains","rule","altName","chain","fn","options","index","opt","beforeName","ruleName","afterName","list","ignoreInvalid","result","idx","chainName","ruler_default","Token","type","tag","nesting","name","attrs","len","attrData","value","idx","token_default","StateCore","src","md","env","token_default","state_core_default","NEWLINES_RE","NULL_RE","normalize","state","str","block","state","token","inline","state","tokens","i","l","tok","isLinkOpen","str","isLinkClose","linkify","state","blockTokens","j","l","tokens","replacements","htmlLinkLevel","i","currentToken","text","links","nodes","level","lastPos","ln","url","fullUrl","urlText","pos","token","token_o","token_t","token_c","newTokensLength","replacement","newTokens","replacementIndex","newTokenIndex","node","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","replaceFn","match","name","replace_scoped","inlineTokens","inside_autolink","i","token","replace_rare","replace","state","blkIdx","QUOTE_TEST_RE","QUOTE_RE","APOSTROPHE","MAX_OPENERS","truncateStack","stack","heads","length","item","addReplacement","replacements","tokenIdx","pos","ch","applyReplacements","str","result","lastPos","a","b","i","replacement","process_inlines","tokens","state","j","token","thisLevel","text","max","OUTER","t","canOpen","canClose","isSingle","lastChar","nextChar","isLastPunctChar","isMdAsciiPunct","isPunctCharCode","isNextPunctChar","isLastWhiteSpace","isWhiteSpace","isNextWhiteSpace","openQuote","closeQuote","smartquotes","blkIdx","text_join","state","curr","last","blockTokens","l","j","tokens","max","_rules","normalize","block","inline","linkify","replace","smartquotes","text_join","Core","ruler_default","i","state","rules","l","state_core_default","parser_core_default","StateBlock","src","md","env","tokens","s","start","pos","indent","offset","len","indent_found","ch","isSpace","type","tag","nesting","token","token_default","line","from","max","min","code","begin","end","keepLastLF","queue","i","lineIndent","lineStart","first","last","state_block_default","MAX_AUTOCOMPLETED_CELLS","getLine","state","line","pos","max","escapedSplit","str","result","ch","isEscaped","lastPos","current","table","startLine","endLine","silent","nextLine","firstCh","secondCh","isSpace","lineText","columns","aligns","i","t","columnCount","oldParentType","terminatorRules","token_to","tableLines","token_tho","token_htro","token_ho","token_il","tbodyLines","autocompletedCells","terminate","l","token_tbo","token_tro","token_tdo","code","state","startLine","endLine","nextLine","last","token","fence","state","startLine","endLine","silent","pos","max","marker","mem","len","markup","params","nextLine","haveEndMarker","token","blockquote","state","startLine","endLine","silent","pos","max","oldLineMax","oldBMarks","oldBSCount","oldSCount","oldTShift","terminatorRules","oldParentType","lastLineEmpty","nextLine","isOutdented","initial","spaceAfterMarker","adjustTab","offset","ch","isSpace","terminate","i","l","oldIndent","token_o","lines","token_c","hr","state","startLine","endLine","silent","max","pos","marker","cnt","ch","isSpace","token","skipBulletListMarker","state","startLine","max","pos","marker","ch","isSpace","skipOrderedListMarker","start","markTightParagraphs","idx","level","l","list","endLine","silent","token","nextLine","tight","isTerminatingParagraph","isOrdered","markerValue","posAfterMarker","markerCharCode","listTokIdx","listLines","prevEmptyEnd","terminatorRules","oldParentType","initial","offset","contentStart","indentAfterMarker","indent","itemLines","oldTight","oldTShift","oldSCount","oldListIndent","terminate","i","MAX_LABEL_LENGTH","countCodePoints","str","length","i","high","low","lineEnd","state","line","getNextLinePos","nextLine","endLine","isContinuation","terminatorRules","oldParentType","terminate","l","reference","startLine","_endLine","silent","src","pos","max","rawLabel","labelEnd","segmentStart","ch","nextPos","isSpace","destRes","href","destEndPos","destEndMax","destEndLineNo","titleStart","titleRes","title","label","normalizeReference","html_blocks_default","attr_name","unquoted","single_quoted","double_quoted","attr_value","attribute","open_tag","close_tag","comment","processing","declaration","cdata","HTML_TAG_RE","HTML_OPEN_CLOSE_TAG_RE","HTML_SEQUENCES","html_blocks_default","HTML_OPEN_CLOSE_TAG_RE","html_block","state","startLine","endLine","silent","pos","max","lineText","i","nextLine","endsOnBlankLine","token","heading","state","startLine","endLine","silent","pos","max","ch","level","isSpace","tmp","token_o","token_i","asciiTrim","token_c","lheading","state","startLine","endLine","terminatorRules","oldParentType","level","marker","nextLine","pos","max","terminate","i","l","content","asciiTrim","token_o","token_i","token_c","paragraph","state","startLine","endLine","terminatorRules","oldParentType","nextLine","terminate","i","l","content","asciiTrim","token_o","token_i","_rules","table","code","fence","blockquote","hr","list","reference","html_block","heading","lheading","paragraph","ParserBlock","ruler_default","i","state","startLine","endLine","rules","len","maxNesting","line","hasEmptyLines","prevLine","ok","src","md","env","outTokens","state_block_default","parser_block_default","StateInline","src","md","env","outTokens","token","token_default","type","tag","nesting","token_meta","start","canSplitWord","max","marker","lastChar","highSurr","pos","count","nextChar","lowSurr","isLastPunctChar","isMdAsciiPunct","isPunctCharCode","isNextPunctChar","isLastWhiteSpace","isWhiteSpace","isNextWhiteSpace","left_flanking","right_flanking","state_inline_default","isTerminatorChar","ch","text","state","silent","pos","isAsciiAlpha","code","isSchemeChar","linkify","state","silent","pos","max","protoMin","protoStart","protoLength","link","url","urlEnd","fullUrl","token_o","token_t","token_c","newline","state","silent","pos","pmax","max","ws","isSpace","ESCAPED","i","ch","escape","state","silent","pos","max","ch1","isSpace","token","escapedStr","ch2","origStr","backtick","state","silent","pos","start","max","marker","openerLength","matchEnd","matchStart","closerLength","token","strikethrough_tokenize","state","silent","start","marker","scanned","len","ch","token","i","postProcess","delimiters","loneMarkers","max","startDelim","endDelim","j","strikethrough_postProcess","tokens_meta","curr","strikethrough_default","emphasis_tokenize","state","silent","start","marker","scanned","i","token","postProcess","delimiters","max","startDelim","endDelim","isStrong","ch","token_o","token_c","emphasis_post_process","tokens_meta","curr","emphasis_default","link","state","silent","code","label","res","ref","href","title","start","parseReference","oldPos","max","labelStart","labelEnd","pos","isSpace","normalizeReference","token_o","attrs","image","state","silent","code","content","label","pos","ref","res","title","start","href","oldPos","max","labelStart","labelEnd","isSpace","normalizeReference","tokens","token","attrs","EMAIL_RE","AUTOLINK_RE","autolink","state","silent","pos","start","max","ch","url","fullUrl","token_o","token_t","token_c","isLinkOpen","str","isLinkClose","isLetter","ch","lc","scanSpecial","state","pos","src","start","terminator","end","html_inline","silent","max","match","HTML_OPEN_CLOSE_TAG_RE","token","decodeHTMLStrict","DIGITAL_RE","NAMED_RE","entity","state","silent","pos","max","match","code","token","isValidEntityCode","fromCodePoint","decoded","decodeHTMLStrict","processDelimiters","delimiters","openersBottom","max","headerIdx","lastTokenIdx","jumps","closerIdx","closer","minOpenerIdx","openerIdx","newMinOpenerIdx","opener","isOddMatch","lastJump","link_pairs","state","tokens_meta","curr","fragments_join","state","curr","last","level","tokens","max","_rules","text","linkify","newline","escape","backtick","strikethrough_default","emphasis_default","link","image","autolink","html_inline","entity","_rules2","link_pairs","fragments_join","ParserInline","ruler_default","i","state","pos","rules","len","maxNesting","cache","ok","end","prevPos","str","md","env","outTokens","state_inline_default","parser_inline_default","LinkifyIt","mdurl","punycode","default_default","zero_default","commonmark_default","config","default_default","zero_default","commonmark_default","BAD_PROTO_RE","GOOD_DATA_RE","validateLink","url","str","RECODE_HOSTNAME_FOR","normalizeLink","parsed","punycode","er","normalizeLinkText","MarkdownIt","presetName","options","isString","parser_inline_default","parser_block_default","parser_core_default","renderer_default","LinkifyIt","utils_exports","assign","helpers_exports","presets","self","name","list","ignoreInvalid","result","chain","missed","plugin","args","src","env","state","lib_default"],"sources":["../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/common/utils.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/helpers/index.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/helpers/parse_link_label.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/helpers/parse_link_destination.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/helpers/parse_link_title.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/renderer.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/ruler.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/token.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/state_core.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/normalize.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/block.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/inline.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/linkify.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/replacements.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/smartquotes.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_core/text_join.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/parser_core.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/state_block.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/table.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/code.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/fence.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/blockquote.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/hr.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/list.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/reference.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/common/html_blocks.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/common/html_re.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/html_block.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/heading.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/lheading.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_block/paragraph.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/parser_block.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/state_inline.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/text.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/linkify.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/newline.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/escape.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/backticks.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/strikethrough.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/emphasis.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/link.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/image.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/autolink.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/html_inline.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/entity.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/balance_pairs.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/rules_inline/fragments_join.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/parser_inline.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/index.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/presets/default.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/presets/zero.mjs","../esm/npm/markdown-it@14.3.3/node_modules/markdown-it/lib/presets/commonmark.mjs"],"sourcesContent":["// Utilities\n//\n\nimport * as mdurl from 'mdurl'\nimport * as ucmicro from 'uc.micro'\nimport { decodeHTML } from 'entities'\n\nfunction _class (obj) { return Object.prototype.toString.call(obj) }\n\nfunction isString (obj) { return _class(obj) === '[object String]' }\n\nconst _hasOwnProperty = Object.prototype.hasOwnProperty\n\nfunction has (object, key) {\n  return _hasOwnProperty.call(object, key)\n}\n\n// Merge objects\n//\nfunction assign (obj /* from1, from2, from3, ... */) {\n  const sources = Array.prototype.slice.call(arguments, 1)\n\n  sources.forEach(function (source) {\n    if (!source) { return }\n\n    if (typeof source !== 'object') {\n      throw new TypeError(source + 'must be object')\n    }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key]\n    })\n  })\n\n  return obj\n}\n\n// Remove element from array and put another array at those position.\n// Useful for some operations with tokens\nfunction arrayReplaceAt (src, pos, newElements) {\n  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1))\n}\n\nfunction isValidEntityCode (c) {\n  // broken sequence\n  if (c \u003e= 0xD800 \u0026\u0026 c \u003c= 0xDFFF) { return false }\n  // never used\n  if (c \u003e= 0xFDD0 \u0026\u0026 c \u003c= 0xFDEF) { return false }\n  if ((c \u0026 0xFFFF) === 0xFFFF || (c \u0026 0xFFFF) === 0xFFFE) { return false }\n  // control codes\n  if (c \u003e= 0x00 \u0026\u0026 c \u003c= 0x08) { return false }\n  if (c === 0x0B) { return false }\n  if (c \u003e= 0x0E \u0026\u0026 c \u003c= 0x1F) { return false }\n  if (c \u003e= 0x7F \u0026\u0026 c \u003c= 0x9F) { return false }\n  // out of range\n  if (c \u003e 0x10FFFF) { return false }\n  return true\n}\n\nfunction fromCodePoint (c) {\n  /* eslint no-bitwise:0 */\n  if (c \u003e 0xffff) {\n    c -= 0x10000\n    const surrogate1 = 0xd800 + (c \u003e\u003e 10)\n    const surrogate2 = 0xdc00 + (c \u0026 0x3ff)\n\n    return String.fromCharCode(surrogate1, surrogate2)\n  }\n  return String.fromCharCode(c)\n}\n\nconst UNESCAPE_MD_RE = /\\\\([!\"#$%\u0026'()*+,\\-./:;\u003c=\u003e?@[\\\\\\]^_`{|}~])/g\nconst ENTITY_RE = /\u0026([a-z#][a-z0-9]{1,31});/gi\nconst UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi')\n\nconst DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i\n\nfunction replaceEntityPattern (match, name) {\n  if (name.charCodeAt(0) === 0x23/* # */ \u0026\u0026 DIGITAL_ENTITY_TEST_RE.test(name)) {\n    const code = name[1].toLowerCase() === 'x'\n      ? parseInt(name.slice(2), 16)\n      : parseInt(name.slice(1), 10)\n\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code)\n    }\n\n    return match\n  }\n\n  const decoded = decodeHTML(match)\n  if (decoded !== match) {\n    return decoded\n  }\n\n  return match\n}\n\nfunction unescapeMd (str) {\n  if (str.indexOf('\\\\') \u003c 0) { return str }\n  return str.replace(UNESCAPE_MD_RE, '$1')\n}\n\nfunction unescapeAll (str) {\n  if (str.indexOf('\\\\') \u003c 0 \u0026\u0026 str.indexOf('\u0026') \u003c 0) { return str }\n\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) { return escaped }\n    return replaceEntityPattern(match, entity)\n  })\n}\n\nconst HTML_ESCAPE_TEST_RE = /[\u0026\u003c\u003e\"]/\nconst HTML_ESCAPE_REPLACE_RE = /[\u0026\u003c\u003e\"]/g\nconst HTML_REPLACEMENTS = {\n  '\u0026': '\u0026amp;',\n  '\u003c': '\u0026lt;',\n  '\u003e': '\u0026gt;',\n  '\"': '\u0026quot;'\n}\n\nfunction replaceUnsafeChar (ch) {\n  return HTML_REPLACEMENTS[ch]\n}\n\nfunction escapeHtml (str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar)\n  }\n  return str\n}\n\nconst REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g\n\nfunction escapeRE (str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$\u0026')\n}\n\nfunction isSpace (code) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true\n  }\n  return false\n}\n\n// Zs (unicode class) || [\\t\\f\\v\\r\\n]\nfunction isWhiteSpace (code) {\n  if (code \u003e= 0x2000 \u0026\u0026 code \u003c= 0x200A) { return true }\n  switch (code) {\n    case 0x09: // \\t\n    case 0x0A: // \\n\n    case 0x0B: // \\v\n    case 0x0C: // \\f\n    case 0x0D: // \\r\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true\n  }\n  return false\n}\n\n// Currently without astral characters support.\nfunction isPunctChar (ch) {\n  return ucmicro.P.test(ch) || ucmicro.S.test(ch)\n}\n\nfunction isPunctCharCode (code) {\n  return isPunctChar(fromCodePoint(code))\n}\n\n// Markdown ASCII punctuation characters.\n//\n// !, \", #, $, %, \u0026, ', (, ), *, +, ,, -, ., /, :, ;, \u003c, =, \u003e, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\n//\n// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.\n//\nfunction isMdAsciiPunct (ch) {\n  switch (ch) {\n    case 0x21/* ! */:\n    case 0x22/* \" */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* \u0026 */:\n    case 0x27/* ' */:\n    case 0x28/* ( */:\n    case 0x29/* ) */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2C/* , */:\n    case 0x2D/* - */:\n    case 0x2E/* . */:\n    case 0x2F/* / */:\n    case 0x3A/* : */:\n    case 0x3B/* ; */:\n    case 0x3C/* \u003c */:\n    case 0x3D/* = */:\n    case 0x3E/* \u003e */:\n    case 0x3F/* ? */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7C/* | */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true\n    default:\n      return false\n  }\n}\n\n// Hepler to unify [reference labels].\n//\nfunction normalizeReference (str) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' ')\n\n  // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug\n  // fixed in v12 (couldn't find any details).\n  //\n  // So treat this one as a special case\n  // (remove this when node v10 is no longer supported).\n  //\n  if ('ẞ'.toLowerCase() === 'Ṿ') {\n    /* c8 ignore next 2 */\n    str = str.replace(/ẞ/g, 'ß')\n  }\n\n  // .toLowerCase().toUpperCase() should get rid of all differences\n  // between letter variants.\n  //\n  // Simple .toLowerCase() doesn't normalize 125 code points correctly,\n  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:\n  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;\u003ccompat\u003e 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;\u003ccompat\u003e 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n  return str.toLowerCase().toUpperCase()\n}\n\nfunction isAsciiTrimmable (c) {\n  return c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d\n}\n\n// \"Light\" .trim() for blocks (headers, paragraphs), where unicode spaces\n// should be preserved.\nfunction asciiTrim (str) {\n  let start = 0\n  for (; start \u003c str.length; start++) {\n    if (!isAsciiTrimmable(str.charCodeAt(start))) {\n      break\n    }\n  }\n  let end = str.length - 1\n  for (; end \u003e= start; end--) {\n    if (!isAsciiTrimmable(str.charCodeAt(end))) {\n      break\n    }\n  }\n  return str.slice(start, end + 1)\n}\n\n// Re-export libraries commonly used in both markdown-it and its plugins,\n// so plugins won't have to depend on them explicitly, which reduces their\n// bundled size (e.g. a browser build).\n//\nconst lib = { mdurl, ucmicro }\n\nexport {\n  lib,\n  assign,\n  isString,\n  has,\n  unescapeMd,\n  unescapeAll,\n  isValidEntityCode,\n  fromCodePoint,\n  escapeHtml,\n  arrayReplaceAt,\n  isSpace,\n  isWhiteSpace,\n  isMdAsciiPunct,\n  isPunctChar,\n  isPunctCharCode,\n  escapeRE,\n  normalizeReference,\n  asciiTrim\n}\n","// Just a shortcut for bulk export\n\nimport parseLinkLabel from './parse_link_label.mjs'\nimport parseLinkDestination from './parse_link_destination.mjs'\nimport parseLinkTitle from './parse_link_title.mjs'\n\nexport {\n  parseLinkLabel,\n  parseLinkDestination,\n  parseLinkTitle\n}\n","// Parse link label\n//\n// this function assumes that first character (\"[\") already matches;\n// returns the end of the label\n//\n\nexport default function parseLinkLabel (state, start, disableNested) {\n  let level, found, marker, prevPos\n\n  const max = state.posMax\n  const oldPos = state.pos\n\n  state.pos = start + 1\n  level = 1\n\n  while (state.pos \u003c max) {\n    marker = state.src.charCodeAt(state.pos)\n    if (marker === 0x5D /* ] */) {\n      level--\n      if (level === 0) {\n        found = true\n        break\n      }\n    }\n\n    prevPos = state.pos\n    state.md.inline.skipToken(state)\n    if (marker === 0x5B /* [ */) {\n      if (prevPos === state.pos - 1) {\n        // increase level if we find text `[`, which is not a part of any token\n        level++\n      } else if (disableNested) {\n        state.pos = oldPos\n        return -1\n      }\n    }\n  }\n\n  let labelEnd = -1\n\n  if (found) {\n    labelEnd = state.pos\n  }\n\n  // restore old state\n  state.pos = oldPos\n\n  return labelEnd\n}\n","// Parse link destination\n//\n\nimport { unescapeAll } from '../common/utils.mjs'\n\nexport default function parseLinkDestination (str, start, max) {\n  let code\n  let pos = start\n\n  const result = {\n    ok: false,\n    pos: 0,\n    str: ''\n  }\n\n  if (str.charCodeAt(pos) === 0x3C /* \u003c */) {\n    pos++\n    while (pos \u003c max) {\n      code = str.charCodeAt(pos)\n      if (code === 0x0A /* \\n */) { return result }\n      if (code === 0x3C /* \u003c */) { return result }\n      if (code === 0x3E /* \u003e */) {\n        result.pos = pos + 1\n        result.str = unescapeAll(str.slice(start + 1, pos))\n        result.ok = true\n        return result\n      }\n      if (code === 0x5C /* \\ */ \u0026\u0026 pos + 1 \u003c max) {\n        pos += 2\n        continue\n      }\n\n      pos++\n    }\n\n    // no closing '\u003e'\n    return result\n  }\n\n  // this should be ... } else { ... branch\n\n  let level = 0\n  while (pos \u003c max) {\n    code = str.charCodeAt(pos)\n\n    if (code === 0x20) { break }\n\n    // ascii control characters\n    if (code \u003c 0x20 || code === 0x7F) { break }\n\n    if (code === 0x5C /* \\ */ \u0026\u0026 pos + 1 \u003c max) {\n      if (str.charCodeAt(pos + 1) === 0x20) { pos++; continue }\n      pos += 2\n      continue\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++\n      if (level \u003e 32) { return result }\n    }\n\n    if (code === 0x29 /* ) */) {\n      if (level === 0) { break }\n      level--\n    }\n\n    pos++\n  }\n\n  if (start === pos) { return result }\n  if (level !== 0) { return result }\n\n  result.str = unescapeAll(str.slice(start, pos))\n  result.pos = pos\n  result.ok = true\n  return result\n}\n","// Parse link title\n//\n\nimport { unescapeAll } from '../common/utils.mjs'\n\n// Parse link title within `str` in [start, max] range,\n// or continue previous parsing if `prev_state` is defined (equal to result of last execution).\n//\nexport default function parseLinkTitle (str, start, max, prev_state) {\n  let code\n  let pos = start\n\n  const state = {\n    // if `true`, this is a valid link title\n    ok: false,\n    // if `true`, this link can be continued on the next line\n    can_continue: false,\n    // if `ok`, it's the position of the first character after the closing marker\n    pos: 0,\n    // if `ok`, it's the unescaped title\n    str: '',\n    // expected closing marker character code\n    marker: 0\n  }\n\n  if (prev_state) {\n    // this is a continuation of a previous parseLinkTitle call on the next line,\n    // used in reference links only\n    state.str = prev_state.str\n    state.marker = prev_state.marker\n  } else {\n    if (pos \u003e= max) { return state }\n\n    let marker = str.charCodeAt(pos)\n    if (marker !== 0x22 /* \" */ \u0026\u0026 marker !== 0x27 /* ' */ \u0026\u0026 marker !== 0x28 /* ( */) { return state }\n\n    start++\n    pos++\n\n    // if opening marker is \"(\", switch it to closing marker \")\"\n    if (marker === 0x28) { marker = 0x29 }\n\n    state.marker = marker\n  }\n\n  while (pos \u003c max) {\n    code = str.charCodeAt(pos)\n    if (code === state.marker) {\n      state.pos = pos + 1\n      state.str += unescapeAll(str.slice(start, pos))\n      state.ok = true\n      return state\n    } else if (code === 0x28 /* ( */ \u0026\u0026 state.marker === 0x29 /* ) */) {\n      return state\n    } else if (code === 0x5C /* \\ */ \u0026\u0026 pos + 1 \u003c max) {\n      pos++\n    }\n\n    pos++\n  }\n\n  // no closing marker found, but this link title may continue on the next line (for references)\n  state.can_continue = true\n  state.str += unescapeAll(str.slice(start, pos))\n  return state\n}\n","/**\n * class Renderer\n *\n * Generates HTML from parsed token stream. Each instance has independent\n * copy of rules. Those can be rewritten with ease. Also, you can add new\n * rules if you create plugin and adds new token types.\n **/\n\nimport { assign, unescapeAll, escapeHtml } from './common/utils.mjs'\n\nconst default_rules = {}\n\ndefault_rules.code_inline = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx]\n\n  return '\u003ccode' + slf.renderAttrs(token) + '\u003e' +\n          escapeHtml(token.content) +\n          '\u003c/code\u003e'\n}\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx]\n\n  return '\u003cpre' + slf.renderAttrs(token) + '\u003e\u003ccode\u003e' +\n          escapeHtml(tokens[idx].content) +\n          '\u003c/code\u003e\u003c/pre\u003e\\n'\n}\n\ndefault_rules.fence = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx]\n  const info = token.info ? unescapeAll(token.info).trim() : ''\n  let langName = ''\n  let langAttrs = ''\n\n  if (info) {\n    const arr = info.split(/(\\s+)/g)\n    langName = arr[0]\n    langAttrs = arr.slice(2).join('')\n  }\n\n  let highlighted\n  if (options.highlight) {\n    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content)\n  } else {\n    highlighted = escapeHtml(token.content)\n  }\n\n  if (highlighted.indexOf('\u003cpre') === 0) {\n    return highlighted + '\\n'\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .deepClone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    const i = token.attrIndex('class')\n    const tmpAttrs = token.attrs ? token.attrs.slice() : []\n\n    if (i \u003c 0) {\n      tmpAttrs.push(['class', options.langPrefix + langName])\n    } else {\n      tmpAttrs[i] = tmpAttrs[i].slice()\n      tmpAttrs[i][1] += ' ' + options.langPrefix + langName\n    }\n\n    // Fake token just to render attributes\n    const tmpToken = {\n      attrs: tmpAttrs\n    }\n\n    return `\u003cpre\u003e\u003ccode${slf.renderAttrs(tmpToken)}\u003e${highlighted}\u003c/code\u003e\u003c/pre\u003e\\n`\n  }\n\n  return `\u003cpre\u003e\u003ccode${slf.renderAttrs(token)}\u003e${highlighted}\u003c/code\u003e\u003c/pre\u003e\\n`\n}\n\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx]\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs[token.attrIndex('alt')][1] =\n    slf.renderInlineAsText(token.children, options, env)\n\n  return slf.renderToken(tokens, idx, options)\n}\n\ndefault_rules.hardbreak = function (tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '\u003cbr /\u003e\\n' : '\u003cbr\u003e\\n'\n}\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '\u003cbr /\u003e\\n' : '\u003cbr\u003e\\n') : '\\n'\n}\n\ndefault_rules.text = function (tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content)\n}\n\ndefault_rules.html_block = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content\n}\ndefault_rules.html_inline = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content\n}\n\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\nfunction Renderer () {\n  /**\n   * Renderer#rules -\u003e Object\n   *\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * md.renderer.rules.strong_open  = function () { return '\u003cb\u003e'; };\n   * md.renderer.rules.strong_close = function () { return '\u003c/b\u003e'; };\n   *\n   * var result = md.renderInline(...);\n   * ```\n   *\n   * Each rule is called as independent static function with fixed signature:\n   *\n   * ```javascript\n   * function my_token_render(tokens, idx, options, env, renderer) {\n   *   // ...\n   *   return renderedHTML;\n   * }\n   * ```\n   *\n   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)\n   * for more details and examples.\n   **/\n  this.rules = assign({}, default_rules)\n}\n\n/**\n * Renderer.renderAttrs(token) -\u003e String\n *\n * Render token attributes to string.\n **/\nRenderer.prototype.renderAttrs = function renderAttrs (token) {\n  let i, l, result\n\n  if (!token.attrs) { return '' }\n\n  result = ''\n\n  for (i = 0, l = token.attrs.length; i \u003c l; i++) {\n    result += ' ' + escapeHtml(token.attrs[i][0]) + '=\"' + escapeHtml(token.attrs[i][1]) + '\"'\n  }\n\n  return result\n}\n\n/**\n * Renderer.renderToken(tokens, idx, options) -\u003e String\n * - tokens (Array): list of tokens\n * - idx (Numbed): token index to render\n * - options (Object): params of parser instance\n *\n * Default token renderer. Can be overriden by custom function\n * in [[Renderer#rules]].\n **/\nRenderer.prototype.renderToken = function renderToken (tokens, idx, options) {\n  const token = tokens[idx]\n  let result = ''\n\n  // Tight list paragraphs\n  if (token.hidden) {\n    return ''\n  }\n\n  // Insert a newline between hidden paragraph and subsequent opening\n  // block-level tag.\n  //\n  // For example, here we should insert a newline before blockquote:\n  //  - a\n  //    \u003e\n  //\n  if (token.block \u0026\u0026 token.nesting !== -1 \u0026\u0026 idx \u0026\u0026 tokens[idx - 1].hidden) {\n    result += '\\n'\n  }\n\n  // Add token name, e.g. `\u003cimg`\n  result += (token.nesting === -1 ? '\u003c/' : '\u003c') + token.tag\n\n  // Encode attributes, e.g. `\u003cimg src=\"foo\"`\n  result += this.renderAttrs(token)\n\n  // Add a slash for self-closing tags, e.g. `\u003cimg src=\"foo\" /`\n  if (token.nesting === 0 \u0026\u0026 options.xhtmlOut) {\n    result += ' /'\n  }\n\n  // Check if we need to add a newline after this tag\n  let needLf = false\n  if (token.block) {\n    needLf = true\n\n    if (token.nesting === 1) {\n      if (idx + 1 \u003c tokens.length) {\n        const nextToken = tokens[idx + 1]\n\n        if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n          needLf = false\n        } else if (nextToken.nesting === -1 \u0026\u0026 nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `\u003cli\u003e\u003c/li\u003e`.\n          //\n          needLf = false\n        }\n      }\n    }\n  }\n\n  result += needLf ? '\u003e\\n' : '\u003e'\n\n  return result\n}\n\n/**\n * Renderer.renderInline(tokens, options, env) -\u003e String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * The same as [[Renderer.render]], but for single token of `inline` type.\n **/\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  let result = ''\n  const rules = this.rules\n\n  for (let i = 0, len = tokens.length; i \u003c len; i++) {\n    const type = tokens[i].type\n\n    if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this)\n    } else {\n      result += this.renderToken(tokens, i, options)\n    }\n  }\n\n  return result\n}\n\n/** internal\n * Renderer.renderInlineAsText(tokens, options, env) -\u003e String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Special kludge for image `alt` attributes to conform CommonMark spec.\n * Don't try to use it! Spec requires to show `alt` content with stripped markup,\n * instead of simple escaping.\n **/\nRenderer.prototype.renderInlineAsText = function (tokens, options, env) {\n  let result = ''\n\n  for (let i = 0, len = tokens.length; i \u003c len; i++) {\n    switch (tokens[i].type) {\n      case 'text':\n        result += tokens[i].content\n        break\n      case 'image':\n        result += this.renderInlineAsText(tokens[i].children, options, env)\n        break\n      case 'html_inline':\n      case 'html_block':\n        result += tokens[i].content\n        break\n      case 'softbreak':\n      case 'hardbreak':\n        result += '\\n'\n        break\n      default:\n        // all other tokens are skipped\n    }\n  }\n\n  return result\n}\n\n/**\n * Renderer.render(tokens, options, env) -\u003e String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Takes token stream and generates HTML. Probably, you will never need to call\n * this method directly.\n **/\nRenderer.prototype.render = function (tokens, options, env) {\n  let result = ''\n  const rules = this.rules\n\n  for (let i = 0, len = tokens.length; i \u003c len; i++) {\n    const type = tokens[i].type\n\n    if (type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env)\n    } else if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this)\n    } else {\n      result += this.renderToken(tokens, i, options, env)\n    }\n  }\n\n  return result\n}\n\nexport default Renderer\n","/**\n * class Ruler\n *\n * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and\n * [[MarkdownIt#inline]] to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and\n * [[MarkdownIt.use]].\n **/\n\n/**\n * new Ruler()\n **/\nfunction Ruler () {\n  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\n  this.__rules__ = []\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null\n}\n\n// Helper methods, should not be used directly\n\n// Find rule index by name\n//\nRuler.prototype.__find__ = function (name) {\n  for (let i = 0; i \u003c this.__rules__.length; i++) {\n    if (this.__rules__[i].name === name) {\n      return i\n    }\n  }\n  return -1\n}\n\n// Build rules lookup cache\n//\nRuler.prototype.__compile__ = function () {\n  const self = this\n  const chains = ['']\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) { return }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) \u003c 0) {\n        chains.push(altName)\n      }\n    })\n  })\n\n  self.__cache__ = {}\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = []\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) { return }\n\n      if (chain \u0026\u0026 rule.alt.indexOf(chain) \u003c 0) { return }\n\n      self.__cache__[chain].push(rule.fn)\n    })\n  })\n}\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function \u0026 options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing typographer replacement rule with new one:\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.at('replacements', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.at = function (name, fn, options) {\n  const index = this.__find__(name)\n  const opt = options || {}\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + name) }\n\n  this.__rules__[index].fn = fn\n  this.__rules__[index].alt = opt.alt || []\n  this.__cache__ = null\n}\n\n/**\n * Ruler.before(beforeName, ruleName, fn [, options])\n * - beforeName (String): new rule will be added before this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain before one with given name. See also\n * [[Ruler.after]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  const index = this.__find__(beforeName)\n  const opt = options || {}\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName) }\n\n  this.__rules__.splice(index, 0, {\n    name: ruleName,\n    enabled: true,\n    fn,\n    alt: opt.alt || []\n  })\n\n  this.__cache__ = null\n}\n\n/**\n * Ruler.after(afterName, ruleName, fn [, options])\n * - afterName (String): new rule will be added after this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain after one with given name. See also\n * [[Ruler.before]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.inline.ruler.after('text', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  const index = this.__find__(afterName)\n  const opt = options || {}\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + afterName) }\n\n  this.__rules__.splice(index + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn,\n    alt: opt.alt || []\n  })\n\n  this.__cache__ = null\n}\n\n/**\n * Ruler.push(ruleName, fn [, options])\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Push new rule to the end of chain. See also\n * [[Ruler.before]], [[Ruler.after]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.push('my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.push = function (ruleName, fn, options) {\n  const opt = options || {}\n\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn,\n    alt: opt.alt || []\n  })\n\n  this.__cache__ = null\n}\n\n/**\n * Ruler.enable(list [, ignoreInvalid]) -\u003e Array\n * - list (String|Array): list of rule names to enable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.disable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [list] }\n\n  const result = []\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    const idx = this.__find__(name)\n\n    if (idx \u003c 0) {\n      if (ignoreInvalid) { return }\n      throw new Error('Rules manager: invalid rule name ' + name)\n    }\n    this.__rules__[idx].enabled = true\n    result.push(name)\n  }, this)\n\n  this.__cache__ = null\n  return result\n}\n\n/**\n * Ruler.enableOnly(list [, ignoreInvalid])\n * - list (String|Array): list of rule names to enable (whitelist).\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names, and disable everything else. If any rule name\n * not found - throw Error. Errors can be disabled by second param.\n *\n * See also [[Ruler.disable]], [[Ruler.enable]].\n **/\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [list] }\n\n  this.__rules__.forEach(function (rule) { rule.enabled = false })\n\n  this.enable(list, ignoreInvalid)\n}\n\n/**\n * Ruler.disable(list [, ignoreInvalid]) -\u003e Array\n * - list (String|Array): list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Disable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.enable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [list] }\n\n  const result = []\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    const idx = this.__find__(name)\n\n    if (idx \u003c 0) {\n      if (ignoreInvalid) { return }\n      throw new Error('Rules manager: invalid rule name ' + name)\n    }\n    this.__rules__[idx].enabled = false\n    result.push(name)\n  }, this)\n\n  this.__cache__ = null\n  return result\n}\n\n/**\n * Ruler.getRules(chainName) -\u003e Array\n *\n * Return array of active functions (rules) for given chain name. It analyzes\n * rules configuration, compiles caches if not exists and returns result.\n *\n * Default chain name is `''` (empty string). It can't be skipped. That's\n * done intentionally, to keep signature monomorphic for high speed.\n **/\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__()\n  }\n\n  // Chain can be empty, if rules disabled. But we still have to return Array.\n  return this.__cache__[chainName] || []\n}\n\nexport default Ruler\n","// Token class\n\n/**\n * class Token\n **/\n\n/**\n * new Token(type, tag, nesting)\n *\n * Create new token and fill passed properties.\n **/\nfunction Token (type, tag, nesting) {\n  /**\n   * Token#type -\u003e String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type = type\n\n  /**\n   * Token#tag -\u003e String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag = tag\n\n  /**\n   * Token#attrs -\u003e Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs = null\n\n  /**\n   * Token#map -\u003e Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map = null\n\n  /**\n   * Token#nesting -\u003e Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n  this.nesting = nesting\n\n  /**\n   * Token#level -\u003e Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level = 0\n\n  /**\n   * Token#children -\u003e Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null\n\n  /**\n   * Token#content -\u003e String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content = ''\n\n  /**\n   * Token#markup -\u003e String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup = ''\n\n  /**\n   * Token#info -\u003e String\n   *\n   * Additional information:\n   *\n   * - Info string for \"fence\" tokens\n   * - The value \"auto\" for autolink \"link_open\" and \"link_close\" tokens\n   * - The string value of the item marker for ordered-list \"list_item_open\" tokens\n   **/\n  this.info = ''\n\n  /**\n   * Token#meta -\u003e Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta = null\n\n  /**\n   * Token#block -\u003e Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block = false\n\n  /**\n   * Token#hidden -\u003e Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden = false\n}\n\n/**\n * Token.attrIndex(name) -\u003e Number\n *\n * Search attribute index by name.\n **/\nToken.prototype.attrIndex = function attrIndex (name) {\n  if (!this.attrs) { return -1 }\n\n  const attrs = this.attrs\n\n  for (let i = 0, len = attrs.length; i \u003c len; i++) {\n    if (attrs[i][0] === name) { return i }\n  }\n  return -1\n}\n\n/**\n * Token.attrPush(attrData)\n *\n * Add `[ name, value ]` attribute to list. Init attrs if necessary\n **/\nToken.prototype.attrPush = function attrPush (attrData) {\n  if (this.attrs) {\n    this.attrs.push(attrData)\n  } else {\n    this.attrs = [attrData]\n  }\n}\n\n/**\n * Token.attrSet(name, value)\n *\n * Set `name` attribute to `value`. Override old value if exists.\n **/\nToken.prototype.attrSet = function attrSet (name, value) {\n  const idx = this.attrIndex(name)\n  const attrData = [name, value]\n\n  if (idx \u003c 0) {\n    this.attrPush(attrData)\n  } else {\n    this.attrs[idx] = attrData\n  }\n}\n\n/**\n * Token.attrGet(name)\n *\n * Get the value of attribute `name`, or null if it does not exist.\n **/\nToken.prototype.attrGet = function attrGet (name) {\n  const idx = this.attrIndex(name)\n  let value = null\n  if (idx \u003e= 0) {\n    value = this.attrs[idx][1]\n  }\n  return value\n}\n\n/**\n * Token.attrJoin(name, value)\n *\n * Join value to existing attribute via space. Or create new attribute if not\n * exists. Useful to operate with token classes.\n **/\nToken.prototype.attrJoin = function attrJoin (name, value) {\n  const idx = this.attrIndex(name)\n\n  if (idx \u003c 0) {\n    this.attrPush([name, value])\n  } else {\n    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value\n  }\n}\n\nexport default Token\n","// Core state object\n//\n\nimport Token from '../token.mjs'\n\nfunction StateCore (src, md, env) {\n  this.src = src\n  this.env = env\n  this.tokens = []\n  this.inlineMode = false\n  this.md = md // link to parser instance\n}\n\n// re-export Token class to use in core rules\nStateCore.prototype.Token = Token\n\nexport default StateCore\n","// Normalize input string\n\n// https://spec.commonmark.org/0.29/#line-ending\nconst NEWLINES_RE = /\\r\\n?|\\n/g\nconst NULL_RE = /\\0/g\n\nexport default function normalize (state) {\n  let str\n\n  // Normalize newlines\n  str = state.src.replace(NEWLINES_RE, '\\n')\n\n  // Replace NULL characters\n  str = str.replace(NULL_RE, '\\uFFFD')\n\n  state.src = str\n}\n","export default function block (state) {\n  let token\n\n  if (state.inlineMode) {\n    token = new state.Token('inline', '', 0)\n    token.content = state.src\n    token.map = [0, 1]\n    token.children = []\n    state.tokens.push(token)\n  } else {\n    state.md.block.parse(state.src, state.md, state.env, state.tokens)\n  }\n}\n","export default function inline (state) {\n  const tokens = state.tokens\n\n  // Parse inlines\n  for (let i = 0, l = tokens.length; i \u003c l; i++) {\n    const tok = tokens[i]\n    if (tok.type === 'inline') {\n      state.md.inline.parse(tok.content, state.md, state.env, tok.children)\n    }\n  }\n}\n","// Replace link-like texts with link nodes.\n//\n// Currently restricted by `md.validateLink()` to http/https/ftp\n//\n\nfunction isLinkOpen (str) {\n  return /^\u003ca[\u003e\\s]/i.test(str)\n}\nfunction isLinkClose (str) {\n  return /^\u003c\\/a\\s*\u003e/i.test(str)\n}\n\nexport default function linkify (state) {\n  const blockTokens = state.tokens\n\n  if (!state.md.options.linkify) { return }\n\n  for (let j = 0, l = blockTokens.length; j \u003c l; j++) {\n    if (blockTokens[j].type !== 'inline' ||\n        !state.md.linkify.pretest(blockTokens[j].content)) {\n      continue\n    }\n\n    const tokens = blockTokens[j].children\n    const replacements = []\n\n    let htmlLinkLevel = 0\n\n    // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n    for (let i = tokens.length - 1; i \u003e= 0; i--) {\n      const currentToken = tokens[i]\n\n      // Skip content of markdown links\n      if (currentToken.type === 'link_close') {\n        i--\n        while (tokens[i].level !== currentToken.level \u0026\u0026 tokens[i].type !== 'link_open') {\n          i--\n        }\n        continue\n      }\n\n      // Skip content of html tag links\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen(currentToken.content) \u0026\u0026 htmlLinkLevel \u003e 0) {\n          htmlLinkLevel--\n        }\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++\n        }\n      }\n      if (htmlLinkLevel \u003e 0) { continue }\n\n      if (currentToken.type === 'text' \u0026\u0026 state.md.linkify.test(currentToken.content)) {\n        const text = currentToken.content\n        let links = state.md.linkify.match(text)\n\n        // Now split string to nodes\n        const nodes = []\n        let level = currentToken.level\n        let lastPos = 0\n\n        // forbid escape sequence at the start of the string,\n        // this avoids http\\://example.com/ from being linkified as\n        // http:\u003ca href=\"//example.com/\"\u003e//example.com/\u003c/a\u003e\n        if (links.length \u003e 0 \u0026\u0026\n            links[0].index === 0 \u0026\u0026\n            i \u003e 0 \u0026\u0026\n            tokens[i - 1].type === 'text_special') {\n          links = links.slice(1)\n        }\n\n        for (let ln = 0; ln \u003c links.length; ln++) {\n          const url = links[ln].url\n          const fullUrl = state.md.normalizeLink(url)\n          if (!state.md.validateLink(fullUrl)) { continue }\n\n          let urlText = links[ln].text\n\n          // Linkifier might send raw hostnames like \"example.com\", where url\n          // starts with domain name. So we prepend http:// in those cases,\n          // and remove it afterwards.\n          //\n          if (!links[ln].schema) {\n            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\\/\\//, '')\n          } else if (links[ln].schema === 'mailto:' \u0026\u0026 !/^mailto:/i.test(urlText)) {\n            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '')\n          } else {\n            urlText = state.md.normalizeLinkText(urlText)\n          }\n\n          const pos = links[ln].index\n\n          if (pos \u003e lastPos) {\n            const token = new state.Token('text', '', 0)\n            token.content = text.slice(lastPos, pos)\n            token.level = level\n            nodes.push(token)\n          }\n\n          const token_o = new state.Token('link_open', 'a', 1)\n          token_o.attrs = [['href', fullUrl]]\n          token_o.level = level++\n          token_o.markup = 'linkify'\n          token_o.info = 'auto'\n          nodes.push(token_o)\n\n          const token_t = new state.Token('text', '', 0)\n          token_t.content = urlText\n          token_t.level = level\n          nodes.push(token_t)\n\n          const token_c = new state.Token('link_close', 'a', -1)\n          token_c.level = --level\n          token_c.markup = 'linkify'\n          token_c.info = 'auto'\n          nodes.push(token_c)\n\n          lastPos = links[ln].lastIndex\n        }\n        if (lastPos \u003c text.length) {\n          const token = new state.Token('text', '', 0)\n          token.content = text.slice(lastPos)\n          token.level = level\n          nodes.push(token)\n        }\n\n        replacements.push({ index: i, nodes })\n      }\n    }\n\n    if (replacements.length \u003e 0) {\n      let newTokensLength = tokens.length\n      for (const replacement of replacements) {\n        newTokensLength += replacement.nodes.length - 1\n      }\n\n      const newTokens = new Array(newTokensLength)\n      let replacementIndex = 0\n      let newTokenIndex = 0\n\n      replacements.reverse()\n\n      for (let i = 0; i \u003c tokens.length; i++) {\n        const replacement = replacements[replacementIndex]\n\n        if (replacement?.index === i) {\n          for (const node of replacement.nodes) {\n            newTokens[newTokenIndex++] = node\n          }\n          replacementIndex++\n        } else {\n          newTokens[newTokenIndex++] = tokens[i]\n        }\n      }\n\n      blockTokens[j].children = newTokens\n    }\n  }\n}\n","// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → \u0026ndash;, --- → \u0026mdash;\n//\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -\u003e ½, ¼, ¾\n// - multiplications 2 x 4 -\u003e 2 × 4\n\nconst RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/\n\n// Workaround for phantomjs - need regex without /g flag,\n// or root check will fail every second time\nconst SCOPED_ABBR_TEST_RE = /\\((c|tm|r)\\)/i\n\nconst SCOPED_ABBR_RE = /\\((c|tm|r)\\)/ig\nconst SCOPED_ABBR = {\n  c: '©',\n  r: '®',\n  tm: '™'\n}\n\nfunction replaceFn (match, name) {\n  return SCOPED_ABBR[name.toLowerCase()]\n}\n\nfunction replace_scoped (inlineTokens) {\n  let inside_autolink = 0\n\n  for (let i = inlineTokens.length - 1; i \u003e= 0; i--) {\n    const token = inlineTokens[i]\n\n    if (token.type === 'text' \u0026\u0026 !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn)\n    }\n\n    if (token.type === 'link_open' \u0026\u0026 token.info === 'auto') {\n      inside_autolink--\n    }\n\n    if (token.type === 'link_close' \u0026\u0026 token.info === 'auto') {\n      inside_autolink++\n    }\n  }\n}\n\nfunction replace_rare (inlineTokens) {\n  let inside_autolink = 0\n\n  for (let i = inlineTokens.length - 1; i \u003e= 0; i--) {\n    const token = inlineTokens[i]\n\n    if (token.type === 'text' \u0026\u0026 !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content\n          .replace(/\\+-/g, '±')\n          // .., ..., ....... -\u003e …\n          // but ?..... \u0026 !..... -\u003e ?.. \u0026 !..\n          .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..')\n          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n          // em-dash\n          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\\u2014')\n          // en-dash\n          .replace(/(^|\\s)--(?=\\s|$)/mg, '$1\\u2013')\n          .replace(/(^|[^-\\s])--(?=[^-\\s]|$)/mg, '$1\\u2013')\n      }\n    }\n\n    if (token.type === 'link_open' \u0026\u0026 token.info === 'auto') {\n      inside_autolink--\n    }\n\n    if (token.type === 'link_close' \u0026\u0026 token.info === 'auto') {\n      inside_autolink++\n    }\n  }\n}\n\nexport default function replace (state) {\n  let blkIdx\n\n  if (!state.md.options.typographer) { return }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx \u003e= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline') { continue }\n\n    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {\n      replace_scoped(state.tokens[blkIdx].children)\n    }\n\n    if (RARE_RE.test(state.tokens[blkIdx].content)) {\n      replace_rare(state.tokens[blkIdx].children)\n    }\n  }\n}\n","// Convert straight quotation marks to typographic ones\n//\n\nimport { isWhiteSpace, isPunctCharCode, isMdAsciiPunct } from '../common/utils.mjs'\n\nconst QUOTE_TEST_RE = /['\"]/\nconst QUOTE_RE = /['\"]/g\nconst APOSTROPHE = '\\u2019' /* ’ */\n// Caps memory on malicious input\nconst MAX_OPENERS = 1000\n\nfunction truncateStack (stack, heads, length) {\n  while (stack.length \u003e length) {\n    const item = stack.pop()\n    if (item.isSingleQuote) {\n      heads.single = item.prevSameQuoteIdx\n    } else {\n      heads.double = item.prevSameQuoteIdx\n    }\n  }\n}\n\nfunction addReplacement (replacements, tokenIdx, pos, ch) {\n  if (!replacements[tokenIdx]) {\n    replacements[tokenIdx] = []\n  }\n\n  replacements[tokenIdx].push({ pos, ch })\n}\n\nfunction applyReplacements (str, replacements) {\n  let result = ''\n  let lastPos = 0\n\n  replacements.sort((a, b) =\u003e a.pos - b.pos)\n\n  for (let i = 0; i \u003c replacements.length; i++) {\n    const replacement = replacements[i]\n\n    result += str.slice(lastPos, replacement.pos) + replacement.ch\n    lastPos = replacement.pos + 1\n  }\n\n  return result + str.slice(lastPos)\n}\n\nfunction process_inlines (tokens, state) {\n  let j\n\n  const stack = []\n  // stack indexes of topmost openers of each type (-1 if none)\n  const heads = { single: -1, double: -1 }\n  // token index -\u003e list of replacements in the original token content\n  const replacements = {}\n\n  for (let i = 0; i \u003c tokens.length; i++) {\n    const token = tokens[i]\n\n    const thisLevel = tokens[i].level\n\n    for (j = stack.length - 1; j \u003e= 0; j--) {\n      if (stack[j].level \u003c= thisLevel) { break }\n    }\n    truncateStack(stack, heads, j + 1)\n\n    if (token.type !== 'text') { continue }\n\n    const text = token.content\n    let pos = 0\n    const max = text.length\n\n    /* eslint no-labels:0,block-scoped-var:0 */\n    OUTER:\n    while (pos \u003c max) {\n      QUOTE_RE.lastIndex = pos\n      const t = QUOTE_RE.exec(text)\n      if (!t) { break }\n\n      let canOpen = true\n      let canClose = true\n      pos = t.index + 1\n      const isSingle = (t[0] === \"'\")\n\n      // Find previous character,\n      // default to space if it's the beginning of the line\n      //\n      let lastChar = 0x20\n\n      if (t.index - 1 \u003e= 0) {\n        lastChar = text.charCodeAt(t.index - 1)\n      } else {\n        for (j = i - 1; j \u003e= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // lastChar defaults to 0x20\n          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1)\n          break\n        }\n      }\n\n      // Find next character,\n      // default to space if it's the end of the line\n      //\n      let nextChar = 0x20\n\n      if (pos \u003c max) {\n        nextChar = text.charCodeAt(pos)\n      } else {\n        for (j = i + 1; j \u003c tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // nextChar defaults to 0x20\n          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          nextChar = tokens[j].content.charCodeAt(0)\n          break\n        }\n      }\n\n      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar)\n      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar)\n\n      const isLastWhiteSpace = isWhiteSpace(lastChar)\n      const isNextWhiteSpace = isWhiteSpace(nextChar)\n\n      if (isNextWhiteSpace) {\n        canOpen = false\n      } else if (isNextPunctChar) {\n        if (!(isLastWhiteSpace || isLastPunctChar)) {\n          canOpen = false\n        }\n      }\n\n      if (isLastWhiteSpace) {\n        canClose = false\n      } else if (isLastPunctChar) {\n        if (!(isNextWhiteSpace || isNextPunctChar)) {\n          canClose = false\n        }\n      }\n\n      if (nextChar === 0x22 /* \" */ \u0026\u0026 t[0] === '\"') {\n        if (lastChar \u003e= 0x30 /* 0 */ \u0026\u0026 lastChar \u003c= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false\n        }\n      }\n\n      if (canOpen \u0026\u0026 canClose) {\n        // Replace quotes in the middle of punctuation sequence, but not\n        // in the middle of the words, i.e.:\n        //\n        // 1. foo \" bar \" baz - not replaced\n        // 2. foo-\"-bar-\"-baz - replaced\n        // 3. foo\"bar\"baz     - not replaced\n        //\n        canOpen = isLastPunctChar\n        canClose = isNextPunctChar\n      }\n\n      if (!canOpen \u0026\u0026 !canClose) {\n        // middle of word\n        if (isSingle) {\n          addReplacement(replacements, i, t.index, APOSTROPHE)\n        }\n        continue\n      }\n\n      if (canClose) {\n        // Stack levels never decrease, so an opener of this type below\n        // the current level means there is no match\n        j = isSingle ? heads.single : heads.double\n        if (j \u003e= 0 \u0026\u0026 stack[j].level === thisLevel) {\n          const item = stack[j]\n\n          let openQuote\n          let closeQuote\n          if (isSingle) {\n            openQuote = state.md.options.quotes[2]\n            closeQuote = state.md.options.quotes[3]\n          } else {\n            openQuote = state.md.options.quotes[0]\n            closeQuote = state.md.options.quotes[1]\n          }\n\n          addReplacement(replacements, i, t.index, closeQuote)\n          addReplacement(replacements, item.tokenIdx, item.contentPos, openQuote)\n\n          truncateStack(stack, heads, j)\n          continue OUTER\n        }\n      }\n\n      if (canOpen) {\n        if (stack.length \u003e= MAX_OPENERS) { return }\n        stack.push({\n          tokenIdx: i,\n          contentPos: t.index,\n          isSingleQuote: isSingle,\n          level: thisLevel,\n          // stack index of the previous opener of the same quote type, -1 if none\n          prevSameQuoteIdx: isSingle ? heads.single : heads.double\n        })\n        if (isSingle) {\n          heads.single = stack.length - 1\n        } else {\n          heads.double = stack.length - 1\n        }\n      } else if (canClose \u0026\u0026 isSingle) {\n        addReplacement(replacements, i, t.index, APOSTROPHE)\n      }\n    }\n  }\n\n  Object.keys(replacements).forEach(function (tokenIdx) {\n    tokens[tokenIdx].content = applyReplacements(tokens[tokenIdx].content, replacements[tokenIdx])\n  })\n}\n\nexport default function smartquotes (state) {\n  /* eslint max-depth:0 */\n  if (!state.md.options.typographer) { return }\n\n  for (let blkIdx = state.tokens.length - 1; blkIdx \u003e= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline' ||\n        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {\n      continue\n    }\n\n    process_inlines(state.tokens[blkIdx].children, state)\n  }\n}\n","// Join raw text tokens with the rest of the text\n//\n// This is set as a separate rule to provide an opportunity for plugins\n// to run text replacements after text join, but before escape join.\n//\n// For example, `\\:)` shouldn't be replaced with an emoji.\n//\n\nexport default function text_join (state) {\n  let curr, last\n  const blockTokens = state.tokens\n  const l = blockTokens.length\n\n  for (let j = 0; j \u003c l; j++) {\n    if (blockTokens[j].type !== 'inline') continue\n\n    const tokens = blockTokens[j].children\n    const max = tokens.length\n\n    for (curr = 0; curr \u003c max; curr++) {\n      if (tokens[curr].type === 'text_special') {\n        tokens[curr].type = 'text'\n      }\n    }\n\n    for (curr = last = 0; curr \u003c max; curr++) {\n      if (tokens[curr].type === 'text' \u0026\u0026\n          curr + 1 \u003c max \u0026\u0026\n          tokens[curr + 1].type === 'text') {\n        // collapse two adjacent text nodes\n        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content\n      } else {\n        if (curr !== last) { tokens[last] = tokens[curr] }\n\n        last++\n      }\n    }\n\n    if (curr !== last) {\n      tokens.length = last\n    }\n  }\n}\n","/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n\nimport Ruler from './ruler.mjs'\nimport StateCore from './rules_core/state_core.mjs'\n\nimport r_normalize from './rules_core/normalize.mjs'\nimport r_block from './rules_core/block.mjs'\nimport r_inline from './rules_core/inline.mjs'\nimport r_linkify from './rules_core/linkify.mjs'\nimport r_replacements from './rules_core/replacements.mjs'\nimport r_smartquotes from './rules_core/smartquotes.mjs'\nimport r_text_join from './rules_core/text_join.mjs'\n\nconst _rules = [\n  ['normalize', r_normalize],\n  ['block', r_block],\n  ['inline', r_inline],\n  ['linkify', r_linkify],\n  ['replacements', r_replacements],\n  ['smartquotes', r_smartquotes],\n  // `text_join` finds `text_special` tokens (for escape sequences)\n  // and joins them with the rest of the text\n  ['text_join', r_text_join]\n]\n\n/**\n * new Core()\n **/\nfunction Core () {\n  /**\n   * Core#ruler -\u003e Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i \u003c _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1])\n  }\n}\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  const rules = this.ruler.getRules('')\n\n  for (let i = 0, l = rules.length; i \u003c l; i++) {\n    rules[i](state)\n  }\n}\n\nCore.prototype.State = StateCore\n\nexport default Core\n","// Parser state class\n\nimport Token from '../token.mjs'\nimport { isSpace } from '../common/utils.mjs'\n\nfunction StateBlock (src, md, env, tokens) {\n  this.src = src\n\n  // link to parser instance\n  this.md = md\n\n  this.env = env\n\n  //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens\n\n  this.bMarks = []  // line begin offsets for fast jumps\n  this.eMarks = []  // line end offsets for fast jumps\n  this.tShift = []  // offsets of the first non-space characters (tabs not expanded)\n  this.sCount = []  // indents for each line (tabs expanded)\n\n  // An amount of virtual spaces (tabs expanded) between beginning\n  // of each line (bMarks) and real beginning of that line.\n  //\n  // It exists only as a hack because blockquotes override bMarks\n  // losing information in the process.\n  //\n  // It's used only when expanding tabs, you can think about it as\n  // an initial tab length, e.g. bsCount=21 applied to string `\\t123`\n  // means first tab should be expanded to 4-21%4 === 3 spaces.\n  //\n  this.bsCount = []\n\n  // block parser variables\n\n  // required block content indent (for example, if we are\n  // inside a list, it would be positioned after list marker)\n  this.blkIndent = 0\n  this.line = 0 // line index in src\n  this.lineMax = 0 // lines count\n  this.tight = false  // loose/tight mode for lists\n  this.ddIndent = -1 // indent of the current dd block (-1 if there isn't any)\n  this.listIndent = -1 // indent of the current list block (-1 if there isn't any)\n\n  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'\n  // used in lists to determine if they interrupt a paragraph\n  this.parentType = 'root'\n\n  this.level = 0\n\n  // Create caches\n  // Generate markers.\n  const s = this.src\n\n  for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos \u003c len; pos++) {\n    const ch = s.charCodeAt(pos)\n\n    if (!indent_found) {\n      if (isSpace(ch)) {\n        indent++\n\n        if (ch === 0x09) {\n          offset += 4 - offset % 4\n        } else {\n          offset++\n        }\n        continue\n      } else {\n        indent_found = true\n      }\n    }\n\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) { pos++ }\n      this.bMarks.push(start)\n      this.eMarks.push(pos)\n      this.tShift.push(indent)\n      this.sCount.push(offset)\n      this.bsCount.push(0)\n\n      indent_found = false\n      indent = 0\n      offset = 0\n      start = pos + 1\n    }\n  }\n\n  // Push fake entry to simplify cache bounds checks\n  this.bMarks.push(s.length)\n  this.eMarks.push(s.length)\n  this.tShift.push(0)\n  this.sCount.push(0)\n  this.bsCount.push(0)\n\n  this.lineMax = this.bMarks.length - 1 // don't count last fake line\n}\n\n// Push new token to \"stream\".\n//\nStateBlock.prototype.push = function (type, tag, nesting) {\n  const token = new Token(type, tag, nesting)\n  token.block = true\n\n  if (nesting \u003c 0) this.level-- // closing tag\n  token.level = this.level\n  if (nesting \u003e 0) this.level++ // opening tag\n\n  this.tokens.push(token)\n  return token\n}\n\nStateBlock.prototype.isEmpty = function isEmpty (line) {\n  return this.bMarks[line] + this.tShift[line] \u003e= this.eMarks[line]\n}\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines (from) {\n  for (let max = this.lineMax; from \u003c max; from++) {\n    if (this.bMarks[from] + this.tShift[from] \u003c this.eMarks[from]) {\n      break\n    }\n  }\n  return from\n}\n\n// Skip spaces from given position.\nStateBlock.prototype.skipSpaces = function skipSpaces (pos) {\n  for (let max = this.src.length; pos \u003c max; pos++) {\n    const ch = this.src.charCodeAt(pos)\n    if (!isSpace(ch)) { break }\n  }\n  return pos\n}\n\n// Skip spaces from given position in reverse.\nStateBlock.prototype.skipSpacesBack = function skipSpacesBack (pos, min) {\n  if (pos \u003c= min) { return pos }\n\n  while (pos \u003e min) {\n    if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1 }\n  }\n  return pos\n}\n\n// Skip char codes from given position\nStateBlock.prototype.skipChars = function skipChars (pos, code) {\n  for (let max = this.src.length; pos \u003c max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) { break }\n  }\n  return pos\n}\n\n// Skip char codes reverse from given position - 1\nStateBlock.prototype.skipCharsBack = function skipCharsBack (pos, code, min) {\n  if (pos \u003c= min) { return pos }\n\n  while (pos \u003e min) {\n    if (code !== this.src.charCodeAt(--pos)) { return pos + 1 }\n  }\n  return pos\n}\n\n// cut lines range from source.\nStateBlock.prototype.getLines = function getLines (begin, end, indent, keepLastLF) {\n  if (begin \u003e= end) {\n    return ''\n  }\n\n  const queue = new Array(end - begin)\n\n  for (let i = 0, line = begin; line \u003c end; line++, i++) {\n    let lineIndent = 0\n    const lineStart = this.bMarks[line]\n    let first = lineStart\n    let last\n\n    if (line + 1 \u003c end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1\n    } else {\n      last = this.eMarks[line]\n    }\n\n    while (first \u003c last \u0026\u0026 lineIndent \u003c indent) {\n      const ch = this.src.charCodeAt(first)\n\n      if (isSpace(ch)) {\n        if (ch === 0x09) {\n          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4\n        } else {\n          lineIndent++\n        }\n      } else if (first - lineStart \u003c this.tShift[line]) {\n        // patched tShift masked characters to look like spaces (blockquotes, list markers)\n        lineIndent++\n      } else {\n        break\n      }\n\n      first++\n    }\n\n    if (lineIndent \u003e indent) {\n      // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n      // with indent=2 becomes '  \\tfoobar'\n      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last)\n    } else {\n      queue[i] = this.src.slice(first, last)\n    }\n  }\n\n  return queue.join('')\n}\n\n// re-export Token class to use in block rules\nStateBlock.prototype.Token = Token\n\nexport default StateBlock\n","// GFM table, https://github.github.com/gfm/#tables-extension-\n\nimport { isSpace } from '../common/utils.mjs'\n\n// Limit the amount of empty autocompleted cells in a table,\n// see https://github.com/markdown-it/markdown-it/issues/1000,\n//\n// Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k.\n// We set it to 65k, which can expand user input by a factor of x370\n// (256x256 square is 1.8kB expanded into 650kB).\nconst MAX_AUTOCOMPLETED_CELLS = 0x10000\n\nfunction getLine (state, line) {\n  const pos = state.bMarks[line] + state.tShift[line]\n  const max = state.eMarks[line]\n\n  return state.src.slice(pos, max)\n}\n\nfunction escapedSplit (str) {\n  const result = []\n  const max = str.length\n\n  let pos = 0\n  let ch = str.charCodeAt(pos)\n  let isEscaped = false\n  let lastPos = 0\n  let current = ''\n\n  while (pos \u003c max) {\n    if (ch === 0x7c/* | */) {\n      if (!isEscaped) {\n        // pipe separating cells, '|'\n        result.push(current + str.substring(lastPos, pos))\n        current = ''\n        lastPos = pos + 1\n      } else {\n        // escaped pipe, '\\|'\n        current += str.substring(lastPos, pos - 1)\n        lastPos = pos\n      }\n    }\n\n    isEscaped = (ch === 0x5c/* \\ */)\n    pos++\n\n    ch = str.charCodeAt(pos)\n  }\n\n  result.push(current + str.substring(lastPos))\n\n  return result\n}\n\nexport default function table (state, startLine, endLine, silent) {\n  // should have at least two lines\n  if (startLine + 2 \u003e endLine) { return false }\n\n  let nextLine = startLine + 1\n\n  if (state.sCount[nextLine] \u003c state.blkIndent) { return false }\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { return false }\n\n  // first character of the second line should be '|', '-', ':',\n  // and no other characters are allowed but spaces;\n  // basically, this is the equivalent of /^[-:|][-:|\\s]*$/ regexp\n\n  let pos = state.bMarks[nextLine] + state.tShift[nextLine]\n  if (pos \u003e= state.eMarks[nextLine]) { return false }\n\n  const firstCh = state.src.charCodeAt(pos++)\n  if (firstCh !== 0x7C/* | */ \u0026\u0026 firstCh !== 0x2D/* - */ \u0026\u0026 firstCh !== 0x3A/* : */) { return false }\n\n  if (pos \u003e= state.eMarks[nextLine]) { return false }\n\n  const secondCh = state.src.charCodeAt(pos++)\n  if (secondCh !== 0x7C/* | */ \u0026\u0026 secondCh !== 0x2D/* - */ \u0026\u0026 secondCh !== 0x3A/* : */ \u0026\u0026 !isSpace(secondCh)) {\n    return false\n  }\n\n  // if first character is '-', then second character must not be a space\n  // (due to parsing ambiguity with list)\n  if (firstCh === 0x2D/* - */ \u0026\u0026 isSpace(secondCh)) { return false }\n\n  while (pos \u003c state.eMarks[nextLine]) {\n    const ch = state.src.charCodeAt(pos)\n\n    if (ch !== 0x7C/* | */ \u0026\u0026 ch !== 0x2D/* - */ \u0026\u0026 ch !== 0x3A/* : */ \u0026\u0026 !isSpace(ch)) { return false }\n\n    pos++\n  }\n\n  let lineText = getLine(state, startLine + 1)\n  let columns = lineText.split('|')\n  const aligns = []\n  for (let i = 0; i \u003c columns.length; i++) {\n    const t = columns[i].trim()\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === columns.length - 1) {\n        continue\n      } else {\n        return false\n      }\n    }\n\n    if (!/^:?-+:?$/.test(t)) { return false }\n    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {\n      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right')\n    } else if (t.charCodeAt(0) === 0x3A/* : */) {\n      aligns.push('left')\n    } else {\n      aligns.push('')\n    }\n  }\n\n  lineText = getLine(state, startLine).trim()\n  if (lineText.indexOf('|') === -1) { return false }\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n  columns = escapedSplit(lineText)\n  if (columns.length \u0026\u0026 columns[0] === '') columns.shift()\n  if (columns.length \u0026\u0026 columns[columns.length - 1] === '') columns.pop()\n\n  // header row will define an amount of columns in the entire table,\n  // and align row should be exactly the same (the rest of the rows can differ)\n  const columnCount = columns.length\n  if (columnCount === 0 || columnCount !== aligns.length) { return false }\n\n  if (silent) { return true }\n\n  const oldParentType = state.parentType\n  state.parentType = 'table'\n\n  // use 'blockquote' lists for termination because it's\n  // the most similar to tables\n  const terminatorRules = state.md.block.ruler.getRules('blockquote')\n\n  const token_to = state.push('table_open', 'table', 1)\n  const tableLines = [startLine, 0]\n  token_to.map = tableLines\n\n  const token_tho = state.push('thead_open', 'thead', 1)\n  token_tho.map = [startLine, startLine + 1]\n\n  const token_htro = state.push('tr_open', 'tr', 1)\n  token_htro.map = [startLine, startLine + 1]\n\n  for (let i = 0; i \u003c columns.length; i++) {\n    const token_ho = state.push('th_open', 'th', 1)\n    if (aligns[i]) {\n      token_ho.attrs = [['style', 'text-align:' + aligns[i]]]\n    }\n\n    const token_il = state.push('inline', '', 0)\n    token_il.content = columns[i].trim()\n    token_il.children = []\n\n    state.push('th_close', 'th', -1)\n  }\n\n  state.push('tr_close', 'tr', -1)\n  state.push('thead_close', 'thead', -1)\n\n  let tbodyLines\n  let autocompletedCells = 0\n\n  for (nextLine = startLine + 2; nextLine \u003c endLine; nextLine++) {\n    if (state.sCount[nextLine] \u003c state.blkIndent) { break }\n\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n\n    if (terminate) { break }\n    lineText = getLine(state, nextLine).trim()\n    if (!lineText) { break }\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { break }\n    columns = escapedSplit(lineText)\n    if (columns.length \u0026\u0026 columns[0] === '') columns.shift()\n    if (columns.length \u0026\u0026 columns[columns.length - 1] === '') columns.pop()\n\n    // note: autocomplete count can be negative if user specifies more columns than header,\n    // but that does not affect intended use (which is limiting expansion)\n    autocompletedCells += columnCount - columns.length\n    if (autocompletedCells \u003e MAX_AUTOCOMPLETED_CELLS) { break }\n\n    if (nextLine === startLine + 2) {\n      const token_tbo = state.push('tbody_open', 'tbody', 1)\n      token_tbo.map = tbodyLines = [startLine + 2, 0]\n    }\n\n    const token_tro = state.push('tr_open', 'tr', 1)\n    token_tro.map = [nextLine, nextLine + 1]\n\n    for (let i = 0; i \u003c columnCount; i++) {\n      const token_tdo = state.push('td_open', 'td', 1)\n      if (aligns[i]) {\n        token_tdo.attrs = [['style', 'text-align:' + aligns[i]]]\n      }\n\n      const token_il = state.push('inline', '', 0)\n      token_il.content = columns[i] ? columns[i].trim() : ''\n      token_il.children = []\n\n      state.push('td_close', 'td', -1)\n    }\n    state.push('tr_close', 'tr', -1)\n  }\n\n  if (tbodyLines) {\n    state.push('tbody_close', 'tbody', -1)\n    tbodyLines[1] = nextLine\n  }\n\n  state.push('table_close', 'table', -1)\n  tableLines[1] = nextLine\n\n  state.parentType = oldParentType\n  state.line = nextLine\n  return true\n}\n","// Code block (4 spaces padded)\n\nexport default function code (state, startLine, endLine/*, silent */) {\n  if (state.sCount[startLine] - state.blkIndent \u003c 4) { return false }\n\n  let nextLine = startLine + 1\n  let last = nextLine\n\n  while (nextLine \u003c endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++\n      continue\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) {\n      nextLine++\n      last = nextLine\n      continue\n    }\n    break\n  }\n\n  state.line = last\n\n  const token = state.push('code_block', 'code', 0)\n  token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\\n'\n  token.map = [startLine, state.line]\n\n  return true\n}\n","// fences (``` lang, ~~~ lang)\n\nexport default function fence (state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n\n  if (pos + 3 \u003e max) { return false }\n\n  const marker = state.src.charCodeAt(pos)\n\n  if (marker !== 0x7E/* ~ */ \u0026\u0026 marker !== 0x60 /* ` */) {\n    return false\n  }\n\n  // scan marker length\n  let mem = pos\n  pos = state.skipChars(pos, marker)\n\n  let len = pos - mem\n\n  if (len \u003c 3) { return false }\n\n  const markup = state.src.slice(mem, pos)\n  const params = state.src.slice(pos, max)\n\n  if (marker === 0x60 /* ` */) {\n    if (params.indexOf(String.fromCharCode(marker)) \u003e= 0) {\n      return false\n    }\n  }\n\n  // Since start is found, we can report success here in validation mode\n  if (silent) { return true }\n\n  // search end of block\n  let nextLine = startLine\n  let haveEndMarker = false\n\n  for (;;) {\n    nextLine++\n    if (nextLine \u003e= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]\n    max = state.eMarks[nextLine]\n\n    if (pos \u003c max \u0026\u0026 state.sCount[nextLine] \u003c state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) { continue }\n\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue\n    }\n\n    pos = state.skipChars(pos, marker)\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem \u003c len) { continue }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos)\n\n    if (pos \u003c max) { continue }\n\n    haveEndMarker = true\n    // found!\n    break\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.sCount[startLine]\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0)\n\n  const token = state.push('fence', 'code', 0)\n  token.info = params\n  token.content = state.getLines(startLine + 1, nextLine, len, true)\n  token.markup = markup\n  token.map = [startLine, state.line]\n\n  return true\n}\n","// Block quotes\n\nimport { isSpace } from '../common/utils.mjs'\n\nexport default function blockquote (state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  const oldLineMax = state.lineMax\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos) !== 0x3E/* \u003e */) { return false }\n\n  // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n  if (silent) { return true }\n\n  const oldBMarks = []\n  const oldBSCount = []\n  const oldSCount = []\n  const oldTShift = []\n\n  const terminatorRules = state.md.block.ruler.getRules('blockquote')\n\n  const oldParentType = state.parentType\n  state.parentType = 'blockquote'\n  let lastLineEmpty = false\n  let nextLine\n\n  // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     \u003e test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     \u003e\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     \u003e test\n  //      - - -\n  //     ```\n  for (nextLine = startLine; nextLine \u003c endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    \u003e current blockquote\n    // 2. checking this line\n    // ```\n    const isOutdented = state.sCount[nextLine] \u003c state.blkIndent\n\n    pos = state.bMarks[nextLine] + state.tShift[nextLine]\n    max = state.eMarks[nextLine]\n\n    if (pos \u003e= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* \u003e */ \u0026\u0026 !isOutdented) {\n      // This line is inside the blockquote.\n\n      // set offset past spaces and \"\u003e\"\n      let initial = state.sCount[nextLine] + 1\n      let spaceAfterMarker\n      let adjustTab\n\n      // skip one optional space after '\u003e'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' \u003e   test '\n        //     ^ -- position start of line here:\n        pos++\n        initial++\n        adjustTab = false\n        spaceAfterMarker = true\n      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n        spaceAfterMarker = true\n\n        if ((state.bsCount[nextLine] + initial) % 4 === 3) {\n          // '  \u003e\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++\n          initial++\n          adjustTab = false\n        } else {\n          // ' \u003e\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true\n        }\n      } else {\n        spaceAfterMarker = false\n      }\n\n      let offset = initial\n      oldBMarks.push(state.bMarks[nextLine])\n      state.bMarks[nextLine] = pos\n\n      while (pos \u003c max) {\n        const ch = state.src.charCodeAt(pos)\n\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4\n          } else {\n            offset++\n          }\n        } else {\n          break\n        }\n\n        pos++\n      }\n\n      lastLineEmpty = pos \u003e= max\n\n      oldBSCount.push(state.bsCount[nextLine])\n      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0)\n\n      oldSCount.push(state.sCount[nextLine])\n      state.sCount[nextLine] = offset - initial\n\n      oldTShift.push(state.tShift[nextLine])\n      state.tShift[nextLine] = pos - state.bMarks[nextLine]\n      continue\n    }\n\n    // Case 2: line is not inside the blockquote, and the last line was empty.\n    if (lastLineEmpty) { break }\n\n    // Case 3: another tag found.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n\n    if (terminate) {\n      // Quirk to enforce \"hard termination mode\" for paragraphs;\n      // normally if you call `tokenize(state, startLine, nextLine)`,\n      // paragraphs will look below nextLine for paragraph continuation,\n      // but if blockquote is terminated by another tag, they shouldn't\n      state.lineMax = nextLine\n\n      if (state.blkIndent !== 0) {\n        // state.blkIndent was non-zero, we now set it to zero,\n        // so we need to re-calculate all offsets to appear as\n        // if indent wasn't changed\n        oldBMarks.push(state.bMarks[nextLine])\n        oldBSCount.push(state.bsCount[nextLine])\n        oldTShift.push(state.tShift[nextLine])\n        oldSCount.push(state.sCount[nextLine])\n        state.sCount[nextLine] -= state.blkIndent\n      }\n\n      break\n    }\n\n    oldBMarks.push(state.bMarks[nextLine])\n    oldBSCount.push(state.bsCount[nextLine])\n    oldTShift.push(state.tShift[nextLine])\n    oldSCount.push(state.sCount[nextLine])\n\n    // A negative indentation means that this is a paragraph continuation\n    //\n    state.sCount[nextLine] = -1\n  }\n\n  const oldIndent = state.blkIndent\n  state.blkIndent = 0\n\n  const token_o = state.push('blockquote_open', 'blockquote', 1)\n  token_o.markup = '\u003e'\n  const lines = [startLine, 0]\n  token_o.map = lines\n\n  state.md.block.tokenize(state, startLine, nextLine)\n\n  const token_c = state.push('blockquote_close', 'blockquote', -1)\n  token_c.markup = '\u003e'\n\n  state.lineMax = oldLineMax\n  state.parentType = oldParentType\n  lines[1] = state.line\n\n  // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n  for (let i = 0; i \u003c oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i]\n    state.tShift[i + startLine] = oldTShift[i]\n    state.sCount[i + startLine] = oldSCount[i]\n    state.bsCount[i + startLine] = oldBSCount[i]\n  }\n  state.blkIndent = oldIndent\n\n  return true\n}\n","// Horizontal rule\n\nimport { isSpace } from '../common/utils.mjs'\n\nexport default function hr (state, startLine, endLine, silent) {\n  const max = state.eMarks[startLine]\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  const marker = state.src.charCodeAt(pos++)\n\n  // Check hr marker\n  if (marker !== 0x2A/* * */ \u0026\u0026\n      marker !== 0x2D/* - */ \u0026\u0026\n      marker !== 0x5F/* _ */) {\n    return false\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 of them\n\n  let cnt = 1\n  while (pos \u003c max) {\n    const ch = state.src.charCodeAt(pos++)\n    if (ch !== marker \u0026\u0026 !isSpace(ch)) { return false }\n    if (ch === marker) { cnt++ }\n  }\n\n  if (cnt \u003c 3) { return false }\n\n  if (silent) { return true }\n\n  state.line = startLine + 1\n\n  const token = state.push('hr', 'hr', 0)\n  token.map = [startLine, state.line]\n  token.markup = Array(cnt + 1).join(String.fromCharCode(marker))\n\n  return true\n}\n","// Lists\n\nimport { isSpace } from '../common/utils.mjs'\n\n// Search `[-+*][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipBulletListMarker (state, startLine) {\n  const max = state.eMarks[startLine]\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n\n  const marker = state.src.charCodeAt(pos++)\n  // Check bullet\n  if (marker !== 0x2A/* * */ \u0026\u0026\n      marker !== 0x2D/* - */ \u0026\u0026\n      marker !== 0x2B/* + */) {\n    return -1\n  }\n\n  if (pos \u003c max) {\n    const ch = state.src.charCodeAt(pos)\n\n    if (!isSpace(ch)) {\n      // \" -test \" - is not a list item\n      return -1\n    }\n  }\n\n  return pos\n}\n\n// Search `\\d+[.)][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker (state, startLine) {\n  const start = state.bMarks[startLine] + state.tShift[startLine]\n  const max = state.eMarks[startLine]\n  let pos = start\n\n  // List marker should have at least 2 chars (digit + dot)\n  if (pos + 1 \u003e= max) { return -1 }\n\n  let ch = state.src.charCodeAt(pos++)\n\n  if (ch \u003c 0x30/* 0 */ || ch \u003e 0x39/* 9 */) { return -1 }\n\n  for (;;) {\n    // EOL -\u003e fail\n    if (pos \u003e= max) { return -1 }\n\n    ch = state.src.charCodeAt(pos++)\n\n    if (ch \u003e= 0x30/* 0 */ \u0026\u0026 ch \u003c= 0x39/* 9 */) {\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start \u003e= 10) { return -1 }\n\n      continue\n    }\n\n    // found valid marker\n    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {\n      break\n    }\n\n    return -1\n  }\n\n  if (pos \u003c max) {\n    ch = state.src.charCodeAt(pos)\n\n    if (!isSpace(ch)) {\n      // \" 1.test \" - is not a list item\n      return -1\n    }\n  }\n  return pos\n}\n\nfunction markTightParagraphs (state, idx) {\n  const level = state.level + 2\n\n  for (let i = idx + 2, l = state.tokens.length - 2; i \u003c l; i++) {\n    if (state.tokens[i].level === level \u0026\u0026 state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true\n      state.tokens[i].hidden = true\n      i += 2\n    }\n  }\n}\n\nexport default function list (state, startLine, endLine, silent) {\n  let max, pos, start, token\n  let nextLine = startLine\n  let tight = true\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { return false }\n\n  // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n  if (state.listIndent \u003e= 0 \u0026\u0026\n      state.sCount[nextLine] - state.listIndent \u003e= 4 \u0026\u0026\n      state.sCount[nextLine] \u003c state.blkIndent) {\n    return false\n  }\n\n  let isTerminatingParagraph = false\n\n  // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n  if (silent \u0026\u0026 state.parentType === 'paragraph') {\n    // Next list item should still terminate previous list item;\n    //\n    // This code can fail if plugins use blkIndent as well as lists,\n    // but I hope the spec gets fixed long before that happens.\n    //\n    if (state.sCount[nextLine] \u003e= state.blkIndent) {\n      isTerminatingParagraph = true\n    }\n  }\n\n  // Detect list type and position after marker\n  let isOrdered\n  let markerValue\n  let posAfterMarker\n  if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) \u003e= 0) {\n    isOrdered = true\n    start = state.bMarks[nextLine] + state.tShift[nextLine]\n    markerValue = Number(state.src.slice(start, posAfterMarker - 1))\n\n    // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n    if (isTerminatingParagraph \u0026\u0026 markerValue !== 1) return false\n  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) \u003e= 0) {\n    isOrdered = false\n  } else {\n    return false\n  }\n\n  // If we're starting a new unordered list right after\n  // a paragraph, first line should not be empty.\n  if (isTerminatingParagraph) {\n    if (state.skipSpaces(posAfterMarker) \u003e= state.eMarks[nextLine]) return false\n  }\n\n  // For validation mode we can terminate immediately\n  if (silent) { return true }\n\n  // We should terminate list on style change. Remember first one to compare.\n  const markerCharCode = state.src.charCodeAt(posAfterMarker - 1)\n\n  // Start list\n  const listTokIdx = state.tokens.length\n\n  if (isOrdered) {\n    token = state.push('ordered_list_open', 'ol', 1)\n    if (markerValue !== 1) {\n      token.attrs = [['start', markerValue]]\n    }\n  } else {\n    token = state.push('bullet_list_open', 'ul', 1)\n  }\n\n  const listLines = [nextLine, 0]\n  token.map = listLines\n  token.markup = String.fromCharCode(markerCharCode)\n\n  //\n  // Iterate list items\n  //\n\n  let prevEmptyEnd = false\n  const terminatorRules = state.md.block.ruler.getRules('list')\n\n  const oldParentType = state.parentType\n  state.parentType = 'list'\n\n  while (nextLine \u003c endLine) {\n    pos = posAfterMarker\n    max = state.eMarks[nextLine]\n\n    const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine])\n    let offset = initial\n\n    while (pos \u003c max) {\n      const ch = state.src.charCodeAt(pos)\n\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[nextLine]) % 4\n      } else if (ch === 0x20) {\n        offset++\n      } else {\n        break\n      }\n\n      pos++\n    }\n\n    const contentStart = pos\n    let indentAfterMarker\n\n    if (contentStart \u003e= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1\n    } else {\n      indentAfterMarker = offset - initial\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker \u003e 4) { indentAfterMarker = 1 }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    const indent = initial + indentAfterMarker\n\n    // Run subparser \u0026 write tokens\n    token = state.push('list_item_open', 'li', 1)\n    token.markup = String.fromCharCode(markerCharCode)\n    const itemLines = [nextLine, 0]\n    token.map = itemLines\n    if (isOrdered) {\n      token.info = state.src.slice(start, posAfterMarker - 1)\n    }\n\n    // change current state, then restore it after parser subcall\n    const oldTight = state.tight\n    const oldTShift = state.tShift[nextLine]\n    const oldSCount = state.sCount[nextLine]\n\n    //  - example list\n    // ^ listIndent position will be here\n    //   ^ blkIndent position will be here\n    //\n    const oldListIndent = state.listIndent\n    state.listIndent = state.blkIndent\n    state.blkIndent = indent\n\n    state.tight = true\n    state.tShift[nextLine] = contentStart - state.bMarks[nextLine]\n    state.sCount[nextLine] = offset\n\n    if (contentStart \u003e= max \u0026\u0026 state.isEmpty(nextLine + 1)) {\n      // workaround for this case\n      // (list item is empty, list terminates before \"foo\"):\n      // ~~~~~~~~\n      //   -\n      //\n      //     foo\n      // ~~~~~~~~\n      state.line = Math.min(state.line + 2, endLine)\n    } else {\n      state.md.block.tokenize(state, nextLine, endLine, true)\n    }\n\n    // If any of list item is tight, mark list as tight\n    if (!state.tight || prevEmptyEnd) {\n      tight = false\n    }\n    // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n    prevEmptyEnd = (state.line - nextLine) \u003e 1 \u0026\u0026 state.isEmpty(state.line - 1)\n\n    state.blkIndent = state.listIndent\n    state.listIndent = oldListIndent\n    state.tShift[nextLine] = oldTShift\n    state.sCount[nextLine] = oldSCount\n    state.tight = oldTight\n\n    token = state.push('list_item_close', 'li', -1)\n    token.markup = String.fromCharCode(markerCharCode)\n\n    nextLine = state.line\n    itemLines[1] = nextLine\n\n    if (nextLine \u003e= endLine) { break }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] \u003c state.blkIndent) { break }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[nextLine] - state.blkIndent \u003e= 4) { break }\n\n    // fail if terminating block found\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine)\n      if (posAfterMarker \u003c 0) { break }\n      start = state.bMarks[nextLine] + state.tShift[nextLine]\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine)\n      if (posAfterMarker \u003c 0) { break }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break }\n  }\n\n  // Finalize list\n  if (isOrdered) {\n    token = state.push('ordered_list_close', 'ol', -1)\n  } else {\n    token = state.push('bullet_list_close', 'ul', -1)\n  }\n  token.markup = String.fromCharCode(markerCharCode)\n\n  listLines[1] = nextLine\n  state.line = nextLine\n\n  state.parentType = oldParentType\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx)\n  }\n\n  return true\n}\n","import { isSpace, normalizeReference } from '../common/utils.mjs'\n\n// CommonMark limits reference labels to 999 Unicode code points.\nconst MAX_LABEL_LENGTH = 999\n\nfunction countCodePoints (str) {\n  let length = str.length\n\n  for (let i = 0; i \u003c str.length - 1; i++) {\n    const high = str.charCodeAt(i)\n    if (high \u003c 0xD800 || high \u003e 0xDBFF) { continue }\n\n    const low = str.charCodeAt(i + 1)\n    if (low \u003e= 0xDC00 \u0026\u0026 low \u003c= 0xDFFF) {\n      length--\n      i++\n    }\n  }\n\n  return length\n}\n\n// Exclusive end offset of the line, after its newline if present\nfunction lineEnd (state, line) {\n  return Math.min(state.eMarks[line] + 1, state.src.length)\n}\n\n// Returns -1 if the reference can't continue on this line\nfunction getNextLinePos (state, nextLine) {\n  const endLine = state.lineMax\n\n  if (nextLine \u003e= endLine || state.isEmpty(nextLine)) {\n    // empty line or end of input\n    return -1\n  }\n\n  let isContinuation = false\n\n  // this would be a code block normally, but after paragraph\n  // it's considered a lazy continuation regardless of what's there\n  if (state.sCount[nextLine] - state.blkIndent \u003e 3) { isContinuation = true }\n\n  // quirk for blockquotes, this line should already be checked by that rule\n  if (state.sCount[nextLine] \u003c 0) { isContinuation = true }\n\n  if (!isContinuation) {\n    const terminatorRules = state.md.block.ruler.getRules('reference')\n    const oldParentType = state.parentType\n    state.parentType = 'reference'\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n\n    state.parentType = oldParentType\n    if (terminate) {\n      // terminated by another block\n      return -1\n    }\n  }\n\n  return state.bMarks[nextLine] + state.tShift[nextLine]\n}\n\nexport default function reference (state, startLine, _endLine, silent) {\n  const src = state.src\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let nextLine = startLine + 1\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n\n  if (src.charCodeAt(pos) !== 0x5B/* [ */) { return false }\n\n  // Scan the source directly: indexing a string after each appended line\n  // can make V8 copy the accumulated prefix on every continuation.\n  let max = lineEnd(state, startLine)\n\n  let rawLabel = ''\n  let labelEnd = -1\n  let segmentStart = ++pos\n\n  while (pos \u003c max) {\n    if (rawLabel.length + pos - segmentStart \u003e MAX_LABEL_LENGTH * 2) { return false }\n\n    let ch = src.charCodeAt(pos)\n    if (ch === 0x5B /* [ */) { return false }\n    if (ch === 0x5D /* ] */) {\n      labelEnd = pos\n      break\n    }\n    if (ch === 0x5C /* \\ */) { ch = src.charCodeAt(++pos) }\n\n    if (ch === 0x0A /* \\n */ \u0026\u0026 pos \u003c max) {\n      const nextPos = getNextLinePos(state, nextLine)\n      if (nextPos \u003c 0) { return false }\n      rawLabel += src.slice(segmentStart, max)\n      pos = segmentStart = nextPos\n      max = lineEnd(state, nextLine++)\n      continue\n    }\n    pos++\n  }\n\n  if (labelEnd \u003c 0 || src.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }\n\n  rawLabel += src.slice(segmentStart, labelEnd)\n\n  if (rawLabel.length \u003e MAX_LABEL_LENGTH \u0026\u0026 countCodePoints(rawLabel) \u003e MAX_LABEL_LENGTH) {\n    return false\n  }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  pos = labelEnd + 2\n  while (pos \u003c max) {\n    const ch = src.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const nextPos = getNextLinePos(state, nextLine)\n      if (nextPos \u003c 0) { break }\n      pos = nextPos\n      max = lineEnd(state, nextLine++)\n    } else if (isSpace(ch)) {\n      pos++\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  const destRes = state.md.helpers.parseLinkDestination(src, pos, max)\n  if (!destRes.ok) { return false }\n\n  const href = state.md.normalizeLink(destRes.str)\n  if (!state.md.validateLink(href)) { return false }\n\n  pos = destRes.pos\n\n  // save cursor state, we could require to rollback later\n  const destEndPos = pos\n  const destEndMax = max\n  const destEndLineNo = nextLine\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  while (pos \u003c max) {\n    const ch = src.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const nextPos = getNextLinePos(state, nextLine)\n      if (nextPos \u003c 0) { break }\n      pos = nextPos\n      max = lineEnd(state, nextLine++)\n    } else if (isSpace(ch)) {\n      pos++\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  const titleStart = pos\n  let titleRes = state.md.helpers.parseLinkTitle(src, pos, max)\n  while (titleRes.can_continue) {\n    const nextPos = getNextLinePos(state, nextLine)\n    if (nextPos \u003c 0) break\n    pos = nextPos\n    max = lineEnd(state, nextLine++)\n    titleRes = state.md.helpers.parseLinkTitle(src, pos, max, titleRes)\n  }\n  let title\n\n  if (titleStart !== destEndPos \u0026\u0026 titleRes.ok) {\n    title = titleRes.str\n    pos = titleRes.pos\n  } else {\n    title = ''\n    pos = destEndPos\n    max = destEndMax\n    nextLine = destEndLineNo\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos \u003c max) {\n    const ch = src.charCodeAt(pos)\n    if (!isSpace(ch)) { break }\n    pos++\n  }\n\n  if (pos \u003c max \u0026\u0026 src.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = ''\n      pos = destEndPos\n      max = destEndMax\n      nextLine = destEndLineNo\n      while (pos \u003c max) {\n        const ch = src.charCodeAt(pos)\n        if (!isSpace(ch)) { break }\n        pos++\n      }\n    }\n  }\n\n  if (pos \u003c max \u0026\u0026 src.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false\n  }\n\n  const label = normalizeReference(rawLabel)\n  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false\n  }\n\n  // Reference can not terminate anything. This check is for safety only.\n  /* istanbul ignore if */\n  if (silent) { return true }\n\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {}\n  }\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = { title, href }\n  }\n\n  state.line = nextLine\n  return true\n}\n","// List of valid html blocks names, according to commonmark spec\n// https://spec.commonmark.org/0.30/#html-blocks\n\nexport default [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n","// Regexps to match html elements\n\nconst attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*'\n\nconst unquoted = '[^\"\\'=\u003c\u003e`\\\\x00-\\\\x20]+'\nconst single_quoted = \"'[^']*'\"\nconst double_quoted = '\"[^\"]*\"'\n\nconst attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')'\n\nconst attribute = '(?:\\\\s+' + attr_name + '(?:\\\\s*=\\\\s*' + attr_value + ')?)'\n\nconst open_tag = '\u003c[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?\u003e'\n\nconst close_tag = '\u003c\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*\u003e'\nconst comment = '\u003c!---?\u003e|\u003c!--(?:[^-]|-[^-]|--[^\u003e])*--\u003e'\nconst processing = '\u003c[?][\\\\s\\\\S]*?[?]\u003e'\nconst declaration = '\u003c![A-Za-z][^\u003e]*\u003e'\nconst cdata = '\u003c!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]\u003e'\n\nconst HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +\n                        '|' + processing + '|' + declaration + '|' + cdata + ')')\nconst HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')')\n\nexport { HTML_TAG_RE, HTML_OPEN_CLOSE_TAG_RE }\n","// HTML block\n\nimport block_names from '../common/html_blocks.mjs'\nimport { HTML_OPEN_CLOSE_TAG_RE } from '../common/html_re.mjs'\n\n// An array of opening and corresponding closing sequences for html tags,\n// last argument defines whether it can terminate a paragraph or not\n//\nconst HTML_SEQUENCES = [\n  [/^\u003c(script|pre|style|textarea)(?=(\\s|\u003e|$))/i, /\u003c\\/(script|pre|style|textarea)\u003e/i, true],\n  [/^\u003c!--/, /--\u003e/, true],\n  [/^\u003c\\?/, /\\?\u003e/, true],\n  [/^\u003c![A-Za-z]/, /\u003e/, true],\n  [/^\u003c!\\[CDATA\\[/, /\\]\\]\u003e/, true],\n  [new RegExp('^\u003c/?(' + block_names.join('|') + ')(?=(\\\\s|/?\u003e|$))', 'i'), /^$/, true],\n  [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\\\s*$'), /^$/, false]\n]\n\nexport default function html_block (state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n\n  if (!state.md.options.html) { return false }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* \u003c */) { return false }\n\n  let lineText = state.src.slice(pos, max)\n\n  let i = 0\n  for (; i \u003c HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) { break }\n  }\n  if (i === HTML_SEQUENCES.length) { return false }\n\n  if (silent) {\n    // true if this sequence can be a terminator, false otherwise\n    return HTML_SEQUENCES[i][2]\n  }\n\n  let nextLine = startLine + 1\n\n  // Block types 6 and 7 (the only ones whose end condition is a blank line)\n  // have `/^$/` as their closing regexp. For all other types (1-5, e.g.\n  // `\u003c!--` comments), a blank line is regular content and must not terminate\n  // the block - it ends only when its closing sequence is found.\n  const endsOnBlankLine = HTML_SEQUENCES[i][1].test('')\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine \u003c endLine; nextLine++) {\n      if (state.sCount[nextLine] \u003c state.blkIndent) {\n        // An outdented blank line shouldn't end a block that doesn't end on a\n        // blank line (e.g. a `\u003c!--` comment inside a list item). Such blocks\n        // must continue until their closing sequence regardless of indent.\n        if (endsOnBlankLine || !state.isEmpty(nextLine)) { break }\n      }\n\n      pos = state.bMarks[nextLine] + state.tShift[nextLine]\n      max = state.eMarks[nextLine]\n      lineText = state.src.slice(pos, max)\n\n      if (HTML_SEQUENCES[i][1].test(lineText)) {\n        if (lineText.length !== 0) { nextLine++ }\n        break\n      }\n    }\n  }\n\n  state.line = nextLine\n\n  const token = state.push('html_block', '', 0)\n  token.map = [startLine, nextLine]\n  token.content = state.getLines(startLine, nextLine, state.blkIndent, true)\n\n  return true\n}\n","// heading (#, ##, ...)\n\nimport { isSpace, asciiTrim } from '../common/utils.mjs'\n\nexport default function heading (state, startLine, endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n\n  let ch = state.src.charCodeAt(pos)\n\n  if (ch !== 0x23/* # */ || pos \u003e= max) { return false }\n\n  // count heading level\n  let level = 1\n  ch = state.src.charCodeAt(++pos)\n  while (ch === 0x23/* # */ \u0026\u0026 pos \u003c max \u0026\u0026 level \u003c= 6) {\n    level++\n    ch = state.src.charCodeAt(++pos)\n  }\n\n  if (level \u003e 6 || (pos \u003c max \u0026\u0026 !isSpace(ch))) { return false }\n\n  if (silent) { return true }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipSpacesBack(max, pos)\n  const tmp = state.skipCharsBack(max, 0x23, pos) // #\n  if (tmp \u003e pos \u0026\u0026 isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp\n  }\n\n  state.line = startLine + 1\n\n  const token_o = state.push('heading_open', 'h' + String(level), 1)\n  token_o.markup = '########'.slice(0, level)\n  token_o.map = [startLine, state.line]\n\n  const token_i = state.push('inline', '', 0)\n  token_i.content = asciiTrim(state.src.slice(pos, max))\n  token_i.map = [startLine, state.line]\n  token_i.children = []\n\n  const token_c = state.push('heading_close', 'h' + String(level), -1)\n  token_c.markup = '########'.slice(0, level)\n\n  return true\n}\n","// lheading (---, ===)\n\nimport { asciiTrim } from '../common/utils.mjs'\n\nexport default function lheading (state, startLine, endLine/*, silent */) {\n  const terminatorRules = state.md.block.ruler.getRules('paragraph')\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent \u003e= 4) { return false }\n\n  const oldParentType = state.parentType\n  state.parentType = 'paragraph' // use paragraph to match terminatorRules\n\n  // jump line-by-line until empty one or EOF\n  let level = 0\n  let marker\n  let nextLine = startLine + 1\n\n  for (; nextLine \u003c endLine \u0026\u0026 !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent \u003e 3) { continue }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] \u003e= state.blkIndent) {\n      let pos = state.bMarks[nextLine] + state.tShift[nextLine]\n      const max = state.eMarks[nextLine]\n\n      if (pos \u003c max) {\n        marker = state.src.charCodeAt(pos)\n\n        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {\n          pos = state.skipChars(pos, marker)\n          pos = state.skipSpaces(pos)\n\n          if (pos \u003e= max) {\n            level = (marker === 0x3D/* = */ ? 1 : 2)\n            break\n          }\n        }\n      }\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] \u003c 0) { continue }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n  }\n\n  if (!level) {\n    // Didn't find valid underline\n    state.parentType = oldParentType\n    return false\n  }\n\n  const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false))\n\n  state.line = nextLine + 1\n\n  const token_o = state.push('heading_open', 'h' + String(level), 1)\n  token_o.markup = String.fromCharCode(marker)\n  token_o.map = [startLine, state.line]\n\n  const token_i = state.push('inline', '', 0)\n  token_i.content = content\n  token_i.map = [startLine, state.line - 1]\n  token_i.children = []\n\n  const token_c = state.push('heading_close', 'h' + String(level), -1)\n  token_c.markup = String.fromCharCode(marker)\n\n  state.parentType = oldParentType\n\n  return true\n}\n","// Paragraph\n\nimport { asciiTrim } from '../common/utils.mjs'\n\nexport default function paragraph (state, startLine, endLine) {\n  const terminatorRules = state.md.block.ruler.getRules('paragraph')\n  const oldParentType = state.parentType\n  let nextLine = startLine + 1\n  state.parentType = 'paragraph'\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine \u003c endLine \u0026\u0026 !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent \u003e 3) { continue }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] \u003c 0) { continue }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i \u003c l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n  }\n\n  const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false))\n\n  state.line = nextLine\n\n  const token_o = state.push('paragraph_open', 'p', 1)\n  token_o.map = [startLine, state.line]\n\n  const token_i = state.push('inline', '', 0)\n  token_i.content = content\n  token_i.map = [startLine, state.line]\n  token_i.children = []\n\n  state.push('paragraph_close', 'p', -1)\n\n  state.parentType = oldParentType\n\n  return true\n}\n","/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n\nimport Ruler from './ruler.mjs'\nimport StateBlock from './rules_block/state_block.mjs'\n\nimport r_table from './rules_block/table.mjs'\nimport r_code from './rules_block/code.mjs'\nimport r_fence from './rules_block/fence.mjs'\nimport r_blockquote from './rules_block/blockquote.mjs'\nimport r_hr from './rules_block/hr.mjs'\nimport r_list from './rules_block/list.mjs'\nimport r_reference from './rules_block/reference.mjs'\nimport r_html_block from './rules_block/html_block.mjs'\nimport r_heading from './rules_block/heading.mjs'\nimport r_lheading from './rules_block/lheading.mjs'\nimport r_paragraph from './rules_block/paragraph.mjs'\n\nconst _rules = [\n  // First 2 params - rule name \u0026 source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  ['table', r_table, ['paragraph', 'reference']],\n  ['code', r_code],\n  ['fence', r_fence, ['paragraph', 'reference', 'blockquote', 'list']],\n  ['blockquote', r_blockquote, ['paragraph', 'reference', 'blockquote', 'list']],\n  ['hr', r_hr, ['paragraph', 'reference', 'blockquote', 'list']],\n  ['list', r_list, ['paragraph', 'reference', 'blockquote']],\n  ['reference', r_reference],\n  ['html_block', r_html_block, ['paragraph', 'reference', 'blockquote']],\n  ['heading', r_heading, ['paragraph', 'reference', 'blockquote']],\n  ['lheading', r_lheading],\n  ['paragraph', r_paragraph]\n]\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock () {\n  /**\n   * ParserBlock#ruler -\u003e Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i \u003c _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() })\n  }\n}\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  const rules = this.ruler.getRules('')\n  const len = rules.length\n  const maxNesting = state.md.options.maxNesting\n  let line = startLine\n  let hasEmptyLines = false\n\n  while (line \u003c endLine) {\n    state.line = line = state.skipEmptyLines(line)\n    if (line \u003e= endLine) { break }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes \u0026 lists\n    if (state.sCount[line] \u003c state.blkIndent) { break }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level \u003e= maxNesting) {\n      state.line = endLine\n      break\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n    const prevLine = state.line\n    let ok = false\n\n    for (let i = 0; i \u003c len; i++) {\n      ok = rules[i](state, line, endLine, false)\n      if (ok) {\n        if (prevLine \u003e= state.line) {\n          throw new Error(\"block rule didn't increment state.line\")\n        }\n        break\n      }\n    }\n\n    // this can only happen if user disables paragraph rule\n    if (!ok) throw new Error('none of the block rules matched')\n\n    // set state.tight if we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true\n    }\n\n    line = state.line\n\n    if (line \u003c endLine \u0026\u0026 state.isEmpty(line)) {\n      hasEmptyLines = true\n      line++\n      state.line = line\n    }\n  }\n}\n\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  if (!src) { return }\n\n  const state = new this.State(src, md, env, outTokens)\n\n  this.tokenize(state, state.line, state.lineMax)\n}\n\nParserBlock.prototype.State = StateBlock\n\nexport default ParserBlock\n","// Inline parser state\n\nimport Token from '../token.mjs'\nimport { isWhiteSpace, isPunctCharCode, isMdAsciiPunct } from '../common/utils.mjs'\n\nfunction StateInline (src, md, env, outTokens) {\n  this.src = src\n  this.env = env\n  this.md = md\n  this.tokens = outTokens\n  this.tokens_meta = Array(outTokens.length)\n\n  this.pos = 0\n  this.posMax = this.src.length\n  this.level = 0\n  this.pending = ''\n  this.pendingLevel = 0\n\n  // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n  this.cache = {}\n\n  // List of emphasis-like delimiters for current tag\n  this.delimiters = []\n\n  // Stack of delimiter lists for upper level tags\n  this._prev_delimiters = []\n\n  // backtick length =\u003e last seen position\n  this.backticks = {}\n  this.backticksScanned = false\n\n  // Set when html comment / PI / declaration / CDATA has no terminator,\n  // to skip further scans of these constructs\n  this.skipHtmlSpecial = false\n\n  // Counter used to disable inline linkify-it execution\n  // inside \u003ca\u003e and markdown links\n  this.linkLevel = 0\n}\n\n// Flush pending text\n//\nStateInline.prototype.pushPending = function () {\n  const token = new Token('text', '', 0)\n  token.content = this.pending\n  token.level = this.pendingLevel\n  this.tokens.push(token)\n  this.pending = ''\n  return token\n}\n\n// Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\nStateInline.prototype.push = function (type, tag, nesting) {\n  if (this.pending) {\n    this.pushPending()\n  }\n\n  const token = new Token(type, tag, nesting)\n  let token_meta = null\n\n  if (nesting \u003c 0) {\n    // closing tag\n    this.level--\n    this.delimiters = this._prev_delimiters.pop()\n  }\n\n  token.level = this.level\n\n  if (nesting \u003e 0) {\n    // opening tag\n    this.level++\n    this._prev_delimiters.push(this.delimiters)\n    this.delimiters = []\n    token_meta = { delimiters: this.delimiters }\n  }\n\n  this.pendingLevel = this.level\n  this.tokens.push(token)\n  this.tokens_meta.push(token_meta)\n  return token\n}\n\n// Scan a sequence of emphasis-like markers, and determine whether\n// it can start an emphasis sequence or end an emphasis sequence.\n//\n//  - start - position to scan from (it should point at a valid marker);\n//  - canSplitWord - determine if these markers can be found inside a word\n//\nStateInline.prototype.scanDelims = function (start, canSplitWord) {\n  const max = this.posMax\n  const marker = this.src.charCodeAt(start)\n\n  // Astral characters below are combined manually, because .codePointAt()\n  // does not guarantee numeric type output. And we don't wish JIT cache issues.\n  // The broken surrogate pairs are evaluated as U+FFFD to prevent possible\n  // crashes.\n\n  let lastChar\n  if (start === 0) {\n    // treat beginning of the line as a whitespace\n    lastChar = 0x20\n  } else if (start === 1) {\n    lastChar = this.src.charCodeAt(0)\n    if ((lastChar \u0026 0xF800) === 0xD800) { lastChar = 0xFFFD }\n  } else {\n    lastChar = this.src.charCodeAt(start - 1)\n    if ((lastChar \u0026 0xFC00) === 0xDC00) {\n      // low surrogate =\u003e add high one, replace broken pair with U+FFFD\n      const highSurr = this.src.charCodeAt(start - 2)\n      lastChar = (highSurr \u0026 0xFC00) === 0xD800\n        ? 0x10000 + ((highSurr - 0xD800) \u003c\u003c 10) + (lastChar - 0xDC00)\n        : 0xFFFD\n    } else if ((lastChar \u0026 0xFC00) === 0xD800) {\n      lastChar = 0xFFFD\n    }\n  }\n\n  let pos = start\n  while (pos \u003c max \u0026\u0026 this.src.charCodeAt(pos) === marker) { pos++ }\n\n  const count = pos - start\n\n  // treat end of the line as a whitespace\n  let nextChar = pos \u003c max ? this.src.charCodeAt(pos) : 0x20\n  if ((nextChar \u0026 0xFC00) === 0xD800) {\n    // high surrogate =\u003e add low one, replace broken pair with U+FFFD\n    const lowSurr = this.src.charCodeAt(pos + 1)\n    nextChar = (lowSurr \u0026 0xFC00) === 0xDC00\n      ? 0x10000 + ((nextChar - 0xD800) \u003c\u003c 10) + (lowSurr - 0xDC00)\n      : 0xFFFD\n  } else if ((nextChar \u0026 0xFC00) === 0xDC00) {\n    nextChar = 0xFFFD\n  }\n\n  const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar)\n  const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar)\n\n  const isLastWhiteSpace = isWhiteSpace(lastChar)\n  const isNextWhiteSpace = isWhiteSpace(nextChar)\n\n  const left_flanking =\n    !isNextWhiteSpace \u0026\u0026 (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar)\n  const right_flanking =\n    !isLastWhiteSpace \u0026\u0026 (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar)\n\n  const can_open = left_flanking \u0026\u0026 (canSplitWord || !right_flanking || isLastPunctChar)\n  const can_close = right_flanking \u0026\u0026 (canSplitWord || !left_flanking || isNextPunctChar)\n\n  return { can_open, can_close, length: count }\n}\n\n// re-export Token class to use in block rules\nStateInline.prototype.Token = Token\n\nexport default StateInline\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\n// !, \", #, $, %, \u0026, ', (, ), *, +, ,, -, ., /, :, ;, \u003c, =, \u003e, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\nfunction isTerminatorChar (ch) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x21/* ! */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* \u0026 */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2D/* - */:\n    case 0x3A/* : */:\n    case 0x3C/* \u003c */:\n    case 0x3D/* = */:\n    case 0x3E/* \u003e */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true\n    default:\n      return false\n  }\n}\n\nexport default function text (state, silent) {\n  let pos = state.pos\n\n  while (pos \u003c state.posMax \u0026\u0026 !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++\n  }\n\n  if (pos === state.pos) { return false }\n\n  if (!silent) { state.pending += state.src.slice(state.pos, pos) }\n\n  state.pos = pos\n\n  return true\n}\n\n// Alternative implementation, for memory.\n//\n// It costs 10% of performance, but allows extend terminators list, if place it\n// to `ParserInline` property. Probably, will switch to it sometime, such\n// flexibility required.\n\n/*\nvar TERMINATOR_RE = /[\\n!#$%\u0026*+\\-:\u003c=\u003e@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -\u003e empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -\u003e text till end of string\n  if (idx \u003c 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n}; */\n","// Early process links like https://example.org/ to have priority\n// over emphasis, etc.\n\n// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\nfunction isAsciiAlpha (code) {\n  return (code \u003e= 0x41 \u0026\u0026 code \u003c= 0x5A) || (code \u003e= 0x61 \u0026\u0026 code \u003c= 0x7A)\n}\n\nfunction isSchemeChar (code) {\n  return (code \u003e= 0x41 \u0026\u0026 code \u003c= 0x5A) ||\n    (code \u003e= 0x61 \u0026\u0026 code \u003c= 0x7A) ||\n    (code \u003e= 0x30 \u0026\u0026 code \u003c= 0x39) ||\n    code === 0x2B || code === 0x2D || code === 0x2E\n}\n\nexport default function linkify (state, silent) {\n  if (!state.md.options.linkify) return false\n  if (state.linkLevel \u003e 0) return false\n\n  const pos = state.pos\n  const max = state.posMax\n\n  if (pos + 3 \u003e max) return false\n  if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false\n  if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false\n  if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false\n\n  // Search backwards for the scheme, but no more than 10 characters, the length\n  // of the pending string, or the length of the source prefix.\n  // Use state.src instead of state.pending because it is faster to access.\n  const protoMin = pos - Math.min(10, state.pending.length, pos)\n  let protoStart = pos\n  while (protoStart \u003e protoMin \u0026\u0026 isSchemeChar(state.src.charCodeAt(protoStart - 1))) {\n    protoStart--\n  }\n\n  if (protoStart === pos || !isAsciiAlpha(state.src.charCodeAt(protoStart))) return false\n\n  const protoLength = pos - protoStart\n\n  const link = state.md.linkify.matchAtStart(state.src.slice(protoStart))\n  if (!link) return false\n\n  let url = link.url\n\n  // invalid link, but still detected by linkify somehow;\n  // need to check to prevent infinite loop below\n  if (url.length \u003c= protoLength) return false\n\n  // disallow '*' at the end of the link (conflicts with emphasis)\n  // do manual backsearch to avoid perf issues with regex /\\*+$/ on \"****...****a\".\n  let urlEnd = url.length\n  while (urlEnd \u003e 0 \u0026\u0026 url.charCodeAt(urlEnd - 1) === 0x2A/* * */) {\n    urlEnd--\n  }\n  if (urlEnd !== url.length) {\n    url = url.slice(0, urlEnd)\n  }\n\n  const fullUrl = state.md.normalizeLink(url)\n  if (!state.md.validateLink(fullUrl)) return false\n\n  if (!silent) {\n    state.pending = state.pending.slice(0, -protoLength)\n\n    const token_o = state.push('link_open', 'a', 1)\n    token_o.attrs = [['href', fullUrl]]\n    token_o.markup = 'linkify'\n    token_o.info = 'auto'\n\n    const token_t = state.push('text', '', 0)\n    token_t.content = state.md.normalizeLinkText(url)\n\n    const token_c = state.push('link_close', 'a', -1)\n    token_c.markup = 'linkify'\n    token_c.info = 'auto'\n  }\n\n  state.pos += url.length - protoLength\n  return true\n}\n","// Proceess '\\n'\n\nimport { isSpace } from '../common/utils.mjs'\n\nexport default function newline (state, silent) {\n  let pos = state.pos\n\n  if (state.src.charCodeAt(pos) !== 0x0A/* \\n */) { return false }\n\n  const pmax = state.pending.length - 1\n  const max = state.posMax\n\n  // '  \\n' -\u003e hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n  if (!silent) {\n    if (pmax \u003e= 0 \u0026\u0026 state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax \u003e= 1 \u0026\u0026 state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Find whitespaces tail of pending chars.\n        let ws = pmax - 1\n        while (ws \u003e= 1 \u0026\u0026 state.pending.charCodeAt(ws - 1) === 0x20) ws--\n\n        state.pending = state.pending.slice(0, ws)\n        state.push('hardbreak', 'br', 0)\n      } else {\n        state.pending = state.pending.slice(0, -1)\n        state.push('softbreak', 'br', 0)\n      }\n    } else {\n      state.push('softbreak', 'br', 0)\n    }\n  }\n\n  pos++\n\n  // skip heading spaces for next line\n  while (pos \u003c max \u0026\u0026 isSpace(state.src.charCodeAt(pos))) { pos++ }\n\n  state.pos = pos\n  return true\n}\n","// Process escaped chars and hardbreaks\n\nimport { isSpace } from '../common/utils.mjs'\n\nconst ESCAPED = []\n\nfor (let i = 0; i \u003c 256; i++) { ESCAPED.push(0) }\n\n'\\\\!\"#$%\u0026\\'()*+,./:;\u003c=\u003e?@[]^_`{|}~-'\n  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1 })\n\nexport default function escape (state, silent) {\n  let pos = state.pos\n  const max = state.posMax\n\n  if (state.src.charCodeAt(pos) !== 0x5C/* \\ */) return false\n  pos++\n\n  // '\\' at the end of the inline block\n  if (pos \u003e= max) return false\n\n  let ch1 = state.src.charCodeAt(pos)\n\n  if (ch1 === 0x0A) {\n    if (!silent) {\n      state.push('hardbreak', 'br', 0)\n    }\n\n    pos++\n    // skip leading whitespaces from next line\n    while (pos \u003c max) {\n      ch1 = state.src.charCodeAt(pos)\n      if (!isSpace(ch1)) break\n      pos++\n    }\n\n    state.pos = pos\n    return true\n  }\n\n  // '\\' before a space is a literal backslash. Don't consume the space, so a\n  // trailing two-space hard line break is still detected by the newline rule.\n  if (ch1 === 0x20) {\n    if (!silent) {\n      const token = state.push('text_special', '', 0)\n      token.content = '\\\\'\n      token.markup = '\\\\'\n      token.info = 'escape'\n    }\n\n    state.pos = pos\n    return true\n  }\n\n  let escapedStr = state.src[pos]\n\n  if (ch1 \u003e= 0xD800 \u0026\u0026 ch1 \u003c= 0xDBFF \u0026\u0026 pos + 1 \u003c max) {\n    const ch2 = state.src.charCodeAt(pos + 1)\n\n    if (ch2 \u003e= 0xDC00 \u0026\u0026 ch2 \u003c= 0xDFFF) {\n      escapedStr += state.src[pos + 1]\n      pos++\n    }\n  }\n\n  const origStr = '\\\\' + escapedStr\n\n  if (!silent) {\n    const token = state.push('text_special', '', 0)\n\n    if (ch1 \u003c 256 \u0026\u0026 ESCAPED[ch1] !== 0) {\n      token.content = escapedStr\n    } else {\n      token.content = origStr\n    }\n\n    token.markup = origStr\n    token.info = 'escape'\n  }\n\n  state.pos = pos + 1\n  return true\n}\n","// Parse backticks\n\nexport default function backtick (state, silent) {\n  let pos = state.pos\n  const ch = state.src.charCodeAt(pos)\n\n  if (ch !== 0x60/* ` */) { return false }\n\n  const start = pos\n  pos++\n  const max = state.posMax\n\n  // scan marker length\n  while (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x60/* ` */) { pos++ }\n\n  const marker = state.src.slice(start, pos)\n  const openerLength = marker.length\n\n  if (state.backticksScanned \u0026\u0026 (state.backticks[openerLength] || 0) \u003c= start) {\n    if (!silent) state.pending += marker\n    state.pos += openerLength\n    return true\n  }\n\n  let matchEnd = pos\n  let matchStart\n\n  // Nothing found in the cache, scan until the end of the line (or until marker is found)\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1\n\n    // scan marker length\n    while (matchEnd \u003c max \u0026\u0026 state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++ }\n\n    const closerLength = matchEnd - matchStart\n\n    if (closerLength === openerLength) {\n      // Found matching closer length.\n      if (!silent) {\n        const token = state.push('code_inline', 'code', 0)\n        token.markup = marker\n        token.content = state.src.slice(pos, matchStart)\n          .replace(/\\n/g, ' ')\n          .replace(/^ (.+) $/, '$1')\n      }\n      state.pos = matchEnd\n      return true\n    }\n\n    // Some different length found, put it in cache as upper limit of where closer can be found\n    state.backticks[closerLength] = matchStart\n  }\n\n  // Scanned through the end, didn't find anything\n  state.backticksScanned = true\n\n  if (!silent) state.pending += marker\n  state.pos += openerLength\n  return true\n}\n","// ~~strike through~~\n//\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nfunction strikethrough_tokenize (state, silent) {\n  const start = state.pos\n  const marker = state.src.charCodeAt(start)\n\n  if (silent) { return false }\n\n  if (marker !== 0x7E/* ~ */) { return false }\n\n  const scanned = state.scanDelims(state.pos, true)\n  let len = scanned.length\n  const ch = String.fromCharCode(marker)\n\n  if (len \u003c 2) { return false }\n\n  let token\n\n  if (len % 2) {\n    token = state.push('text', '', 0)\n    token.content = ch\n    len--\n  }\n\n  for (let i = 0; i \u003c len; i += 2) {\n    token = state.push('text', '', 0)\n    token.content = ch + ch\n\n    state.delimiters.push({\n      marker,\n      length: 0,     // disable \"rule of 3\" length checks meant for emphasis\n      token: state.tokens.length - 1,\n      end: -1,\n      open: scanned.can_open,\n      close: scanned.can_close\n    })\n  }\n\n  state.pos += scanned.length\n\n  return true\n}\n\nfunction postProcess (state, delimiters) {\n  let token\n  const loneMarkers = []\n  const max = delimiters.length\n\n  for (let i = 0; i \u003c max; i++) {\n    const startDelim = delimiters[i]\n\n    if (startDelim.marker !== 0x7E/* ~ */) {\n      continue\n    }\n\n    if (startDelim.end === -1) {\n      continue\n    }\n\n    const endDelim = delimiters[startDelim.end]\n\n    token = state.tokens[startDelim.token]\n    token.type = 's_open'\n    token.tag = 's'\n    token.nesting = 1\n    token.markup = '~~'\n    token.content = ''\n\n    token = state.tokens[endDelim.token]\n    token.type = 's_close'\n    token.tag = 's'\n    token.nesting = -1\n    token.markup = '~~'\n    token.content = ''\n\n    if (state.tokens[endDelim.token - 1].type === 'text' \u0026\u0026\n        state.tokens[endDelim.token - 1].content === '~') {\n      loneMarkers.push(endDelim.token - 1)\n    }\n  }\n\n  // If a marker sequence has an odd number of characters, it's splitted\n  // like this: `~~~~~` -\u003e `~` + `~~` + `~~`, leaving one marker at the\n  // start of the sequence.\n  //\n  // So, we have to move all those markers after subsequent s_close tags.\n  //\n  while (loneMarkers.length) {\n    const i = loneMarkers.pop()\n    let j = i + 1\n\n    while (j \u003c state.tokens.length \u0026\u0026 state.tokens[j].type === 's_close') {\n      j++\n    }\n\n    j--\n\n    if (i !== j) {\n      token = state.tokens[j]\n      state.tokens[j] = state.tokens[i]\n      state.tokens[i] = token\n    }\n  }\n}\n\n// Walk through delimiter list and replace text tokens with tags\n//\nfunction strikethrough_postProcess (state) {\n  const tokens_meta = state.tokens_meta\n  const max = state.tokens_meta.length\n\n  postProcess(state, state.delimiters)\n\n  for (let curr = 0; curr \u003c max; curr++) {\n    if (tokens_meta[curr] \u0026\u0026 tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters)\n    }\n  }\n}\n\nexport default {\n  tokenize: strikethrough_tokenize,\n  postProcess: strikethrough_postProcess\n}\n","// Process *this* and _that_\n//\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nfunction emphasis_tokenize (state, silent) {\n  const start = state.pos\n  const marker = state.src.charCodeAt(start)\n\n  if (silent) { return false }\n\n  if (marker !== 0x5F /* _ */ \u0026\u0026 marker !== 0x2A /* * */) { return false }\n\n  const scanned = state.scanDelims(state.pos, marker === 0x2A)\n\n  for (let i = 0; i \u003c scanned.length; i++) {\n    const token = state.push('text', '', 0)\n    token.content = String.fromCharCode(marker)\n\n    state.delimiters.push({\n      // Char code of the starting marker (number).\n      //\n      marker,\n\n      // Total length of these series of delimiters.\n      //\n      length: scanned.length,\n\n      // A position of the token this delimiter corresponds to.\n      //\n      token: state.tokens.length - 1,\n\n      // If this delimiter is matched as a valid opener, `end` will be\n      // equal to its position, otherwise it's `-1`.\n      //\n      end: -1,\n\n      // Boolean flags that determine if this delimiter could open or close\n      // an emphasis.\n      //\n      open: scanned.can_open,\n      close: scanned.can_close\n    })\n  }\n\n  state.pos += scanned.length\n\n  return true\n}\n\nfunction postProcess (state, delimiters) {\n  const max = delimiters.length\n\n  for (let i = max - 1; i \u003e= 0; i--) {\n    const startDelim = delimiters[i]\n\n    if (startDelim.marker !== 0x5F/* _ */ \u0026\u0026 startDelim.marker !== 0x2A/* * */) {\n      continue\n    }\n\n    // Process only opening markers\n    if (startDelim.end === -1) {\n      continue\n    }\n\n    const endDelim = delimiters[startDelim.end]\n\n    // If the previous delimiter has the same marker and is adjacent to this one,\n    // merge those into one strong delimiter.\n    //\n    // `\u003cem\u003e\u003cem\u003ewhatever\u003c/em\u003e\u003c/em\u003e` -\u003e `\u003cstrong\u003ewhatever\u003c/strong\u003e`\n    //\n    const isStrong = i \u003e 0 \u0026\u0026\n               delimiters[i - 1].end === startDelim.end + 1 \u0026\u0026\n               // check that first two markers match and adjacent\n               delimiters[i - 1].marker === startDelim.marker \u0026\u0026\n               delimiters[i - 1].token === startDelim.token - 1 \u0026\u0026\n               // check that last two markers are adjacent (we can safely assume they match)\n               delimiters[startDelim.end + 1].token === endDelim.token + 1\n\n    const ch = String.fromCharCode(startDelim.marker)\n\n    const token_o = state.tokens[startDelim.token]\n    token_o.type = isStrong ? 'strong_open' : 'em_open'\n    token_o.tag = isStrong ? 'strong' : 'em'\n    token_o.nesting = 1\n    token_o.markup = isStrong ? ch + ch : ch\n    token_o.content = ''\n\n    const token_c = state.tokens[endDelim.token]\n    token_c.type = isStrong ? 'strong_close' : 'em_close'\n    token_c.tag = isStrong ? 'strong' : 'em'\n    token_c.nesting = -1\n    token_c.markup = isStrong ? ch + ch : ch\n    token_c.content = ''\n\n    if (isStrong) {\n      state.tokens[delimiters[i - 1].token].content = ''\n      state.tokens[delimiters[startDelim.end + 1].token].content = ''\n      i--\n    }\n  }\n}\n\n// Walk through delimiter list and replace text tokens with tags\n//\nfunction emphasis_post_process (state) {\n  const tokens_meta = state.tokens_meta\n  const max = state.tokens_meta.length\n\n  postProcess(state, state.delimiters)\n\n  for (let curr = 0; curr \u003c max; curr++) {\n    if (tokens_meta[curr] \u0026\u0026 tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters)\n    }\n  }\n}\n\nexport default {\n  tokenize: emphasis_tokenize,\n  postProcess: emphasis_post_process\n}\n","// Process [link](\u003cto\u003e \"stuff\")\n\nimport { normalizeReference, isSpace } from '../common/utils.mjs'\n\nexport default function link (state, silent) {\n  let code, label, res, ref\n  let href = ''\n  let title = ''\n  let start = state.pos\n  let parseReference = true\n\n  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false }\n\n  const oldPos = state.pos\n  const max = state.posMax\n  const labelStart = state.pos + 1\n  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true)\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd \u003c 0) { return false }\n\n  let pos = labelEnd + 1\n  if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++\n    for (; pos \u003c max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break }\n    }\n    if (pos \u003e= max) { return false }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str)\n      if (state.md.validateLink(href)) {\n        pos = res.pos\n      } else {\n        href = ''\n      }\n\n      // [link](  \u003chref\u003e  \"title\"  )\n      //                ^^ skipping these spaces\n      start = pos\n      for (; pos \u003c max; pos++) {\n        code = state.src.charCodeAt(pos)\n        if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break }\n      }\n\n      // [link](  \u003chref\u003e  \"title\"  )\n      //                  ^^^^^^^ parsing link title\n      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)\n      if (pos \u003c max \u0026\u0026 start !== pos \u0026\u0026 res.ok) {\n        title = res.str\n        pos = res.pos\n\n        // [link](  \u003chref\u003e  \"title\"  )\n        //                         ^^ skipping these spaces\n        for (; pos \u003c max; pos++) {\n          code = state.src.charCodeAt(pos)\n          if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break }\n        }\n      }\n    }\n\n    if (pos \u003e= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true\n    }\n    pos++\n  }\n\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false }\n\n    if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1\n      pos = state.md.helpers.parseLinkLabel(state, pos)\n      if (pos \u003e= 0) {\n        label = state.src.slice(start, pos++)\n      } else {\n        pos = labelEnd + 1\n      }\n    } else {\n      pos = labelEnd + 1\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd) }\n\n    ref = state.env.references[normalizeReference(label)]\n    if (!ref) {\n      state.pos = oldPos\n      return false\n    }\n    href = ref.href\n    title = ref.title\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    state.pos = labelStart\n    state.posMax = labelEnd\n\n    const token_o = state.push('link_open', 'a', 1)\n    const attrs = [['href', href]]\n    token_o.attrs = attrs\n    if (title) {\n      attrs.push(['title', title])\n    }\n\n    state.linkLevel++\n    state.md.inline.tokenize(state)\n    state.linkLevel--\n\n    state.push('link_close', 'a', -1)\n  }\n\n  state.pos = pos\n  state.posMax = max\n  return true\n}\n","// Process ![image](\u003csrc\u003e \"title\")\n\nimport { normalizeReference, isSpace } from '../common/utils.mjs'\n\nexport default function image (state, silent) {\n  let code, content, label, pos, ref, res, title, start\n  let href = ''\n  const oldPos = state.pos\n  const max = state.posMax\n\n  if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false }\n  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false }\n\n  const labelStart = state.pos + 2\n  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false)\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd \u003c 0) { return false }\n\n  pos = labelEnd + 1\n  if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++\n    for (; pos \u003c max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break }\n    }\n    if (pos \u003e= max) { return false }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str)\n      if (state.md.validateLink(href)) {\n        pos = res.pos\n      } else {\n        href = ''\n      }\n    }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos\n    for (; pos \u003c max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break }\n    }\n\n    // [link](  \u003chref\u003e  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)\n    if (pos \u003c max \u0026\u0026 start !== pos \u0026\u0026 res.ok) {\n      title = res.str\n      pos = res.pos\n\n      // [link](  \u003chref\u003e  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos \u003c max; pos++) {\n        code = state.src.charCodeAt(pos)\n        if (!isSpace(code) \u0026\u0026 code !== 0x0A) { break }\n      }\n    } else {\n      title = ''\n    }\n\n    if (pos \u003e= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      state.pos = oldPos\n      return false\n    }\n    pos++\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false }\n\n    if (pos \u003c max \u0026\u0026 state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1\n      pos = state.md.helpers.parseLinkLabel(state, pos)\n      if (pos \u003e= 0) {\n        label = state.src.slice(start, pos++)\n      } else {\n        pos = labelEnd + 1\n      }\n    } else {\n      pos = labelEnd + 1\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd) }\n\n    ref = state.env.references[normalizeReference(label)]\n    if (!ref) {\n      state.pos = oldPos\n      return false\n    }\n    href = ref.href\n    title = ref.title\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd)\n\n    const tokens = []\n    state.md.inline.parse(\n      content,\n      state.md,\n      state.env,\n      tokens\n    )\n\n    const token = state.push('image', 'img', 0)\n    const attrs = [['src', href], ['alt', '']]\n    token.attrs = attrs\n    token.children = tokens\n    token.content = content\n\n    if (title) {\n      attrs.push(['title', title])\n    }\n  }\n\n  state.pos = pos\n  state.posMax = max\n  return true\n}\n","// Process autolinks '\u003cprotocol:...\u003e'\n\n/* eslint max-len:0 */\nconst EMAIL_RE = /^([a-zA-Z0-9.!#$%\u0026'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/\n/* eslint-disable-next-line no-control-regex */\nconst AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^\u003c\u003e\\x00-\\x20]*)$/\n\nexport default function autolink (state, silent) {\n  let pos = state.pos\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* \u003c */) { return false }\n\n  const start = state.pos\n  const max = state.posMax\n\n  for (;;) {\n    if (++pos \u003e= max) return false\n\n    const ch = state.src.charCodeAt(pos)\n\n    if (ch === 0x3C /* \u003c */) return false\n    if (ch === 0x3E /* \u003e */) break\n  }\n\n  const url = state.src.slice(start + 1, pos)\n\n  if (AUTOLINK_RE.test(url)) {\n    const fullUrl = state.md.normalizeLink(url)\n    if (!state.md.validateLink(fullUrl)) { return false }\n\n    if (!silent) {\n      const token_o = state.push('link_open', 'a', 1)\n      token_o.attrs = [['href', fullUrl]]\n      token_o.markup = 'autolink'\n      token_o.info = 'auto'\n\n      const token_t = state.push('text', '', 0)\n      token_t.content = state.md.normalizeLinkText(url)\n\n      const token_c = state.push('link_close', 'a', -1)\n      token_c.markup = 'autolink'\n      token_c.info = 'auto'\n    }\n\n    state.pos += url.length + 2\n    return true\n  }\n\n  if (EMAIL_RE.test(url)) {\n    const fullUrl = state.md.normalizeLink('mailto:' + url)\n    if (!state.md.validateLink(fullUrl)) { return false }\n\n    if (!silent) {\n      const token_o = state.push('link_open', 'a', 1)\n      token_o.attrs = [['href', fullUrl]]\n      token_o.markup = 'autolink'\n      token_o.info = 'auto'\n\n      const token_t = state.push('text', '', 0)\n      token_t.content = state.md.normalizeLinkText(url)\n\n      const token_c = state.push('link_close', 'a', -1)\n      token_c.markup = 'autolink'\n      token_c.info = 'auto'\n    }\n\n    state.pos += url.length + 2\n    return true\n  }\n\n  return false\n}\n","// Process html tags\n\nimport { HTML_OPEN_CLOSE_TAG_RE } from '../common/html_re.mjs'\n\nfunction isLinkOpen (str) {\n  return /^\u003ca[\u003e\\s]/i.test(str)\n}\nfunction isLinkClose (str) {\n  return /^\u003c\\/a\\s*\u003e/i.test(str)\n}\n\nfunction isLetter (ch) {\n  /* eslint no-bitwise:0 */\n  const lc = ch | 0x20 // to lower case\n  return (lc \u003e= 0x61/* a */) \u0026\u0026 (lc \u003c= 0x7a/* z */)\n}\n\n// Comment, processing instruction, declaration or CDATA: fixed opener,\n// then everything up to the first terminator. Returns end position or -1.\nfunction scanSpecial (state, pos) {\n  const src = state.src\n  let start\n  let terminator\n\n  if (src.startsWith('\u003c!--', pos)) {\n    if (src.startsWith('\u003e', pos + 4)) { return pos + 5 }\n    if (src.startsWith('-\u003e', pos + 4)) { return pos + 6 }\n    start = pos + 4\n    terminator = '--\u003e'\n  } else if (src.startsWith('\u003c![CDATA[', pos)) {\n    start = pos + 9\n    terminator = ']]\u003e'\n  } else if (src.charCodeAt(pos + 1) === 0x3F/* ? */) {\n    start = pos + 2\n    terminator = '?\u003e'\n  } else if (isLetter(src.charCodeAt(pos + 2))) {\n    start = pos + 3\n    terminator = '\u003e'\n  } else {\n    return -1\n  }\n\n  if (state.skipHtmlSpecial) { return -1 }\n\n  const end = src.indexOf(terminator, start)\n  if (end \u003c 0) {\n    // One flag for all constructs to keep code simple. Valid constructs after\n    // an unclosed one in the same paragraph become text, that's acceptable.\n    state.skipHtmlSpecial = true\n    return -1\n  }\n  return end + terminator.length\n}\n\nexport default function html_inline (state, silent) {\n  if (!state.md.options.html) { return false }\n\n  // Check start\n  const max = state.posMax\n  const pos = state.pos\n  if (state.src.charCodeAt(pos) !== 0x3C/* \u003c */ ||\n      pos + 2 \u003e= max) {\n    return false\n  }\n\n  let end\n  const ch = state.src.charCodeAt(pos + 1)\n\n  if (ch === 0x21/* ! */ || ch === 0x3F/* ? */) {\n    end = scanSpecial(state, pos)\n  } else if (ch === 0x2F/* / */ || isLetter(ch)) {\n    const match = state.src.slice(pos).match(HTML_OPEN_CLOSE_TAG_RE)\n    end = match ? pos + match[0].length : -1\n  } else {\n    return false\n  }\n\n  if (end \u003c 0) { return false }\n\n  if (!silent) {\n    const token = state.push('html_inline', '', 0)\n    token.content = state.src.slice(pos, end)\n\n    if (isLinkOpen(token.content)) state.linkLevel++\n    if (isLinkClose(token.content)) state.linkLevel--\n  }\n  state.pos = end\n  return true\n}\n","// Process html entity - \u0026#123;, \u0026#xAF;, \u0026quot;, ...\n\nimport { decodeHTMLStrict } from 'entities'\nimport { isValidEntityCode, fromCodePoint } from '../common/utils.mjs'\n\nconst DIGITAL_RE = /^\u0026#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i\nconst NAMED_RE = /^\u0026([a-z][a-z0-9]{1,31});/i\n\nexport default function entity (state, silent) {\n  const pos = state.pos\n  const max = state.posMax\n\n  if (state.src.charCodeAt(pos) !== 0x26/* \u0026 */) return false\n\n  if (pos + 1 \u003e= max) return false\n\n  const ch = state.src.charCodeAt(pos + 1)\n\n  if (ch === 0x23 /* # */) {\n    const match = state.src.slice(pos).match(DIGITAL_RE)\n    if (match) {\n      if (!silent) {\n        const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10)\n\n        const token = state.push('text_special', '', 0)\n        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD)\n        token.markup = match[0]\n        token.info = 'entity'\n      }\n      state.pos += match[0].length\n      return true\n    }\n  } else {\n    const match = state.src.slice(pos).match(NAMED_RE)\n    if (match) {\n      const decoded = decodeHTMLStrict(match[0])\n      if (decoded !== match[0]) {\n        if (!silent) {\n          const token = state.push('text_special', '', 0)\n          token.content = decoded\n          token.markup = match[0]\n          token.info = 'entity'\n        }\n        state.pos += match[0].length\n        return true\n      }\n    }\n  }\n\n  return false\n}\n","// For each opening emphasis-like marker find a matching closing one\n//\n\nfunction processDelimiters (delimiters) {\n  const openersBottom = {}\n  const max = delimiters.length\n\n  if (!max) return\n\n  // headerIdx is the first delimiter of the current (where closer is) delimiter run\n  let headerIdx = 0\n  let lastTokenIdx = -2 // needs any value lower than -1\n  const jumps = []\n\n  for (let closerIdx = 0; closerIdx \u003c max; closerIdx++) {\n    const closer = delimiters[closerIdx]\n\n    jumps.push(0)\n\n    // markers belong to same delimiter run if:\n    //  - they have adjacent tokens\n    //  - AND markers are the same\n    //\n    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {\n      headerIdx = closerIdx\n    }\n\n    lastTokenIdx = closer.token\n\n    // Length is only used for emphasis-specific \"rule of 3\",\n    // if it's not defined (in strikethrough or 3rd party plugins),\n    // we can default it to 0 to disable those checks.\n    //\n    closer.length = closer.length || 0\n\n    if (!closer.close) continue\n\n    // Previously calculated lower bounds (previous fails)\n    // for each marker, each delimiter length modulo 3,\n    // and for whether this closer can be an opener;\n    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460\n    /* eslint-disable-next-line no-prototype-builtins */\n    if (!openersBottom.hasOwnProperty(closer.marker)) {\n      openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1]\n    }\n\n    const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length % 3)]\n\n    let openerIdx = headerIdx - jumps[headerIdx] - 1\n\n    let newMinOpenerIdx = openerIdx\n\n    for (; openerIdx \u003e minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {\n      const opener = delimiters[openerIdx]\n\n      if (opener.marker !== closer.marker) continue\n\n      if (opener.open \u0026\u0026 opener.end \u003c 0) {\n        let isOddMatch = false\n\n        // from spec:\n        //\n        // If one of the delimiters can both open and close emphasis, then the\n        // sum of the lengths of the delimiter runs containing the opening and\n        // closing delimiters must not be a multiple of 3 unless both lengths\n        // are multiples of 3.\n        //\n        if (opener.close || closer.open) {\n          if ((opener.length + closer.length) % 3 === 0) {\n            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {\n              isOddMatch = true\n            }\n          }\n        }\n\n        if (!isOddMatch) {\n          // If previous delimiter cannot be an opener, we can safely skip\n          // the entire sequence in future checks. This is required to make\n          // sure algorithm has linear complexity (see *_*_*_*_*_... case).\n          //\n          const lastJump = openerIdx \u003e 0 \u0026\u0026 !delimiters[openerIdx - 1].open\n            ? jumps[openerIdx - 1] + 1\n            : 0\n\n          jumps[closerIdx] = closerIdx - openerIdx + lastJump\n          jumps[openerIdx] = lastJump\n\n          closer.open = false\n          opener.end = closerIdx\n          opener.close = false\n          newMinOpenerIdx = -1\n          // treat next token as start of run,\n          // it optimizes skips in **\u003c...\u003e**a**\u003c...\u003e** pathological case\n          lastTokenIdx = -2\n          break\n        }\n      }\n    }\n\n    if (newMinOpenerIdx !== -1) {\n      // If match for this delimiter run failed, we want to set lower bound for\n      // future lookups. This is required to make sure algorithm has linear\n      // complexity.\n      //\n      // See details here:\n      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442\n      //\n      openersBottom[closer.marker][(closer.open ? 3 : 0) + ((closer.length || 0) % 3)] = newMinOpenerIdx\n    }\n  }\n}\n\nexport default function link_pairs (state) {\n  const tokens_meta = state.tokens_meta\n  const max = state.tokens_meta.length\n\n  processDelimiters(state.delimiters)\n\n  for (let curr = 0; curr \u003c max; curr++) {\n    if (tokens_meta[curr] \u0026\u0026 tokens_meta[curr].delimiters) {\n      processDelimiters(tokens_meta[curr].delimiters)\n    }\n  }\n}\n","// Clean up tokens after emphasis and strikethrough postprocessing:\n// merge adjacent text nodes into one and re-calculate all token levels\n//\n// This is necessary because initially emphasis delimiter markers (*, _, ~)\n// are treated as their own separate text tokens. Then emphasis rule either\n// leaves them as text (needed to merge with adjacent text) or turns them\n// into opening/closing tags (which messes up levels inside).\n//\n\nexport default function fragments_join (state) {\n  let curr, last\n  let level = 0\n  const tokens = state.tokens\n  const max = state.tokens.length\n\n  for (curr = last = 0; curr \u003c max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting \u003c 0) level-- // closing tag\n    tokens[curr].level = level\n    if (tokens[curr].nesting \u003e 0) level++ // opening tag\n\n    if (tokens[curr].type === 'text' \u0026\u0026\n        curr + 1 \u003c max \u0026\u0026\n        tokens[curr + 1].type === 'text') {\n      // collapse two adjacent text nodes\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content\n    } else {\n      if (curr !== last) { tokens[last] = tokens[curr] }\n\n      last++\n    }\n  }\n\n  if (curr !== last) {\n    tokens.length = last\n  }\n}\n","/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n\nimport Ruler from './ruler.mjs'\nimport StateInline from './rules_inline/state_inline.mjs'\n\nimport r_text from './rules_inline/text.mjs'\nimport r_linkify from './rules_inline/linkify.mjs'\nimport r_newline from './rules_inline/newline.mjs'\nimport r_escape from './rules_inline/escape.mjs'\nimport r_backticks from './rules_inline/backticks.mjs'\nimport r_strikethrough from './rules_inline/strikethrough.mjs'\nimport r_emphasis from './rules_inline/emphasis.mjs'\nimport r_link from './rules_inline/link.mjs'\nimport r_image from './rules_inline/image.mjs'\nimport r_autolink from './rules_inline/autolink.mjs'\nimport r_html_inline from './rules_inline/html_inline.mjs'\nimport r_entity from './rules_inline/entity.mjs'\n\nimport r_balance_pairs from './rules_inline/balance_pairs.mjs'\nimport r_fragments_join from './rules_inline/fragments_join.mjs'\n\n// Parser rules\n\nconst _rules = [\n  ['text', r_text],\n  ['linkify', r_linkify],\n  ['newline', r_newline],\n  ['escape', r_escape],\n  ['backticks', r_backticks],\n  ['strikethrough', r_strikethrough.tokenize],\n  ['emphasis', r_emphasis.tokenize],\n  ['link', r_link],\n  ['image', r_image],\n  ['autolink', r_autolink],\n  ['html_inline', r_html_inline],\n  ['entity', r_entity]\n]\n\n// `rule2` ruleset was created specifically for emphasis/strikethrough\n// post-processing and may be changed in the future.\n//\n// Don't use this for anything except pairs (plugins working with `balance_pairs`).\n//\nconst _rules2 = [\n  ['balance_pairs', r_balance_pairs],\n  ['strikethrough', r_strikethrough.postProcess],\n  ['emphasis', r_emphasis.postProcess],\n  // rules for pairs separate '**' into its own text tokens, which may be left unused,\n  // rule below merges unused segments back with the rest of the text\n  ['fragments_join', r_fragments_join]\n]\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline () {\n  /**\n   * ParserInline#ruler -\u003e Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i \u003c _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1])\n  }\n\n  /**\n   * ParserInline#ruler2 -\u003e Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler()\n\n  for (let i = 0; i \u003c _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1])\n  }\n}\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  const pos = state.pos\n  const rules = this.ruler.getRules('')\n  const len = rules.length\n  const maxNesting = state.md.options.maxNesting\n  const cache = state.cache\n\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos]\n    return\n  }\n\n  let ok = false\n\n  if (state.level \u003c maxNesting) {\n    for (let i = 0; i \u003c len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++\n      ok = rules[i](state, true)\n      state.level--\n\n      if (ok) {\n        if (pos \u003e= state.pos) { throw new Error(\"inline rule didn't increment state.pos\") }\n        break\n      }\n    }\n  } else {\n    // Too much nesting, just skip until the end of the paragraph.\n    //\n    // NOTE: this will cause links to behave incorrectly in the following case,\n    //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n    //\n    //       [[[[[[[[[[[[[[[[[[[[[foo]()\n    //\n    // TODO: remove this workaround when CM standard will allow nested links\n    //       (we can replace it by preventing links from being parsed in\n    //       validation mode)\n    //\n    state.pos = state.posMax\n  }\n\n  if (!ok) { state.pos++ }\n  cache[pos] = state.pos\n}\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  const rules = this.ruler.getRules('')\n  const len = rules.length\n  const end = state.posMax\n  const maxNesting = state.md.options.maxNesting\n\n  while (state.pos \u003c end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n    const prevPos = state.pos\n    let ok = false\n\n    if (state.level \u003c maxNesting) {\n      for (let i = 0; i \u003c len; i++) {\n        ok = rules[i](state, false)\n        if (ok) {\n          if (prevPos \u003e= state.pos) { throw new Error(\"inline rule didn't increment state.pos\") }\n          break\n        }\n      }\n    }\n\n    if (ok) {\n      if (state.pos \u003e= end) { break }\n      continue\n    }\n\n    state.pending += state.src[state.pos++]\n  }\n\n  if (state.pending) {\n    state.pushPending()\n  }\n}\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  const state = new this.State(str, md, env, outTokens)\n\n  this.tokenize(state)\n\n  const rules = this.ruler2.getRules('')\n  const len = rules.length\n\n  for (let i = 0; i \u003c len; i++) {\n    rules[i](state)\n  }\n}\n\nParserInline.prototype.State = StateInline\n\nexport default ParserInline\n","// Main parser class\n\nimport * as utils from './common/utils.mjs'\nimport * as helpers from './helpers/index.mjs'\nimport Renderer from './renderer.mjs'\nimport ParserCore from './parser_core.mjs'\nimport ParserBlock from './parser_block.mjs'\nimport ParserInline from './parser_inline.mjs'\nimport LinkifyIt from 'linkify-it'\nimport * as mdurl from 'mdurl'\nimport punycode from 'punycode.js'\n\nimport cfg_default from './presets/default.mjs'\nimport cfg_zero from './presets/zero.mjs'\nimport cfg_commonmark from './presets/commonmark.mjs'\n\nconst config = {\n  default: cfg_default,\n  zero: cfg_zero,\n  commonmark: cfg_commonmark\n}\n\n//\n// This validator can prohibit more than really needed to prevent XSS. It's a\n// tradeoff to keep code simple and to be secure by default.\n//\n// If you need different setup - override validator method as you wish. Or\n// replace it with dummy function and use external sanitizer.\n//\n\nconst BAD_PROTO_RE = /^(vbscript|javascript|file|data):/\nconst GOOD_DATA_RE = /^data:image\\/(gif|png|jpeg|webp);/\n\nfunction validateLink (url) {\n  // url should be normalized at this point, and existing entities are decoded\n  const str = url.trim().toLowerCase()\n\n  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true\n}\n\nconst RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:']\n\nfunction normalizeLink (url) {\n  const parsed = mdurl.parse(url, true)\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) \u003e= 0) {\n      try {\n        parsed.hostname = punycode.toASCII(parsed.hostname)\n      } catch (er) { /**/ }\n    }\n  }\n\n  return mdurl.encode(mdurl.format(parsed))\n}\n\nfunction normalizeLinkText (url) {\n  const parsed = mdurl.parse(url, true)\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) \u003e= 0) {\n      try {\n        parsed.hostname = punycode.toUnicode(parsed.hostname)\n      } catch (er) { /**/ }\n    }\n  }\n\n  // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720\n  return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%')\n}\n\n/**\n * class MarkdownIt\n *\n * Main parser/renderer class.\n *\n * ##### Usage\n *\n * ```javascript\n * // node.js, \"classic\" way:\n * var MarkdownIt = require('markdown-it'),\n *     md = new MarkdownIt();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // node.js, the same, but with sugar:\n * var md = require('markdown-it')();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // browser without AMD, added to \"window\" on script load\n * // Note, there are no dash.\n * var md = window.markdownit();\n * var result = md.render('# markdown-it rulezz!');\n * ```\n *\n * Single line rendering, without paragraph wrap:\n *\n * ```javascript\n * var md = require('markdown-it')();\n * var result = md.renderInline('__markdown-it__ rulezz!');\n * ```\n **/\n\n/**\n * new MarkdownIt([presetName, options])\n * - presetName (String): optional, `commonmark` / `zero`\n * - options (Object)\n *\n * Creates parser instanse with given config. Can be called without `new`.\n *\n * ##### presetName\n *\n * MarkdownIt provides named presets as a convenience to quickly\n * enable/disable active syntax rules and options for common use cases.\n *\n * - [\"commonmark\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -\n *   configures parser to strict [CommonMark](http://commonmark.org/) mode.\n * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -\n *   similar to GFM, used when no preset name given. Enables all available rules,\n *   but still without html, typographer \u0026 autolinker.\n * - [\"zero\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -\n *   all rules disabled. Useful to quickly setup your config via `.enable()`.\n *   For example, when you need only `bold` and `italic` markup and nothing else.\n *\n * ##### options:\n *\n * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!\n *   That's not safe! You may need external sanitizer to protect output from XSS.\n *   It's better to extend features via plugins, instead of enabling HTML.\n * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags\n *   (`\u003cbr /\u003e`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `\u003cbr\u003e`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +\n *   quotes beautification (smartquotes).\n * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement\n *   pairs, when typographer enabled and smartquotes on. For example, you can\n *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and\n *   `['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›']` for French (including nbsp).\n * - __highlight__ - `null`. Highlighter function for fenced code blocks.\n *   Highlighter `function (str, lang)` should return escaped HTML. It can also\n *   return empty string if the source was not changed and should be escaped\n *   externaly. If result starts with \u003cpre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang \u0026\u0026 hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `\u003cpre\u003e` or `\u003ccode\u003e`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang \u0026\u0026 hljs.getLanguage(lang)) {\n *       try {\n *         return '\u003cpre\u003e\u003ccode class=\"hljs\"\u003e' +\n *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n *                '\u003c/code\u003e\u003c/pre\u003e';\n *       } catch (__) {}\n *     }\n *\n *     return '\u003cpre\u003e\u003ccode class=\"hljs\"\u003e' + md.utils.escapeHtml(str) + '\u003c/code\u003e\u003c/pre\u003e';\n *   }\n * });\n * ```\n *\n **/\nfunction MarkdownIt (presetName, options) {\n  if (!(this instanceof MarkdownIt)) {\n    return new MarkdownIt(presetName, options)\n  }\n\n  if (!options) {\n    if (!utils.isString(presetName)) {\n      options = presetName || {}\n      presetName = 'default'\n    }\n  }\n\n  /**\n   * MarkdownIt#inline -\u003e ParserInline\n   *\n   * Instance of [[ParserInline]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.inline = new ParserInline()\n\n  /**\n   * MarkdownIt#block -\u003e ParserBlock\n   *\n   * Instance of [[ParserBlock]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.block = new ParserBlock()\n\n  /**\n   * MarkdownIt#core -\u003e Core\n   *\n   * Instance of [[Core]] chain executor. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.core = new ParserCore()\n\n  /**\n   * MarkdownIt#renderer -\u003e Renderer\n   *\n   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   *\n   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).\n   **/\n  this.renderer = new Renderer()\n\n  /**\n   * MarkdownIt#linkify -\u003e LinkifyIt\n   *\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)\n   * rule.\n   **/\n  this.linkify = new LinkifyIt()\n\n  /**\n   * MarkdownIt#validateLink(url) -\u003e Boolean\n   *\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   **/\n  this.validateLink = validateLink\n\n  /**\n   * MarkdownIt#normalizeLink(url) -\u003e String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n  this.normalizeLink = normalizeLink\n\n  /**\n   * MarkdownIt#normalizeLinkText(url) -\u003e String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText\n\n  // Expose utils \u0026 helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -\u003e utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).\n   **/\n  this.utils = utils\n\n  /**\n   * MarkdownIt#helpers -\u003e helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n  this.helpers = utils.assign({}, helpers)\n\n  this.options = {}\n  this.configure(presetName)\n\n  if (options) { this.set(options) }\n}\n\n/** chainable\n * MarkdownIt.set(options)\n *\n * Set parser options (in the same format as in constructor). Probably, you\n * will never need it, but you can change options after constructor call.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .set({ html: true, breaks: true })\n *             .set({ typographer: true });\n * ```\n *\n * __Note:__ To achieve the best possible performance, don't modify a\n * `markdown-it` instance options on the fly. If you need multiple configurations\n * it's best to create multiple instances and initialize each with separate\n * config.\n **/\nMarkdownIt.prototype.set = function (options) {\n  utils.assign(this.options, options)\n  return this\n}\n\n/** chainable, internal\n * MarkdownIt.configure(presets)\n *\n * Batch load of all options and compenent settings. This is internal method,\n * and you probably will not need it. But if you will - see available presets\n * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)\n *\n * We strongly recommend to use presets instead of direct config loads. That\n * will give better compatibility with next versions.\n **/\nMarkdownIt.prototype.configure = function (presets) {\n  const self = this\n\n  if (utils.isString(presets)) {\n    const presetName = presets\n    presets = config[presetName]\n    if (!presets) { throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name') }\n  }\n\n  if (!presets) { throw new Error('Wrong `markdown-it` preset, can\\'t be empty') }\n\n  if (presets.options) { self.set(presets.options) }\n\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enableOnly(presets.components[name].rules)\n      }\n      if (presets.components[name].rules2) {\n        self[name].ruler2.enableOnly(presets.components[name].rules2)\n      }\n    })\n  }\n  return this\n}\n\n/** chainable\n * MarkdownIt.enable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to enable\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable list or rules. It will automatically find appropriate components,\n * containing rules with given names. If rule not found, and `ignoreInvalid`\n * not set - throws exception.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .enable(['sub', 'sup'])\n *             .disable('smartquotes');\n * ```\n **/\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n  let result = []\n\n  if (!Array.isArray(list)) { list = [list] }\n\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.enable(list, true))\n  }, this)\n\n  result = result.concat(this.inline.ruler2.enable(list, true))\n\n  const missed = list.filter(function (name) { return result.indexOf(name) \u003c 0 })\n\n  if (missed.length \u0026\u0026 !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed)\n  }\n\n  return this\n}\n\n/** chainable\n * MarkdownIt.disable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * The same as [[MarkdownIt.enable]], but turn specified rules off.\n **/\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n  let result = []\n\n  if (!Array.isArray(list)) { list = [list] }\n\n  ['core', 'block', 'inline'].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.disable(list, true))\n  }, this)\n\n  result = result.concat(this.inline.ruler2.disable(list, true))\n\n  const missed = list.filter(function (name) { return result.indexOf(name) \u003c 0 })\n\n  if (missed.length \u0026\u0026 !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed)\n  }\n  return this\n}\n\n/** chainable\n * MarkdownIt.use(plugin, params)\n *\n * Load specified plugin with given params into current parser instance.\n * It's just a sugar to call `plugin(md, params)` with curring.\n *\n * ##### Example\n *\n * ```javascript\n * var iterator = require('markdown-it-for-inline');\n * var md = require('markdown-it')()\n *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');\n *             });\n * ```\n **/\nMarkdownIt.prototype.use = function (plugin /*, params, ... */) {\n  const args = [this].concat(Array.prototype.slice.call(arguments, 1))\n  plugin.apply(plugin, args)\n  return this\n}\n\n/** internal\n * MarkdownIt.parse(src, env) -\u003e Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Parse input string and return list of block tokens (special token type\n * \"inline\" will contain list of inline tokens). You should not call this\n * method directly, until you write custom renderer (for example, to produce\n * AST).\n *\n * `env` is used to pass data between \"distributed\" rules and return additional\n * metadata like reference info, needed for the renderer. It also can be used to\n * inject data in specific cases. Usually, you will be ok to pass `{}`,\n * and then pass updated object to renderer.\n **/\nMarkdownIt.prototype.parse = function (src, env) {\n  if (typeof src !== 'string') {\n    throw new Error('Input data should be a String')\n  }\n\n  const state = new this.core.State(src, this, env)\n\n  this.core.process(state)\n\n  return state.tokens\n}\n\n/**\n * MarkdownIt.render(src [, env]) -\u003e String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Render markdown string into html. It does all magic for you :).\n *\n * `env` can be used to inject additional metadata (`{}` by default).\n * But you will not need it with high probability. See also comment\n * in [[MarkdownIt.parse]].\n **/\nMarkdownIt.prototype.render = function (src, env) {\n  env = env || {}\n\n  return this.renderer.render(this.parse(src, env), this.options, env)\n}\n\n/** internal\n * MarkdownIt.parseInline(src, env) -\u003e Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the\n * block tokens list with the single `inline` element, containing parsed inline\n * tokens in `children` property. Also updates `env` object.\n **/\nMarkdownIt.prototype.parseInline = function (src, env) {\n  const state = new this.core.State(src, this, env)\n\n  state.inlineMode = true\n  this.core.process(state)\n\n  return state.tokens\n}\n\n/**\n * MarkdownIt.renderInline(src [, env]) -\u003e String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `\u003cp\u003e` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {}\n\n  return this.renderer.render(this.parseInline(src, env), this.options, env)\n}\n\nexport default MarkdownIt\n","// markdown-it default options\n\nexport default {\n  options: {\n    // Enable HTML tags in source\n    html: false,\n\n    // Use '/' to close single tags (\u003cbr /\u003e)\n    xhtmlOut: false,\n\n    // Convert '\\n' in paragraphs into \u003cbr\u003e\n    breaks: false,\n\n    // CSS language prefix for fenced blocks\n    langPrefix: 'language-',\n\n    // autoconvert URL-like texts to links\n    linkify: false,\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with \u003cpre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    // Internal protection, recursion limit\n    maxNesting: 100\n  },\n\n  components: {\n    core: {},\n    block: {},\n    inline: {}\n  }\n}\n","// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\nexport default {\n  options: {\n    // Enable HTML tags in source\n    html: false,\n\n    // Use '/' to close single tags (\u003cbr /\u003e)\n    xhtmlOut: false,\n\n    // Convert '\\n' in paragraphs into \u003cbr\u003e\n    breaks: false,\n\n    // CSS language prefix for fenced blocks\n    langPrefix: 'language-',\n\n    // autoconvert URL-like texts to links\n    linkify: false,\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with \u003cpre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    // Internal protection, recursion limit\n    maxNesting: 20\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'fragments_join'\n      ]\n    }\n  }\n}\n","// Commonmark default options\n\nexport default {\n  options: {\n    // Enable HTML tags in source\n    html: true,\n\n    // Use '/' to close single tags (\u003cbr /\u003e)\n    xhtmlOut: true,\n\n    // Convert '\\n' in paragraphs into \u003cbr\u003e\n    breaks: false,\n\n    // CSS language prefix for fenced blocks\n    langPrefix: 'language-',\n\n    // autoconvert URL-like texts to links\n    linkify: false,\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer: false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with \u003cpre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    // Internal protection, recursion limit\n    maxNesting: 20\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'fragments_join'\n      ]\n    }\n  }\n}\n"],"version":3}
