/**

* marked - a markdown parser

* Copyright (c) 2011-2018, Christopher Jeffrey. (MIT Licensed)

* https://github.com/markedjs/marked

*/

;(function(root) {

'use strict';

/**

* Block-Level Grammar

*/

var block = {

newline: /^\n+/,

code: /^( {4}[^\n]+\n*)+/,

fences: /^ {0,3}(`{3,}|~{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: noop,

table: noop,

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(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(block.item, 'gm')

.replace(/bull/g, block.bullet)

.getRegex();

block.list = edit(block.list)

.replace(/bull/g, block.bullet)

.replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')

.replace('def', '\\n+(?=' + block.def.source + ')')

.getRegex();

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(block.html, 'i')

.replace('comment', block._comment)

.replace('tag', block._tag)

.replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)

.getRegex();

block.paragraph = edit(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,}|~{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(block.blockquote)

.replace('paragraph', block.paragraph)

.getRegex();

/**

* Normal Block Grammar

*/

block.normal = merge({}, block);

/**

* GFM Block Grammar

*/

block.gfm = merge({}, block.normal, {

nptable: /^ *([^|\n ].*\|.*)\n *([-:]+ *\|[-| :]*)(?:\n((?:.*[^>\n ].*(?:\n|$))*)\n*|$)/,

table: /^ *\|(.+)\n *\|?( *[-:]+[-| :]*)(?:\n((?: *[^>\n ].*(?:\n|$))*)\n*|$)/

});

/**

* Pedantic grammar (original John Gruber's loose markdown specification)

*/

block.pedantic = merge({}, block.normal, {

html: edit(

'^ *(?: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: noop, // fences not supported

paragraph: edit(block.normal._paragraph)

.replace('hr', block.hr)

.replace('heading', ' *#{1,6} *[^\n]')

.replace('lheading', block.lheading)

.replace('blockquote', ' {0,3}>')

.replace('|fences', '')

.replace('|list', '')

.replace('|html', '')

.getRegex()

});

/**

* Block Lexer

*/

function Lexer(options) {

this.tokens = [];

this.tokens.links = Object.create(null);

this.options = options || marked.defaults;

this.rules = block.normal;

if (this.options.pedantic) {

this.rules = block.pedantic;

} else if (this.options.gfm) {

this.rules = block.gfm;

}

}

/**

* Expose Block Rules

*/

Lexer.rules = block;

/**

* Static Lex Method

*/

Lexer.lex = function(src, options) {

var lexer = new Lexer(options);

return lexer.lex(src);

};

/**

* Preprocessing

*/

Lexer.prototype.lex = function(src) {

src = src

.replace(/\r\n|\r/g, '\n')

.replace(/\t/g, ' ')

.replace(/\u00a0/g, ' ')

.replace(/\u2424/g, '\n');

return this.token(src, true);

};

/**

* Lexing

*/

Lexer.prototype.token = function(src, top) {

src = src.replace(/^ +$/gm, '');

var next,

loose,

cap,

bull,

b,

item,

listStart,

listItems,

t,

space,

i,

tag,

l,

isordered,

istask,

ischecked;

while (src) {

// newline

if (cap = this.rules.newline.exec(src)) {

src = src.substring(cap[0].length);

if (cap[0].length > 1) {

this.tokens.push({

type: 'space'

});

}

}

// code

if (cap = this.rules.code.exec(src)) {

var lastToken = this.tokens[this.tokens.length - 1];

src = src.substring(cap[0].length);

// An indented code block cannot interrupt a paragraph.

if (lastToken && lastToken.type === 'paragraph') {

lastToken.text += '\n' + cap[0].trimRight();

} else {

cap = cap[0].replace(/^ {4}/gm, '');

this.tokens.push({

type: 'code',

codeBlockStyle: 'indented',

text: !this.options.pedantic

? rtrim(cap, '\n')

: cap

});

}

continue;

}

// fences

if (cap = this.rules.fences.exec(src)) {

src = src.substring(cap[0].length);

this.tokens.push({

type: 'code',

lang: cap[2] ? cap[2].trim() : cap[2],

text: cap[3] || ''

});

continue;

}

// heading

if (cap = this.rules.heading.exec(src)) {

src = src.substring(cap[0].length);

this.tokens.push({

type: 'heading',

depth: cap[1].length,

text: cap[2]

});

continue;

}

// table no leading pipe (gfm)

if (cap = this.rules.nptable.exec(src)) {

item = {

type: 'table',

header: splitCells(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) {

src = src.substring(cap[0].length);

for (i = 0; i < item.align.length; 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;

}

}

for (i = 0; i < item.cells.length; i++) {

item.cells[i] = splitCells(item.cells[i], item.header.length);

}

this.tokens.push(item);

continue;

}

}

// hr

if (cap = this.rules.hr.exec(src)) {

src = src.substring(cap[0].length);

this.tokens.push({

type: 'hr'

});

continue;

}

// blockquote

if (cap = this.rules.blockquote.exec(src)) {

src = src.substring(cap[0].length);

this.tokens.push({

type: 'blockquote_start'

});

cap = cap[0].replace(/^ *> ?/gm, '');

// Pass `top` to keep the current

// "toplevel" state. This is exactly

// how markdown.pl works.

this.token(cap, top);

this.tokens.push({

type: 'blockquote_end'

});

continue;

}

// list

if (cap = this.rules.list.exec(src)) {

src = src.substring(cap[0].length);

bull = cap[2];

isordered = bull.length > 1;

listStart = {

type: 'list_start',

ordered: isordered,

start: isordered ? +bull : '',

loose: false

};

this.tokens.push(listStart);

// Get each top-level item.

cap = cap[0].match(this.rules.item);

listItems = [];

next = false;

l = cap.length;

i = 0;

for (; i < l; i++) {

item = cap[i];

// 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 = block.bullet.exec(cap[i + 1])[0];

if (bull.length > 1 ? b.length === 1

: (b.length > 1 || (this.options.smartLists && b !== bull))) {

src = cap.slice(i + 1).join('\n') + src;

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) {

listStart.loose = true;

}

// Check for task list items

istask = /^\[[ xX]\] /.test(item);

ischecked = undefined;

if (istask) {

ischecked = item[1] !== ' ';

item = item.replace(/^\[[ xX]\] +/, '');

}

t = {

type: 'list_item_start',

task: istask,

checked: ischecked,

loose: loose

};

listItems.push(t);

this.tokens.push(t);

// Recurse.

this.token(item, false);

this.tokens.push({

type: 'list_item_end'

});

}

if (listStart.loose) {

l = listItems.length;

i = 0;

for (; i < l; i++) {

listItems[i].loose = true;

}

}

this.tokens.push({

type: 'list_end'

});

continue;

}

// html

if (cap = this.rules.html.exec(src)) {

src = src.substring(cap[0].length);

this.tokens.push({

type: this.options.sanitize

? 'paragraph'

: 'html',

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(cap[0])) : cap[0]

});

continue;

}

// def

if (top && (cap = this.rules.def.exec(src))) {

src = src.substring(cap[0].length);

if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);

tag = cap[1].toLowerCase().replace(/\s+/g, ' ');

if (!this.tokens.links[tag]) {

this.tokens.links[tag] = {

href: cap[2],

title: cap[3]

};

}

continue;

}

// table (gfm)

if (cap = this.rules.table.exec(src)) {

item = {

type: 'table',

header: splitCells(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) {

src = src.substring(cap[0].length);

for (i = 0; i < item.align.length; 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;

}

}

for (i = 0; i < item.cells.length; i++) {

item.cells[i] = splitCells(

item.cells[i].replace(/^ *\| *| *\| *$/g, ''),

item.header.length);

}

this.tokens.push(item);

continue;

}

}

// lheading

if (cap = this.rules.lheading.exec(src)) {

src = src.substring(cap[0].length);

this.tokens.push({

type: 'heading',

depth: cap[2].charAt(0) === '=' ? 1 : 2,

text: cap[1]

});

continue;

}

// top-level paragraph

if (top && (cap = this.rules.paragraph.exec(src))) {

src = src.substring(cap[0].length);

this.tokens.push({

type: 'paragraph',

text: cap[1].charAt(cap[1].length - 1) === '\n'

? cap[1].slice(0, -1)

: cap[1]

});

continue;

}

// text

if (cap = this.rules.text.exec(src)) {

// Top-level should never reach here.

src = src.substring(cap[0].length);

this.tokens.push({

type: 'text',

text: cap[0]

});

continue;

}

if (src) {

throw new Error('Infinite loop on byte: ' + src.charCodeAt(0));

}

}

return this.tokens;

};

/**

* Inline-Level Grammar

*/

var inline = {

escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,

autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,

url: noop,

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*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,

strong: /^__([^\s_])__(?!_)|^\*\*([^\s*])\*\*(?!\*)|^__([^\s][\s\S]*?[^\s])__(?!_)|^\*\*([^\s][\s\S]*?[^\s])\*\*(?!\*)/,

em: /^_([^\s_])_(?!_)|^\*([^\s*<\[])\*(?!\*)|^_([^\s<][\s\S]*?[^\s_])_(?!_|[^\spunctuation])|^_([^\s_<][\s\S]*?[^\s])_(?!_|[^\spunctuation])|^\*([^\s<"][\s\S]*?[^\s\*])\*(?!\*|[^\spunctuation])|^\*([^\s*"<\[][\s\S]*?[^\s])\*(?!\*)/,

code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,

br: /^( {2,}|\\)\n(?!\s*$)/,

del: noop,

text: /^(`+|[^`])(?:[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n))|(?= {2,}\n))/

};

// list of punctuation marks from common mark spec

// without ` and ] to workaround Rule 17 (inline code blocks/links)

inline._punctuation = '!"#$%&\'()*+,\\-./:;<=>?@\\[^_{|}~';

inline.em = edit(inline.em).replace(/punctuation/g, inline._punctuation).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(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(inline.tag)

.replace('comment', block._comment)

.replace('attribute', inline._attribute)

.getRegex();

inline._label = /(?:\[[^\[\]]*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;

inline._href = /<(?:\\[<>]?|[^\s<>\\])*>|[^\s\x00-\x1f]*/;

inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;

inline.link = edit(inline.link)

.replace('label', inline._label)

.replace('href', inline._href)

.replace('title', inline._title)

.getRegex();

inline.reflink = edit(inline.reflink)

.replace('label', inline._label)

.getRegex();

/**

* Normal Inline Grammar

*/

inline.normal = merge({}, inline);

/**

* Pedantic Inline Grammar

*/

inline.pedantic = merge({}, inline.normal, {

strong: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,

em: /^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/,

link: edit(/^!?\[(label)\]\((.*?)\)/)

.replace('label', inline._label)

.getRegex(),

reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/)

.replace('label', inline._label)

.getRegex()

});

/**

* GFM Inline Grammar

*/

inline.gfm = merge({}, inline.normal, {

escape: edit(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: /^(`+|[^`])(?:[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?= {2,}\n|[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/

});

inline.gfm.url = edit(inline.gfm.url, 'i')

.replace('email', inline.gfm._extended_email)

.getRegex();

/**

* GFM + Line Breaks Inline Grammar

*/

inline.breaks = merge({}, inline.gfm, {

br: edit(inline.br).replace('{2,}', '*').getRegex(),

text: edit(inline.gfm.text)

.replace('\\b_', '\\b_| {2,}\\n')

.replace(/\{2,\}/g, '*')

.getRegex()

});

/**

* Inline Lexer & Compiler

*/

function InlineLexer(links, options) {

this.options = options || marked.defaults;

this.links = links;

this.rules = inline.normal;

this.renderer = this.options.renderer || new Renderer();

this.renderer.options = this.options;

if (!this.links) {

throw new Error('Tokens array requires a `links` property.');

}

if (this.options.pedantic) {

this.rules = inline.pedantic;

} else if (this.options.gfm) {

if (this.options.breaks) {

this.rules = inline.breaks;

} else {

this.rules = inline.gfm;

}

}

}

/**

* Expose Inline Rules

*/

InlineLexer.rules = inline;

/**

* Static Lexing/Compiling Method

*/

InlineLexer.output = function(src, links, options) {

var inline = new InlineLexer(links, options);

return inline.output(src);

};

/**

* Lexing/Compiling

*/

InlineLexer.prototype.output = function(src) {

var out = '',

link,

text,

href,

title,

cap,

prevCapZero;

while (src) {

// escape

if (cap = this.rules.escape.exec(src)) {

src = src.substring(cap[0].length);

out += escape(cap[1]);

continue;

}

// tag

if (cap = this.rules.tag.exec(src)) {

if (!this.inLink && /^<a /i.test(cap[0])) {

this.inLink = true;

} else if (this.inLink && /^<\/a>/i.test(cap[0])) {

this.inLink = false;

}

if (!this.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {

this.inRawBlock = true;

} else if (this.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {

this.inRawBlock = false;

}

src = src.substring(cap[0].length);

out += this.options.sanitize

? this.options.sanitizer

? this.options.sanitizer(cap[0])

: escape(cap[0])

: cap[0];

continue;

}

// link

if (cap = this.rules.link.exec(src)) {

var lastParenIndex = findClosingBracket(cap[2], '()');

if (lastParenIndex > -1) {

var linkLen = 4 + cap[1].length + lastParenIndex;

cap[2] = cap[2].substring(0, lastParenIndex);

cap[0] = cap[0].substring(0, linkLen).trim();

cap[3] = '';

}

src = src.substring(cap[0].length);

this.inLink = true;

href = cap[2];

if (this.options.pedantic) {

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');

out += this.outputLink(cap, {

href: InlineLexer.escapes(href),

title: InlineLexer.escapes(title)

});

this.inLink = false;

continue;

}

// reflink, nolink

if ((cap = this.rules.reflink.exec(src))

|| (cap = this.rules.nolink.exec(src))) {

src = src.substring(cap[0].length);

link = (cap[2] || cap[1]).replace(/\s+/g, ' ');

link = this.links[link.toLowerCase()];

if (!link || !link.href) {

out += cap[0].charAt(0);

src = cap[0].substring(1) + src;

continue;

}

this.inLink = true;

out += this.outputLink(cap, link);

this.inLink = false;

continue;

}

// strong

if (cap = this.rules.strong.exec(src)) {

src = src.substring(cap[0].length);

out += this.renderer.strong(this.output(cap[4] || cap[3] || cap[2] || cap[1]));

continue;

}

// em

if (cap = this.rules.em.exec(src)) {

src = src.substring(cap[0].length);

out += this.renderer.em(this.output(cap[6] || cap[5] || cap[4] || cap[3] || cap[2] || cap[1]));

continue;

}

// code

if (cap = this.rules.code.exec(src)) {

src = src.substring(cap[0].length);

out += this.renderer.codespan(escape(cap[2].trim(), true));

continue;

}

// br

if (cap = this.rules.br.exec(src)) {

src = src.substring(cap[0].length);

out += this.renderer.br();

continue;

}

// del (gfm)

if (cap = this.rules.del.exec(src)) {

src = src.substring(cap[0].length);

out += this.renderer.del(this.output(cap[1]));

continue;

}

// autolink

if (cap = this.rules.autolink.exec(src)) {

src = src.substring(cap[0].length);

if (cap[2] === '@') {

text = escape(this.mangle(cap[1]));

href = 'mailto:' + text;

} else {

text = escape(cap[1]);

href = text;

}

out += this.renderer.link(href, null, text);

continue;

}

// url (gfm)

if (!this.inLink && (cap = this.rules.url.exec(src))) {

if (cap[2] === '@') {

text = escape(cap[0]);

href = 'mailto:' + text;

} else {

// do extended autolink path validation

do {

prevCapZero = cap[0];

cap[0] = this.rules._backpedal.exec(cap[0])[0];

} while (prevCapZero !== cap[0]);

text = escape(cap[0]);

if (cap[1] === 'www.') {

href = 'http://' + text;

} else {

href = text;

}

}

src = src.substring(cap[0].length);

out += this.renderer.link(href, null, text);

continue;

}

// text

if (cap = this.rules.text.exec(src)) {

src = src.substring(cap[0].length);

if (this.inRawBlock) {

out += this.renderer.text(this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0])) : cap[0]);

} else {

out += this.renderer.text(escape(this.smartypants(cap[0])));

}

continue;

}

if (src) {

throw new Error('Infinite loop on byte: ' + src.charCodeAt(0));

}

}

return out;

};

InlineLexer.escapes = function(text) {

return text ? text.replace(InlineLexer.rules._escapes, '$1') : text;

};

/**

* Compile Link

*/

InlineLexer.prototype.outputLink = function(cap, link) {

var href = link.href,

title = link.title ? escape(link.title) : null;

return cap[0].charAt(0) !== '!'

? this.renderer.link(href, title, this.output(cap[1]))

: this.renderer.image(href, title, escape(cap[1]));

};

/**

* Smartypants Transformations

*/

InlineLexer.prototype.smartypants = function(text) {

if (!this.options.smartypants) return 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 Links

*/

InlineLexer.prototype.mangle = function(text) {

if (!this.options.mangle) return text;

var out = '',

l = text.length,

i = 0,

ch;

for (; i < l; i++) {

ch = text.charCodeAt(i);

if (Math.random() > 0.5) {

ch = 'x' + ch.toString(16);

}

out += '&#' + ch + ';';

}

return out;

};

/**

* Renderer

*/

function Renderer(options) {

this.options = options || marked.defaults;

}

Renderer.prototype.code = function(code, infostring, escaped) {

var lang = (infostring || '').match(/\S*/)[0];

if (this.options.highlight) {

var out = this.options.highlight(code, lang);

if (out != null && out !== code) {

escaped = true;

code = out;

}

}

if (!lang) {

return '<pre><code>'

+ (escaped ? code : escape(code, true))

+ '</code></pre>';

}

return '<pre><code class="'

+ this.options.langPrefix

+ escape(lang, true)

+ '">'

+ (escaped ? code : escape(code, true))

+ '</code></pre>\n';

};

Renderer.prototype.blockquote = function(quote) {

return '<blockquote>\n' + quote + '</blockquote>\n';

};

Renderer.prototype.html = function(html) {

return html;

};

Renderer.prototype.heading = function(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';

};

Renderer.prototype.hr = function() {

return this.options.xhtml ? '<hr/>\n' : '<hr>\n';

};

Renderer.prototype.list = function(body, ordered, start) {

var type = ordered ? 'ol' : 'ul',

startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';

return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';

};

Renderer.prototype.listitem = function(text) {

return '<li>' + text + '</li>\n';

};

Renderer.prototype.checkbox = function(checked) {

return '<input '

+ (checked ? 'checked="" ' : '')