l0bsterssg

marked.esm.js (65751B)

---

 /**
  * marked - a markdown parser
  * Copyright (c) 2011-2020, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
 
 /**
  * DO NOT EDIT THIS FILE
  * The code in this file is generated from files in ./src/
  */
 
 function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
 
 var defaults = createCommonjsModule(function (module) {
 function getDefaults() {
   return {
     baseUrl: null,
     breaks: false,
     gfm: true,
     headerIds: true,
     headerPrefix: '',
     highlight: null,
     langPrefix: 'language-',
     mangle: true,
     pedantic: false,
     renderer: null,
     sanitize: false,
     sanitizer: null,
     silent: false,
     smartLists: false,
     smartypants: false,
     tokenizer: null,
     walkTokens: null,
     xhtml: false
   };
 }
 
 function changeDefaults(newDefaults) {
   module.exports.defaults = newDefaults;
 }
 
 module.exports = {
   defaults: getDefaults(),
   getDefaults,
   changeDefaults
 };
 });
 var defaults_1 = defaults.defaults;
 var defaults_2 = defaults.getDefaults;
 var defaults_3 = defaults.changeDefaults;
 
 /**
  * Helpers
  */
 const escapeTest = /[&<>"']/;
 const escapeReplace = /[&<>"']/g;
 const escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
 const escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
 const escapeReplacements = {
   '&': '&amp;',
   '<': '&lt;',
   '>': '&gt;',
   '"': '&quot;',
   "'": '&#39;'
 };
 const getEscapeReplacement = (ch) => escapeReplacements[ch];
 function escape(html, encode) {
   if (encode) {
     if (escapeTest.test(html)) {
       return html.replace(escapeReplace, getEscapeReplacement);
     }
   } else {
     if (escapeTestNoEncode.test(html)) {
       return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
     }
   }
 
   return html;
 }
 
 const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
 
 function unescape(html) {
   // explicitly match decimal, hex, and named HTML entities
   return html.replace(unescapeTest, (_, n) => {
     n = n.toLowerCase();
     if (n === 'colon') return ':';
     if (n.charAt(0) === '#') {
       return n.charAt(1) === 'x'
         ? String.fromCharCode(parseInt(n.substring(2), 16))
         : String.fromCharCode(+n.substring(1));
     }
     return '';
   });
 }
 
 const caret = /(^|[^\[])\^/g;
 function edit(regex, opt) {
   regex = regex.source || regex;
   opt = opt || '';
   const obj = {
     replace: (name, val) => {
       val = val.source || val;
       val = val.replace(caret, '$1');
       regex = regex.replace(name, val);
       return obj;
     },
     getRegex: () => {
       return new RegExp(regex, opt);
     }
   };
   return obj;
 }
 
 const nonWordAndColonTest = /[^\w:]/g;
 const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
 function cleanUrl(sanitize, base, href) {
   if (sanitize) {
     let prot;
     try {
       prot = decodeURIComponent(unescape(href))
         .replace(nonWordAndColonTest, '')
         .toLowerCase();
     } catch (e) {
       return null;
     }
     if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
       return null;
     }
   }
   if (base && !originIndependentUrl.test(href)) {
     href = resolveUrl(base, href);
   }
   try {
     href = encodeURI(href).replace(/%25/g, '%');
   } catch (e) {
     return null;
   }
   return href;
 }
 
 const baseUrls = {};
 const justDomain = /^[^:]+:\/*[^/]*$/;
 const protocol = /^([^:]+:)[\s\S]*$/;
 const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
 
 function resolveUrl(base, href) {
   if (!baseUrls[' ' + base]) {
     // we can ignore everything in base after the last slash of its path component,
     // but we might need to add _that_
     // https://tools.ietf.org/html/rfc3986#section-3
     if (justDomain.test(base)) {
       baseUrls[' ' + base] = base + '/';
     } else {
       baseUrls[' ' + base] = rtrim(base, '/', true);
     }
   }
   base = baseUrls[' ' + base];
   const relativeBase = base.indexOf(':') === -1;
 
   if (href.substring(0, 2) === '//') {
     if (relativeBase) {
       return href;
     }
     return base.replace(protocol, '$1') + href;
   } else if (href.charAt(0) === '/') {
     if (relativeBase) {
       return href;
     }
     return base.replace(domain, '$1') + href;
   } else {
     return base + href;
   }
 }
 
 const noopTest = { exec: function noopTest() {} };
 
 function merge(obj) {
   let i = 1,
     target,
     key;
 
   for (; i < arguments.length; i++) {
     target = arguments[i];
     for (key in target) {
       if (Object.prototype.hasOwnProperty.call(target, key)) {
         obj[key] = target[key];
       }
     }
   }
 
   return obj;
 }
 
 function splitCells(tableRow, count) {
   // ensure that every cell-delimiting pipe has a space
   // before it to distinguish it from an escaped pipe
   const row = tableRow.replace(/\|/g, (match, offset, str) => {
       let escaped = false,
         curr = offset;
       while (--curr >= 0 && str[curr] === '\\') escaped = !escaped;
       if (escaped) {
         // odd number of slashes means | is escaped
         // so we leave it alone
         return '|';
       } else {
         // add space before unescaped |
         return ' |';
       }
     }),
     cells = row.split(/ \|/);
   let i = 0;
 
   if (cells.length > count) {
     cells.splice(count);
   } else {
     while (cells.length < count) cells.push('');
   }
 
   for (; i < cells.length; i++) {
     // leading or trailing whitespace is ignored per the gfm spec
     cells[i] = cells[i].trim().replace(/\\\|/g, '|');
   }
   return cells;
 }
 
 // Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
 // /c*$/ is vulnerable to REDOS.
 // invert: Remove suffix of non-c chars instead. Default falsey.
 function rtrim(str, c, invert) {
   const l = str.length;
   if (l === 0) {
     return '';
   }
 
   // Length of suffix matching the invert condition.
   let suffLen = 0;
 
   // Step left until we fail to match the invert condition.
   while (suffLen < l) {
     const currChar = str.charAt(l - suffLen - 1);
     if (currChar === c && !invert) {
       suffLen++;
     } else if (currChar !== c && invert) {
       suffLen++;
     } else {
       break;
     }
   }
 
   return str.substr(0, l - suffLen);
 }
 
 function findClosingBracket(str, b) {
   if (str.indexOf(b[1]) === -1) {
     return -1;
   }
   const l = str.length;
   let level = 0,
     i = 0;
   for (; i < l; i++) {
     if (str[i] === '\\') {
       i++;
     } else if (str[i] === b[0]) {
       level++;
     } else if (str[i] === b[1]) {
       level--;
       if (level < 0) {
         return i;
       }
     }
   }
   return -1;
 }
 
 function checkSanitizeDeprecation(opt) {
   if (opt && opt.sanitize && !opt.silent) {
     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');
   }
 }
 
 var helpers = {
   escape,
   unescape,
   edit,
   cleanUrl,
   resolveUrl,
   noopTest,
   merge,
   splitCells,
   rtrim,
   findClosingBracket,
   checkSanitizeDeprecation
 };
 
 const { defaults: defaults$1 } = defaults;
 const {
   rtrim: rtrim$1,
   splitCells: splitCells$1,
   escape: escape$1,
   findClosingBracket: findClosingBracket$1
 } = helpers;
 
 function outputLink(cap, link, raw) {
   const href = link.href;
   const title = link.title ? escape$1(link.title) : null;
   const text = cap[1].replace(/\\([\[\]])/g, '$1');
 
   if (cap[0].charAt(0) !== '!') {
     return {
       type: 'link',
       raw,
       href,
       title,
       text
     };
   } else {
     return {
       type: 'image',
       raw,
       href,
       title,
       text: escape$1(text)
     };
   }
 }
 
 function indentCodeCompensation(raw, text) {
   const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
 
   if (matchIndentToCode === null) {
     return text;
   }
 
   const indentToCode = matchIndentToCode[1];
 
   return text
     .split('\n')
     .map(node => {
       const matchIndentInNode = node.match(/^\s+/);
       if (matchIndentInNode === null) {
         return node;
       }
 
       const [indentInNode] = matchIndentInNode;
 
       if (indentInNode.length >= indentToCode.length) {
         return node.slice(indentToCode.length);
       }
 
       return node;
     })
     .join('\n');
 }
 
 /**
  * Tokenizer
  */
 var Tokenizer_1 = class Tokenizer {
   constructor(options) {
     this.options = options || defaults$1;
   }
 
   space(src) {
     const cap = this.rules.block.newline.exec(src);
     if (cap) {
       if (cap[0].length > 1) {
         return {
           type: 'space',
           raw: cap[0]
         };
       }
       return { raw: '\n' };
     }
   }
 
   code(src, tokens) {
     const cap = this.rules.block.code.exec(src);
     if (cap) {
       const lastToken = tokens[tokens.length - 1];
       // An indented code block cannot interrupt a paragraph.
       if (lastToken && lastToken.type === 'paragraph') {
         return {
           raw: cap[0],
           text: cap[0].trimRight()
         };
       }
 
       const text = cap[0].replace(/^ {4}/gm, '');
       return {
         type: 'code',
         raw: cap[0],
         codeBlockStyle: 'indented',
         text: !this.options.pedantic
           ? rtrim$1(text, '\n')
           : text
       };
     }
   }
 
   fences(src) {
     const cap = this.rules.block.fences.exec(src);
     if (cap) {
       const raw = cap[0];
       const text = indentCodeCompensation(raw, cap[3] || '');
 
       return {
         type: 'code',
         raw,
         lang: cap[2] ? cap[2].trim() : cap[2],
         text
       };
     }
   }
 
   heading(src) {
     const cap = this.rules.block.heading.exec(src);
     if (cap) {
       return {
         type: 'heading',
         raw: cap[0],
         depth: cap[1].length,
         text: cap[2]
       };
     }
   }
 
   nptable(src) {
     const cap = this.rules.block.nptable.exec(src);
     if (cap) {
       const item = {
         type: 'table',
         header: splitCells$1(cap[1].replace(/^ *| *\| *$/g, '')),
         align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
         cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : [],
         raw: cap[0]
       };
 
       if (item.header.length === item.align.length) {
         let l = item.align.length;
         let i;
         for (i = 0; i < l; i++) {
           if (/^ *-+: *$/.test(item.align[i])) {
             item.align[i] = 'right';
           } else if (/^ *:-+: *$/.test(item.align[i])) {
             item.align[i] = 'center';
           } else if (/^ *:-+ *$/.test(item.align[i])) {
             item.align[i] = 'left';
           } else {
             item.align[i] = null;
           }
         }
 
         l = item.cells.length;
         for (i = 0; i < l; i++) {
           item.cells[i] = splitCells$1(item.cells[i], item.header.length);
         }
 
         return item;
       }
     }
   }
 
   hr(src) {
     const cap = this.rules.block.hr.exec(src);
     if (cap) {
       return {
         type: 'hr',
         raw: cap[0]
       };
     }
   }
 
   blockquote(src) {
     const cap = this.rules.block.blockquote.exec(src);
     if (cap) {
       const text = cap[0].replace(/^ *> ?/gm, '');
 
       return {
         type: 'blockquote',
         raw: cap[0],
         text
       };
     }
   }
 
   list(src) {
     const cap = this.rules.block.list.exec(src);
     if (cap) {
       let raw = cap[0];
       const bull = cap[2];
       const isordered = bull.length > 1;
       const isparen = bull[bull.length - 1] === ')';
 
       const list = {
         type: 'list',
         raw,
         ordered: isordered,
         start: isordered ? +bull.slice(0, -1) : '',
         loose: false,
         items: []
       };
 
       // Get each top-level item.
       const itemMatch = cap[0].match(this.rules.block.item);
 
       let next = false,
         item,
         space,
         b,
         addBack,
         loose,
         istask,
         ischecked;
 
       const l = itemMatch.length;
       for (let i = 0; i < l; i++) {
         item = itemMatch[i];
         raw = item;
 
         // Remove the list item's bullet
         // so it is seen as the next token.
         space = item.length;
         item = item.replace(/^ *([*+-]|\d+[.)]) */, '');
 
         // Outdent whatever the
         // list item contains. Hacky.
         if (~item.indexOf('\n ')) {
           space -= item.length;
           item = !this.options.pedantic
             ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
             : item.replace(/^ {1,4}/gm, '');
         }
 
         // Determine whether the next list item belongs here.
         // Backpedal if it does not belong in this list.
         if (i !== l - 1) {
           b = this.rules.block.bullet.exec(itemMatch[i + 1])[0];
           if (isordered ? b.length === 1 || (!isparen && b[b.length - 1] === ')')
             : (b.length > 1 || (this.options.smartLists && b !== bull))) {
             addBack = itemMatch.slice(i + 1).join('\n');
             list.raw = list.raw.substring(0, list.raw.length - addBack.length);
             i = l - 1;
           }
         }
 
         // Determine whether item is loose or not.
         // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
         // for discount behavior.
         loose = next || /\n\n(?!\s*$)/.test(item);
         if (i !== l - 1) {
           next = item.charAt(item.length - 1) === '\n';
           if (!loose) loose = next;
         }
 
         if (loose) {
           list.loose = true;
         }
 
         // Check for task list items
         istask = /^\[[ xX]\] /.test(item);
         ischecked = undefined;
         if (istask) {
           ischecked = item[1] !== ' ';
           item = item.replace(/^\[[ xX]\] +/, '');
         }
 
         list.items.push({
           type: 'list_item',
           raw,
           task: istask,
           checked: ischecked,
           loose: loose,
           text: item
         });
       }
 
       return list;
     }
   }
 
   html(src) {
     const cap = this.rules.block.html.exec(src);
     if (cap) {
       return {
         type: this.options.sanitize
           ? 'paragraph'
           : 'html',
         raw: cap[0],
         pre: !this.options.sanitizer
           && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
         text: this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape$1(cap[0])) : cap[0]
       };
     }
   }
 
   def(src) {
     const cap = this.rules.block.def.exec(src);
     if (cap) {
       if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);
       const tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
       return {
         tag,
         raw: cap[0],
         href: cap[2],
         title: cap[3]
       };
     }
   }
 
   table(src) {
     const cap = this.rules.block.table.exec(src);
     if (cap) {
       const item = {
         type: 'table',
         header: splitCells$1(cap[1].replace(/^ *| *\| *$/g, '')),
         align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
         cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : []
       };
 
       if (item.header.length === item.align.length) {
         item.raw = cap[0];
 
         let l = item.align.length;
         let i;
         for (i = 0; i < l; i++) {
           if (/^ *-+: *$/.test(item.align[i])) {
             item.align[i] = 'right';
           } else if (/^ *:-+: *$/.test(item.align[i])) {
             item.align[i] = 'center';
           } else if (/^ *:-+ *$/.test(item.align[i])) {
             item.align[i] = 'left';
           } else {
             item.align[i] = null;
           }
         }
 
         l = item.cells.length;
         for (i = 0; i < l; i++) {
           item.cells[i] = splitCells$1(
             item.cells[i].replace(/^ *\| *| *\| *$/g, ''),
             item.header.length);
         }
 
         return item;
       }
     }
   }
 
   lheading(src) {
     const cap = this.rules.block.lheading.exec(src);
     if (cap) {
       return {
         type: 'heading',
         raw: cap[0],
         depth: cap[2].charAt(0) === '=' ? 1 : 2,
         text: cap[1]
       };
     }
   }
 
   paragraph(src) {
     const cap = this.rules.block.paragraph.exec(src);
     if (cap) {
       return {
         type: 'paragraph',
         raw: cap[0],
         text: cap[1].charAt(cap[1].length - 1) === '\n'
           ? cap[1].slice(0, -1)
           : cap[1]
       };
     }
   }
 
   text(src, tokens) {
     const cap = this.rules.block.text.exec(src);
     if (cap) {
       const lastToken = tokens[tokens.length - 1];
       if (lastToken && lastToken.type === 'text') {
         return {
           raw: cap[0],
           text: cap[0]
         };
       }
 
       return {
         type: 'text',
         raw: cap[0],
         text: cap[0]
       };
     }
   }
 
   escape(src) {
     const cap = this.rules.inline.escape.exec(src);
     if (cap) {
       return {
         type: 'escape',
         raw: cap[0],
         text: escape$1(cap[1])
       };
     }
   }
 
   tag(src, inLink, inRawBlock) {
     const cap = this.rules.inline.tag.exec(src);
     if (cap) {
       if (!inLink && /^<a /i.test(cap[0])) {
         inLink = true;
       } else if (inLink && /^<\/a>/i.test(cap[0])) {
         inLink = false;
       }
       if (!inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
         inRawBlock = true;
       } else if (inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
         inRawBlock = false;
       }
 
       return {
         type: this.options.sanitize
           ? 'text'
           : 'html',
         raw: cap[0],
         inLink,
         inRawBlock,
         text: this.options.sanitize
           ? (this.options.sanitizer
             ? this.options.sanitizer(cap[0])
             : escape$1(cap[0]))
           : cap[0]
       };
     }
   }
 
   link(src) {
     const cap = this.rules.inline.link.exec(src);
     if (cap) {
       const lastParenIndex = findClosingBracket$1(cap[2], '()');
       if (lastParenIndex > -1) {
         const start = cap[0].indexOf('!') === 0 ? 5 : 4;
         const linkLen = start + cap[1].length + lastParenIndex;
         cap[2] = cap[2].substring(0, lastParenIndex);
         cap[0] = cap[0].substring(0, linkLen).trim();
         cap[3] = '';
       }
       let href = cap[2];
       let title = '';
       if (this.options.pedantic) {
         const link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
 
         if (link) {
           href = link[1];
           title = link[3];
         } else {
           title = '';
         }
       } else {
         title = cap[3] ? cap[3].slice(1, -1) : '';
       }
       href = href.trim().replace(/^<([\s\S]*)>$/, '$1');
       const token = outputLink(cap, {
         href: href ? href.replace(this.rules.inline._escapes, '$1') : href,
         title: title ? title.replace(this.rules.inline._escapes, '$1') : title
       }, cap[0]);
       return token;
     }
   }
 
   reflink(src, links) {
     let cap;
     if ((cap = this.rules.inline.reflink.exec(src))
         || (cap = this.rules.inline.nolink.exec(src))) {
       let link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
       link = links[link.toLowerCase()];
       if (!link || !link.href) {
         const text = cap[0].charAt(0);
         return {
           type: 'text',
           raw: text,
           text
         };
       }
       const token = outputLink(cap, link, cap[0]);
       return token;
     }
   }
 
   strong(src, maskedSrc, prevChar = '') {
     let match = this.rules.inline.strong.start.exec(src);
 
     if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
       maskedSrc = maskedSrc.slice(-1 * src.length);
       const endReg = match[0] === '**' ? this.rules.inline.strong.endAst : this.rules.inline.strong.endUnd;
 
       endReg.lastIndex = 0;
 
       let cap;
       while ((match = endReg.exec(maskedSrc)) != null) {
         cap = this.rules.inline.strong.middle.exec(maskedSrc.slice(0, match.index + 3));
         if (cap) {
           return {
             type: 'strong',
             raw: src.slice(0, cap[0].length),
             text: src.slice(2, cap[0].length - 2)
           };
         }
       }
     }
   }
 
   em(src, maskedSrc, prevChar = '') {
     let match = this.rules.inline.em.start.exec(src);
 
     if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
       maskedSrc = maskedSrc.slice(-1 * src.length);
       const endReg = match[0] === '*' ? this.rules.inline.em.endAst : this.rules.inline.em.endUnd;
 
       endReg.lastIndex = 0;
 
       let cap;
       while ((match = endReg.exec(maskedSrc)) != null) {
         cap = this.rules.inline.em.middle.exec(maskedSrc.slice(0, match.index + 2));
         if (cap) {
           return {
             type: 'em',
             raw: src.slice(0, cap[0].length),
             text: src.slice(1, cap[0].length - 1)
           };
         }
       }
     }
   }
 
   codespan(src) {
     const cap = this.rules.inline.code.exec(src);
     if (cap) {
       let text = cap[2].replace(/\n/g, ' ');
       const hasNonSpaceChars = /[^ ]/.test(text);
       const hasSpaceCharsOnBothEnds = text.startsWith(' ') && text.endsWith(' ');
       if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
         text = text.substring(1, text.length - 1);
       }
       text = escape$1(text, true);
       return {
         type: 'codespan',
         raw: cap[0],
         text
       };
     }
   }
 
   br(src) {
     const cap = this.rules.inline.br.exec(src);
     if (cap) {
       return {
         type: 'br',
         raw: cap[0]
       };
     }
   }
 
   del(src) {
     const cap = this.rules.inline.del.exec(src);
     if (cap) {
       return {
         type: 'del',
         raw: cap[0],
         text: cap[1]
       };
     }
   }
 
   autolink(src, mangle) {
     const cap = this.rules.inline.autolink.exec(src);
     if (cap) {
       let text, href;
       if (cap[2] === '@') {
         text = escape$1(this.options.mangle ? mangle(cap[1]) : cap[1]);
         href = 'mailto:' + text;
       } else {
         text = escape$1(cap[1]);
         href = text;
       }
 
       return {
         type: 'link',
         raw: cap[0],
         text,
         href,
         tokens: [
           {
             type: 'text',
             raw: text,
             text
           }
         ]
       };
     }
   }
 
   url(src, mangle) {
     let cap;
     if (cap = this.rules.inline.url.exec(src)) {
       let text, href;
       if (cap[2] === '@') {
         text = escape$1(this.options.mangle ? mangle(cap[0]) : cap[0]);
         href = 'mailto:' + text;
       } else {
         // do extended autolink path validation
         let prevCapZero;
         do {
           prevCapZero = cap[0];
           cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
         } while (prevCapZero !== cap[0]);
         text = escape$1(cap[0]);
         if (cap[1] === 'www.') {
           href = 'http://' + text;
         } else {
           href = text;
         }
       }
       return {
         type: 'link',
         raw: cap[0],
         text,
         href,
         tokens: [
           {
             type: 'text',
             raw: text,
             text
           }
         ]
       };
     }
   }
 
   inlineText(src, inRawBlock, smartypants) {
     const cap = this.rules.inline.text.exec(src);
     if (cap) {
       let text;
       if (inRawBlock) {
         text = this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape$1(cap[0])) : cap[0];
       } else {
         text = escape$1(this.options.smartypants ? smartypants(cap[0]) : cap[0]);
       }
       return {
         type: 'text',
         raw: cap[0],
         text
       };
     }
   }
 };
 
 const {
   noopTest: noopTest$1,
   edit: edit$1,
   merge: merge$1
 } = helpers;
 
 /**
  * Block-Level Grammar
  */
 const block = {
   newline: /^\n+/,
   code: /^( {4}[^\n]+\n*)+/,
   fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/,
   hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
   heading: /^ {0,3}(#{1,6}) +([^\n]*?)(?: +#+)? *(?:\n+|$)/,
   blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
   list: /^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,
   html: '^ {0,3}(?:' // optional indentation
     + '<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
     + '|comment[^\\n]*(\\n+|$)' // (2)
     + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
     + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
     + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
     + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:\\n{2,}|$)' // (6)
     + '|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) open tag
     + '|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) closing tag
     + ')',
   def: /^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,
   nptable: noopTest$1,
   table: noopTest$1,
   lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
   // regex template, placeholders will be replaced according to different paragraph
   // interruption rules of commonmark and the original markdown spec:
   _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html)[^\n]+)*)/,
   text: /^[^\n]+/
 };
 
 block._label = /(?!\s*\])(?:\\[\[\]]|[^\[\]])+/;
 block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
 block.def = edit$1(block.def)
   .replace('label', block._label)
   .replace('title', block._title)
   .getRegex();
 
 block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
 block.item = /^( *)(bull) ?[^\n]*(?:\n(?!\1bull ?)[^\n]*)*/;
 block.item = edit$1(block.item, 'gm')
   .replace(/bull/g, block.bullet)
   .getRegex();
 
 block.list = edit$1(block.list)
   .replace(/bull/g, block.bullet)
   .replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
   .replace('def', '\\n+(?=' + block.def.source + ')')
   .getRegex();
 
 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';
 block._comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
 block.html = edit$1(block.html, 'i')
   .replace('comment', block._comment)
   .replace('tag', block._tag)
   .replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
   .getRegex();
 
 block.paragraph = edit$1(block._paragraph)
   .replace('hr', block.hr)
   .replace('heading', ' {0,3}#{1,6} ')
   .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
   .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
   .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
   .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
   .getRegex();
 
 block.blockquote = edit$1(block.blockquote)
   .replace('paragraph', block.paragraph)
   .getRegex();
 
 /**
  * Normal Block Grammar
  */
 
 block.normal = merge$1({}, block);
 
 /**
  * GFM Block Grammar
  */
 
 block.gfm = merge$1({}, block.normal, {
   nptable: '^ *([^|\\n ].*\\|.*)\\n' // Header
     + ' {0,3}([-:]+ *\\|[-| :]*)' // Align
     + '(?:\\n((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)', // Cells
   table: '^ *\\|(.+)\\n' // Header
     + ' {0,3}\\|?( *[-:]+[-| :]*)' // Align
     + '(?:\\n *((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
 });
 
 block.gfm.nptable = edit$1(block.gfm.nptable)
   .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
   .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
   .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
   .getRegex();
 
 block.gfm.table = edit$1(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
   .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
   .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
   .getRegex();
 
 /**
  * Pedantic grammar (original John Gruber's loose markdown specification)
  */
 
 block.pedantic = merge$1({}, block.normal, {
   html: edit$1(
     '^ *(?:comment *(?:\\n|\\s*$)'
     + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
     + '|<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(),
   def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
   heading: /^ *(#{1,6}) *([^\n]+?) *(?:#+ *)?(?:\n+|$)/,
   fences: noopTest$1, // fences not supported
   paragraph: edit$1(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()
 });
 
 /**
  * Inline-Level Grammar
  */
 const inline = {
   escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,
   autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
   url: noopTest$1,
   tag: '^comment'
     + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
     + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
     + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
     + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
     + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>', // CDATA section
   link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
   reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
   nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
   reflinkSearch: 'reflink|nolink(?!\\()',
   strong: {
     start: /^(?:(\*\*(?=[*punctuation]))|\*\*)(?![\s])|__/, // (1) returns if starts w/ punctuation
     middle: /^\*\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?)__$/,
     endAst: /[^punctuation\s]\*\*(?!\*)|[punctuation]\*\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
     endUnd: /[^\s]__(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
   },
   em: {
     start: /^(?:(\*(?=[punctuation]))|\*)(?![*\s])|_/, // (1) returns if starts w/ punctuation
     middle: /^\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?_$/,
     endAst: /[^punctuation\s]\*(?!\*)|[punctuation]\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
     endUnd: /[^\s]_(?!_)(?:(?=[punctuation*\s])|$)/ // last char can't be a space, and final _ must preceed punct or \s (or endline)
   },
   code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
   br: /^( {2,}|\\)\n(?!\s*$)/,
   del: noopTest$1,
   text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n)))/,
   punctuation: /^([\s*punctuation])/
 };
 
 // list of punctuation marks from common mark spec
 // without * and _ to workaround cases with double emphasis
 inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~';
 inline.punctuation = edit$1(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
 
 // sequences em should skip over [title](link), `code`, <html>
 inline._blockSkip = '\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>';
 inline._overlapSkip = '__[^_]*?__|\\*\\*\\[^\\*\\]*?\\*\\*';
 
 inline._comment = edit$1(block._comment).replace('(?:-->|$)', '-->').getRegex();
 
 inline.em.start = edit$1(inline.em.start)
   .replace(/punctuation/g, inline._punctuation)
   .getRegex();
 
 inline.em.middle = edit$1(inline.em.middle)
   .replace(/punctuation/g, inline._punctuation)
   .replace(/overlapSkip/g, inline._overlapSkip)
   .getRegex();
 
 inline.em.endAst = edit$1(inline.em.endAst, 'g')
   .replace(/punctuation/g, inline._punctuation)
   .getRegex();
 
 inline.em.endUnd = edit$1(inline.em.endUnd, 'g')
   .replace(/punctuation/g, inline._punctuation)
   .getRegex();
 
 inline.strong.start = edit$1(inline.strong.start)
   .replace(/punctuation/g, inline._punctuation)
   .getRegex();
 
 inline.strong.middle = edit$1(inline.strong.middle)
   .replace(/punctuation/g, inline._punctuation)
   .replace(/overlapSkip/g, inline._overlapSkip)
   .getRegex();
 
 inline.strong.endAst = edit$1(inline.strong.endAst, 'g')
   .replace(/punctuation/g, inline._punctuation)
   .getRegex();
 
 inline.strong.endUnd = edit$1(inline.strong.endUnd, 'g')
   .replace(/punctuation/g, inline._punctuation)
   .getRegex();
 
 inline.blockSkip = edit$1(inline._blockSkip, 'g')
   .getRegex();
 
 inline.overlapSkip = edit$1(inline._overlapSkip, 'g')
   .getRegex();
 
 inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
 
 inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
 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])?)+(?![-_])/;
 inline.autolink = edit$1(inline.autolink)
   .replace('scheme', inline._scheme)
   .replace('email', inline._email)
   .getRegex();
 
 inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;
 
 inline.tag = edit$1(inline.tag)
   .replace('comment', inline._comment)
   .replace('attribute', inline._attribute)
   .getRegex();
 
 inline._label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
 inline._href = /<(?:\\[<>]?|[^\s<>\\])*>|[^\s\x00-\x1f]*/;
 inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;
 
 inline.link = edit$1(inline.link)
   .replace('label', inline._label)
   .replace('href', inline._href)
   .replace('title', inline._title)
   .getRegex();
 
 inline.reflink = edit$1(inline.reflink)
   .replace('label', inline._label)
   .getRegex();
 
 inline.reflinkSearch = edit$1(inline.reflinkSearch, 'g')
   .replace('reflink', inline.reflink)
   .replace('nolink', inline.nolink)
   .getRegex();
 
 /**
  * Normal Inline Grammar
  */
 
 inline.normal = merge$1({}, inline);
 
 /**
  * Pedantic Inline Grammar
  */
 
 inline.pedantic = merge$1({}, inline.normal, {
   strong: {
     start: /^__|\*\*/,
     middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
     endAst: /\*\*(?!\*)/g,
     endUnd: /__(?!_)/g
   },
   em: {
     start: /^_|\*/,
     middle: /^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,
     endAst: /\*(?!\*)/g,
     endUnd: /_(?!_)/g
   },
   link: edit$1(/^!?\[(label)\]\((.*?)\)/)
     .replace('label', inline._label)
     .getRegex(),
   reflink: edit$1(/^!?\[(label)\]\s*\[([^\]]*)\]/)
     .replace('label', inline._label)
     .getRegex()
 });
 
 /**
  * GFM Inline Grammar
  */
 
 inline.gfm = merge$1({}, inline.normal, {
   escape: edit$1(inline.escape).replace('])', '~|])').getRegex(),
   _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
   url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
   _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
   del: /^~+(?=\S)([\s\S]*?\S)~+/,
   text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
 });
 
 inline.gfm.url = edit$1(inline.gfm.url, 'i')
   .replace('email', inline.gfm._extended_email)
   .getRegex();
 /**
  * GFM + Line Breaks Inline Grammar
  */
 
 inline.breaks = merge$1({}, inline.gfm, {
   br: edit$1(inline.br).replace('{2,}', '*').getRegex(),
   text: edit$1(inline.gfm.text)
     .replace('\\b_', '\\b_| {2,}\\n')
     .replace(/\{2,\}/g, '*')
     .getRegex()
 });
 
 var rules = {
   block,
   inline
 };
 
 const { defaults: defaults$2 } = defaults;
 const { block: block$1, inline: inline$1 } = rules;
 
 /**
  * smartypants text replacement
  */
 function smartypants(text) {
   return text
     // em-dashes
     .replace(/---/g, '\u2014')
     // en-dashes
     .replace(/--/g, '\u2013')
     // opening singles
     .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
     // closing singles & apostrophes
     .replace(/'/g, '\u2019')
     // opening doubles
     .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
     // closing doubles
     .replace(/"/g, '\u201d')
     // ellipses
     .replace(/\.{3}/g, '\u2026');
 }
 
 /**
  * mangle email addresses
  */
 function mangle(text) {
   let out = '',
     i,
     ch;
 
   const l = text.length;
   for (i = 0; i < l; i++) {
     ch = text.charCodeAt(i);
     if (Math.random() > 0.5) {
       ch = 'x' + ch.toString(16);
     }
     out += '&#' + ch + ';';
   }
 
   return out;
 }
 
 /**
  * Block Lexer
  */
 var Lexer_1 = class Lexer {
   constructor(options) {
     this.tokens = [];
     this.tokens.links = Object.create(null);
     this.options = options || defaults$2;
     this.options.tokenizer = this.options.tokenizer || new Tokenizer_1();
     this.tokenizer = this.options.tokenizer;
     this.tokenizer.options = this.options;
 
     const rules = {
       block: block$1.normal,
       inline: inline$1.normal
     };
 
     if (this.options.pedantic) {
       rules.block = block$1.pedantic;
       rules.inline = inline$1.pedantic;
     } else if (this.options.gfm) {
       rules.block = block$1.gfm;
       if (this.options.breaks) {
         rules.inline = inline$1.breaks;
       } else {
         rules.inline = inline$1.gfm;
       }
     }
     this.tokenizer.rules = rules;
   }
 
   /**
    * Expose Rules
    */
   static get rules() {
     return {
       block: block$1,
       inline: inline$1
     };
   }
 
   /**
    * Static Lex Method
    */
   static lex(src, options) {
     const lexer = new Lexer(options);
     return lexer.lex(src);
   }
 
   /**
    * Static Lex Inline Method
    */
   static lexInline(src, options) {
     const lexer = new Lexer(options);
     return lexer.inlineTokens(src);
   }
 
   /**
    * Preprocessing
    */
   lex(src) {
     src = src
       .replace(/\r\n|\r/g, '\n')
       .replace(/\t/g, '    ');
 
     this.blockTokens(src, this.tokens, true);
 
     this.inline(this.tokens);
 
     return this.tokens;
   }
 
   /**
    * Lexing
    */
   blockTokens(src, tokens = [], top = true) {
     src = src.replace(/^ +$/gm, '');
     let token, i, l, lastToken;
 
     while (src) {
       // newline
       if (token = this.tokenizer.space(src)) {
         src = src.substring(token.raw.length);
         if (token.type) {
           tokens.push(token);
         }
         continue;
       }
 
       // code
       if (token = this.tokenizer.code(src, tokens)) {
         src = src.substring(token.raw.length);
         if (token.type) {
           tokens.push(token);
         } else {
           lastToken = tokens[tokens.length - 1];
           lastToken.raw += '\n' + token.raw;
           lastToken.text += '\n' + token.text;
         }
         continue;
       }
 
       // fences
       if (token = this.tokenizer.fences(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // heading
       if (token = this.tokenizer.heading(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // table no leading pipe (gfm)
       if (token = this.tokenizer.nptable(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // hr
       if (token = this.tokenizer.hr(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // blockquote
       if (token = this.tokenizer.blockquote(src)) {
         src = src.substring(token.raw.length);
         token.tokens = this.blockTokens(token.text, [], top);
         tokens.push(token);
         continue;
       }
 
       // list
       if (token = this.tokenizer.list(src)) {
         src = src.substring(token.raw.length);
         l = token.items.length;
         for (i = 0; i < l; i++) {
           token.items[i].tokens = this.blockTokens(token.items[i].text, [], false);
         }
         tokens.push(token);
         continue;
       }
 
       // html
       if (token = this.tokenizer.html(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // def
       if (top && (token = this.tokenizer.def(src))) {
         src = src.substring(token.raw.length);
         if (!this.tokens.links[token.tag]) {
           this.tokens.links[token.tag] = {
             href: token.href,
             title: token.title
           };
         }
         continue;
       }
 
       // table (gfm)
       if (token = this.tokenizer.table(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // lheading
       if (token = this.tokenizer.lheading(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // top-level paragraph
       if (top && (token = this.tokenizer.paragraph(src))) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // text
       if (token = this.tokenizer.text(src, tokens)) {
         src = src.substring(token.raw.length);
         if (token.type) {
           tokens.push(token);
         } else {
           lastToken = tokens[tokens.length - 1];
           lastToken.raw += '\n' + token.raw;
           lastToken.text += '\n' + token.text;
         }
         continue;
       }
 
       if (src) {
         const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
         if (this.options.silent) {
           console.error(errMsg);
           break;
         } else {
           throw new Error(errMsg);
         }
       }
     }
 
     return tokens;
   }
 
   inline(tokens) {
     let i,
       j,
       k,
       l2,
       row,
       token;
 
     const l = tokens.length;
     for (i = 0; i < l; i++) {
       token = tokens[i];
       switch (token.type) {
         case 'paragraph':
         case 'text':
         case 'heading': {
           token.tokens = [];
           this.inlineTokens(token.text, token.tokens);
           break;
         }
         case 'table': {
           token.tokens = {
             header: [],
             cells: []
           };
 
           // header
           l2 = token.header.length;
           for (j = 0; j < l2; j++) {
             token.tokens.header[j] = [];
             this.inlineTokens(token.header[j], token.tokens.header[j]);
           }
 
           // cells
           l2 = token.cells.length;
           for (j = 0; j < l2; j++) {
             row = token.cells[j];
             token.tokens.cells[j] = [];
             for (k = 0; k < row.length; k++) {
               token.tokens.cells[j][k] = [];
               this.inlineTokens(row[k], token.tokens.cells[j][k]);
             }
           }
 
           break;
         }
         case 'blockquote': {
           this.inline(token.tokens);
           break;
         }
         case 'list': {
           l2 = token.items.length;
           for (j = 0; j < l2; j++) {
             this.inline(token.items[j].tokens);
           }
           break;
         }
       }
     }
 
     return tokens;
   }
 
   /**
    * Lexing/Compiling
    */
   inlineTokens(src, tokens = [], inLink = false, inRawBlock = false, prevChar = '') {
     let token;
 
     // String with links masked to avoid interference with em and strong
     let maskedSrc = src;
     let match;
 
     // Mask out reflinks
     if (this.tokens.links) {
       const links = Object.keys(this.tokens.links);
       if (links.length > 0) {
         while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
           if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {
             maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
           }
         }
       }
     }
     // Mask out other blocks
     while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
       maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
     }
 
     while (src) {
       // escape
       if (token = this.tokenizer.escape(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // tag
       if (token = this.tokenizer.tag(src, inLink, inRawBlock)) {
         src = src.substring(token.raw.length);
         inLink = token.inLink;
         inRawBlock = token.inRawBlock;
         tokens.push(token);
         continue;
       }
 
       // link
       if (token = this.tokenizer.link(src)) {
         src = src.substring(token.raw.length);
         if (token.type === 'link') {
           token.tokens = this.inlineTokens(token.text, [], true, inRawBlock);
         }
         tokens.push(token);
         continue;
       }
 
       // reflink, nolink
       if (token = this.tokenizer.reflink(src, this.tokens.links)) {
         src = src.substring(token.raw.length);
         if (token.type === 'link') {
           token.tokens = this.inlineTokens(token.text, [], true, inRawBlock);
         }
         tokens.push(token);
         continue;
       }
 
       // strong
       if (token = this.tokenizer.strong(src, maskedSrc, prevChar)) {
         src = src.substring(token.raw.length);
         token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
         tokens.push(token);
         continue;
       }
 
       // em
       if (token = this.tokenizer.em(src, maskedSrc, prevChar)) {
         src = src.substring(token.raw.length);
         token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
         tokens.push(token);
         continue;
       }
 
       // code
       if (token = this.tokenizer.codespan(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // br
       if (token = this.tokenizer.br(src)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // del (gfm)
       if (token = this.tokenizer.del(src)) {
         src = src.substring(token.raw.length);
         token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
         tokens.push(token);
         continue;
       }
 
       // autolink
       if (token = this.tokenizer.autolink(src, mangle)) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // url (gfm)
       if (!inLink && (token = this.tokenizer.url(src, mangle))) {
         src = src.substring(token.raw.length);
         tokens.push(token);
         continue;
       }
 
       // text
       if (token = this.tokenizer.inlineText(src, inRawBlock, smartypants)) {
         src = src.substring(token.raw.length);
         prevChar = token.raw.slice(-1);
         tokens.push(token);
         continue;
       }
 
       if (src) {
         const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
         if (this.options.silent) {
           console.error(errMsg);
           break;
         } else {
           throw new Error(errMsg);
         }
       }
     }
 
     return tokens;
   }
 };
 
 const { defaults: defaults$3 } = defaults;
 const {
   cleanUrl: cleanUrl$1,
   escape: escape$2
 } = helpers;
 
 /**
  * Renderer
  */
 var Renderer_1 = class Renderer {
   constructor(options) {
     this.options = options || defaults$3;
   }
 
   code(code, infostring, escaped) {
     const lang = (infostring || '').match(/\S*/)[0];
     if (this.options.highlight) {
       const out = this.options.highlight(code, lang);
       if (out != null && out !== code) {
         escaped = true;
         code = out;
       }
     }
 
     if (!lang) {
       return '<pre><code>'
         + (escaped ? code : escape$2(code, true))
         + '</code></pre>\n';
     }
 
     return '<pre><code class="'
       + this.options.langPrefix
       + escape$2(lang, true)
       + '">'
       + (escaped ? code : escape$2(code, true))
       + '</code></pre>\n';
   }
 
   blockquote(quote) {
     return '<blockquote>\n' + quote + '</blockquote>\n';
   }
 
   html(html) {
     return html;
   }
 
   heading(text, level, raw, slugger) {
     if (this.options.headerIds) {
       return '<h'
         + level
         + ' id="'
         + this.options.headerPrefix
         + slugger.slug(raw)
         + '">'
         + text
         + '</h'
         + level
         + '>\n';
     }
     // ignore IDs
     return '<h' + level + '>' + text + '</h' + level + '>\n';
   }
 
   hr() {
     return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
   }
 
   list(body, ordered, start) {
     const type = ordered ? 'ol' : 'ul',
       startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
     return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
   }
 
   listitem(text) {
     return '<li>' + text + '</li>\n';
   }
 
   checkbox(checked) {
     return '<input '
       + (checked ? 'checked="" ' : '')
       + 'disabled="" type="checkbox"'
       + (this.options.xhtml ? ' /' : '')
       + '> ';
   }
 
   paragraph(text) {
     return '<p>' + text + '</p>\n';
   }
 
   table(header, body) {
     if (body) body = '<tbody>' + body + '</tbody>';
 
     return '<table>\n'
       + '<thead>\n'
       + header
       + '</thead>\n'
       + body
       + '</table>\n';
   }
 
   tablerow(content) {
     return '<tr>\n' + content + '</tr>\n';
   }
 
   tablecell(content, flags) {
     const type = flags.header ? 'th' : 'td';
     const tag = flags.align
       ? '<' + type + ' align="' + flags.align + '">'
       : '<' + type + '>';
     return tag + content + '</' + type + '>\n';
   }
 
   // span level renderer
   strong(text) {
     return '<strong>' + text + '</strong>';
   }
 
   em(text) {
     return '<em>' + text + '</em>';
   }
 
   codespan(text) {
     return '<code>' + text + '</code>';
   }
 
   br() {
     return this.options.xhtml ? '<br/>' : '<br>';
   }
 
   del(text) {
     return '<del>' + text + '</del>';
   }
 
   link(href, title, text) {
     href = cleanUrl$1(this.options.sanitize, this.options.baseUrl, href);
     if (href === null) {
       return text;
     }
     let out = '<a href="' + escape$2(href) + '"';
     if (title) {
       out += ' title="' + title + '"';
     }
     out += '>' + text + '</a>';
     return out;
   }
 
   image(href, title, text) {
     href = cleanUrl$1(this.options.sanitize, this.options.baseUrl, href);
     if (href === null) {
       return text;
     }
 
     let out = '<img src="' + href + '" alt="' + text + '"';
     if (title) {
       out += ' title="' + title + '"';
     }
     out += this.options.xhtml ? '/>' : '>';
     return out;
   }
 
   text(text) {
     return text;
   }
 };
 
 /**
  * TextRenderer
  * returns only the textual part of the token
  */
 var TextRenderer_1 = class TextRenderer {
   // no need for block level renderers
   strong(text) {
     return text;
   }
 
   em(text) {
     return text;
   }
 
   codespan(text) {
     return text;
   }
 
   del(text) {
     return text;
   }
 
   html(text) {
     return text;
   }
 
   text(text) {
     return text;
   }
 
   link(href, title, text) {
     return '' + text;
   }
 
   image(href, title, text) {
     return '' + text;
   }
 
   br() {
     return '';
   }
 };
 
 /**
  * Slugger generates header id
  */
 var Slugger_1 = class Slugger {
   constructor() {
     this.seen = {};
   }
 
   serialize(value) {
     return value
       .toLowerCase()
       .trim()
       // remove html tags
       .replace(/<[!\/a-z].*?>/ig, '')
       // remove unwanted chars
       .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '')
       .replace(/\s/g, '-');
   }
 
   /**
    * Finds the next safe (unique) slug to use
    */
   getNextSafeSlug(originalSlug, isDryRun) {
     let slug = originalSlug;
     let occurenceAccumulator = 0;
     if (this.seen.hasOwnProperty(slug)) {
       occurenceAccumulator = this.seen[originalSlug];
       do {
         occurenceAccumulator++;
         slug = originalSlug + '-' + occurenceAccumulator;
       } while (this.seen.hasOwnProperty(slug));
     }
     if (!isDryRun) {
       this.seen[originalSlug] = occurenceAccumulator;
       this.seen[slug] = 0;
     }
     return slug;
   }
 
   /**
    * Convert string to unique id
    * @param {object} options
    * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
    */
   slug(value, options = {}) {
     const slug = this.serialize(value);
     return this.getNextSafeSlug(slug, options.dryrun);
   }
 };
 
 const { defaults: defaults$4 } = defaults;
 const {
   unescape: unescape$1
 } = helpers;
 
 /**
  * Parsing & Compiling
  */
 var Parser_1 = class Parser {
   constructor(options) {
     this.options = options || defaults$4;
     this.options.renderer = this.options.renderer || new Renderer_1();
     this.renderer = this.options.renderer;
     this.renderer.options = this.options;
     this.textRenderer = new TextRenderer_1();
     this.slugger = new Slugger_1();
   }
 
   /**
    * Static Parse Method
    */
   static parse(tokens, options) {
     const parser = new Parser(options);
     return parser.parse(tokens);
   }
 
   /**
    * Static Parse Inline Method
    */
   static parseInline(tokens, options) {
     const parser = new Parser(options);
     return parser.parseInline(tokens);
   }
 
   /**
    * Parse Loop
    */
   parse(tokens, top = true) {
     let out = '',
       i,
       j,
       k,
       l2,
       l3,
       row,
       cell,
       header,
       body,
       token,
       ordered,
       start,
       loose,
       itemBody,
       item,
       checked,
       task,
       checkbox;
 
     const l = tokens.length;
     for (i = 0; i < l; i++) {
       token = tokens[i];
       switch (token.type) {
         case 'space': {
           continue;
         }
         case 'hr': {
           out += this.renderer.hr();
           continue;
         }
         case 'heading': {
           out += this.renderer.heading(
             this.parseInline(token.tokens),
             token.depth,
             unescape$1(this.parseInline(token.tokens, this.textRenderer)),
             this.slugger);
           continue;
         }
         case 'code': {
           out += this.renderer.code(token.text,
             token.lang,
             token.escaped);
           continue;
         }
         case 'table': {
           header = '';
 
           // header
           cell = '';
           l2 = token.header.length;
           for (j = 0; j < l2; j++) {
             cell += this.renderer.tablecell(
               this.parseInline(token.tokens.header[j]),
               { header: true, align: token.align[j] }
             );
           }
           header += this.renderer.tablerow(cell);
 
           body = '';
           l2 = token.cells.length;
           for (j = 0; j < l2; j++) {
             row = token.tokens.cells[j];
 
             cell = '';
             l3 = row.length;
             for (k = 0; k < l3; k++) {
               cell += this.renderer.tablecell(
                 this.parseInline(row[k]),
                 { header: false, align: token.align[k] }
               );
             }
 
             body += this.renderer.tablerow(cell);
           }
           out += this.renderer.table(header, body);
           continue;
         }
         case 'blockquote': {
           body = this.parse(token.tokens);
           out += this.renderer.blockquote(body);
           continue;
         }
         case 'list': {
           ordered = token.ordered;
           start = token.start;
           loose = token.loose;
           l2 = token.items.length;
 
           body = '';
           for (j = 0; j < l2; j++) {
             item = token.items[j];
             checked = item.checked;
             task = item.task;
 
             itemBody = '';
             if (item.task) {
               checkbox = this.renderer.checkbox(checked);
               if (loose) {
                 if (item.tokens.length > 0 && item.tokens[0].type === 'text') {
                   item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
                   if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
                     item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
                   }
                 } else {
                   item.tokens.unshift({
                     type: 'text',
                     text: checkbox
                   });
                 }
               } else {
                 itemBody += checkbox;
               }
             }
 
             itemBody += this.parse(item.tokens, loose);
             body += this.renderer.listitem(itemBody, task, checked);
           }
 
           out += this.renderer.list(body, ordered, start);
           continue;
         }
         case 'html': {
           // TODO parse inline content if parameter markdown=1
           out += this.renderer.html(token.text);
           continue;
         }
         case 'paragraph': {
           out += this.renderer.paragraph(this.parseInline(token.tokens));
           continue;
         }
         case 'text': {
           body = token.tokens ? this.parseInline(token.tokens) : token.text;
           while (i + 1 < l && tokens[i + 1].type === 'text') {
             token = tokens[++i];
             body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
           }
           out += top ? this.renderer.paragraph(body) : body;
           continue;
         }
         default: {
           const errMsg = 'Token with "' + token.type + '" type was not found.';
           if (this.options.silent) {
             console.error(errMsg);
             return;
           } else {
             throw new Error(errMsg);
           }
         }
       }
     }
 
     return out;
   }
 
   /**
    * Parse Inline Tokens
    */
   parseInline(tokens, renderer) {
     renderer = renderer || this.renderer;
     let out = '',
       i,
       token;
 
     const l = tokens.length;
     for (i = 0; i < l; i++) {
       token = tokens[i];
       switch (token.type) {
         case 'escape': {
           out += renderer.text(token.text);
           break;
         }
         case 'html': {
           out += renderer.html(token.text);
           break;
         }
         case 'link': {
           out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
           break;
         }
         case 'image': {
           out += renderer.image(token.href, token.title, token.text);
           break;
         }
         case 'strong': {
           out += renderer.strong(this.parseInline(token.tokens, renderer));
           break;
         }
         case 'em': {
           out += renderer.em(this.parseInline(token.tokens, renderer));
           break;
         }
         case 'codespan': {
           out += renderer.codespan(token.text);
           break;
         }
         case 'br': {
           out += renderer.br();
           break;
         }
         case 'del': {
           out += renderer.del(this.parseInline(token.tokens, renderer));
           break;
         }
         case 'text': {
           out += renderer.text(token.text);
           break;
         }
         default: {
           const errMsg = 'Token with "' + token.type + '" type was not found.';
           if (this.options.silent) {
             console.error(errMsg);
             return;
           } else {
             throw new Error(errMsg);
           }
         }
       }
     }
     return out;
   }
 };
 
 const {
   merge: merge$2,
   checkSanitizeDeprecation: checkSanitizeDeprecation$1,
   escape: escape$3
 } = helpers;
 const {
   getDefaults,
   changeDefaults,
   defaults: defaults$5
 } = defaults;
 
 /**
  * Marked
  */
 function marked(src, opt, callback) {
   // throw error in case of non string input
   if (typeof src === 'undefined' || src === null) {
     throw new Error('marked(): input parameter is undefined or null');
   }
   if (typeof src !== 'string') {
     throw new Error('marked(): input parameter is of type '
       + Object.prototype.toString.call(src) + ', string expected');
   }
 
   if (typeof opt === 'function') {
     callback = opt;
     opt = null;
   }
 
   opt = merge$2({}, marked.defaults, opt || {});
   checkSanitizeDeprecation$1(opt);
 
   if (callback) {
     const highlight = opt.highlight;
     let tokens;
 
     try {
       tokens = Lexer_1.lex(src, opt);
     } catch (e) {
       return callback(e);
     }
 
     const done = function(err) {
       let out;
 
       if (!err) {
         try {
           out = Parser_1.parse(tokens, opt);
         } catch (e) {
           err = e;
         }
       }
 
       opt.highlight = highlight;
 
       return err
         ? callback(err)
         : callback(null, out);
     };
 
     if (!highlight || highlight.length < 3) {
       return done();
     }
 
     delete opt.highlight;
 
     if (!tokens.length) return done();
 
     let pending = 0;
     marked.walkTokens(tokens, function(token) {
       if (token.type === 'code') {
         pending++;
         setTimeout(() => {
           highlight(token.text, token.lang, function(err, code) {
             if (err) {
               return done(err);
             }
             if (code != null && code !== token.text) {
               token.text = code;
               token.escaped = true;
             }
 
             pending--;
             if (pending === 0) {
               done();
             }
           });
         }, 0);
       }
     });
 
     if (pending === 0) {
       done();
     }
 
     return;
   }
 
   try {
     const tokens = Lexer_1.lex(src, opt);
     if (opt.walkTokens) {
       marked.walkTokens(tokens, opt.walkTokens);
     }
     return Parser_1.parse(tokens, opt);
   } catch (e) {
     e.message += '\nPlease report this to https://github.com/markedjs/marked.';
     if (opt.silent) {
       return '<p>An error occurred:</p><pre>'
         + escape$3(e.message + '', true)
         + '</pre>';
     }
     throw e;
   }
 }
 
 /**
  * Options
  */
 
 marked.options =
 marked.setOptions = function(opt) {
   merge$2(marked.defaults, opt);
   changeDefaults(marked.defaults);
   return marked;
 };
 
 marked.getDefaults = getDefaults;
 
 marked.defaults = defaults$5;
 
 /**
  * Use Extension
  */
 
 marked.use = function(extension) {
   const opts = merge$2({}, extension);
   if (extension.renderer) {
     const renderer = marked.defaults.renderer || new Renderer_1();
     for (const prop in extension.renderer) {
       const prevRenderer = renderer[prop];
       renderer[prop] = (...args) => {
         let ret = extension.renderer[prop].apply(renderer, args);
         if (ret === false) {
           ret = prevRenderer.apply(renderer, args);
         }
         return ret;
       };
     }
     opts.renderer = renderer;
   }
   if (extension.tokenizer) {
     const tokenizer = marked.defaults.tokenizer || new Tokenizer_1();
     for (const prop in extension.tokenizer) {
       const prevTokenizer = tokenizer[prop];
       tokenizer[prop] = (...args) => {
         let ret = extension.tokenizer[prop].apply(tokenizer, args);
         if (ret === false) {
           ret = prevTokenizer.apply(tokenizer, args);
         }
         return ret;
       };
     }
     opts.tokenizer = tokenizer;
   }
   if (extension.walkTokens) {
     const walkTokens = marked.defaults.walkTokens;
     opts.walkTokens = (token) => {
       extension.walkTokens(token);
       if (walkTokens) {
         walkTokens(token);
       }
     };
   }
   marked.setOptions(opts);
 };
 
 /**
  * Run callback for every token
  */
 
 marked.walkTokens = function(tokens, callback) {
   for (const token of tokens) {
     callback(token);
     switch (token.type) {
       case 'table': {
         for (const cell of token.tokens.header) {
           marked.walkTokens(cell, callback);
         }
         for (const row of token.tokens.cells) {
           for (const cell of row) {
             marked.walkTokens(cell, callback);
           }
         }
         break;
       }
       case 'list': {
         marked.walkTokens(token.items, callback);
         break;
       }
       default: {
         if (token.tokens) {
           marked.walkTokens(token.tokens, callback);
         }
       }
     }
   }
 };
 
 /**
  * Parse Inline
  */
 marked.parseInline = function(src, opt) {
   // throw error in case of non string input
   if (typeof src === 'undefined' || src === null) {
     throw new Error('marked.parseInline(): input parameter is undefined or null');
   }
   if (typeof src !== 'string') {
     throw new Error('marked.parseInline(): input parameter is of type '
       + Object.prototype.toString.call(src) + ', string expected');
   }
 
   opt = merge$2({}, marked.defaults, opt || {});
   checkSanitizeDeprecation$1(opt);
 
   try {
     const tokens = Lexer_1.lexInline(src, opt);
     if (opt.walkTokens) {
       marked.walkTokens(tokens, opt.walkTokens);
     }
     return Parser_1.parseInline(tokens, opt);
   } catch (e) {
     e.message += '\nPlease report this to https://github.com/markedjs/marked.';
     if (opt.silent) {
       return '<p>An error occurred:</p><pre>'
         + escape$3(e.message + '', true)
         + '</pre>';
     }
     throw e;
   }
 };
 
 /**
  * Expose
  */
 
 marked.Parser = Parser_1;
 marked.parser = Parser_1.parse;
 
 marked.Renderer = Renderer_1;
 marked.TextRenderer = TextRenderer_1;
 
 marked.Lexer = Lexer_1;
 marked.lexer = Lexer_1.lex;
 
 marked.Tokenizer = Tokenizer_1;
 
 marked.Slugger = Slugger_1;
 
 marked.parse = marked;
 
 var marked_1 = marked;
 
 export default marked_1;