{"version":3,"file":"static/js/npm.markdown-it.1743590013140.js","mappings":"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,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,GAAG,UAAU,CAAC,GAAG,WAAW,CAAC,GAAG,YAAY,CAAC,GAAG,WAAW,CAAC,IAAI,UAAU,CAAC,EAAE,WAAW,CAAC,GAAG,WAAW,CAAC,EAAE,oBAAoB,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,sBAAsB,CAAC,EAAE,WAAW,CAAC,GAAG,eAAe,CAAC,IAAI,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,aAAa,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,aAAa,CAAC,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,EAAE,SAAS,CAAC,EAAE,aAAa,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,aAAa,CAAC,EAAE,QAAQ,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,EAAE,cAAc,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,aAAa,CAAC,GAAG,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,iBAAiB,CAAC,GAAG,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAA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,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,eAAe,CAAC,KAAK,WAAW,CAAC,EAAE,WAAW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","sources":["https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/decode.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/decode-data-html.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/decode-data-xml.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/decode_codepoint.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/encode-html.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/escape.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/encode.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/index.ts","webpack://jbs-activity/./node_modules/markdown-it/lib/common/utils.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/helpers/parse_link_label.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/helpers/parse_link_destination.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/helpers/parse_link_title.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/renderer.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/ruler.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/token.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/state_core.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/normalize.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/block.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/inline.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/linkify.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/replacements.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/smartquotes.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_core/text_join.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/parser_core.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/state_block.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/table.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/code.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/fence.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/blockquote.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/hr.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/list.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/reference.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/common/html_blocks.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/common/html_re.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/html_block.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/heading.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/lheading.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_block/paragraph.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/parser_block.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/state_inline.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/text.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/linkify.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/newline.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/escape.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/backticks.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/strikethrough.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/emphasis.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/link.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/image.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/autolink.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/html_inline.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/entity.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/balance_pairs.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/rules_inline/fragments_join.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/parser_inline.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/presets/default.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/presets/zero.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/presets/commonmark.mjs","webpack://jbs-activity/./node_modules/markdown-it/lib/index.mjs"],"sourcesContent":[null,null,null,null,null,null,null,null,"// 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  /* eslint no-bitwise:0 */\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) { return false }\n  // never used\n  if (c >= 0xFDD0 && c <= 0xFDEF) { return false }\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false }\n  // control codes\n  if (c >= 0x00 && c <= 0x08) { return false }\n  if (c === 0x0B) { return false }\n  if (c >= 0x0E && c <= 0x1F) { return false }\n  if (c >= 0x7F && c <= 0x9F) { return false }\n  // out of range\n  if (c > 0x10FFFF) { return false }\n  return true\n}\n\nfunction fromCodePoint (c) {\n  /* eslint no-bitwise:0 */\n  if (c > 0xffff) {\n    c -= 0x10000\n    const surrogate1 = 0xd800 + (c >> 10)\n    const surrogate2 = 0xdc00 + (c & 0x3ff)\n\n    return String.fromCharCode(surrogate1, surrogate2)\n  }\n  return String.fromCharCode(c)\n}\n\nconst UNESCAPE_MD_RE  = /\\\\([!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_`{|}~])/g\nconst ENTITY_RE       = /&([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/* # */ && 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\n/* function replaceEntities(str) {\n  if (str.indexOf('&') < 0) { return str; }\n\n  return str.replace(ENTITY_RE, replaceEntityPattern);\n} */\n\nfunction unescapeMd (str) {\n  if (str.indexOf('\\\\') < 0) { return str }\n  return str.replace(UNESCAPE_MD_RE, '$1')\n}\n\nfunction unescapeAll (str) {\n  if (str.indexOf('\\\\') < 0 && str.indexOf('&') < 0) { return str }\n\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) { return escaped }\n    return replaceEntityPattern(match, entity)\n  })\n}\n\nconst HTML_ESCAPE_TEST_RE = /[&<>\"]/\nconst HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g\nconst HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n}\n\nfunction replaceUnsafeChar (ch) {\n  return HTML_REPLACEMENTS[ch]\n}\n\nfunction escapeHtml (str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar)\n  }\n  return str\n}\n\nconst REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g\n\nfunction escapeRE (str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$&')\n}\n\nfunction isSpace (code) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true\n  }\n  return false\n}\n\n// Zs (unicode class) || [\\t\\f\\v\\r\\n]\nfunction isWhiteSpace (code) {\n  if (code >= 0x2000 && code <= 0x200A) { return true }\n  switch (code) {\n    case 0x09: // \\t\n    case 0x0A: // \\n\n    case 0x0B: // \\v\n    case 0x0C: // \\f\n    case 0x0D: // \\r\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true\n  }\n  return false\n}\n\n/* eslint-disable max-len */\n\n// Currently without astral characters support.\nfunction isPunctChar (ch) {\n  return ucmicro.P.test(ch) || ucmicro.S.test(ch)\n}\n\n// Markdown ASCII punctuation characters.\n//\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\n//\n// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.\n//\nfunction isMdAsciiPunct (ch) {\n  switch (ch) {\n    case 0x21/* ! */:\n    case 0x22/* \" */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x27/* ' */:\n    case 0x28/* ( */:\n    case 0x29/* ) */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2C/* , */:\n    case 0x2D/* - */:\n    case 0x2E/* . */:\n    case 0x2F/* / */:\n    case 0x3A/* : */:\n    case 0x3B/* ; */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x3F/* ? */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7C/* | */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true\n    default:\n      return false\n  }\n}\n\n// Hepler to unify [reference labels].\n//\nfunction normalizeReference (str) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' ')\n\n  // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug\n  // fixed in v12 (couldn't find any details).\n  //\n  // So treat this one as a special case\n  // (remove this when node v10 is no longer supported).\n  //\n  if ('ẞ'.toLowerCase() === 'Ṿ') {\n    str = str.replace(/ẞ/g, 'ß')\n  }\n\n  // .toLowerCase().toUpperCase() should get rid of all differences\n  // between letter variants.\n  //\n  // Simple .toLowerCase() doesn't normalize 125 code points correctly,\n  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:\n  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n  return str.toLowerCase().toUpperCase()\n}\n\n// 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  escapeRE,\n  normalizeReference\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 < 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 /* < */) {\n    pos++\n    while (pos < max) {\n      code = str.charCodeAt(pos)\n      if (code === 0x0A /* \\n */) { return result }\n      if (code === 0x3C /* < */) { return result }\n      if (code === 0x3E /* > */) {\n        result.pos = pos + 1\n        result.str = unescapeAll(str.slice(start + 1, pos))\n        result.ok = true\n        return result\n      }\n      if (code === 0x5C /* \\ */ && pos + 1 < max) {\n        pos += 2\n        continue\n      }\n\n      pos++\n    }\n\n    // no closing '>'\n    return result\n  }\n\n  // this should be ... } else { ... branch\n\n  let level = 0\n  while (pos < max) {\n    code = str.charCodeAt(pos)\n\n    if (code === 0x20) { break }\n\n    // ascii control characters\n    if (code < 0x20 || code === 0x7F) { break }\n\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      if (str.charCodeAt(pos + 1) === 0x20) { break }\n      pos += 2\n      continue\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++\n      if (level > 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 >= max) { return state }\n\n    let marker = str.charCodeAt(pos)\n    if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && 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 < 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 /* ( */ && state.marker === 0x29 /* ) */) {\n      return state\n    } else if (code === 0x5C /* \\ */ && pos + 1 < 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  '<code' + slf.renderAttrs(token) + '>' +\n          escapeHtml(token.content) +\n          '</code>'\n}\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  const token = tokens[idx]\n\n  return  '<pre' + slf.renderAttrs(token) + '><code>' +\n          escapeHtml(tokens[idx].content) +\n          '</code></pre>\\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('<pre') === 0) {\n    return highlighted + '\\n'\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .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 < 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 `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\\n`\n  }\n\n  return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>\\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 ? '<br />\\n' : '<br>\\n'\n}\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n'\n}\n\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 -> Object\n   *\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * md.renderer.rules.strong_open  = function () { return '<b>'; };\n   * md.renderer.rules.strong_close = function () { return '</b>'; };\n   *\n   * var result = md.renderInline(...);\n   * ```\n   *\n   * Each rule is called as independent static function with fixed signature:\n   *\n   * ```javascript\n   * function my_token_render(tokens, idx, options, env, renderer) {\n   *   // ...\n   *   return renderedHTML;\n   * }\n   * ```\n   *\n   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)\n   * for more details and examples.\n   **/\n  this.rules = assign({}, default_rules)\n}\n\n/**\n * Renderer.renderAttrs(token) -> 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 < 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) -> 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  //    >\n  //\n  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {\n    result += '\\n'\n  }\n\n  // Add token name, e.g. `<img`\n  result += (token.nesting === -1 ? '</' : '<') + token.tag\n\n  // Encode attributes, e.g. `<img src=\"foo\"`\n  result += this.renderAttrs(token)\n\n  // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n  if (token.nesting === 0 && options.xhtmlOut) {\n    result += ' /'\n  }\n\n  // Check if we need to add a newline after this tag\n  let needLf = false\n  if (token.block) {\n    needLf = true\n\n    if (token.nesting === 1) {\n      if (idx + 1 < 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 && nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `<li></li>`.\n          //\n          needLf = false\n        }\n      }\n    }\n  }\n\n  result += needLf ? '>\\n' : '>'\n\n  return result\n}\n\n/**\n * Renderer.renderInline(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to render\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * The same as [[Renderer.render]], but for single token of `inline` type.\n **/\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 < 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) -> 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 < 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) -> 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 < 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 < 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) < 0) {\n        chains.push(altName)\n      }\n    })\n  })\n\n  self.__cache__ = {}\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = []\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) { return }\n\n      if (chain && rule.alt.indexOf(chain) < 0) { return }\n\n      self.__cache__[chain].push(rule.fn)\n    })\n  })\n}\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function & options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing typographer replacement rule with new one:\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.at('replacements', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.at = function (name, fn, options) {\n  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]) -> 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 < 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]) -> 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 < 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) -> 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 -> String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type     = type\n\n  /**\n   * Token#tag -> String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag      = tag\n\n  /**\n   * Token#attrs -> Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs    = null\n\n  /**\n   * Token#map -> Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map      = null\n\n  /**\n   * Token#nesting -> Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n  this.nesting  = nesting\n\n  /**\n   * Token#level -> Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level    = 0\n\n  /**\n   * Token#children -> Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null\n\n  /**\n   * Token#content -> String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content  = ''\n\n  /**\n   * Token#markup -> String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup   = ''\n\n  /**\n   * Token#info -> String\n   *\n   * 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 -> Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta     = null\n\n  /**\n   * Token#block -> Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block    = false\n\n  /**\n   * Token#hidden -> Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden   = false\n}\n\n/**\n * Token.attrIndex(name) -> 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 < 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 < 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 >= 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 < 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 < 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\nimport { arrayReplaceAt } from '../common/utils.mjs'\n\nfunction isLinkOpen (str) {\n  return /^<a[>\\s]/i.test(str)\n}\nfunction isLinkClose (str) {\n  return /^<\\/a\\s*>/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 < l; j++) {\n    if (blockTokens[j].type !== 'inline' ||\n        !state.md.linkify.pretest(blockTokens[j].content)) {\n      continue\n    }\n\n    let tokens = blockTokens[j].children\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 >= 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 && tokens[i].type !== 'link_open') {\n          i--\n        }\n        continue\n      }\n\n      // Skip content of html tag links\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {\n          htmlLinkLevel--\n        }\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++\n        }\n      }\n      if (htmlLinkLevel > 0) { continue }\n\n      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {\n        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:<a href=\"//example.com/\">//example.com/</a>\n        if (links.length > 0 &&\n            links[0].index === 0 &&\n            i > 0 &&\n            tokens[i - 1].type === 'text_special') {\n          links = links.slice(1)\n        }\n\n        for (let ln = 0; ln < 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:' && !/^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 > 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 < 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        // replace current node\n        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)\n      }\n    }\n  }\n}\n","// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → &ndash;, --- → &mdash;\n//\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - multiplications 2 x 4 -> 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 >= 0; i--) {\n    const token = inlineTokens[i]\n\n    if (token.type === 'text' && !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn)\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++\n    }\n  }\n}\n\nfunction replace_rare (inlineTokens) {\n  let inside_autolink = 0\n\n  for (let i = inlineTokens.length - 1; i >= 0; i--) {\n    const token = inlineTokens[i]\n\n    if (token.type === 'text' && !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content\n          .replace(/\\+-/g, '±')\n          // .., ..., ....... -> …\n          // but ?..... & !..... -> ?.. & !..\n          .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..')\n          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n          // em-dash\n          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\\u2014')\n          // en-dash\n          .replace(/(^|\\s)--(?=\\s|$)/mg, '$1\\u2013')\n          .replace(/(^|[^-\\s])--(?=[^-\\s]|$)/mg, '$1\\u2013')\n      }\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++\n    }\n  }\n}\n\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 >= 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, isPunctChar, isMdAsciiPunct } from '../common/utils.mjs'\n\nconst QUOTE_TEST_RE = /['\"]/\nconst QUOTE_RE = /['\"]/g\nconst APOSTROPHE = '\\u2019' /* ’ */\n\nfunction replaceAt (str, index, ch) {\n  return str.slice(0, index) + ch + str.slice(index + 1)\n}\n\nfunction process_inlines (tokens, state) {\n  let j\n\n  const stack = []\n\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i]\n\n    const thisLevel = tokens[i].level\n\n    for (j = stack.length - 1; j >= 0; j--) {\n      if (stack[j].level <= thisLevel) { break }\n    }\n    stack.length = j + 1\n\n    if (token.type !== 'text') { continue }\n\n    let text = token.content\n    let pos = 0\n    let max = text.length\n\n    /* eslint no-labels:0,block-scoped-var:0 */\n    OUTER:\n    while (pos < max) {\n      QUOTE_RE.lastIndex = pos\n      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 >= 0) {\n        lastChar = text.charCodeAt(t.index - 1)\n      } else {\n        for (j = i - 1; j >= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // lastChar defaults to 0x20\n          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1)\n          break\n        }\n      }\n\n      // Find next character,\n      // default to space if it's the end of the line\n      //\n      let nextChar = 0x20\n\n      if (pos < max) {\n        nextChar = text.charCodeAt(pos)\n      } else {\n        for (j = i + 1; j < tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // nextChar defaults to 0x20\n          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          nextChar = tokens[j].content.charCodeAt(0)\n          break\n        }\n      }\n\n      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar))\n      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(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 /* \" */ && t[0] === '\"') {\n        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false\n        }\n      }\n\n      if (canOpen && canClose) {\n        // Replace quotes in the middle of punctuation sequence, but not\n        // in the middle of the words, i.e.:\n        //\n        // 1. foo \" bar \" baz - not replaced\n        // 2. foo-\"-bar-\"-baz - replaced\n        // 3. foo\"bar\"baz     - not replaced\n        //\n        canOpen = isLastPunctChar\n        canClose = isNextPunctChar\n      }\n\n      if (!canOpen && !canClose) {\n        // middle of word\n        if (isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE)\n        }\n        continue\n      }\n\n      if (canClose) {\n        // this could be a closing quote, rewind the stack to get a match\n        for (j = stack.length - 1; j >= 0; j--) {\n          let item = stack[j]\n          if (stack[j].level < thisLevel) { break }\n          if (item.single === isSingle && stack[j].level === thisLevel) {\n            item = stack[j]\n\n            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            // replace token.content *before* tokens[item.token].content,\n            // because, if they are pointing at the same token, replaceAt\n            // could mess up indices when quote length != 1\n            token.content = replaceAt(token.content, t.index, closeQuote)\n            tokens[item.token].content = replaceAt(\n              tokens[item.token].content, item.pos, openQuote)\n\n            pos += closeQuote.length - 1\n            if (item.token === i) { pos += openQuote.length - 1 }\n\n            text = token.content\n            max = text.length\n\n            stack.length = j\n            continue OUTER\n          }\n        }\n      }\n\n      if (canOpen) {\n        stack.push({\n          token: i,\n          pos: t.index,\n          single: isSingle,\n          level: thisLevel\n        })\n      } else if (canClose && isSingle) {\n        token.content = replaceAt(token.content, t.index, APOSTROPHE)\n      }\n    }\n  }\n}\n\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 >= 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 < 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 < max; curr++) {\n      if (tokens[curr].type === 'text_special') {\n        tokens[curr].type = 'text'\n      }\n    }\n\n    for (curr = last = 0; curr < max; curr++) {\n      if (tokens[curr].type === 'text' &&\n          curr + 1 < max &&\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 -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i < _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 < 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 < 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 < 0) this.level-- // closing tag\n  token.level = this.level\n  if (nesting > 0) this.level++ // opening tag\n\n  this.tokens.push(token)\n  return token\n}\n\nStateBlock.prototype.isEmpty = function isEmpty (line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line]\n}\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines (from) {\n  for (let max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break\n    }\n  }\n  return from\n}\n\n// Skip spaces from given position.\nStateBlock.prototype.skipSpaces = function skipSpaces (pos) {\n  for (let max = this.src.length; pos < 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 <= min) { return pos }\n\n  while (pos > min) {\n    if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1 }\n  }\n  return pos\n}\n\n// Skip char codes from given position\nStateBlock.prototype.skipChars = function skipChars (pos, code) {\n  for (let max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) { break }\n  }\n  return pos\n}\n\n// Skip char codes reverse from given position - 1\nStateBlock.prototype.skipCharsBack = function skipCharsBack (pos, code, min) {\n  if (pos <= min) { return pos }\n\n  while (pos > min) {\n    if (code !== this.src.charCodeAt(--pos)) { return pos + 1 }\n  }\n  return pos\n}\n\n// cut lines range from source.\nStateBlock.prototype.getLines = function getLines (begin, end, indent, keepLastLF) {\n  if (begin >= end) {\n    return ''\n  }\n\n  const queue = new Array(end - begin)\n\n  for (let i = 0, line = begin; line < 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 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1\n    } else {\n      last = this.eMarks[line]\n    }\n\n    while (first < last && lineIndent < indent) {\n      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 < this.tShift[line]) {\n        // patched tShift masked characters to look like spaces (blockquotes, list markers)\n        lineIndent++\n      } else {\n        break\n      }\n\n      first++\n    }\n\n    if (lineIndent > indent) {\n      // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n      // with indent=2 becomes '  \\tfoobar'\n      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last)\n    } else {\n      queue[i] = this.src.slice(first, last)\n    }\n  }\n\n  return queue.join('')\n}\n\n// re-export Token class to use in block rules\nStateBlock.prototype.Token = Token\n\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 < 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 > endLine) { return false }\n\n  let nextLine = startLine + 1\n\n  if (state.sCount[nextLine] < state.blkIndent) { return false }\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }\n\n  // first character of the second line should be '|', '-', ':',\n  // and no other characters are allowed but spaces;\n  // basically, this is the equivalent of /^[-:|][-:|\\s]*$/ regexp\n\n  let pos = state.bMarks[nextLine] + state.tShift[nextLine]\n  if (pos >= state.eMarks[nextLine]) { return false }\n\n  const firstCh = state.src.charCodeAt(pos++)\n  if (firstCh !== 0x7C/* | */ && firstCh !== 0x2D/* - */ && firstCh !== 0x3A/* : */) { return false }\n\n  if (pos >= state.eMarks[nextLine]) { return false }\n\n  const secondCh = state.src.charCodeAt(pos++)\n  if (secondCh !== 0x7C/* | */ && secondCh !== 0x2D/* - */ && secondCh !== 0x3A/* : */ && !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/* - */ && isSpace(secondCh)) { return false }\n\n  while (pos < state.eMarks[nextLine]) {\n    const ch = state.src.charCodeAt(pos)\n\n    if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !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 < 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 >= 4) { return false }\n  columns = escapedSplit(lineText)\n  if (columns.length && columns[0] === '') columns.shift()\n  if (columns.length && 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 < 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 < endLine; nextLine++) {\n    if (state.sCount[nextLine] < state.blkIndent) { break }\n\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n\n    if (terminate) { break }\n    lineText = getLine(state, nextLine).trim()\n    if (!lineText) { break }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) { break }\n    columns = escapedSplit(lineText)\n    if (columns.length && columns[0] === '') columns.shift()\n    if (columns.length && 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 > 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 < 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 < 4) { return false }\n\n  let nextLine = startLine + 1\n  let last = nextLine\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++\n      continue\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      nextLine++\n      last = nextLine\n      continue\n    }\n    break\n  }\n\n  state.line = last\n\n  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 >= 4) { return false }\n\n  if (pos + 3 > max) { return false }\n\n  const marker = state.src.charCodeAt(pos)\n\n  if (marker !== 0x7E/* ~ */ && 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 < 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)) >= 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 >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]\n    max = state.eMarks[nextLine]\n\n    if (pos < max && state.sCount[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) { continue }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue\n    }\n\n    pos = state.skipChars(pos, marker)\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem < len) { continue }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos)\n\n    if (pos < max) { continue }\n\n    haveEndMarker = true\n    // found!\n    break\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.sCount[startLine]\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0)\n\n  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 >= 4) { return false }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos) !== 0x3E/* > */) { return false }\n\n  // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n  if (silent) { return true }\n\n  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  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n  for (nextLine = startLine; nextLine < endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    > current blockquote\n    // 2. checking this line\n    // ```\n    const isOutdented = state.sCount[nextLine] < state.blkIndent\n\n    pos = state.bMarks[nextLine] + state.tShift[nextLine]\n    max = state.eMarks[nextLine]\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !isOutdented) {\n      // This line is inside the blockquote.\n\n      // set offset past spaces and \">\"\n      let initial = state.sCount[nextLine] + 1\n      let spaceAfterMarker\n      let adjustTab\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' >   test '\n        //     ^ -- position start of line here:\n        pos++\n        initial++\n        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          // '  >\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++\n          initial++\n          adjustTab = false\n        } else {\n          // ' >\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true\n        }\n      } else {\n        spaceAfterMarker = false\n      }\n\n      let offset = initial\n      oldBMarks.push(state.bMarks[nextLine])\n      state.bMarks[nextLine] = pos\n\n      while (pos < 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 >= 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 < 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 = '>'\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 = '>'\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 < 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 >= 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/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x5F/* _ */) {\n    return false\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 of them\n\n  let cnt = 1\n  while (pos < max) {\n    const ch = state.src.charCodeAt(pos++)\n    if (ch !== marker && !isSpace(ch)) { return false }\n    if (ch === marker) { cnt++ }\n  }\n\n  if (cnt < 3) { return false }\n\n  if (silent) { return true }\n\n  state.line = startLine + 1\n\n  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/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x2B/* + */) {\n    return -1\n  }\n\n  if (pos < 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 >= max) { return -1 }\n\n  let ch = state.src.charCodeAt(pos++)\n\n  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1 }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) { return -1 }\n\n    ch = state.src.charCodeAt(pos++)\n\n    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start >= 10) { return -1 }\n\n      continue\n    }\n\n    // found valid marker\n    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {\n      break\n    }\n\n    return -1\n  }\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos)\n\n    if (!isSpace(ch)) {\n      // \" 1.test \" - is not a list item\n      return -1\n    }\n  }\n  return pos\n}\n\nfunction markTightParagraphs (state, idx) {\n  const level = state.level + 2\n\n  for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true\n      state.tokens[i].hidden = true\n      i += 2\n    }\n  }\n}\n\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 >= 4) { return false }\n\n  // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n  if (state.listIndent >= 0 &&\n      state.sCount[nextLine] - state.listIndent >= 4 &&\n      state.sCount[nextLine] < 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 && 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] >= 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)) >= 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 && markerValue !== 1) return false\n  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 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) >= 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 < 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 < 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 >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1\n    } else {\n      indentAfterMarker = offset - initial\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker > 4) { indentAfterMarker = 1 }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    const indent = initial + indentAfterMarker\n\n    // Run subparser & write tokens\n    token        = state.push('list_item_open', 'li', 1)\n    token.markup = String.fromCharCode(markerCharCode)\n    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 >= max && 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) > 1 && 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 >= endLine) { break }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] < state.blkIndent) { break }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[nextLine] - state.blkIndent >= 4) { break }\n\n    // fail if terminating block found\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine)\n      if (posAfterMarker < 0) { break }\n      start = state.bMarks[nextLine] + state.tShift[nextLine]\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine)\n      if (posAfterMarker < 0) { break }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break }\n  }\n\n  // Finalize list\n  if (isOrdered) {\n    token = state.push('ordered_list_close', 'ol', -1)\n  } else {\n    token = state.push('bullet_list_close', 'ul', -1)\n  }\n  token.markup = String.fromCharCode(markerCharCode)\n\n  listLines[1] = nextLine\n  state.line = nextLine\n\n  state.parentType = oldParentType\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx)\n  }\n\n  return true\n}\n","import { isSpace, normalizeReference } from '../common/utils.mjs'\n\nexport default function reference (state, startLine, _endLine, silent) {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[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 >= 4) { return false }\n\n  if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false }\n\n  function getNextLine (nextLine) {\n    const endLine = state.lineMax\n\n    if (nextLine >= endLine || state.isEmpty(nextLine)) {\n      // empty line or end of input\n      return null\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 > 3) { isContinuation = true }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 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 < 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 null\n      }\n    }\n\n    const pos = state.bMarks[nextLine] + state.tShift[nextLine]\n    const max = state.eMarks[nextLine]\n\n    // max + 1 explicitly includes the newline\n    return state.src.slice(pos, max + 1)\n  }\n\n  let str = state.src.slice(pos, max + 1)\n\n  max = str.length\n  let labelEnd = -1\n\n  for (pos = 1; pos < max; pos++) {\n    const ch = str.charCodeAt(pos)\n    if (ch === 0x5B /* [ */) {\n      return false\n    } else if (ch === 0x5D /* ] */) {\n      labelEnd = pos\n      break\n    } else if (ch === 0x0A /* \\n */) {\n      const lineContent = getNextLine(nextLine)\n      if (lineContent !== null) {\n        str += lineContent\n        max = str.length\n        nextLine++\n      }\n    } else if (ch === 0x5C /* \\ */) {\n      pos++\n      if (pos < max && str.charCodeAt(pos) === 0x0A) {\n        const lineContent = getNextLine(nextLine)\n        if (lineContent !== null) {\n          str += lineContent\n          max = str.length\n          nextLine++\n        }\n      }\n    }\n  }\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    const ch = str.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const lineContent = getNextLine(nextLine)\n      if (lineContent !== null) {\n        str += lineContent\n        max = str.length\n        nextLine++\n      }\n    } else if (isSpace(ch)) {\n      /* eslint no-empty:0 */\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  const destRes = state.md.helpers.parseLinkDestination(str, 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 destEndLineNo = nextLine\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  const start = pos\n  for (; pos < max; pos++) {\n    const ch = str.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const lineContent = getNextLine(nextLine)\n      if (lineContent !== null) {\n        str += lineContent\n        max = str.length\n        nextLine++\n      }\n    } else if (isSpace(ch)) {\n      /* eslint no-empty:0 */\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  let titleRes = state.md.helpers.parseLinkTitle(str, pos, max)\n  while (titleRes.can_continue) {\n    const lineContent = getNextLine(nextLine)\n    if (lineContent === null) break\n    str += lineContent\n    pos = max\n    max = str.length\n    nextLine++\n    titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes)\n  }\n  let title\n\n  if (pos < max && start !== pos && titleRes.ok) {\n    title = titleRes.str\n    pos = titleRes.pos\n  } else {\n    title = ''\n    pos = destEndPos\n    nextLine = destEndLineNo\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos < max) {\n    const ch = str.charCodeAt(pos)\n    if (!isSpace(ch)) { break }\n    pos++\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = ''\n      pos = destEndPos\n      nextLine = destEndLineNo\n      while (pos < max) {\n        const ch = str.charCodeAt(pos)\n        if (!isSpace(ch)) { break }\n        pos++\n      }\n    }\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false\n  }\n\n  const label = normalizeReference(str.slice(1, labelEnd))\n  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false\n  }\n\n  // Reference can not terminate anything. This check is for safety only.\n  /* istanbul ignore if */\n  if (silent) { return true }\n\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {}\n  }\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = { title, 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      = '[^\"\\'=<>`\\\\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    = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>'\n\nconst close_tag   = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>'\nconst comment     = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->'\nconst processing  = '<[?][\\\\s\\\\S]*?[?]>'\nconst declaration = '<![A-Za-z][^>]*>'\nconst cdata       = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>'\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  [/^<(script|pre|style|textarea)(?=(\\s|>|$))/i, /<\\/(script|pre|style|textarea)>/i, true],\n  [/^<!--/,        /-->/,   true],\n  [/^<\\?/,         /\\?>/,   true],\n  [/^<![A-Z]/,     />/,     true],\n  [/^<!\\[CDATA\\[/, /\\]\\]>/, true],\n  [new RegExp('^</?(' + block_names.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true],\n  [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\\\s*$'),  /^$/, false]\n]\n\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 >= 4) { return false }\n\n  if (!state.md.options.html) { return false }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }\n\n  let lineText = state.src.slice(pos, max)\n\n  let i = 0\n  for (; i < 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  // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine < endLine; nextLine++) {\n      if (state.sCount[nextLine] < state.blkIndent) { break }\n\n      pos = state.bMarks[nextLine] + state.tShift[nextLine]\n      max = state.eMarks[nextLine]\n      lineText = state.src.slice(pos, max)\n\n      if (HTML_SEQUENCES[i][1].test(lineText)) {\n        if (lineText.length !== 0) { nextLine++ }\n        break\n      }\n    }\n  }\n\n  state.line = nextLine\n\n  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 } 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 >= 4) { return false }\n\n  let ch  = state.src.charCodeAt(pos)\n\n  if (ch !== 0x23/* # */ || pos >= max) { return false }\n\n  // count heading level\n  let level = 1\n  ch = state.src.charCodeAt(++pos)\n  while (ch === 0x23/* # */ && pos < max && level <= 6) {\n    level++\n    ch = state.src.charCodeAt(++pos)\n  }\n\n  if (level > 6 || (pos < max && !isSpace(ch))) { return false }\n\n  if (silent) { return true }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipSpacesBack(max, pos)\n  const tmp = state.skipCharsBack(max, 0x23, pos) // #\n  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp\n  }\n\n  state.line = startLine + 1\n\n  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  = state.src.slice(pos, max).trim()\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\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 >= 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 < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      let pos = state.bMarks[nextLine] + state.tShift[nextLine]\n      const max = state.eMarks[nextLine]\n\n      if (pos < max) {\n        marker = state.src.charCodeAt(pos)\n\n        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {\n          pos = state.skipChars(pos, marker)\n          pos = state.skipSpaces(pos)\n\n          if (pos >= max) {\n            level = (marker === 0x3D/* = */ ? 1 : 2)\n            break\n          }\n        }\n      }\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n  }\n\n  if (!level) {\n    // Didn't find valid underline\n    return false\n  }\n\n  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim()\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\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 < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n  }\n\n  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim()\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 & 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 -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() })\n  }\n}\n\n// 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 < endLine) {\n    state.line = line = state.skipEmptyLines(line)\n    if (line >= endLine) { break }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.sCount[line] < state.blkIndent) { break }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level >= maxNesting) {\n      state.line = endLine\n      break\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n    const prevLine = state.line\n    let ok = false\n\n    for (let i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false)\n      if (ok) {\n        if (prevLine >= 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 < endLine && 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, isPunctChar, 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 => last seen position\n  this.backticks = {}\n  this.backticksScanned = false\n\n  // Counter used to disable inline linkify-it execution\n  // inside <a> 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 < 0) {\n    // closing tag\n    this.level--\n    this.delimiters = this._prev_delimiters.pop()\n  }\n\n  token.level = this.level\n\n  if (nesting > 0) {\n    // opening tag\n    this.level++\n    this._prev_delimiters.push(this.delimiters)\n    this.delimiters = []\n    token_meta = { delimiters: this.delimiters }\n  }\n\n  this.pendingLevel = this.level\n  this.tokens.push(token)\n  this.tokens_meta.push(token_meta)\n  return token\n}\n\n// 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  // treat beginning of the line as a whitespace\n  const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20\n\n  let pos = start\n  while (pos < max && this.src.charCodeAt(pos) === marker) { pos++ }\n\n  const count = pos - start\n\n  // treat end of the line as a whitespace\n  const nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20\n\n  const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar))\n  const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar))\n\n  const isLastWhiteSpace = isWhiteSpace(lastChar)\n  const isNextWhiteSpace = isWhiteSpace(nextChar)\n\n  const left_flanking =\n    !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar)\n  const right_flanking =\n    !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar)\n\n  const can_open  = left_flanking  && (canSplitWord || !right_flanking || isLastPunctChar)\n  const can_close = right_flanking && (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// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\nfunction isTerminatorChar (ch) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x21/* ! */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2D/* - */:\n    case 0x3A/* : */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true\n    default:\n      return false\n  }\n}\n\nexport default function text (state, silent) {\n  let pos = state.pos\n\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++\n  }\n\n  if (pos === state.pos) { return false }\n\n  if (!silent) { state.pending += state.src.slice(state.pos, pos) }\n\n  state.pos = pos\n\n  return true\n}\n\n// Alternative implementation, for memory.\n//\n// It costs 10% of performance, but allows extend terminators list, if place it\n// to `ParserInline` property. Probably, will switch to it sometime, such\n// flexibility required.\n\n/*\nvar TERMINATOR_RE = /[\\n!#$%&*+\\-:<=>@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -> empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -> text till end of string\n  if (idx < 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n}; */\n","// Process links like https://example.org/\n\n// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\nconst SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i\n\nexport default function linkify (state, silent) {\n  if (!state.md.options.linkify) return false\n  if (state.linkLevel > 0) return false\n\n  const pos = state.pos\n  const max = state.posMax\n\n  if (pos + 3 > 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  const match = state.pending.match(SCHEME_RE)\n  if (!match) return false\n\n  const proto = match[1]\n\n  const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length))\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 <= proto.length) return false\n\n  // disallow '*' at the end of the link (conflicts with emphasis)\n  url = url.replace(/\\*+$/, '')\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, -proto.length)\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 - proto.length\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' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Find whitespaces tail of pending chars.\n        let ws = pmax - 1\n        while (ws >= 1 && 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 < max && 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 < 256; i++) { ESCAPED.push(0) }\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'\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 >= 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 < 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  let escapedStr = state.src[pos]\n\n  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {\n    const ch2 = state.src.charCodeAt(pos + 1)\n\n    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {\n      escapedStr += state.src[pos + 1]\n      pos++\n    }\n  }\n\n  const origStr = '\\\\' + escapedStr\n\n  if (!silent) {\n    const token = state.push('text_special', '', 0)\n\n    if (ch1 < 256 && ESCAPED[ch1] !== 0) {\n      token.content = escapedStr\n    } else {\n      token.content = origStr\n    }\n\n    token.markup = origStr\n    token.info   = 'escape'\n  }\n\n  state.pos = pos + 1\n  return true\n}\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 < max && 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 && (state.backticks[openerLength] || 0) <= 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 < max && 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 < 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 < 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 < 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' &&\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: `~~~~~` -> `~` + `~~` + `~~`, 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 < state.tokens.length && state.tokens[j].type === 's_close') {\n      j++\n    }\n\n    j--\n\n    if (i !== j) {\n      token = state.tokens[j]\n      state.tokens[j] = state.tokens[i]\n      state.tokens[i] = token\n    }\n  }\n}\n\n// 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 < max; curr++) {\n    if (tokens_meta[curr] && 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 /* _ */ && marker !== 0x2A /* * */) { return false }\n\n  const scanned = state.scanDelims(state.pos, marker === 0x2A)\n\n  for (let i = 0; i < 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 >= 0; i--) {\n    const startDelim = delimiters[i]\n\n    if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {\n      continue\n    }\n\n    // Process only opening markers\n    if (startDelim.end === -1) {\n      continue\n    }\n\n    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    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`\n    //\n    const isStrong = i > 0 &&\n               delimiters[i - 1].end === startDelim.end + 1 &&\n               // check that first two markers match and adjacent\n               delimiters[i - 1].marker === startDelim.marker &&\n               delimiters[i - 1].token === startDelim.token - 1 &&\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 < max; curr++) {\n    if (tokens_meta[curr] && 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](<to> \"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 < 0) { return false }\n\n  let pos = labelEnd + 1\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) && code !== 0x0A) { break }\n    }\n    if (pos >= max) { return false }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str)\n      if (state.md.validateLink(href)) {\n        pos = res.pos\n      } else {\n        href = ''\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                ^^ skipping these spaces\n      start = pos\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos)\n        if (!isSpace(code) && code !== 0x0A) { break }\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                  ^^^^^^^ parsing link title\n      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)\n      if (pos < max && start !== pos && res.ok) {\n        title = res.str\n        pos = res.pos\n\n        // [link](  <href>  \"title\"  )\n        //                         ^^ skipping these spaces\n        for (; pos < max; pos++) {\n          code = state.src.charCodeAt(pos)\n          if (!isSpace(code) && code !== 0x0A) { break }\n        }\n      }\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true\n    }\n    pos++\n  }\n\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1\n      pos = state.md.helpers.parseLinkLabel(state, pos)\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++)\n      } else {\n        pos = labelEnd + 1\n      }\n    } else {\n      pos = labelEnd + 1\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd) }\n\n    ref = state.env.references[normalizeReference(label)]\n    if (!ref) {\n      state.pos = oldPos\n      return false\n    }\n    href = ref.href\n    title = ref.title\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    state.pos = labelStart\n    state.posMax = labelEnd\n\n    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](<src> \"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 < 0) { return false }\n\n  pos = labelEnd + 1\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) && code !== 0x0A) { break }\n    }\n    if (pos >= max) { return false }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str)\n      if (state.md.validateLink(href)) {\n        pos = res.pos\n      } else {\n        href = ''\n      }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) && code !== 0x0A) { break }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str\n      pos = res.pos\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos)\n        if (!isSpace(code) && code !== 0x0A) { break }\n      }\n    } else {\n      title = ''\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      state.pos = oldPos\n      return false\n    }\n    pos++\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1\n      pos = state.md.helpers.parseLinkLabel(state, pos)\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++)\n      } else {\n        pos = labelEnd + 1\n      }\n    } else {\n      pos = labelEnd + 1\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd) }\n\n    ref = state.env.references[normalizeReference(label)]\n    if (!ref) {\n      state.pos = oldPos\n      return false\n    }\n    href = ref.href\n    title = ref.title\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd)\n\n    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 '<protocol:...>'\n\n/* eslint max-len:0 */\nconst EMAIL_RE    = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/\n/* eslint-disable-next-line no-control-regex */\nconst AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\\x00-\\x20]*)$/\n\nexport default function autolink (state, silent) {\n  let pos = state.pos\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }\n\n  const start = state.pos\n  const max = state.posMax\n\n  for (;;) {\n    if (++pos >= max) return false\n\n    const ch = state.src.charCodeAt(pos)\n\n    if (ch === 0x3C /* < */) return false\n    if (ch === 0x3E /* > */) 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_TAG_RE } from '../common/html_re.mjs'\n\nfunction isLinkOpen (str) {\n  return /^<a[>\\s]/i.test(str)\n}\nfunction isLinkClose (str) {\n  return /^<\\/a\\s*>/i.test(str)\n}\n\nfunction isLetter (ch) {\n  /* eslint no-bitwise:0 */\n  const lc = ch | 0x20 // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)\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/* < */ ||\n      pos + 2 >= max) {\n    return false\n  }\n\n  // Quick fail on second char\n  const ch = state.src.charCodeAt(pos + 1)\n  if (ch !== 0x21/* ! */ &&\n      ch !== 0x3F/* ? */ &&\n      ch !== 0x2F/* / */ &&\n      !isLetter(ch)) {\n    return false\n  }\n\n  const match = state.src.slice(pos).match(HTML_TAG_RE)\n  if (!match) { return false }\n\n  if (!silent) {\n    const token = state.push('html_inline', '', 0)\n    token.content = match[0]\n\n    if (isLinkOpen(token.content))  state.linkLevel++\n    if (isLinkClose(token.content)) state.linkLevel--\n  }\n  state.pos += match[0].length\n  return true\n}\n","// Process html entity - &#123;, &#xAF;, &quot;, ...\n\nimport { decodeHTML } from 'entities'\nimport { isValidEntityCode, fromCodePoint } from '../common/utils.mjs'\n\nconst DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i\nconst NAMED_RE   = /^&([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/* & */) return false\n\n  if (pos + 1 >= 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 = decodeHTML(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 < 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 > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {\n      const opener = delimiters[openerIdx]\n\n      if (opener.marker !== closer.marker) continue\n\n      if (opener.open && opener.end < 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 > 0 && !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 **<...>**a**<...>** 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 < max; curr++) {\n    if (tokens_meta[curr] && 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 < max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting < 0) level-- // closing tag\n    tokens[curr].level = level\n    if (tokens[curr].nesting > 0) level++ // opening tag\n\n    if (tokens[curr].type === 'text' &&\n        curr + 1 < max &&\n        tokens[curr + 1].type === 'text') {\n      // 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 -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler()\n\n  for (let i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1])\n  }\n\n  /**\n   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler()\n\n  for (let i = 0; i < _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 < maxNesting) {\n    for (let i = 0; i < len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++\n      ok = rules[i](state, true)\n      state.level--\n\n      if (ok) {\n        if (pos >= 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 < 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 < maxNesting) {\n      for (let i = 0; i < len; i++) {\n        ok = rules[i](state, false)\n        if (ok) {\n          if (prevPos >= 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 >= 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 < len; i++) {\n    rules[i](state)\n  }\n}\n\nParserInline.prototype.State = StateInline\n\nexport default ParserInline\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 (<br />)\n    xhtmlOut: false,\n\n    // Convert '\\n' in paragraphs into <br>\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 <pre... 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 (<br />)\n    xhtmlOut: false,\n\n    // Convert '\\n' in paragraphs into <br>\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 <pre... 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 (<br />)\n    xhtmlOut: true,\n\n    // Convert '\\n' in paragraphs into <br>\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 <pre... 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","// 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) >= 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) >= 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 & 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 *   (`<br />`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `<br>`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.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 <pre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(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 `<pre>` or `<code>`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return '<pre><code class=\"hljs\">' +\n *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n *                '</code></pre>';\n *       } catch (__) {}\n *     }\n *\n *     return '<pre><code class=\"hljs\">' + md.utils.escapeHtml(str) + '</code></pre>';\n *   }\n * });\n * ```\n *\n **/\nfunction MarkdownIt (presetName, options) {\n  if (!(this instanceof MarkdownIt)) {\n    return new MarkdownIt(presetName, options)\n  }\n\n  if (!options) {\n    if (!utils.isString(presetName)) {\n      options = presetName || {}\n      presetName = 'default'\n    }\n  }\n\n  /**\n   * MarkdownIt#inline -> ParserInline\n   *\n   * Instance of [[ParserInline]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.inline = new ParserInline()\n\n  /**\n   * MarkdownIt#block -> ParserBlock\n   *\n   * Instance of [[ParserBlock]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.block = new ParserBlock()\n\n  /**\n   * MarkdownIt#core -> Core\n   *\n   * Instance of [[Core]] chain executor. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.core = new ParserCore()\n\n  /**\n   * MarkdownIt#renderer -> Renderer\n   *\n   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   *\n   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).\n   **/\n  this.renderer = new Renderer()\n\n  /**\n   * MarkdownIt#linkify -> LinkifyIt\n   *\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)\n   * rule.\n   **/\n  this.linkify = new LinkifyIt()\n\n  /**\n   * MarkdownIt#validateLink(url) -> Boolean\n   *\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   **/\n  this.validateLink = validateLink\n\n  /**\n   * MarkdownIt#normalizeLink(url) -> String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n  this.normalizeLink = normalizeLink\n\n  /**\n   * MarkdownIt#normalizeLinkText(url) -> String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText\n\n  // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -> utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).\n   **/\n  this.utils = utils\n\n  /**\n   * MarkdownIt#helpers -> helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n  this.helpers = utils.assign({}, helpers)\n\n  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) < 0 })\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed)\n  }\n\n  return this\n}\n\n/** 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) < 0 })\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed)\n  }\n  return this\n}\n\n/** 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) -> 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]) -> 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) -> 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]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `<p>` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {}\n\n  return this.renderer.render(this.parseInline(src, env), this.options, env)\n}\n\nexport default MarkdownIt\n"],"names":["CharCodes","Uint16Array","split","map","c","charCodeAt","decodeMap","Map","fromCodePoint","_a","String","codePoint","output","fromCharCode","replaceCodePoint","get","BinTrieFlags","EntityDecoderState","DecodingMode","TO_LOWER_BIT","isNumber","code","ZERO","NINE","isHexadecimalCharacter","UPPER_A","UPPER_F","LOWER_A","LOWER_F","isAsciiAlphaNumeric","UPPER_Z","LOWER_Z","isEntityInAttributeInvalidEnd","EQUALS","EntityDecoder","decodeTree","emitCodePoint","errors","_classCallCheck","state","EntityStart","consumed","result","treeIndex","excess","decodeMode","Strict","_createClass","key","value","str","offset","NUM","NumericStart","stateNumericStart","NamedEntity","stateNamedEntity","NumericDecimal","stateNumericDecimal","NumericHex","stateNumericHex","length","LOWER_X","start","end","base","digitCount","Math","pow","parseInt","substr","startIdx","char","addToNumericResult","emitNumericEntity","lastCp","expectedLength","absenceOfDigitsInNumericCharacterReference","SEMI","missingSemicolonAfterCharacterReference","validateNumericCharacterReference","current","valueLength","VALUE_LENGTH","determineBranch","max","Attribute","emitNotTerminatedNamedEntity","emitNamedEntityData","getDecoder","ret","decoder","lastIndex","indexOf","slice","startEntity","len","write","nodeIdx","branchCount","BRANCH_LENGTH","jumpOffset","JUMP_TABLE","lo","hi","mid","midVal","htmlDecoder","htmlDecodeTree","xmlDecodeTree","decodeHTML","mode","arguments","undefined","Legacy","restoreDiff","arr","i","v","n","o","xmlCodeMap","prototype","codePointAt","getEscaper","regex","data","match","lastIdx","exec","index","substring","EntityLevel","EncodingMode","_class","obj","Object","toString","call","isString","_hasOwnProperty","hasOwnProperty","has","object","assign","sources","Array","forEach","source","_typeof","TypeError","keys","arrayReplaceAt","src","pos","newElements","concat","isValidEntityCode","surrogate1","surrogate2","UNESCAPE_MD_RE","ENTITY_RE","UNESCAPE_ALL_RE","RegExp","DIGITAL_ENTITY_TEST_RE","replaceEntityPattern","name","test","toLowerCase","decoded","unescapeMd","replace","unescapeAll","escaped","entity","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","ch","escapeHtml","REGEXP_ESCAPE_RE","escapeRE","isSpace","isWhiteSpace","isPunctChar","ucmicro","isMdAsciiPunct","normalizeReference","trim","toUpperCase","lib","mdurl","parseLinkLabel","disableNested","level","found","marker","prevPos","posMax","oldPos","md","inline","skipToken","labelEnd","parseLinkDestination","ok","parseLinkTitle","prev_state","can_continue","default_rules","Renderer","this","rules","code_inline","tokens","idx","options","env","slf","token","renderAttrs","content","code_block","fence","highlighted","info","langName","langAttrs","join","highlight","attrIndex","tmpAttrs","attrs","push","langPrefix","tmpToken","image","renderInlineAsText","children","renderToken","hardbreak","xhtmlOut","softbreak","breaks","text","html_block","html_inline","l","hidden","block","nesting","tag","needLf","nextToken","type","renderInline","render","Ruler","__rules__","__cache__","__find__","__compile__","self","chains","rule","enabled","alt","altName","chain","fn","at","opt","Error","before","beforeName","ruleName","splice","after","afterName","enable","list","ignoreInvalid","isArray","enableOnly","disable","getRules","chainName","Token","markup","meta","attrPush","attrData","attrSet","attrGet","attrJoin","StateCore","inlineMode","NEWLINES_RE","NULL_RE","normalize","parse","tok","isLinkOpen","isLinkClose","linkify","blockTokens","j","pretest","htmlLinkLevel","currentToken","links","nodes","lastPos","ln","url","fullUrl","normalizeLink","validateLink","urlText","schema","normalizeLinkText","token_o","token_t","token_c","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","r","tm","replaceFn","replace_scoped","inlineTokens","inside_autolink","replace_rare","blkIdx","typographer","QUOTE_TEST_RE","QUOTE_RE","APOSTROPHE","replaceAt","process_inlines","stack","thisLevel","OUTER","t","canOpen","canClose","isSingle","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","item","single","openQuote","closeQuote","quotes","smartquotes","text_join","curr","last","_rules","r_normalize","r_block","r_inline","r_linkify","r_replacements","r_smartquotes","r_text_join","Core","ruler","process","State","StateBlock","bMarks","eMarks","tShift","sCount","bsCount","blkIndent","line","lineMax","tight","ddIndent","listIndent","parentType","s","indent","indent_found","isEmpty","skipEmptyLines","from","skipSpaces","skipSpacesBack","min","skipChars","skipCharsBack","getLines","begin","keepLastLF","queue","lineIndent","lineStart","first","MAX_AUTOCOMPLETED_CELLS","getLine","escapedSplit","isEscaped","table","startLine","endLine","silent","nextLine","firstCh","secondCh","lineText","columns","aligns","shift","pop","columnCount","oldParentType","terminatorRules","token_to","tableLines","token_tho","tbodyLines","token_htro","token_ho","token_il","autocompletedCells","terminate","token_tbo","token_tro","token_tdo","mem","params","haveEndMarker","blockquote","oldLineMax","oldBMarks","oldBSCount","oldSCount","oldTShift","lastLineEmpty","isOutdented","initial","spaceAfterMarker","adjustTab","oldIndent","lines","tokenize","hr","cnt","skipBulletListMarker","skipOrderedListMarker","markTightParagraphs","isOrdered","markerValue","posAfterMarker","isTerminatingParagraph","Number","markerCharCode","listTokIdx","listLines","prevEmptyEnd","contentStart","indentAfterMarker","itemLines","oldTight","oldListIndent","reference","_endLine","getNextLine","isContinuation","lineContent","destRes","helpers","href","destEndPos","destEndLineNo","title","titleRes","label","references","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","block_names","html","heading","tmp","token_i","lheading","paragraph","r_table","r_code","r_fence","r_blockquote","r_hr","r_list","r_reference","r_html_block","r_heading","r_lheading","r_paragraph","ParserBlock","maxNesting","hasEmptyLines","prevLine","outTokens","StateInline","tokens_meta","pending","pendingLevel","cache","delimiters","_prev_delimiters","backticks","backticksScanned","linkLevel","pushPending","token_meta","scanDelims","canSplitWord","count","left_flanking","right_flanking","can_open","can_close","isTerminatorChar","SCHEME_RE","proto","link","matchAtStart","newline","pmax","ws","ESCAPED","escape","ch1","escapedStr","ch2","origStr","backtick","openerLength","matchStart","matchEnd","closerLength","strikethrough_tokenize","scanned","open","close","postProcess","loneMarkers","startDelim","endDelim","strikethrough_postProcess","emphasis_tokenize","isStrong","emphasis_post_process","res","ref","parseReference","labelStart","EMAIL_RE","AUTOLINK_RE","autolink","isLetter","lc","DIGITAL_RE","NAMED_RE","processDelimiters","openersBottom","headerIdx","lastTokenIdx","jumps","closerIdx","closer","minOpenerIdx","openerIdx","newMinOpenerIdx","opener","isOddMatch","lastJump","link_pairs","fragments_join","r_text","r_newline","r_escape","r_backticks","r_strikethrough","r_emphasis","r_link","r_image","r_autolink","r_html_inline","r_entity","_rules2","r_balance_pairs","r_fragments_join","ParserInline","ruler2","components","core","rules2","config","default","cfg_default","zero","cfg_zero","commonmark","cfg_commonmark","BAD_PROTO_RE","GOOD_DATA_RE","RECODE_HOSTNAME_FOR","parsed","hostname","protocol","punycode","er","encode","format","decode","defaultChars","MarkdownIt","presetName","utils","ParserCore","renderer","LinkifyIt","configure","set","presets","missed","filter","use","plugin","args","apply","parseInline"],"sourceRoot":""}