/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$2(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$2(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$2(this.options.mangle ? mangle(cap[1]) : cap[1]);
+ href = 'mailto:' + text;
+ } else {
+ text = escape$2(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$2(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$2(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$2(cap[0])) : cap[0];
+ } else {
+ text = escape$2(this.options.smartypants ? smartypants(cap[0]) : cap[0]);
+ }
+ return {
+ type: 'text',
+ raw: cap[0],
+ text
+ };
+ }
+ }
+ };
+
+ const {
+ noopTest: noopTest$1,
+ edit: edit$1,
+ merge: merge$2
+ } = 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]*?(?:[^\\n]*\\n+|$)' // (1)
+ + '|comment[^\\n]*(\\n+|$)' // (2)
+ + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
+ + '|\\n*|$)' // (4)
+ + '|\\n*|$)' // (5)
+ + '|)[\\s\\S]*?(?:\\n{2,}|$)' // (6)
+ + '|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) open tag
+ + '|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) closing tag
+ + ')',
+ def: /^ {0,3}\[(label)\]: *\n? *]+)>?(?:(?: +\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 = /|$)/;
+ 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', ')|<(?: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$2({}, block);
+
+ /**
+ * GFM Block Grammar
+ */
+
+ block.gfm = merge$2({}, 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', ')|<(?: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', ')|<(?: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$2({}, block.normal, {
+ html: edit$1(
+ '^ *(?:comment *(?:\\n|\\s*$)'
+ + '|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)' // closed tag
+ + '|\\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: /^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\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'
+ + '|^' // self-closing tag
+ + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
+ + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g.
+ + '|^' // declaration, e.g.
+ + '|^', // 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]*?(?:(?=[\\?@\\[\\]`^{|}~';
+ inline.punctuation = edit$1(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
+
+ // sequences em should skip over [title](link), `code`,
+ 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$2({}, inline);
+
+ /**
+ * Pedantic Inline Grammar
+ */
+
+ inline.pedantic = merge$2({}, 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$2({}, 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]*?(?:(?=[\\ 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) + '[' + repeatString$1('a', 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) + '[' + repeatString$1('a', 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$3
+ } = 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 ''
+ + (escaped ? code : escape$3(code, true))
+ + '
\n';
+ }
+
+ return ''
+ + (escaped ? code : escape$3(code, true))
+ + '
\n';
+ }
+
+ blockquote(quote) {
+ return '\n' + quote + '
\n';
+ }
+
+ html(html) {
+ return html;
+ }
+
+ heading(text, level, raw, slugger) {
+ if (this.options.headerIds) {
+ return '\n';
+ }
+ // ignore IDs
+ return '' + text + '\n';
+ }
+
+ hr() {
+ return this.options.xhtml ? '
\n' : '
\n';
+ }
+
+ list(body, ordered, start) {
+ const type = ordered ? 'ol' : 'ul',
+ startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
+ return '<' + type + startatt + '>\n' + body + '\n';
+ }
+
+ listitem(text) {
+ return '' + text + '\n';
+ }
+
+ checkbox(checked) {
+ return ' ';
+ }
+
+ paragraph(text) {
+ return '' + text + '
\n';
+ }
+
+ table(header, body) {
+ if (body) body = '' + body + '';
+
+ return '