{"version":3,"sources":["webpack:///./node_modules/marked/lib/marked.umd.js","webpack:///./src/views/Work.vue?2010","webpack:///./src/views/Work.vue","webpack:///./src/views/Work.vue?c809"],"names":["global","factory","exports","this","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","Constructor","protoProps","staticProps","prototype","_unsupportedIterableToArray","o","minLen","_arrayLikeToArray","n","toString","call","slice","constructor","name","Array","from","test","arr","len","arr2","_createForOfIteratorHelperLoose","allowArrayLike","it","Symbol","iterator","next","bind","isArray","done","value","TypeError","getDefaults","async","baseUrl","breaks","extensions","gfm","headerIds","headerPrefix","highlight","langPrefix","mangle","pedantic","renderer","sanitize","sanitizer","silent","smartypants","tokenizer","walkTokens","xhtml","changeDefaults","newDefaults","defaults","escapeTest","escapeReplace","escapeTestNoEncode","escapeReplaceNoEncode","escapeReplacements","getEscapeReplacement","ch","escape","html","encode","replace","unescapeTest","unescape","_","toLowerCase","charAt","String","fromCharCode","parseInt","substring","caret","edit","regex","opt","source","obj","val","getRegex","RegExp","nonWordAndColonTest","originIndependentUrl","cleanUrl","base","href","prot","decodeURIComponent","e","indexOf","resolveUrl","encodeURI","baseUrls","justDomain","protocol","domain","rtrim","relativeBase","noopTest","exec","merge","arguments","hasOwnProperty","splitCells","tableRow","count","row","match","offset","str","escaped","curr","cells","split","trim","shift","pop","splice","push","c","invert","l","suffLen","currChar","findClosingBracket","b","level","checkSanitizeDeprecation","console","warn","repeatString","pattern","result","outputLink","cap","link","raw","lexer","title","text","state","inLink","token","type","tokens","inlineTokens","indentCodeCompensation","matchIndentToCode","indentToCode","map","node","matchIndentInNode","indentInNode","join","Tokenizer","options","_proto","space","src","rules","block","newline","code","codeBlockStyle","fences","lang","heading","trimmed","depth","inline","hr","blockquote","blockTokens","list","istask","ischecked","indent","blankLine","endsWithBlankLine","line","nextLine","rawLine","itemContents","endEarly","bull","isordered","ordered","start","loose","items","itemRegex","trimLeft","search","nextBulletRegex","Math","min","hrRegex","fencesBeginRegex","headingBeginRegex","task","checked","trimRight","top","spacers","filter","t","hasMultipleLineBreaks","every","_step","chars","lineBreaks","_iterator","_char","pre","def","tag","table","item","header","align","rows","j","k","lheading","paragraph","inRawBlock","trimmedUrl","rtrimSlash","lastParenIndex","linkLen","_escapes","reflink","links","nolink","emStrong","maskedSrc","prevChar","lDelim","nextChar","punctuation","rDelim","rLength","lLength","delimTotal","midDelimTotal","endReg","rDelimAst","rDelimUnd","lastIndex","_text","index","codespan","hasNonSpaceChars","hasSpaceCharsOnBothEnds","br","del","autolink","url","prevCapZero","_backpedal","inlineText","_paragraph","_label","_title","bullet","listItemStart","_tag","_comment","normal","reflinkSearch","out","charCodeAt","random","_punctuation","blockSkip","escapedEmSt","_scheme","_email","_attribute","_href","strong","middle","endAst","endUnd","em","_extended_email","Lexer","create","inlineQueue","lex","lexInline","lastToken","cutSrc","lastParagraphClipped","_this","leading","tabs","repeat","some","extTokenizer","startBlock","startIndex","Infinity","tempSrc","tempStart","forEach","getStartIndex","errMsg","error","Error","_this2","keepPrevChar","keys","includes","lastIndexOf","startInline","get","Renderer","_code","infostring","quote","_html","slugger","id","slug","body","startatt","listitem","checkbox","tablerow","content","tablecell","flags","image","TextRenderer","Slugger","seen","serialize","getNextSafeSlug","originalSlug","isDryRun","occurenceAccumulator","dryrun","Parser","textRenderer","parse","parser","parseInline","l2","l3","cell","itemBody","ret","renderers","unshift","marked","callback","err","pending","setTimeout","onError","message","_tokens","Promise","all","then","setOptions","use","_len","args","_key","hasExtensions","opts","apply","concat","childTokens","pack","ext","prevRenderer","_len2","_key2","_loop","prop","_len3","_key3","_loop2","prevTokenizer","_len4","_key4","_walkTokens","values","_loop3","_step2","_iterator2","_step3","_iterator3","_step4","_iterator4","_cell","class","_createElementBlock","_createElementVNode","_toDisplayString","$props","innerHTML","$data","filename","data","container","created","fetch","$route","params","workID","res","d","__exports__","render"],"mappings":"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","file":"js/chunk-cf76f210.7adf41d0.js","sourcesContent":["/**\n * marked - a markdown parser\n * Copyright (c) 2011-2022, Christopher Jeffrey. (MIT Licensed)\n * https://github.com/markedjs/marked\n */\n\n/**\n * DO NOT EDIT THIS FILE\n * The code in this file is generated from files in ./src/\n */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.marked = {}));\n})(this, (function (exports) { 'use strict';\n\n  function _defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  function _createClass(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    Object.defineProperty(Constructor, \"prototype\", {\n      writable: false\n    });\n    return Constructor;\n  }\n\n  function _unsupportedIterableToArray(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(o);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n  }\n\n  function _arrayLikeToArray(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n\n    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n    return arr2;\n  }\n\n  function _createForOfIteratorHelperLoose(o, allowArrayLike) {\n    var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n    if (it) return (it = it.call(o)).next.bind(it);\n\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      return function () {\n        if (i >= o.length) return {\n          done: true\n        };\n        return {\n          done: false,\n          value: o[i++]\n        };\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  function getDefaults() {\n    return {\n      async: false,\n      baseUrl: null,\n      breaks: false,\n      extensions: null,\n      gfm: true,\n      headerIds: true,\n      headerPrefix: '',\n      highlight: null,\n      langPrefix: 'language-',\n      mangle: true,\n      pedantic: false,\n      renderer: null,\n      sanitize: false,\n      sanitizer: null,\n      silent: false,\n      smartypants: false,\n      tokenizer: null,\n      walkTokens: null,\n      xhtml: false\n    };\n  }\n  exports.defaults = getDefaults();\n  function changeDefaults(newDefaults) {\n    exports.defaults = newDefaults;\n  }\n\n  /**\n   * Helpers\n   */\n  var escapeTest = /[&<>\"']/;\n  var escapeReplace = /[&<>\"']/g;\n  var escapeTestNoEncode = /[<>\"']|&(?!#?\\w+;)/;\n  var escapeReplaceNoEncode = /[<>\"']|&(?!#?\\w+;)/g;\n  var escapeReplacements = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  var getEscapeReplacement = function getEscapeReplacement(ch) {\n    return escapeReplacements[ch];\n  };\n\n  function escape(html, encode) {\n    if (encode) {\n      if (escapeTest.test(html)) {\n        return html.replace(escapeReplace, getEscapeReplacement);\n      }\n    } else {\n      if (escapeTestNoEncode.test(html)) {\n        return html.replace(escapeReplaceNoEncode, getEscapeReplacement);\n      }\n    }\n\n    return html;\n  }\n  var unescapeTest = /&(#(?:\\d+)|(?:#x[0-9A-Fa-f]+)|(?:\\w+));?/ig;\n  /**\n   * @param {string} html\n   */\n\n  function unescape(html) {\n    // explicitly match decimal, hex, and named HTML entities\n    return html.replace(unescapeTest, function (_, n) {\n      n = n.toLowerCase();\n      if (n === 'colon') return ':';\n\n      if (n.charAt(0) === '#') {\n        return n.charAt(1) === 'x' ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));\n      }\n\n      return '';\n    });\n  }\n  var caret = /(^|[^\\[])\\^/g;\n  /**\n   * @param {string | RegExp} regex\n   * @param {string} opt\n   */\n\n  function edit(regex, opt) {\n    regex = typeof regex === 'string' ? regex : regex.source;\n    opt = opt || '';\n    var obj = {\n      replace: function replace(name, val) {\n        val = val.source || val;\n        val = val.replace(caret, '$1');\n        regex = regex.replace(name, val);\n        return obj;\n      },\n      getRegex: function getRegex() {\n        return new RegExp(regex, opt);\n      }\n    };\n    return obj;\n  }\n  var nonWordAndColonTest = /[^\\w:]/g;\n  var originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;\n  /**\n   * @param {boolean} sanitize\n   * @param {string} base\n   * @param {string} href\n   */\n\n  function cleanUrl(sanitize, base, href) {\n    if (sanitize) {\n      var prot;\n\n      try {\n        prot = decodeURIComponent(unescape(href)).replace(nonWordAndColonTest, '').toLowerCase();\n      } catch (e) {\n        return null;\n      }\n\n      if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {\n        return null;\n      }\n    }\n\n    if (base && !originIndependentUrl.test(href)) {\n      href = resolveUrl(base, href);\n    }\n\n    try {\n      href = encodeURI(href).replace(/%25/g, '%');\n    } catch (e) {\n      return null;\n    }\n\n    return href;\n  }\n  var baseUrls = {};\n  var justDomain = /^[^:]+:\\/*[^/]*$/;\n  var protocol = /^([^:]+:)[\\s\\S]*$/;\n  var domain = /^([^:]+:\\/*[^/]*)[\\s\\S]*$/;\n  /**\n   * @param {string} base\n   * @param {string} href\n   */\n\n  function resolveUrl(base, href) {\n    if (!baseUrls[' ' + base]) {\n      // we can ignore everything in base after the last slash of its path component,\n      // but we might need to add _that_\n      // https://tools.ietf.org/html/rfc3986#section-3\n      if (justDomain.test(base)) {\n        baseUrls[' ' + base] = base + '/';\n      } else {\n        baseUrls[' ' + base] = rtrim(base, '/', true);\n      }\n    }\n\n    base = baseUrls[' ' + base];\n    var relativeBase = base.indexOf(':') === -1;\n\n    if (href.substring(0, 2) === '//') {\n      if (relativeBase) {\n        return href;\n      }\n\n      return base.replace(protocol, '$1') + href;\n    } else if (href.charAt(0) === '/') {\n      if (relativeBase) {\n        return href;\n      }\n\n      return base.replace(domain, '$1') + href;\n    } else {\n      return base + href;\n    }\n  }\n  var noopTest = {\n    exec: function noopTest() {}\n  };\n  function merge(obj) {\n    var i = 1,\n        target,\n        key;\n\n    for (; i < arguments.length; i++) {\n      target = arguments[i];\n\n      for (key in target) {\n        if (Object.prototype.hasOwnProperty.call(target, key)) {\n          obj[key] = target[key];\n        }\n      }\n    }\n\n    return obj;\n  }\n  function splitCells(tableRow, count) {\n    // ensure that every cell-delimiting pipe has a space\n    // before it to distinguish it from an escaped pipe\n    var row = tableRow.replace(/\\|/g, function (match, offset, str) {\n      var escaped = false,\n          curr = offset;\n\n      while (--curr >= 0 && str[curr] === '\\\\') {\n        escaped = !escaped;\n      }\n\n      if (escaped) {\n        // odd number of slashes means | is escaped\n        // so we leave it alone\n        return '|';\n      } else {\n        // add space before unescaped |\n        return ' |';\n      }\n    }),\n        cells = row.split(/ \\|/);\n    var i = 0; // First/last cell in a row cannot be empty if it has no leading/trailing pipe\n\n    if (!cells[0].trim()) {\n      cells.shift();\n    }\n\n    if (cells.length > 0 && !cells[cells.length - 1].trim()) {\n      cells.pop();\n    }\n\n    if (cells.length > count) {\n      cells.splice(count);\n    } else {\n      while (cells.length < count) {\n        cells.push('');\n      }\n    }\n\n    for (; i < cells.length; i++) {\n      // leading or trailing whitespace is ignored per the gfm spec\n      cells[i] = cells[i].trim().replace(/\\\\\\|/g, '|');\n    }\n\n    return cells;\n  }\n  /**\n   * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').\n   * /c*$/ is vulnerable to REDOS.\n   *\n   * @param {string} str\n   * @param {string} c\n   * @param {boolean} invert Remove suffix of non-c chars instead. Default falsey.\n   */\n\n  function rtrim(str, c, invert) {\n    var l = str.length;\n\n    if (l === 0) {\n      return '';\n    } // Length of suffix matching the invert condition.\n\n\n    var suffLen = 0; // Step left until we fail to match the invert condition.\n\n    while (suffLen < l) {\n      var currChar = str.charAt(l - suffLen - 1);\n\n      if (currChar === c && !invert) {\n        suffLen++;\n      } else if (currChar !== c && invert) {\n        suffLen++;\n      } else {\n        break;\n      }\n    }\n\n    return str.slice(0, l - suffLen);\n  }\n  function findClosingBracket(str, b) {\n    if (str.indexOf(b[1]) === -1) {\n      return -1;\n    }\n\n    var l = str.length;\n    var level = 0,\n        i = 0;\n\n    for (; i < l; i++) {\n      if (str[i] === '\\\\') {\n        i++;\n      } else if (str[i] === b[0]) {\n        level++;\n      } else if (str[i] === b[1]) {\n        level--;\n\n        if (level < 0) {\n          return i;\n        }\n      }\n    }\n\n    return -1;\n  }\n  function checkSanitizeDeprecation(opt) {\n    if (opt && opt.sanitize && !opt.silent) {\n      console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');\n    }\n  } // copied from https://stackoverflow.com/a/5450113/806777\n\n  /**\n   * @param {string} pattern\n   * @param {number} count\n   */\n\n  function repeatString(pattern, count) {\n    if (count < 1) {\n      return '';\n    }\n\n    var result = '';\n\n    while (count > 1) {\n      if (count & 1) {\n        result += pattern;\n      }\n\n      count >>= 1;\n      pattern += pattern;\n    }\n\n    return result + pattern;\n  }\n\n  function outputLink(cap, link, raw, lexer) {\n    var href = link.href;\n    var title = link.title ? escape(link.title) : null;\n    var text = cap[1].replace(/\\\\([\\[\\]])/g, '$1');\n\n    if (cap[0].charAt(0) !== '!') {\n      lexer.state.inLink = true;\n      var token = {\n        type: 'link',\n        raw: raw,\n        href: href,\n        title: title,\n        text: text,\n        tokens: lexer.inlineTokens(text)\n      };\n      lexer.state.inLink = false;\n      return token;\n    }\n\n    return {\n      type: 'image',\n      raw: raw,\n      href: href,\n      title: title,\n      text: escape(text)\n    };\n  }\n\n  function indentCodeCompensation(raw, text) {\n    var matchIndentToCode = raw.match(/^(\\s+)(?:```)/);\n\n    if (matchIndentToCode === null) {\n      return text;\n    }\n\n    var indentToCode = matchIndentToCode[1];\n    return text.split('\\n').map(function (node) {\n      var matchIndentInNode = node.match(/^\\s+/);\n\n      if (matchIndentInNode === null) {\n        return node;\n      }\n\n      var indentInNode = matchIndentInNode[0];\n\n      if (indentInNode.length >= indentToCode.length) {\n        return node.slice(indentToCode.length);\n      }\n\n      return node;\n    }).join('\\n');\n  }\n  /**\n   * Tokenizer\n   */\n\n\n  var Tokenizer = /*#__PURE__*/function () {\n    function Tokenizer(options) {\n      this.options = options || exports.defaults;\n    }\n\n    var _proto = Tokenizer.prototype;\n\n    _proto.space = function space(src) {\n      var cap = this.rules.block.newline.exec(src);\n\n      if (cap && cap[0].length > 0) {\n        return {\n          type: 'space',\n          raw: cap[0]\n        };\n      }\n    };\n\n    _proto.code = function code(src) {\n      var cap = this.rules.block.code.exec(src);\n\n      if (cap) {\n        var text = cap[0].replace(/^ {1,4}/gm, '');\n        return {\n          type: 'code',\n          raw: cap[0],\n          codeBlockStyle: 'indented',\n          text: !this.options.pedantic ? rtrim(text, '\\n') : text\n        };\n      }\n    };\n\n    _proto.fences = function fences(src) {\n      var cap = this.rules.block.fences.exec(src);\n\n      if (cap) {\n        var raw = cap[0];\n        var text = indentCodeCompensation(raw, cap[3] || '');\n        return {\n          type: 'code',\n          raw: raw,\n          lang: cap[2] ? cap[2].trim() : cap[2],\n          text: text\n        };\n      }\n    };\n\n    _proto.heading = function heading(src) {\n      var cap = this.rules.block.heading.exec(src);\n\n      if (cap) {\n        var text = cap[2].trim(); // remove trailing #s\n\n        if (/#$/.test(text)) {\n          var trimmed = rtrim(text, '#');\n\n          if (this.options.pedantic) {\n            text = trimmed.trim();\n          } else if (!trimmed || / $/.test(trimmed)) {\n            // CommonMark requires space before trailing #s\n            text = trimmed.trim();\n          }\n        }\n\n        return {\n          type: 'heading',\n          raw: cap[0],\n          depth: cap[1].length,\n          text: text,\n          tokens: this.lexer.inline(text)\n        };\n      }\n    };\n\n    _proto.hr = function hr(src) {\n      var cap = this.rules.block.hr.exec(src);\n\n      if (cap) {\n        return {\n          type: 'hr',\n          raw: cap[0]\n        };\n      }\n    };\n\n    _proto.blockquote = function blockquote(src) {\n      var cap = this.rules.block.blockquote.exec(src);\n\n      if (cap) {\n        var text = cap[0].replace(/^ *>[ \\t]?/gm, '');\n        return {\n          type: 'blockquote',\n          raw: cap[0],\n          tokens: this.lexer.blockTokens(text, []),\n          text: text\n        };\n      }\n    };\n\n    _proto.list = function list(src) {\n      var cap = this.rules.block.list.exec(src);\n\n      if (cap) {\n        var raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine, line, nextLine, rawLine, itemContents, endEarly;\n        var bull = cap[1].trim();\n        var isordered = bull.length > 1;\n        var list = {\n          type: 'list',\n          raw: '',\n          ordered: isordered,\n          start: isordered ? +bull.slice(0, -1) : '',\n          loose: false,\n          items: []\n        };\n        bull = isordered ? \"\\\\d{1,9}\\\\\" + bull.slice(-1) : \"\\\\\" + bull;\n\n        if (this.options.pedantic) {\n          bull = isordered ? bull : '[*+-]';\n        } // Get next list item\n\n\n        var itemRegex = new RegExp(\"^( {0,3}\" + bull + \")((?:[\\t ][^\\\\n]*)?(?:\\\\n|$))\"); // Check if current bullet point can start a new List Item\n\n        while (src) {\n          endEarly = false;\n\n          if (!(cap = itemRegex.exec(src))) {\n            break;\n          }\n\n          if (this.rules.block.hr.test(src)) {\n            // End list if bullet was actually HR (possibly move into itemRegex?)\n            break;\n          }\n\n          raw = cap[0];\n          src = src.substring(raw.length);\n          line = cap[2].split('\\n', 1)[0];\n          nextLine = src.split('\\n', 1)[0];\n\n          if (this.options.pedantic) {\n            indent = 2;\n            itemContents = line.trimLeft();\n          } else {\n            indent = cap[2].search(/[^ ]/); // Find first non-space char\n\n            indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent\n\n            itemContents = line.slice(indent);\n            indent += cap[1].length;\n          }\n\n          blankLine = false;\n\n          if (!line && /^ *$/.test(nextLine)) {\n            // Items begin with at most one blank line\n            raw += nextLine + '\\n';\n            src = src.substring(nextLine.length + 1);\n            endEarly = true;\n          }\n\n          if (!endEarly) {\n            var nextBulletRegex = new RegExp(\"^ {0,\" + Math.min(3, indent - 1) + \"}(?:[*+-]|\\\\d{1,9}[.)])((?: [^\\\\n]*)?(?:\\\\n|$))\");\n            var hrRegex = new RegExp(\"^ {0,\" + Math.min(3, indent - 1) + \"}((?:- *){3,}|(?:_ *){3,}|(?:\\\\* *){3,})(?:\\\\n+|$)\");\n            var fencesBeginRegex = new RegExp(\"^ {0,\" + Math.min(3, indent - 1) + \"}(?:```|~~~)\");\n            var headingBeginRegex = new RegExp(\"^ {0,\" + Math.min(3, indent - 1) + \"}#\"); // Check if following lines should be included in List Item\n\n            while (src) {\n              rawLine = src.split('\\n', 1)[0];\n              line = rawLine; // Re-align to follow commonmark nesting rules\n\n              if (this.options.pedantic) {\n                line = line.replace(/^ {1,4}(?=( {4})*[^ ])/g, '  ');\n              } // End list item if found code fences\n\n\n              if (fencesBeginRegex.test(line)) {\n                break;\n              } // End list item if found start of new heading\n\n\n              if (headingBeginRegex.test(line)) {\n                break;\n              } // End list item if found start of new bullet\n\n\n              if (nextBulletRegex.test(line)) {\n                break;\n              } // Horizontal rule found\n\n\n              if (hrRegex.test(src)) {\n                break;\n              }\n\n              if (line.search(/[^ ]/) >= indent || !line.trim()) {\n                // Dedent if possible\n                itemContents += '\\n' + line.slice(indent);\n              } else if (!blankLine) {\n                // Until blank line, item doesn't need indentation\n                itemContents += '\\n' + line;\n              } else {\n                // Otherwise, improper indentation ends this item\n                break;\n              }\n\n              if (!blankLine && !line.trim()) {\n                // Check if current line is blank\n                blankLine = true;\n              }\n\n              raw += rawLine + '\\n';\n              src = src.substring(rawLine.length + 1);\n            }\n          }\n\n          if (!list.loose) {\n            // If the previous item ended with a blank line, the list is loose\n            if (endsWithBlankLine) {\n              list.loose = true;\n            } else if (/\\n *\\n *$/.test(raw)) {\n              endsWithBlankLine = true;\n            }\n          } // Check for task list items\n\n\n          if (this.options.gfm) {\n            istask = /^\\[[ xX]\\] /.exec(itemContents);\n\n            if (istask) {\n              ischecked = istask[0] !== '[ ] ';\n              itemContents = itemContents.replace(/^\\[[ xX]\\] +/, '');\n            }\n          }\n\n          list.items.push({\n            type: 'list_item',\n            raw: raw,\n            task: !!istask,\n            checked: ischecked,\n            loose: false,\n            text: itemContents\n          });\n          list.raw += raw;\n        } // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic\n\n\n        list.items[list.items.length - 1].raw = raw.trimRight();\n        list.items[list.items.length - 1].text = itemContents.trimRight();\n        list.raw = list.raw.trimRight();\n        var l = list.items.length; // Item child tokens handled here at end because we needed to have the final item to trim it first\n\n        for (i = 0; i < l; i++) {\n          this.lexer.state.top = false;\n          list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);\n          var spacers = list.items[i].tokens.filter(function (t) {\n            return t.type === 'space';\n          });\n          var hasMultipleLineBreaks = spacers.every(function (t) {\n            var chars = t.raw.split('');\n            var lineBreaks = 0;\n\n            for (var _iterator = _createForOfIteratorHelperLoose(chars), _step; !(_step = _iterator()).done;) {\n              var _char = _step.value;\n\n              if (_char === '\\n') {\n                lineBreaks += 1;\n              }\n\n              if (lineBreaks > 1) {\n                return true;\n              }\n            }\n\n            return false;\n          });\n\n          if (!list.loose && spacers.length && hasMultipleLineBreaks) {\n            // Having a single line break doesn't mean a list is loose. A single line break is terminating the last list item\n            list.loose = true;\n            list.items[i].loose = true;\n          }\n        }\n\n        return list;\n      }\n    };\n\n    _proto.html = function html(src) {\n      var cap = this.rules.block.html.exec(src);\n\n      if (cap) {\n        var token = {\n          type: 'html',\n          raw: cap[0],\n          pre: !this.options.sanitizer && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),\n          text: cap[0]\n        };\n\n        if (this.options.sanitize) {\n          var text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);\n          token.type = 'paragraph';\n          token.text = text;\n          token.tokens = this.lexer.inline(text);\n        }\n\n        return token;\n      }\n    };\n\n    _proto.def = function def(src) {\n      var cap = this.rules.block.def.exec(src);\n\n      if (cap) {\n        if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);\n        var tag = cap[1].toLowerCase().replace(/\\s+/g, ' ');\n        return {\n          type: 'def',\n          tag: tag,\n          raw: cap[0],\n          href: cap[2],\n          title: cap[3]\n        };\n      }\n    };\n\n    _proto.table = function table(src) {\n      var cap = this.rules.block.table.exec(src);\n\n      if (cap) {\n        var item = {\n          type: 'table',\n          header: splitCells(cap[1]).map(function (c) {\n            return {\n              text: c\n            };\n          }),\n          align: cap[2].replace(/^ *|\\| *$/g, '').split(/ *\\| */),\n          rows: cap[3] && cap[3].trim() ? cap[3].replace(/\\n[ \\t]*$/, '').split('\\n') : []\n        };\n\n        if (item.header.length === item.align.length) {\n          item.raw = cap[0];\n          var l = item.align.length;\n          var i, j, k, row;\n\n          for (i = 0; i < l; i++) {\n            if (/^ *-+: *$/.test(item.align[i])) {\n              item.align[i] = 'right';\n            } else if (/^ *:-+: *$/.test(item.align[i])) {\n              item.align[i] = 'center';\n            } else if (/^ *:-+ *$/.test(item.align[i])) {\n              item.align[i] = 'left';\n            } else {\n              item.align[i] = null;\n            }\n          }\n\n          l = item.rows.length;\n\n          for (i = 0; i < l; i++) {\n            item.rows[i] = splitCells(item.rows[i], item.header.length).map(function (c) {\n              return {\n                text: c\n              };\n            });\n          } // parse child tokens inside headers and cells\n          // header child tokens\n\n\n          l = item.header.length;\n\n          for (j = 0; j < l; j++) {\n            item.header[j].tokens = this.lexer.inline(item.header[j].text);\n          } // cell child tokens\n\n\n          l = item.rows.length;\n\n          for (j = 0; j < l; j++) {\n            row = item.rows[j];\n\n            for (k = 0; k < row.length; k++) {\n              row[k].tokens = this.lexer.inline(row[k].text);\n            }\n          }\n\n          return item;\n        }\n      }\n    };\n\n    _proto.lheading = function lheading(src) {\n      var cap = this.rules.block.lheading.exec(src);\n\n      if (cap) {\n        return {\n          type: 'heading',\n          raw: cap[0],\n          depth: cap[2].charAt(0) === '=' ? 1 : 2,\n          text: cap[1],\n          tokens: this.lexer.inline(cap[1])\n        };\n      }\n    };\n\n    _proto.paragraph = function paragraph(src) {\n      var cap = this.rules.block.paragraph.exec(src);\n\n      if (cap) {\n        var text = cap[1].charAt(cap[1].length - 1) === '\\n' ? cap[1].slice(0, -1) : cap[1];\n        return {\n          type: 'paragraph',\n          raw: cap[0],\n          text: text,\n          tokens: this.lexer.inline(text)\n        };\n      }\n    };\n\n    _proto.text = function text(src) {\n      var cap = this.rules.block.text.exec(src);\n\n      if (cap) {\n        return {\n          type: 'text',\n          raw: cap[0],\n          text: cap[0],\n          tokens: this.lexer.inline(cap[0])\n        };\n      }\n    };\n\n    _proto.escape = function escape$1(src) {\n      var cap = this.rules.inline.escape.exec(src);\n\n      if (cap) {\n        return {\n          type: 'escape',\n          raw: cap[0],\n          text: escape(cap[1])\n        };\n      }\n    };\n\n    _proto.tag = function tag(src) {\n      var cap = this.rules.inline.tag.exec(src);\n\n      if (cap) {\n        if (!this.lexer.state.inLink && /^<a /i.test(cap[0])) {\n          this.lexer.state.inLink = true;\n        } else if (this.lexer.state.inLink && /^<\\/a>/i.test(cap[0])) {\n          this.lexer.state.inLink = false;\n        }\n\n        if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\\s|>)/i.test(cap[0])) {\n          this.lexer.state.inRawBlock = true;\n        } else if (this.lexer.state.inRawBlock && /^<\\/(pre|code|kbd|script)(\\s|>)/i.test(cap[0])) {\n          this.lexer.state.inRawBlock = false;\n        }\n\n        return {\n          type: this.options.sanitize ? 'text' : 'html',\n          raw: cap[0],\n          inLink: this.lexer.state.inLink,\n          inRawBlock: this.lexer.state.inRawBlock,\n          text: this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0]\n        };\n      }\n    };\n\n    _proto.link = function link(src) {\n      var cap = this.rules.inline.link.exec(src);\n\n      if (cap) {\n        var trimmedUrl = cap[2].trim();\n\n        if (!this.options.pedantic && /^</.test(trimmedUrl)) {\n          // commonmark requires matching angle brackets\n          if (!/>$/.test(trimmedUrl)) {\n            return;\n          } // ending angle bracket cannot be escaped\n\n\n          var rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\\\');\n\n          if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {\n            return;\n          }\n        } else {\n          // find closing parenthesis\n          var lastParenIndex = findClosingBracket(cap[2], '()');\n\n          if (lastParenIndex > -1) {\n            var start = cap[0].indexOf('!') === 0 ? 5 : 4;\n            var linkLen = start + cap[1].length + lastParenIndex;\n            cap[2] = cap[2].substring(0, lastParenIndex);\n            cap[0] = cap[0].substring(0, linkLen).trim();\n            cap[3] = '';\n          }\n        }\n\n        var href = cap[2];\n        var title = '';\n\n        if (this.options.pedantic) {\n          // split pedantic href and title\n          var link = /^([^'\"]*[^\\s])\\s+(['\"])(.*)\\2/.exec(href);\n\n          if (link) {\n            href = link[1];\n            title = link[3];\n          }\n        } else {\n          title = cap[3] ? cap[3].slice(1, -1) : '';\n        }\n\n        href = href.trim();\n\n        if (/^</.test(href)) {\n          if (this.options.pedantic && !/>$/.test(trimmedUrl)) {\n            // pedantic allows starting angle bracket without ending angle bracket\n            href = href.slice(1);\n          } else {\n            href = href.slice(1, -1);\n          }\n        }\n\n        return outputLink(cap, {\n          href: href ? href.replace(this.rules.inline._escapes, '$1') : href,\n          title: title ? title.replace(this.rules.inline._escapes, '$1') : title\n        }, cap[0], this.lexer);\n      }\n    };\n\n    _proto.reflink = function reflink(src, links) {\n      var cap;\n\n      if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {\n        var link = (cap[2] || cap[1]).replace(/\\s+/g, ' ');\n        link = links[link.toLowerCase()];\n\n        if (!link || !link.href) {\n          var text = cap[0].charAt(0);\n          return {\n            type: 'text',\n            raw: text,\n            text: text\n          };\n        }\n\n        return outputLink(cap, link, cap[0], this.lexer);\n      }\n    };\n\n    _proto.emStrong = function emStrong(src, maskedSrc, prevChar) {\n      if (prevChar === void 0) {\n        prevChar = '';\n      }\n\n      var match = this.rules.inline.emStrong.lDelim.exec(src);\n      if (!match) return; // _ can't be between two alphanumerics. \\p{L}\\p{N} includes non-english alphabet/numbers as well\n\n      if (match[3] && prevChar.match(/(?:[0-9A-Za-z\\xAA\\xB2\\xB3\\xB5\\xB9\\xBA\\xBC-\\xBE\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u064A\\u0660-\\u0669\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07C0-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086A\\u0870-\\u0887\\u0889-\\u088E\\u08A0-\\u08C9\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0966-\\u096F\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09E6-\\u09F1\\u09F4-\\u09F9\\u09FC\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A6F\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AE6-\\u0AEF\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B66-\\u0B6F\\u0B71-\\u0B77\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0BE6-\\u0BF2\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C5D\\u0C60\\u0C61\\u0C66-\\u0C6F\\u0C78-\\u0C7E\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDD\\u0CDE\\u0CE0\\u0CE1\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D04-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D58-\\u0D61\\u0D66-\\u0D78\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DE6-\\u0DEF\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E86-\\u0E8A\\u0E8C-\\u0EA3\\u0EA5\\u0EA7-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F20-\\u0F33\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F-\\u1049\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u1090-\\u1099\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1369-\\u137C\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u1711\\u171F-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u17E0-\\u17E9\\u17F0-\\u17F9\\u1810-\\u1819\\u1820-\\u1878\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19DA\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4C\\u1B50-\\u1B59\\u1B83-\\u1BA0\\u1BAE-\\u1BE5\\u1C00-\\u1C23\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1C80-\\u1C88\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1CE9-\\u1CEC\\u1CEE-\\u1CF3\\u1CF5\\u1CF6\\u1CFA\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2070\\u2071\\u2074-\\u2079\\u207F-\\u2089\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2150-\\u2189\\u2460-\\u249B\\u24EA-\\u24FF\\u2776-\\u2793\\u2C00-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2CFD\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312F\\u3131-\\u318E\\u3192-\\u3195\\u31A0-\\u31BF\\u31F0-\\u31FF\\u3220-\\u3229\\u3248-\\u324F\\u3251-\\u325F\\u3280-\\u3289\\u32B1-\\u32BF\\u3400-\\u4DBF\\u4E00-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7CA\\uA7D0\\uA7D1\\uA7D3\\uA7D5-\\uA7D9\\uA7F2-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA830-\\uA835\\uA840-\\uA873\\uA882-\\uA8B3\\uA8D0-\\uA8D9\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA8FE\\uA900-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF-\\uA9D9\\uA9E0-\\uA9E4\\uA9E6-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB69\\uAB70-\\uABE2\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD07-\\uDD33\\uDD40-\\uDD78\\uDD8A\\uDD8B\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDEE1-\\uDEFB\\uDF00-\\uDF23\\uDF2D-\\uDF4A\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCA0-\\uDCA9\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDD70-\\uDD7A\\uDD7C-\\uDD8A\\uDD8C-\\uDD92\\uDD94\\uDD95\\uDD97-\\uDDA1\\uDDA3-\\uDDB1\\uDDB3-\\uDDB9\\uDDBB\\uDDBC\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67\\uDF80-\\uDF85\\uDF87-\\uDFB0\\uDFB2-\\uDFBA]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC58-\\uDC76\\uDC79-\\uDC9E\\uDCA7-\\uDCAF\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDCFB-\\uDD1B\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBC-\\uDDCF\\uDDD2-\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE35\\uDE40-\\uDE48\\uDE60-\\uDE7E\\uDE80-\\uDE9F\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDEEB-\\uDEEF\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF58-\\uDF72\\uDF78-\\uDF91\\uDFA9-\\uDFAF]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2\\uDCFA-\\uDD23\\uDD30-\\uDD39\\uDE60-\\uDE7E\\uDE80-\\uDEA9\\uDEB0\\uDEB1\\uDF00-\\uDF27\\uDF30-\\uDF45\\uDF51-\\uDF54\\uDF70-\\uDF81\\uDFB0-\\uDFCB\\uDFE0-\\uDFF6]|\\uD804[\\uDC03-\\uDC37\\uDC52-\\uDC6F\\uDC71\\uDC72\\uDC75\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDCF0-\\uDCF9\\uDD03-\\uDD26\\uDD36-\\uDD3F\\uDD44\\uDD47\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDD0-\\uDDDA\\uDDDC\\uDDE1-\\uDDF4\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDEF0-\\uDEF9\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC50-\\uDC59\\uDC5F-\\uDC61\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDCD0-\\uDCD9\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE50-\\uDE59\\uDE80-\\uDEAA\\uDEB8\\uDEC0-\\uDEC9\\uDF00-\\uDF1A\\uDF30-\\uDF3B\\uDF40-\\uDF46]|\\uD806[\\uDC00-\\uDC2B\\uDCA0-\\uDCF2\\uDCFF-\\uDD06\\uDD09\\uDD0C-\\uDD13\\uDD15\\uDD16\\uDD18-\\uDD2F\\uDD3F\\uDD41\\uDD50-\\uDD59\\uDDA0-\\uDDA7\\uDDAA-\\uDDD0\\uDDE1\\uDDE3\\uDE00\\uDE0B-\\uDE32\\uDE3A\\uDE50\\uDE5C-\\uDE89\\uDE9D\\uDEB0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC50-\\uDC6C\\uDC72-\\uDC8F\\uDD00-\\uDD06\\uDD08\\uDD09\\uDD0B-\\uDD30\\uDD46\\uDD50-\\uDD59\\uDD60-\\uDD65\\uDD67\\uDD68\\uDD6A-\\uDD89\\uDD98\\uDDA0-\\uDDA9\\uDEE0-\\uDEF2\\uDFB0\\uDFC0-\\uDFD4]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|\\uD80B[\\uDF90-\\uDFF0]|[\\uD80C\\uD81C-\\uD820\\uD822\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872\\uD874-\\uD879\\uD880-\\uD883][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDE60-\\uDE69\\uDE70-\\uDEBE\\uDEC0-\\uDEC9\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF50-\\uDF59\\uDF5B-\\uDF61\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDE40-\\uDE96\\uDF00-\\uDF4A\\uDF50\\uDF93-\\uDF9F\\uDFE0\\uDFE1\\uDFE3]|\\uD821[\\uDC00-\\uDFF7]|\\uD823[\\uDC00-\\uDCD5\\uDD00-\\uDD08]|\\uD82B[\\uDFF0-\\uDFF3\\uDFF5-\\uDFFB\\uDFFD\\uDFFE]|\\uD82C[\\uDC00-\\uDD22\\uDD50-\\uDD52\\uDD64-\\uDD67\\uDD70-\\uDEFB]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD834[\\uDEE0-\\uDEF3\\uDF60-\\uDF78]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB\\uDFCE-\\uDFFF]|\\uD837[\\uDF00-\\uDF1E]|\\uD838[\\uDD00-\\uDD2C\\uDD37-\\uDD3D\\uDD40-\\uDD49\\uDD4E\\uDE90-\\uDEAD\\uDEC0-\\uDEEB\\uDEF0-\\uDEF9]|\\uD839[\\uDFE0-\\uDFE6\\uDFE8-\\uDFEB\\uDFED\\uDFEE\\uDFF0-\\uDFFE]|\\uD83A[\\uDC00-\\uDCC4\\uDCC7-\\uDCCF\\uDD00-\\uDD43\\uDD4B\\uDD50-\\uDD59]|\\uD83B[\\uDC71-\\uDCAB\\uDCAD-\\uDCAF\\uDCB1-\\uDCB4\\uDD01-\\uDD2D\\uDD2F-\\uDD3D\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD83C[\\uDD00-\\uDD0C]|\\uD83E[\\uDFF0-\\uDFF9]|\\uD869[\\uDC00-\\uDEDF\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF38\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1\\uDEB0-\\uDFFF]|\\uD87A[\\uDC00-\\uDFE0]|\\uD87E[\\uDC00-\\uDE1D]|\\uD884[\\uDC00-\\uDF4A])/)) return;\n      var nextChar = match[1] || match[2] || '';\n\n      if (!nextChar || nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))) {\n        var lLength = match[0].length - 1;\n        var rDelim,\n            rLength,\n            delimTotal = lLength,\n            midDelimTotal = 0;\n        var endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;\n        endReg.lastIndex = 0; // Clip maskedSrc to same section of string as src (move to lexer?)\n\n        maskedSrc = maskedSrc.slice(-1 * src.length + lLength);\n\n        while ((match = endReg.exec(maskedSrc)) != null) {\n          rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];\n          if (!rDelim) continue; // skip single * in __abc*abc__\n\n          rLength = rDelim.length;\n\n          if (match[3] || match[4]) {\n            // found another Left Delim\n            delimTotal += rLength;\n            continue;\n          } else if (match[5] || match[6]) {\n            // either Left or Right Delim\n            if (lLength % 3 && !((lLength + rLength) % 3)) {\n              midDelimTotal += rLength;\n              continue; // CommonMark Emphasis Rules 9-10\n            }\n          }\n\n          delimTotal -= rLength;\n          if (delimTotal > 0) continue; // Haven't found enough closing delimiters\n          // Remove extra characters. *a*** -> *a*\n\n          rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal); // Create `em` if smallest delimiter has odd char count. *a***\n\n          if (Math.min(lLength, rLength) % 2) {\n            var _text = src.slice(1, lLength + match.index + rLength);\n\n            return {\n              type: 'em',\n              raw: src.slice(0, lLength + match.index + rLength + 1),\n              text: _text,\n              tokens: this.lexer.inlineTokens(_text)\n            };\n          } // Create 'strong' if smallest delimiter has even char count. **a***\n\n\n          var text = src.slice(2, lLength + match.index + rLength - 1);\n          return {\n            type: 'strong',\n            raw: src.slice(0, lLength + match.index + rLength + 1),\n            text: text,\n            tokens: this.lexer.inlineTokens(text)\n          };\n        }\n      }\n    };\n\n    _proto.codespan = function codespan(src) {\n      var cap = this.rules.inline.code.exec(src);\n\n      if (cap) {\n        var text = cap[2].replace(/\\n/g, ' ');\n        var hasNonSpaceChars = /[^ ]/.test(text);\n        var hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);\n\n        if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {\n          text = text.substring(1, text.length - 1);\n        }\n\n        text = escape(text, true);\n        return {\n          type: 'codespan',\n          raw: cap[0],\n          text: text\n        };\n      }\n    };\n\n    _proto.br = function br(src) {\n      var cap = this.rules.inline.br.exec(src);\n\n      if (cap) {\n        return {\n          type: 'br',\n          raw: cap[0]\n        };\n      }\n    };\n\n    _proto.del = function del(src) {\n      var cap = this.rules.inline.del.exec(src);\n\n      if (cap) {\n        return {\n          type: 'del',\n          raw: cap[0],\n          text: cap[2],\n          tokens: this.lexer.inlineTokens(cap[2])\n        };\n      }\n    };\n\n    _proto.autolink = function autolink(src, mangle) {\n      var cap = this.rules.inline.autolink.exec(src);\n\n      if (cap) {\n        var text, href;\n\n        if (cap[2] === '@') {\n          text = escape(this.options.mangle ? mangle(cap[1]) : cap[1]);\n          href = 'mailto:' + text;\n        } else {\n          text = escape(cap[1]);\n          href = text;\n        }\n\n        return {\n          type: 'link',\n          raw: cap[0],\n          text: text,\n          href: href,\n          tokens: [{\n            type: 'text',\n            raw: text,\n            text: text\n          }]\n        };\n      }\n    };\n\n    _proto.url = function url(src, mangle) {\n      var cap;\n\n      if (cap = this.rules.inline.url.exec(src)) {\n        var text, href;\n\n        if (cap[2] === '@') {\n          text = escape(this.options.mangle ? mangle(cap[0]) : cap[0]);\n          href = 'mailto:' + text;\n        } else {\n          // do extended autolink path validation\n          var prevCapZero;\n\n          do {\n            prevCapZero = cap[0];\n            cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];\n          } while (prevCapZero !== cap[0]);\n\n          text = escape(cap[0]);\n\n          if (cap[1] === 'www.') {\n            href = 'http://' + text;\n          } else {\n            href = text;\n          }\n        }\n\n        return {\n          type: 'link',\n          raw: cap[0],\n          text: text,\n          href: href,\n          tokens: [{\n            type: 'text',\n            raw: text,\n            text: text\n          }]\n        };\n      }\n    };\n\n    _proto.inlineText = function inlineText(src, smartypants) {\n      var cap = this.rules.inline.text.exec(src);\n\n      if (cap) {\n        var text;\n\n        if (this.lexer.state.inRawBlock) {\n          text = this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0];\n        } else {\n          text = escape(this.options.smartypants ? smartypants(cap[0]) : cap[0]);\n        }\n\n        return {\n          type: 'text',\n          raw: cap[0],\n          text: text\n        };\n      }\n    };\n\n    return Tokenizer;\n  }();\n\n  /**\n   * Block-Level Grammar\n   */\n\n  var block = {\n    newline: /^(?: *(?:\\n|$))+/,\n    code: /^( {4}[^\\n]+(?:\\n(?: *(?:\\n|$))*)?)+/,\n    fences: /^ {0,3}(`{3,}(?=[^`\\n]*\\n)|~{3,})([^\\n]*)\\n(?:|([\\s\\S]*?)\\n)(?: {0,3}\\1[~`]* *(?=\\n|$)|$)/,\n    hr: /^ {0,3}((?:-[\\t ]*){3,}|(?:_[ \\t]*){3,}|(?:\\*[ \\t]*){3,})(?:\\n+|$)/,\n    heading: /^ {0,3}(#{1,6})(?=\\s|$)(.*)(?:\\n+|$)/,\n    blockquote: /^( {0,3}> ?(paragraph|[^\\n]*)(?:\\n|$))+/,\n    list: /^( {0,3}bull)([ \\t][^\\n]+?)?(?:\\n|$)/,\n    html: '^ {0,3}(?:' // optional indentation\n    + '<(script|pre|style|textarea)[\\\\s>][\\\\s\\\\S]*?(?:</\\\\1>[^\\\\n]*\\\\n+|$)' // (1)\n    + '|comment[^\\\\n]*(\\\\n+|$)' // (2)\n    + '|<\\\\?[\\\\s\\\\S]*?(?:\\\\?>\\\\n*|$)' // (3)\n    + '|<![A-Z][\\\\s\\\\S]*?(?:>\\\\n*|$)' // (4)\n    + '|<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?(?:\\\\]\\\\]>\\\\n*|$)' // (5)\n    + '|</?(tag)(?: +|\\\\n|/?>)[\\\\s\\\\S]*?(?:(?:\\\\n *)+\\\\n|$)' // (6)\n    + '|<(?!script|pre|style|textarea)([a-z][\\\\w-]*)(?:attribute)*? */?>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n *)+\\\\n|$)' // (7) open tag\n    + '|</(?!script|pre|style|textarea)[a-z][\\\\w-]*\\\\s*>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n *)+\\\\n|$)' // (7) closing tag\n    + ')',\n    def: /^ {0,3}\\[(label)\\]: *(?:\\n *)?<?([^\\s>]+)>?(?:(?: +(?:\\n *)?| *\\n *)(title))? *(?:\\n+|$)/,\n    table: noopTest,\n    lheading: /^([^\\n]+)\\n {0,3}(=+|-+) *(?:\\n+|$)/,\n    // regex template, placeholders will be replaced according to different paragraph\n    // interruption rules of commonmark and the original markdown spec:\n    _paragraph: /^([^\\n]+(?:\\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\\n)[^\\n]+)*)/,\n    text: /^[^\\n]+/\n  };\n  block._label = /(?!\\s*\\])(?:\\\\.|[^\\[\\]\\\\])+/;\n  block._title = /(?:\"(?:\\\\\"?|[^\"\\\\])*\"|'[^'\\n]*(?:\\n[^'\\n]+)*\\n?'|\\([^()]*\\))/;\n  block.def = edit(block.def).replace('label', block._label).replace('title', block._title).getRegex();\n  block.bullet = /(?:[*+-]|\\d{1,9}[.)])/;\n  block.listItemStart = edit(/^( *)(bull) */).replace('bull', block.bullet).getRegex();\n  block.list = edit(block.list).replace(/bull/g, block.bullet).replace('hr', '\\\\n+(?=\\\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\\\* *){3,})(?:\\\\n+|$))').replace('def', '\\\\n+(?=' + block.def.source + ')').getRegex();\n  block._tag = 'address|article|aside|base|basefont|blockquote|body|caption' + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption' + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe' + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option' + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr' + '|track|ul';\n  block._comment = /<!--(?!-?>)[\\s\\S]*?(?:-->|$)/;\n  block.html = edit(block.html, 'i').replace('comment', block._comment).replace('tag', block._tag).replace('attribute', / +[a-zA-Z:_][\\w.:-]*(?: *= *\"[^\"\\n]*\"| *= *'[^'\\n]*'| *= *[^\\s\"'=<>`]+)?/).getRegex();\n  block.paragraph = edit(block._paragraph).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs\n  .replace('|table', '').replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n  .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // pars can be interrupted by type (6) html blocks\n  .getRegex();\n  block.blockquote = edit(block.blockquote).replace('paragraph', block.paragraph).getRegex();\n  /**\n   * Normal Block Grammar\n   */\n\n  block.normal = merge({}, block);\n  /**\n   * GFM Block Grammar\n   */\n\n  block.gfm = merge({}, block.normal, {\n    table: '^ *([^\\\\n ].*\\\\|.*)\\\\n' // Header\n    + ' {0,3}(?:\\\\| *)?(:?-+:? *(?:\\\\| *:?-+:? *)*)(?:\\\\| *)?' // Align\n    + '(?:\\\\n((?:(?! *\\\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\\\n|$))*)\\\\n*|$)' // Cells\n\n  });\n  block.gfm.table = edit(block.gfm.table).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('blockquote', ' {0,3}>').replace('code', ' {4}[^\\\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n  .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // tables can be interrupted by type (6) html blocks\n  .getRegex();\n  block.gfm.paragraph = edit(block._paragraph).replace('hr', block.hr).replace('heading', ' {0,3}#{1,6} ').replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs\n  .replace('table', block.gfm.table) // interrupt paragraphs with table\n  .replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n  .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', block._tag) // pars can be interrupted by type (6) html blocks\n  .getRegex();\n  /**\n   * Pedantic grammar (original John Gruber's loose markdown specification)\n   */\n\n  block.pedantic = merge({}, block.normal, {\n    html: edit('^ *(?:comment *(?:\\\\n|\\\\s*$)' + '|<(tag)[\\\\s\\\\S]+?</\\\\1> *(?:\\\\n{2,}|\\\\s*$)' // closed tag\n    + '|<tag(?:\"[^\"]*\"|\\'[^\\']*\\'|\\\\s[^\\'\"/>\\\\s]*)*?/?> *(?:\\\\n{2,}|\\\\s*$))').replace('comment', block._comment).replace(/tag/g, '(?!(?:' + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub' + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)' + '\\\\b)\\\\w+(?!:|[^\\\\w\\\\s@]*@)\\\\b').getRegex(),\n    def: /^ *\\[([^\\]]+)\\]: *<?([^\\s>]+)>?(?: +([\"(][^\\n]+[\")]))? *(?:\\n+|$)/,\n    heading: /^(#{1,6})(.*)(?:\\n+|$)/,\n    fences: noopTest,\n    // fences not supported\n    paragraph: edit(block.normal._paragraph).replace('hr', block.hr).replace('heading', ' *#{1,6} *[^\\n]').replace('lheading', block.lheading).replace('blockquote', ' {0,3}>').replace('|fences', '').replace('|list', '').replace('|html', '').getRegex()\n  });\n  /**\n   * Inline-Level Grammar\n   */\n\n  var inline = {\n    escape: /^\\\\([!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~])/,\n    autolink: /^<(scheme:[^\\s\\x00-\\x1f<>]*|email)>/,\n    url: noopTest,\n    tag: '^comment' + '|^</[a-zA-Z][\\\\w:-]*\\\\s*>' // self-closing tag\n    + '|^<[a-zA-Z][\\\\w-]*(?:attribute)*?\\\\s*/?>' // open tag\n    + '|^<\\\\?[\\\\s\\\\S]*?\\\\?>' // processing instruction, e.g. <?php ?>\n    + '|^<![a-zA-Z]+\\\\s[\\\\s\\\\S]*?>' // declaration, e.g. <!DOCTYPE html>\n    + '|^<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>',\n    // CDATA section\n    link: /^!?\\[(label)\\]\\(\\s*(href)(?:\\s+(title))?\\s*\\)/,\n    reflink: /^!?\\[(label)\\]\\[(ref)\\]/,\n    nolink: /^!?\\[(ref)\\](?:\\[\\])?/,\n    reflinkSearch: 'reflink|nolink(?!\\\\()',\n    emStrong: {\n      lDelim: /^(?:\\*+(?:([punct_])|[^\\s*]))|^_+(?:([punct*])|([^\\s_]))/,\n      //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.\n      //          () Skip orphan inside strong  () Consume to delim (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a\n      rDelimAst: /^[^_*]*?\\_\\_[^_*]*?\\*[^_*]*?(?=\\_\\_)|[^*]+(?=[^*])|[punct_](\\*+)(?=[\\s]|$)|[^punct*_\\s](\\*+)(?=[punct_\\s]|$)|[punct_\\s](\\*+)(?=[^punct*_\\s])|[\\s](\\*+)(?=[punct_])|[punct_](\\*+)(?=[punct_])|[^punct*_\\s](\\*+)(?=[^punct*_\\s])/,\n      rDelimUnd: /^[^_*]*?\\*\\*[^_*]*?\\_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|[punct*](\\_+)(?=[\\s]|$)|[^punct*_\\s](\\_+)(?=[punct*\\s]|$)|[punct*\\s](\\_+)(?=[^punct*_\\s])|[\\s](\\_+)(?=[punct*])|[punct*](\\_+)(?=[punct*])/ // ^- Not allowed for _\n\n    },\n    code: /^(`+)([^`]|[^`][\\s\\S]*?[^`])\\1(?!`)/,\n    br: /^( {2,}|\\\\)\\n(?!\\s*$)/,\n    del: noopTest,\n    text: /^(`+|[^`])(?:(?= {2,}\\n)|[\\s\\S]*?(?:(?=[\\\\<!\\[`*_]|\\b_|$)|[^ ](?= {2,}\\n)))/,\n    punctuation: /^([\\spunctuation])/\n  }; // list of punctuation marks from CommonMark spec\n  // without * and _ to handle the different emphasis markers * and _\n\n  inline._punctuation = '!\"#$%&\\'()+\\\\-.,/:;<=>?@\\\\[\\\\]`^{|}~';\n  inline.punctuation = edit(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex(); // sequences em should skip over [title](link), `code`, <html>\n\n  inline.blockSkip = /\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>/g;\n  inline.escapedEmSt = /\\\\\\*|\\\\_/g;\n  inline._comment = edit(block._comment).replace('(?:-->|$)', '-->').getRegex();\n  inline.emStrong.lDelim = edit(inline.emStrong.lDelim).replace(/punct/g, inline._punctuation).getRegex();\n  inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'g').replace(/punct/g, inline._punctuation).getRegex();\n  inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'g').replace(/punct/g, inline._punctuation).getRegex();\n  inline._escapes = /\\\\([!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~])/g;\n  inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;\n  inline._email = /[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  inline.autolink = edit(inline.autolink).replace('scheme', inline._scheme).replace('email', inline._email).getRegex();\n  inline._attribute = /\\s+[a-zA-Z:_][\\w.:-]*(?:\\s*=\\s*\"[^\"]*\"|\\s*=\\s*'[^']*'|\\s*=\\s*[^\\s\"'=<>`]+)?/;\n  inline.tag = edit(inline.tag).replace('comment', inline._comment).replace('attribute', inline._attribute).getRegex();\n  inline._label = /(?:\\[(?:\\\\.|[^\\[\\]\\\\])*\\]|\\\\.|`[^`]*`|[^\\[\\]\\\\`])*?/;\n  inline._href = /<(?:\\\\.|[^\\n<>\\\\])+>|[^\\s\\x00-\\x1f]*/;\n  inline._title = /\"(?:\\\\\"?|[^\"\\\\])*\"|'(?:\\\\'?|[^'\\\\])*'|\\((?:\\\\\\)?|[^)\\\\])*\\)/;\n  inline.link = edit(inline.link).replace('label', inline._label).replace('href', inline._href).replace('title', inline._title).getRegex();\n  inline.reflink = edit(inline.reflink).replace('label', inline._label).replace('ref', block._label).getRegex();\n  inline.nolink = edit(inline.nolink).replace('ref', block._label).getRegex();\n  inline.reflinkSearch = edit(inline.reflinkSearch, 'g').replace('reflink', inline.reflink).replace('nolink', inline.nolink).getRegex();\n  /**\n   * Normal Inline Grammar\n   */\n\n  inline.normal = merge({}, inline);\n  /**\n   * Pedantic Inline Grammar\n   */\n\n  inline.pedantic = merge({}, inline.normal, {\n    strong: {\n      start: /^__|\\*\\*/,\n      middle: /^__(?=\\S)([\\s\\S]*?\\S)__(?!_)|^\\*\\*(?=\\S)([\\s\\S]*?\\S)\\*\\*(?!\\*)/,\n      endAst: /\\*\\*(?!\\*)/g,\n      endUnd: /__(?!_)/g\n    },\n    em: {\n      start: /^_|\\*/,\n      middle: /^()\\*(?=\\S)([\\s\\S]*?\\S)\\*(?!\\*)|^_(?=\\S)([\\s\\S]*?\\S)_(?!_)/,\n      endAst: /\\*(?!\\*)/g,\n      endUnd: /_(?!_)/g\n    },\n    link: edit(/^!?\\[(label)\\]\\((.*?)\\)/).replace('label', inline._label).getRegex(),\n    reflink: edit(/^!?\\[(label)\\]\\s*\\[([^\\]]*)\\]/).replace('label', inline._label).getRegex()\n  });\n  /**\n   * GFM Inline Grammar\n   */\n\n  inline.gfm = merge({}, inline.normal, {\n    escape: edit(inline.escape).replace('])', '~|])').getRegex(),\n    _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,\n    url: /^((?:ftp|https?):\\/\\/|www\\.)(?:[a-zA-Z0-9\\-]+\\.?)+[^\\s<]*|^email/,\n    _backpedal: /(?:[^?!.,:;*_~()&]+|\\([^)]*\\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,\n    del: /^(~~?)(?=[^\\s~])([\\s\\S]*?[^\\s~])\\1(?=[^~]|$)/,\n    text: /^([`~]+|[^`~])(?:(?= {2,}\\n)|(?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)|[\\s\\S]*?(?:(?=[\\\\<!\\[`*~_]|\\b_|https?:\\/\\/|ftp:\\/\\/|www\\.|$)|[^ ](?= {2,}\\n)|[^a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-](?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)))/\n  });\n  inline.gfm.url = edit(inline.gfm.url, 'i').replace('email', inline.gfm._extended_email).getRegex();\n  /**\n   * GFM + Line Breaks Inline Grammar\n   */\n\n  inline.breaks = merge({}, inline.gfm, {\n    br: edit(inline.br).replace('{2,}', '*').getRegex(),\n    text: edit(inline.gfm.text).replace('\\\\b_', '\\\\b_| {2,}\\\\n').replace(/\\{2,\\}/g, '*').getRegex()\n  });\n\n  /**\n   * smartypants text replacement\n   * @param {string} text\n   */\n\n  function smartypants(text) {\n    return text // em-dashes\n    .replace(/---/g, \"\\u2014\") // en-dashes\n    .replace(/--/g, \"\\u2013\") // opening singles\n    .replace(/(^|[-\\u2014/(\\[{\"\\s])'/g, \"$1\\u2018\") // closing singles & apostrophes\n    .replace(/'/g, \"\\u2019\") // opening doubles\n    .replace(/(^|[-\\u2014/(\\[{\\u2018\\s])\"/g, \"$1\\u201C\") // closing doubles\n    .replace(/\"/g, \"\\u201D\") // ellipses\n    .replace(/\\.{3}/g, \"\\u2026\");\n  }\n  /**\n   * mangle email addresses\n   * @param {string} text\n   */\n\n\n  function mangle(text) {\n    var out = '',\n        i,\n        ch;\n    var l = text.length;\n\n    for (i = 0; i < l; i++) {\n      ch = text.charCodeAt(i);\n\n      if (Math.random() > 0.5) {\n        ch = 'x' + ch.toString(16);\n      }\n\n      out += '&#' + ch + ';';\n    }\n\n    return out;\n  }\n  /**\n   * Block Lexer\n   */\n\n\n  var Lexer = /*#__PURE__*/function () {\n    function Lexer(options) {\n      this.tokens = [];\n      this.tokens.links = Object.create(null);\n      this.options = options || exports.defaults;\n      this.options.tokenizer = this.options.tokenizer || new Tokenizer();\n      this.tokenizer = this.options.tokenizer;\n      this.tokenizer.options = this.options;\n      this.tokenizer.lexer = this;\n      this.inlineQueue = [];\n      this.state = {\n        inLink: false,\n        inRawBlock: false,\n        top: true\n      };\n      var rules = {\n        block: block.normal,\n        inline: inline.normal\n      };\n\n      if (this.options.pedantic) {\n        rules.block = block.pedantic;\n        rules.inline = inline.pedantic;\n      } else if (this.options.gfm) {\n        rules.block = block.gfm;\n\n        if (this.options.breaks) {\n          rules.inline = inline.breaks;\n        } else {\n          rules.inline = inline.gfm;\n        }\n      }\n\n      this.tokenizer.rules = rules;\n    }\n    /**\n     * Expose Rules\n     */\n\n\n    /**\n     * Static Lex Method\n     */\n    Lexer.lex = function lex(src, options) {\n      var lexer = new Lexer(options);\n      return lexer.lex(src);\n    }\n    /**\n     * Static Lex Inline Method\n     */\n    ;\n\n    Lexer.lexInline = function lexInline(src, options) {\n      var lexer = new Lexer(options);\n      return lexer.inlineTokens(src);\n    }\n    /**\n     * Preprocessing\n     */\n    ;\n\n    var _proto = Lexer.prototype;\n\n    _proto.lex = function lex(src) {\n      src = src.replace(/\\r\\n|\\r/g, '\\n');\n      this.blockTokens(src, this.tokens);\n      var next;\n\n      while (next = this.inlineQueue.shift()) {\n        this.inlineTokens(next.src, next.tokens);\n      }\n\n      return this.tokens;\n    }\n    /**\n     * Lexing\n     */\n    ;\n\n    _proto.blockTokens = function blockTokens(src, tokens) {\n      var _this = this;\n\n      if (tokens === void 0) {\n        tokens = [];\n      }\n\n      if (this.options.pedantic) {\n        src = src.replace(/\\t/g, '    ').replace(/^ +$/gm, '');\n      } else {\n        src = src.replace(/^( *)(\\t+)/gm, function (_, leading, tabs) {\n          return leading + '    '.repeat(tabs.length);\n        });\n      }\n\n      var token, lastToken, cutSrc, lastParagraphClipped;\n\n      while (src) {\n        if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some(function (extTokenizer) {\n          if (token = extTokenizer.call({\n            lexer: _this\n          }, src, tokens)) {\n            src = src.substring(token.raw.length);\n            tokens.push(token);\n            return true;\n          }\n\n          return false;\n        })) {\n          continue;\n        } // newline\n\n\n        if (token = this.tokenizer.space(src)) {\n          src = src.substring(token.raw.length);\n\n          if (token.raw.length === 1 && tokens.length > 0) {\n            // if there's a single \\n as a spacer, it's terminating the last line,\n            // so move it there so that we don't get unecessary paragraph tags\n            tokens[tokens.length - 1].raw += '\\n';\n          } else {\n            tokens.push(token);\n          }\n\n          continue;\n        } // code\n\n\n        if (token = this.tokenizer.code(src)) {\n          src = src.substring(token.raw.length);\n          lastToken = tokens[tokens.length - 1]; // An indented code block cannot interrupt a paragraph.\n\n          if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {\n            lastToken.raw += '\\n' + token.raw;\n            lastToken.text += '\\n' + token.text;\n            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n          } else {\n            tokens.push(token);\n          }\n\n          continue;\n        } // fences\n\n\n        if (token = this.tokenizer.fences(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // heading\n\n\n        if (token = this.tokenizer.heading(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // hr\n\n\n        if (token = this.tokenizer.hr(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // blockquote\n\n\n        if (token = this.tokenizer.blockquote(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // list\n\n\n        if (token = this.tokenizer.list(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // html\n\n\n        if (token = this.tokenizer.html(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // def\n\n\n        if (token = this.tokenizer.def(src)) {\n          src = src.substring(token.raw.length);\n          lastToken = tokens[tokens.length - 1];\n\n          if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {\n            lastToken.raw += '\\n' + token.raw;\n            lastToken.text += '\\n' + token.raw;\n            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n          } else if (!this.tokens.links[token.tag]) {\n            this.tokens.links[token.tag] = {\n              href: token.href,\n              title: token.title\n            };\n          }\n\n          continue;\n        } // table (gfm)\n\n\n        if (token = this.tokenizer.table(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // lheading\n\n\n        if (token = this.tokenizer.lheading(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // top-level paragraph\n        // prevent paragraph consuming extensions by clipping 'src' to extension start\n\n\n        cutSrc = src;\n\n        if (this.options.extensions && this.options.extensions.startBlock) {\n          (function () {\n            var startIndex = Infinity;\n            var tempSrc = src.slice(1);\n            var tempStart = void 0;\n\n            _this.options.extensions.startBlock.forEach(function (getStartIndex) {\n              tempStart = getStartIndex.call({\n                lexer: this\n              }, tempSrc);\n\n              if (typeof tempStart === 'number' && tempStart >= 0) {\n                startIndex = Math.min(startIndex, tempStart);\n              }\n            });\n\n            if (startIndex < Infinity && startIndex >= 0) {\n              cutSrc = src.substring(0, startIndex + 1);\n            }\n          })();\n        }\n\n        if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {\n          lastToken = tokens[tokens.length - 1];\n\n          if (lastParagraphClipped && lastToken.type === 'paragraph') {\n            lastToken.raw += '\\n' + token.raw;\n            lastToken.text += '\\n' + token.text;\n            this.inlineQueue.pop();\n            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n          } else {\n            tokens.push(token);\n          }\n\n          lastParagraphClipped = cutSrc.length !== src.length;\n          src = src.substring(token.raw.length);\n          continue;\n        } // text\n\n\n        if (token = this.tokenizer.text(src)) {\n          src = src.substring(token.raw.length);\n          lastToken = tokens[tokens.length - 1];\n\n          if (lastToken && lastToken.type === 'text') {\n            lastToken.raw += '\\n' + token.raw;\n            lastToken.text += '\\n' + token.text;\n            this.inlineQueue.pop();\n            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;\n          } else {\n            tokens.push(token);\n          }\n\n          continue;\n        }\n\n        if (src) {\n          var errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);\n\n          if (this.options.silent) {\n            console.error(errMsg);\n            break;\n          } else {\n            throw new Error(errMsg);\n          }\n        }\n      }\n\n      this.state.top = true;\n      return tokens;\n    };\n\n    _proto.inline = function inline(src, tokens) {\n      if (tokens === void 0) {\n        tokens = [];\n      }\n\n      this.inlineQueue.push({\n        src: src,\n        tokens: tokens\n      });\n      return tokens;\n    }\n    /**\n     * Lexing/Compiling\n     */\n    ;\n\n    _proto.inlineTokens = function inlineTokens(src, tokens) {\n      var _this2 = this;\n\n      if (tokens === void 0) {\n        tokens = [];\n      }\n\n      var token, lastToken, cutSrc; // String with links masked to avoid interference with em and strong\n\n      var maskedSrc = src;\n      var match;\n      var keepPrevChar, prevChar; // Mask out reflinks\n\n      if (this.tokens.links) {\n        var links = Object.keys(this.tokens.links);\n\n        if (links.length > 0) {\n          while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {\n            if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {\n              maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);\n            }\n          }\n        }\n      } // Mask out other blocks\n\n\n      while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {\n        maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);\n      } // Mask out escaped em & strong delimiters\n\n\n      while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {\n        maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);\n      }\n\n      while (src) {\n        if (!keepPrevChar) {\n          prevChar = '';\n        }\n\n        keepPrevChar = false; // extensions\n\n        if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some(function (extTokenizer) {\n          if (token = extTokenizer.call({\n            lexer: _this2\n          }, src, tokens)) {\n            src = src.substring(token.raw.length);\n            tokens.push(token);\n            return true;\n          }\n\n          return false;\n        })) {\n          continue;\n        } // escape\n\n\n        if (token = this.tokenizer.escape(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // tag\n\n\n        if (token = this.tokenizer.tag(src)) {\n          src = src.substring(token.raw.length);\n          lastToken = tokens[tokens.length - 1];\n\n          if (lastToken && token.type === 'text' && lastToken.type === 'text') {\n            lastToken.raw += token.raw;\n            lastToken.text += token.text;\n          } else {\n            tokens.push(token);\n          }\n\n          continue;\n        } // link\n\n\n        if (token = this.tokenizer.link(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // reflink, nolink\n\n\n        if (token = this.tokenizer.reflink(src, this.tokens.links)) {\n          src = src.substring(token.raw.length);\n          lastToken = tokens[tokens.length - 1];\n\n          if (lastToken && token.type === 'text' && lastToken.type === 'text') {\n            lastToken.raw += token.raw;\n            lastToken.text += token.text;\n          } else {\n            tokens.push(token);\n          }\n\n          continue;\n        } // em & strong\n\n\n        if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // code\n\n\n        if (token = this.tokenizer.codespan(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // br\n\n\n        if (token = this.tokenizer.br(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // del (gfm)\n\n\n        if (token = this.tokenizer.del(src)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // autolink\n\n\n        if (token = this.tokenizer.autolink(src, mangle)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // url (gfm)\n\n\n        if (!this.state.inLink && (token = this.tokenizer.url(src, mangle))) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          continue;\n        } // text\n        // prevent inlineText consuming extensions by clipping 'src' to extension start\n\n\n        cutSrc = src;\n\n        if (this.options.extensions && this.options.extensions.startInline) {\n          (function () {\n            var startIndex = Infinity;\n            var tempSrc = src.slice(1);\n            var tempStart = void 0;\n\n            _this2.options.extensions.startInline.forEach(function (getStartIndex) {\n              tempStart = getStartIndex.call({\n                lexer: this\n              }, tempSrc);\n\n              if (typeof tempStart === 'number' && tempStart >= 0) {\n                startIndex = Math.min(startIndex, tempStart);\n              }\n            });\n\n            if (startIndex < Infinity && startIndex >= 0) {\n              cutSrc = src.substring(0, startIndex + 1);\n            }\n          })();\n        }\n\n        if (token = this.tokenizer.inlineText(cutSrc, smartypants)) {\n          src = src.substring(token.raw.length);\n\n          if (token.raw.slice(-1) !== '_') {\n            // Track prevChar before string of ____ started\n            prevChar = token.raw.slice(-1);\n          }\n\n          keepPrevChar = true;\n          lastToken = tokens[tokens.length - 1];\n\n          if (lastToken && lastToken.type === 'text') {\n            lastToken.raw += token.raw;\n            lastToken.text += token.text;\n          } else {\n            tokens.push(token);\n          }\n\n          continue;\n        }\n\n        if (src) {\n          var errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);\n\n          if (this.options.silent) {\n            console.error(errMsg);\n            break;\n          } else {\n            throw new Error(errMsg);\n          }\n        }\n      }\n\n      return tokens;\n    };\n\n    _createClass(Lexer, null, [{\n      key: \"rules\",\n      get: function get() {\n        return {\n          block: block,\n          inline: inline\n        };\n      }\n    }]);\n\n    return Lexer;\n  }();\n\n  /**\n   * Renderer\n   */\n\n  var Renderer = /*#__PURE__*/function () {\n    function Renderer(options) {\n      this.options = options || exports.defaults;\n    }\n\n    var _proto = Renderer.prototype;\n\n    _proto.code = function code(_code, infostring, escaped) {\n      var lang = (infostring || '').match(/\\S*/)[0];\n\n      if (this.options.highlight) {\n        var out = this.options.highlight(_code, lang);\n\n        if (out != null && out !== _code) {\n          escaped = true;\n          _code = out;\n        }\n      }\n\n      _code = _code.replace(/\\n$/, '') + '\\n';\n\n      if (!lang) {\n        return '<pre><code>' + (escaped ? _code : escape(_code, true)) + '</code></pre>\\n';\n      }\n\n      return '<pre><code class=\"' + this.options.langPrefix + escape(lang, true) + '\">' + (escaped ? _code : escape(_code, true)) + '</code></pre>\\n';\n    }\n    /**\n     * @param {string} quote\n     */\n    ;\n\n    _proto.blockquote = function blockquote(quote) {\n      return \"<blockquote>\\n\" + quote + \"</blockquote>\\n\";\n    };\n\n    _proto.html = function html(_html) {\n      return _html;\n    }\n    /**\n     * @param {string} text\n     * @param {string} level\n     * @param {string} raw\n     * @param {any} slugger\n     */\n    ;\n\n    _proto.heading = function heading(text, level, raw, slugger) {\n      if (this.options.headerIds) {\n        var id = this.options.headerPrefix + slugger.slug(raw);\n        return \"<h\" + level + \" id=\\\"\" + id + \"\\\">\" + text + \"</h\" + level + \">\\n\";\n      } // ignore IDs\n\n\n      return \"<h\" + level + \">\" + text + \"</h\" + level + \">\\n\";\n    };\n\n    _proto.hr = function hr() {\n      return this.options.xhtml ? '<hr/>\\n' : '<hr>\\n';\n    };\n\n    _proto.list = function list(body, ordered, start) {\n      var type = ordered ? 'ol' : 'ul',\n          startatt = ordered && start !== 1 ? ' start=\"' + start + '\"' : '';\n      return '<' + type + startatt + '>\\n' + body + '</' + type + '>\\n';\n    }\n    /**\n     * @param {string} text\n     */\n    ;\n\n    _proto.listitem = function listitem(text) {\n      return \"<li>\" + text + \"</li>\\n\";\n    };\n\n    _proto.checkbox = function checkbox(checked) {\n      return '<input ' + (checked ? 'checked=\"\" ' : '') + 'disabled=\"\" type=\"checkbox\"' + (this.options.xhtml ? ' /' : '') + '> ';\n    }\n    /**\n     * @param {string} text\n     */\n    ;\n\n    _proto.paragraph = function paragraph(text) {\n      return \"<p>\" + text + \"</p>\\n\";\n    }\n    /**\n     * @param {string} header\n     * @param {string} body\n     */\n    ;\n\n    _proto.table = function table(header, body) {\n      if (body) body = \"<tbody>\" + body + \"</tbody>\";\n      return '<table>\\n' + '<thead>\\n' + header + '</thead>\\n' + body + '</table>\\n';\n    }\n    /**\n     * @param {string} content\n     */\n    ;\n\n    _proto.tablerow = function tablerow(content) {\n      return \"<tr>\\n\" + content + \"</tr>\\n\";\n    };\n\n    _proto.tablecell = function tablecell(content, flags) {\n      var type = flags.header ? 'th' : 'td';\n      var tag = flags.align ? \"<\" + type + \" align=\\\"\" + flags.align + \"\\\">\" : \"<\" + type + \">\";\n      return tag + content + (\"</\" + type + \">\\n\");\n    }\n    /**\n     * span level renderer\n     * @param {string} text\n     */\n    ;\n\n    _proto.strong = function strong(text) {\n      return \"<strong>\" + text + \"</strong>\";\n    }\n    /**\n     * @param {string} text\n     */\n    ;\n\n    _proto.em = function em(text) {\n      return \"<em>\" + text + \"</em>\";\n    }\n    /**\n     * @param {string} text\n     */\n    ;\n\n    _proto.codespan = function codespan(text) {\n      return \"<code>\" + text + \"</code>\";\n    };\n\n    _proto.br = function br() {\n      return this.options.xhtml ? '<br/>' : '<br>';\n    }\n    /**\n     * @param {string} text\n     */\n    ;\n\n    _proto.del = function del(text) {\n      return \"<del>\" + text + \"</del>\";\n    }\n    /**\n     * @param {string} href\n     * @param {string} title\n     * @param {string} text\n     */\n    ;\n\n    _proto.link = function link(href, title, text) {\n      href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);\n\n      if (href === null) {\n        return text;\n      }\n\n      var out = '<a href=\"' + escape(href) + '\"';\n\n      if (title) {\n        out += ' title=\"' + title + '\"';\n      }\n\n      out += '>' + text + '</a>';\n      return out;\n    }\n    /**\n     * @param {string} href\n     * @param {string} title\n     * @param {string} text\n     */\n    ;\n\n    _proto.image = function image(href, title, text) {\n      href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);\n\n      if (href === null) {\n        return text;\n      }\n\n      var out = \"<img src=\\\"\" + href + \"\\\" alt=\\\"\" + text + \"\\\"\";\n\n      if (title) {\n        out += \" title=\\\"\" + title + \"\\\"\";\n      }\n\n      out += this.options.xhtml ? '/>' : '>';\n      return out;\n    };\n\n    _proto.text = function text(_text) {\n      return _text;\n    };\n\n    return Renderer;\n  }();\n\n  /**\n   * TextRenderer\n   * returns only the textual part of the token\n   */\n  var TextRenderer = /*#__PURE__*/function () {\n    function TextRenderer() {}\n\n    var _proto = TextRenderer.prototype;\n\n    // no need for block level renderers\n    _proto.strong = function strong(text) {\n      return text;\n    };\n\n    _proto.em = function em(text) {\n      return text;\n    };\n\n    _proto.codespan = function codespan(text) {\n      return text;\n    };\n\n    _proto.del = function del(text) {\n      return text;\n    };\n\n    _proto.html = function html(text) {\n      return text;\n    };\n\n    _proto.text = function text(_text) {\n      return _text;\n    };\n\n    _proto.link = function link(href, title, text) {\n      return '' + text;\n    };\n\n    _proto.image = function image(href, title, text) {\n      return '' + text;\n    };\n\n    _proto.br = function br() {\n      return '';\n    };\n\n    return TextRenderer;\n  }();\n\n  /**\n   * Slugger generates header id\n   */\n  var Slugger = /*#__PURE__*/function () {\n    function Slugger() {\n      this.seen = {};\n    }\n    /**\n     * @param {string} value\n     */\n\n\n    var _proto = Slugger.prototype;\n\n    _proto.serialize = function serialize(value) {\n      return value.toLowerCase().trim() // remove html tags\n      .replace(/<[!\\/a-z].*?>/ig, '') // remove unwanted chars\n      .replace(/[\\u2000-\\u206F\\u2E00-\\u2E7F\\\\'!\"#$%&()*+,./:;<=>?@[\\]^`{|}~]/g, '').replace(/\\s/g, '-');\n    }\n    /**\n     * Finds the next safe (unique) slug to use\n     * @param {string} originalSlug\n     * @param {boolean} isDryRun\n     */\n    ;\n\n    _proto.getNextSafeSlug = function getNextSafeSlug(originalSlug, isDryRun) {\n      var slug = originalSlug;\n      var occurenceAccumulator = 0;\n\n      if (this.seen.hasOwnProperty(slug)) {\n        occurenceAccumulator = this.seen[originalSlug];\n\n        do {\n          occurenceAccumulator++;\n          slug = originalSlug + '-' + occurenceAccumulator;\n        } while (this.seen.hasOwnProperty(slug));\n      }\n\n      if (!isDryRun) {\n        this.seen[originalSlug] = occurenceAccumulator;\n        this.seen[slug] = 0;\n      }\n\n      return slug;\n    }\n    /**\n     * Convert string to unique id\n     * @param {object} [options]\n     * @param {boolean} [options.dryrun] Generates the next unique slug without\n     * updating the internal accumulator.\n     */\n    ;\n\n    _proto.slug = function slug(value, options) {\n      if (options === void 0) {\n        options = {};\n      }\n\n      var slug = this.serialize(value);\n      return this.getNextSafeSlug(slug, options.dryrun);\n    };\n\n    return Slugger;\n  }();\n\n  /**\n   * Parsing & Compiling\n   */\n\n  var Parser = /*#__PURE__*/function () {\n    function Parser(options) {\n      this.options = options || exports.defaults;\n      this.options.renderer = this.options.renderer || new Renderer();\n      this.renderer = this.options.renderer;\n      this.renderer.options = this.options;\n      this.textRenderer = new TextRenderer();\n      this.slugger = new Slugger();\n    }\n    /**\n     * Static Parse Method\n     */\n\n\n    Parser.parse = function parse(tokens, options) {\n      var parser = new Parser(options);\n      return parser.parse(tokens);\n    }\n    /**\n     * Static Parse Inline Method\n     */\n    ;\n\n    Parser.parseInline = function parseInline(tokens, options) {\n      var parser = new Parser(options);\n      return parser.parseInline(tokens);\n    }\n    /**\n     * Parse Loop\n     */\n    ;\n\n    var _proto = Parser.prototype;\n\n    _proto.parse = function parse(tokens, top) {\n      if (top === void 0) {\n        top = true;\n      }\n\n      var out = '',\n          i,\n          j,\n          k,\n          l2,\n          l3,\n          row,\n          cell,\n          header,\n          body,\n          token,\n          ordered,\n          start,\n          loose,\n          itemBody,\n          item,\n          checked,\n          task,\n          checkbox,\n          ret;\n      var l = tokens.length;\n\n      for (i = 0; i < l; i++) {\n        token = tokens[i]; // Run any renderer extensions\n\n        if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {\n          ret = this.options.extensions.renderers[token.type].call({\n            parser: this\n          }, token);\n\n          if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {\n            out += ret || '';\n            continue;\n          }\n        }\n\n        switch (token.type) {\n          case 'space':\n            {\n              continue;\n            }\n\n          case 'hr':\n            {\n              out += this.renderer.hr();\n              continue;\n            }\n\n          case 'heading':\n            {\n              out += this.renderer.heading(this.parseInline(token.tokens), token.depth, unescape(this.parseInline(token.tokens, this.textRenderer)), this.slugger);\n              continue;\n            }\n\n          case 'code':\n            {\n              out += this.renderer.code(token.text, token.lang, token.escaped);\n              continue;\n            }\n\n          case 'table':\n            {\n              header = ''; // header\n\n              cell = '';\n              l2 = token.header.length;\n\n              for (j = 0; j < l2; j++) {\n                cell += this.renderer.tablecell(this.parseInline(token.header[j].tokens), {\n                  header: true,\n                  align: token.align[j]\n                });\n              }\n\n              header += this.renderer.tablerow(cell);\n              body = '';\n              l2 = token.rows.length;\n\n              for (j = 0; j < l2; j++) {\n                row = token.rows[j];\n                cell = '';\n                l3 = row.length;\n\n                for (k = 0; k < l3; k++) {\n                  cell += this.renderer.tablecell(this.parseInline(row[k].tokens), {\n                    header: false,\n                    align: token.align[k]\n                  });\n                }\n\n                body += this.renderer.tablerow(cell);\n              }\n\n              out += this.renderer.table(header, body);\n              continue;\n            }\n\n          case 'blockquote':\n            {\n              body = this.parse(token.tokens);\n              out += this.renderer.blockquote(body);\n              continue;\n            }\n\n          case 'list':\n            {\n              ordered = token.ordered;\n              start = token.start;\n              loose = token.loose;\n              l2 = token.items.length;\n              body = '';\n\n              for (j = 0; j < l2; j++) {\n                item = token.items[j];\n                checked = item.checked;\n                task = item.task;\n                itemBody = '';\n\n                if (item.task) {\n                  checkbox = this.renderer.checkbox(checked);\n\n                  if (loose) {\n                    if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {\n                      item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;\n\n                      if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {\n                        item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;\n                      }\n                    } else {\n                      item.tokens.unshift({\n                        type: 'text',\n                        text: checkbox\n                      });\n                    }\n                  } else {\n                    itemBody += checkbox;\n                  }\n                }\n\n                itemBody += this.parse(item.tokens, loose);\n                body += this.renderer.listitem(itemBody, task, checked);\n              }\n\n              out += this.renderer.list(body, ordered, start);\n              continue;\n            }\n\n          case 'html':\n            {\n              // TODO parse inline content if parameter markdown=1\n              out += this.renderer.html(token.text);\n              continue;\n            }\n\n          case 'paragraph':\n            {\n              out += this.renderer.paragraph(this.parseInline(token.tokens));\n              continue;\n            }\n\n          case 'text':\n            {\n              body = token.tokens ? this.parseInline(token.tokens) : token.text;\n\n              while (i + 1 < l && tokens[i + 1].type === 'text') {\n                token = tokens[++i];\n                body += '\\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);\n              }\n\n              out += top ? this.renderer.paragraph(body) : body;\n              continue;\n            }\n\n          default:\n            {\n              var errMsg = 'Token with \"' + token.type + '\" type was not found.';\n\n              if (this.options.silent) {\n                console.error(errMsg);\n                return;\n              } else {\n                throw new Error(errMsg);\n              }\n            }\n        }\n      }\n\n      return out;\n    }\n    /**\n     * Parse Inline Tokens\n     */\n    ;\n\n    _proto.parseInline = function parseInline(tokens, renderer) {\n      renderer = renderer || this.renderer;\n      var out = '',\n          i,\n          token,\n          ret;\n      var l = tokens.length;\n\n      for (i = 0; i < l; i++) {\n        token = tokens[i]; // Run any renderer extensions\n\n        if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {\n          ret = this.options.extensions.renderers[token.type].call({\n            parser: this\n          }, token);\n\n          if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {\n            out += ret || '';\n            continue;\n          }\n        }\n\n        switch (token.type) {\n          case 'escape':\n            {\n              out += renderer.text(token.text);\n              break;\n            }\n\n          case 'html':\n            {\n              out += renderer.html(token.text);\n              break;\n            }\n\n          case 'link':\n            {\n              out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));\n              break;\n            }\n\n          case 'image':\n            {\n              out += renderer.image(token.href, token.title, token.text);\n              break;\n            }\n\n          case 'strong':\n            {\n              out += renderer.strong(this.parseInline(token.tokens, renderer));\n              break;\n            }\n\n          case 'em':\n            {\n              out += renderer.em(this.parseInline(token.tokens, renderer));\n              break;\n            }\n\n          case 'codespan':\n            {\n              out += renderer.codespan(token.text);\n              break;\n            }\n\n          case 'br':\n            {\n              out += renderer.br();\n              break;\n            }\n\n          case 'del':\n            {\n              out += renderer.del(this.parseInline(token.tokens, renderer));\n              break;\n            }\n\n          case 'text':\n            {\n              out += renderer.text(token.text);\n              break;\n            }\n\n          default:\n            {\n              var errMsg = 'Token with \"' + token.type + '\" type was not found.';\n\n              if (this.options.silent) {\n                console.error(errMsg);\n                return;\n              } else {\n                throw new Error(errMsg);\n              }\n            }\n        }\n      }\n\n      return out;\n    };\n\n    return Parser;\n  }();\n\n  /**\n   * Marked\n   */\n\n  function marked(src, opt, callback) {\n    // throw error in case of non string input\n    if (typeof src === 'undefined' || src === null) {\n      throw new Error('marked(): input parameter is undefined or null');\n    }\n\n    if (typeof src !== 'string') {\n      throw new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');\n    }\n\n    if (typeof opt === 'function') {\n      callback = opt;\n      opt = null;\n    }\n\n    opt = merge({}, marked.defaults, opt || {});\n    checkSanitizeDeprecation(opt);\n\n    if (callback) {\n      var highlight = opt.highlight;\n      var tokens;\n\n      try {\n        tokens = Lexer.lex(src, opt);\n      } catch (e) {\n        return callback(e);\n      }\n\n      var done = function done(err) {\n        var out;\n\n        if (!err) {\n          try {\n            if (opt.walkTokens) {\n              marked.walkTokens(tokens, opt.walkTokens);\n            }\n\n            out = Parser.parse(tokens, opt);\n          } catch (e) {\n            err = e;\n          }\n        }\n\n        opt.highlight = highlight;\n        return err ? callback(err) : callback(null, out);\n      };\n\n      if (!highlight || highlight.length < 3) {\n        return done();\n      }\n\n      delete opt.highlight;\n      if (!tokens.length) return done();\n      var pending = 0;\n      marked.walkTokens(tokens, function (token) {\n        if (token.type === 'code') {\n          pending++;\n          setTimeout(function () {\n            highlight(token.text, token.lang, function (err, code) {\n              if (err) {\n                return done(err);\n              }\n\n              if (code != null && code !== token.text) {\n                token.text = code;\n                token.escaped = true;\n              }\n\n              pending--;\n\n              if (pending === 0) {\n                done();\n              }\n            });\n          }, 0);\n        }\n      });\n\n      if (pending === 0) {\n        done();\n      }\n\n      return;\n    }\n\n    function onError(e) {\n      e.message += '\\nPlease report this to https://github.com/markedjs/marked.';\n\n      if (opt.silent) {\n        return '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';\n      }\n\n      throw e;\n    }\n\n    try {\n      var _tokens = Lexer.lex(src, opt);\n\n      if (opt.walkTokens) {\n        if (opt.async) {\n          return Promise.all(marked.walkTokens(_tokens, opt.walkTokens)).then(function () {\n            return Parser.parse(_tokens, opt);\n          })[\"catch\"](onError);\n        }\n\n        marked.walkTokens(_tokens, opt.walkTokens);\n      }\n\n      return Parser.parse(_tokens, opt);\n    } catch (e) {\n      onError(e);\n    }\n  }\n  /**\n   * Options\n   */\n\n  marked.options = marked.setOptions = function (opt) {\n    merge(marked.defaults, opt);\n    changeDefaults(marked.defaults);\n    return marked;\n  };\n\n  marked.getDefaults = getDefaults;\n  marked.defaults = exports.defaults;\n  /**\n   * Use Extension\n   */\n\n  marked.use = function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    var opts = merge.apply(void 0, [{}].concat(args));\n    var extensions = marked.defaults.extensions || {\n      renderers: {},\n      childTokens: {}\n    };\n    var hasExtensions;\n    args.forEach(function (pack) {\n      // ==-- Parse \"addon\" extensions --== //\n      if (pack.extensions) {\n        hasExtensions = true;\n        pack.extensions.forEach(function (ext) {\n          if (!ext.name) {\n            throw new Error('extension name required');\n          }\n\n          if (ext.renderer) {\n            // Renderer extensions\n            var prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;\n\n            if (prevRenderer) {\n              // Replace extension with func to run new extension but fall back if false\n              extensions.renderers[ext.name] = function () {\n                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n                  args[_key2] = arguments[_key2];\n                }\n\n                var ret = ext.renderer.apply(this, args);\n\n                if (ret === false) {\n                  ret = prevRenderer.apply(this, args);\n                }\n\n                return ret;\n              };\n            } else {\n              extensions.renderers[ext.name] = ext.renderer;\n            }\n          }\n\n          if (ext.tokenizer) {\n            // Tokenizer Extensions\n            if (!ext.level || ext.level !== 'block' && ext.level !== 'inline') {\n              throw new Error(\"extension level must be 'block' or 'inline'\");\n            }\n\n            if (extensions[ext.level]) {\n              extensions[ext.level].unshift(ext.tokenizer);\n            } else {\n              extensions[ext.level] = [ext.tokenizer];\n            }\n\n            if (ext.start) {\n              // Function to check for start of token\n              if (ext.level === 'block') {\n                if (extensions.startBlock) {\n                  extensions.startBlock.push(ext.start);\n                } else {\n                  extensions.startBlock = [ext.start];\n                }\n              } else if (ext.level === 'inline') {\n                if (extensions.startInline) {\n                  extensions.startInline.push(ext.start);\n                } else {\n                  extensions.startInline = [ext.start];\n                }\n              }\n            }\n          }\n\n          if (ext.childTokens) {\n            // Child tokens to be visited by walkTokens\n            extensions.childTokens[ext.name] = ext.childTokens;\n          }\n        });\n      } // ==-- Parse \"overwrite\" extensions --== //\n\n\n      if (pack.renderer) {\n        (function () {\n          var renderer = marked.defaults.renderer || new Renderer();\n\n          var _loop = function _loop(prop) {\n            var prevRenderer = renderer[prop]; // Replace renderer with func to run extension, but fall back if false\n\n            renderer[prop] = function () {\n              for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n                args[_key3] = arguments[_key3];\n              }\n\n              var ret = pack.renderer[prop].apply(renderer, args);\n\n              if (ret === false) {\n                ret = prevRenderer.apply(renderer, args);\n              }\n\n              return ret;\n            };\n          };\n\n          for (var prop in pack.renderer) {\n            _loop(prop);\n          }\n\n          opts.renderer = renderer;\n        })();\n      }\n\n      if (pack.tokenizer) {\n        (function () {\n          var tokenizer = marked.defaults.tokenizer || new Tokenizer();\n\n          var _loop2 = function _loop2(prop) {\n            var prevTokenizer = tokenizer[prop]; // Replace tokenizer with func to run extension, but fall back if false\n\n            tokenizer[prop] = function () {\n              for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n                args[_key4] = arguments[_key4];\n              }\n\n              var ret = pack.tokenizer[prop].apply(tokenizer, args);\n\n              if (ret === false) {\n                ret = prevTokenizer.apply(tokenizer, args);\n              }\n\n              return ret;\n            };\n          };\n\n          for (var prop in pack.tokenizer) {\n            _loop2(prop);\n          }\n\n          opts.tokenizer = tokenizer;\n        })();\n      } // ==-- Parse WalkTokens extensions --== //\n\n\n      if (pack.walkTokens) {\n        var _walkTokens = marked.defaults.walkTokens;\n\n        opts.walkTokens = function (token) {\n          var values = [];\n          values.push(pack.walkTokens.call(this, token));\n\n          if (_walkTokens) {\n            values = values.concat(_walkTokens.call(this, token));\n          }\n\n          return values;\n        };\n      }\n\n      if (hasExtensions) {\n        opts.extensions = extensions;\n      }\n\n      marked.setOptions(opts);\n    });\n  };\n  /**\n   * Run callback for every token\n   */\n\n\n  marked.walkTokens = function (tokens, callback) {\n    var values = [];\n\n    var _loop3 = function _loop3() {\n      var token = _step.value;\n      values = values.concat(callback.call(marked, token));\n\n      switch (token.type) {\n        case 'table':\n          {\n            for (var _iterator2 = _createForOfIteratorHelperLoose(token.header), _step2; !(_step2 = _iterator2()).done;) {\n              var cell = _step2.value;\n              values = values.concat(marked.walkTokens(cell.tokens, callback));\n            }\n\n            for (var _iterator3 = _createForOfIteratorHelperLoose(token.rows), _step3; !(_step3 = _iterator3()).done;) {\n              var row = _step3.value;\n\n              for (var _iterator4 = _createForOfIteratorHelperLoose(row), _step4; !(_step4 = _iterator4()).done;) {\n                var _cell = _step4.value;\n                values = values.concat(marked.walkTokens(_cell.tokens, callback));\n              }\n            }\n\n            break;\n          }\n\n        case 'list':\n          {\n            values = values.concat(marked.walkTokens(token.items, callback));\n            break;\n          }\n\n        default:\n          {\n            if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) {\n              // Walk any extensions\n              marked.defaults.extensions.childTokens[token.type].forEach(function (childTokens) {\n                values = values.concat(marked.walkTokens(token[childTokens], callback));\n              });\n            } else if (token.tokens) {\n              values = values.concat(marked.walkTokens(token.tokens, callback));\n            }\n          }\n      }\n    };\n\n    for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {\n      _loop3();\n    }\n\n    return values;\n  };\n  /**\n   * Parse Inline\n   * @param {string} src\n   */\n\n\n  marked.parseInline = function (src, opt) {\n    // throw error in case of non string input\n    if (typeof src === 'undefined' || src === null) {\n      throw new Error('marked.parseInline(): input parameter is undefined or null');\n    }\n\n    if (typeof src !== 'string') {\n      throw new Error('marked.parseInline(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');\n    }\n\n    opt = merge({}, marked.defaults, opt || {});\n    checkSanitizeDeprecation(opt);\n\n    try {\n      var tokens = Lexer.lexInline(src, opt);\n\n      if (opt.walkTokens) {\n        marked.walkTokens(tokens, opt.walkTokens);\n      }\n\n      return Parser.parseInline(tokens, opt);\n    } catch (e) {\n      e.message += '\\nPlease report this to https://github.com/markedjs/marked.';\n\n      if (opt.silent) {\n        return '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';\n      }\n\n      throw e;\n    }\n  };\n  /**\n   * Expose\n   */\n\n\n  marked.Parser = Parser;\n  marked.parser = Parser.parse;\n  marked.Renderer = Renderer;\n  marked.TextRenderer = TextRenderer;\n  marked.Lexer = Lexer;\n  marked.lexer = Lexer.lex;\n  marked.Tokenizer = Tokenizer;\n  marked.Slugger = Slugger;\n  marked.parse = marked;\n  var options = marked.options;\n  var setOptions = marked.setOptions;\n  var use = marked.use;\n  var walkTokens = marked.walkTokens;\n  var parseInline = marked.parseInline;\n  var parse = marked;\n  var parser = Parser.parse;\n  var lexer = Lexer.lex;\n\n  exports.Lexer = Lexer;\n  exports.Parser = Parser;\n  exports.Renderer = Renderer;\n  exports.Slugger = Slugger;\n  exports.TextRenderer = TextRenderer;\n  exports.Tokenizer = Tokenizer;\n  exports.getDefaults = getDefaults;\n  exports.lexer = lexer;\n  exports.marked = marked;\n  exports.options = options;\n  exports.parse = parse;\n  exports.parseInline = parseInline;\n  exports.parser = parser;\n  exports.setOptions = setOptions;\n  exports.use = use;\n  exports.walkTokens = walkTokens;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader-v16/dist/index.js??ref--1-1!./Work.vue?vue&type=style&index=0&id=75bd7554&scoped=true&lang=css\"","<template>\n  <div class=\"work\">\n    <div class=\"container\">\n      <h1 v-text=\"title\"></h1>\n      <div class=\"content\" v-html=\"container\"></div>\n    </div>\n  </div>\n</template>\n\n<script>\nimport { marked } from \"marked\";\n\nexport default {\n  name: \"Work\",\n  props: {\n    title: String,\n    filename: String,\n  },\n  data() {\n    return {\n      container: \"\",\n    };\n  },\n  created() {\n    fetch(`/md/${this.$route.params.workID}.md`)\n      .then((res) => res.text())\n      .then((d) => {\n        this.container = marked.parse(d);\n      });\n  },\n};\n</script>\n\n<style scoped>\n.work {\n  position: relative;\n}\n.container {\n  position: relative;\n  width: 50%;\n  padding: 0 0 4rem;\n}\n.container >>> h1 {\n  font-size: 1.5rem;\n  margin: 0.8rem 0 1.7rem;\n}\n.container >>> h2 {\n  font-size: 1.2rem;\n}\n.container >>> h3 {\n  font-size: 1rem;\n}\n.container >>> p,\n.container >>> li {\n  letter-spacing: 0.08rem;\n  line-height: 1.38rem;\n}\n.container >>> li {\n  margin: 0.8rem 0 0 1.1rem;\n}\n.container >>> h2,\n.container >>> h3,\n.container >>> p {\n  margin: 0.8rem 0;\n}\n.container >>> .image-name {\n  font-size: 0.7rem;\n  margin: 0 0 1rem 0;\n  color: #666;\n  text-align: center;\n}\n.content {\n  position: relative;\n}\n.container >>> .author {\n  position: fixed;\n  right: 10%;\n  top: 5rem;\n}\n.container >>> .author li {\n  list-style: none;\n  margin: 0.3rem 0 0 0;\n}\n\n.container >>> img {\n  width: 80%;\n  display: block;\n  margin: 0 auto;\n}\n</style>\n","import { render } from \"./Work.vue?vue&type=template&id=75bd7554&scoped=true\"\nimport script from \"./Work.vue?vue&type=script&lang=js\"\nexport * from \"./Work.vue?vue&type=script&lang=js\"\n\nimport \"./Work.vue?vue&type=style&index=0&id=75bd7554&scoped=true&lang=css\"\n\nimport exportComponent from \"C:\\\\Users\\\\45764\\\\coding\\\\camp2022\\\\node_modules\\\\vue-loader-v16\\\\dist\\\\exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render],['__scopeId',\"data-v-75bd7554\"]])\n\nexport default __exports__"],"sourceRoot":""}