/i.test(cap[0])) {
+ this.lexer.state.inLink = false;
+ }
+ if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = true;
+ } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+ this.lexer.state.inRawBlock = false;
}
- token2 = self2.symbols_[token2] || token2;
+ return {
+ type: "html",
+ raw: cap[0],
+ inLink: this.lexer.state.inLink,
+ inRawBlock: this.lexer.state.inRawBlock,
+ block: false,
+ text: cap[0]
+ };
}
- return token2;
}
- var symbol, state2, action, r, yyval = {}, p, len, newState, expected;
- while (true) {
- state2 = stack[stack.length - 1];
- if (this.defaultActions[state2]) {
- action = this.defaultActions[state2];
- } else {
- if (symbol === null || typeof symbol == "undefined") {
- symbol = lex2();
+ link(src) {
+ const cap = this.rules.inline.link.exec(src);
+ if (cap) {
+ const trimmedUrl = cap[2].trim();
+ if (!this.options.pedantic && /^$/.test(trimmedUrl)) {
+ return;
+ }
+ const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
+ if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+ return;
+ }
+ } else {
+ const lastParenIndex = findClosingBracket(cap[2], "()");
+ if (lastParenIndex > -1) {
+ const start3 = cap[0].indexOf("!") === 0 ? 5 : 4;
+ const linkLen = start3 + 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 title2 = "";
+ if (this.options.pedantic) {
+ const link3 = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+ if (link3) {
+ href = link3[1];
+ title2 = link3[3];
+ }
+ } else {
+ title2 = cap[3] ? cap[3].slice(1, -1) : "";
}
- action = table[state2] && table[state2][symbol];
- }
- if (typeof action === "undefined" || !action.length || !action[0]) {
- var errStr = "";
- expected = [];
- for (p in table[state2]) {
- if (this.terminals_[p] && p > TERROR) {
- expected.push("'" + this.terminals_[p] + "'");
+ href = href.trim();
+ if (/^$/.test(trimmedUrl)) {
+ href = href.slice(1);
+ } else {
+ href = href.slice(1, -1);
}
}
- if (lexer2.showPosition) {
- errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer2.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
- } else {
- errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
- }
- this.parseError(errStr, {
- text: lexer2.match,
- token: this.terminals_[symbol] || symbol,
- line: lexer2.yylineno,
- loc: yyloc,
- expected
- });
+ return outputLink(cap, {
+ href: href ? href.replace(this.rules.inline.anyPunctuation, "$1") : href,
+ title: title2 ? title2.replace(this.rules.inline.anyPunctuation, "$1") : title2
+ }, cap[0], this.lexer);
}
- if (action[0] instanceof Array && action.length > 1) {
- throw new Error("Parse Error: multiple actions possible at state: " + state2 + ", token: " + symbol);
+ }
+ reflink(src, links3) {
+ let cap;
+ if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+ const linkString = (cap[2] || cap[1]).replace(/\s+/g, " ");
+ const link3 = links3[linkString.toLowerCase()];
+ if (!link3) {
+ const text2 = cap[0].charAt(0);
+ return {
+ type: "text",
+ raw: text2,
+ text: text2
+ };
+ }
+ return outputLink(cap, link3, cap[0], this.lexer);
}
- switch (action[0]) {
- case 1:
- stack.push(symbol);
- vstack.push(lexer2.yytext);
- lstack.push(lexer2.yylloc);
- stack.push(action[1]);
- symbol = null;
- {
- yyleng = lexer2.yyleng;
- yytext = lexer2.yytext;
- yylineno = lexer2.yylineno;
- yyloc = lexer2.yylloc;
+ }
+ emStrong(src, maskedSrc, prevChar = "") {
+ let match2 = this.rules.inline.emStrongLDelim.exec(src);
+ if (!match2)
+ return;
+ if (match2[3] && prevChar.match(/[\p{L}\p{N}]/u))
+ return;
+ const nextChar = match2[1] || match2[2] || "";
+ if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
+ const lLength = [...match2[0]].length - 1;
+ let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+ const endReg = match2[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+ endReg.lastIndex = 0;
+ maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+ while ((match2 = endReg.exec(maskedSrc)) != null) {
+ rDelim = match2[1] || match2[2] || match2[3] || match2[4] || match2[5] || match2[6];
+ if (!rDelim)
+ continue;
+ rLength = [...rDelim].length;
+ if (match2[3] || match2[4]) {
+ delimTotal += rLength;
+ continue;
+ } else if (match2[5] || match2[6]) {
+ if (lLength % 3 && !((lLength + rLength) % 3)) {
+ midDelimTotal += rLength;
+ continue;
+ }
}
- break;
- case 2:
- len = this.productions_[action[1]][1];
- yyval.$ = vstack[vstack.length - len];
- yyval._$ = {
- first_line: lstack[lstack.length - (len || 1)].first_line,
- last_line: lstack[lstack.length - 1].last_line,
- first_column: lstack[lstack.length - (len || 1)].first_column,
- last_column: lstack[lstack.length - 1].last_column
- };
- if (ranges) {
- yyval._$.range = [
- lstack[lstack.length - (len || 1)].range[0],
- lstack[lstack.length - 1].range[1]
- ];
+ delimTotal -= rLength;
+ if (delimTotal > 0)
+ continue;
+ rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+ const lastCharLength = [...match2[0]][0].length;
+ const raw = src.slice(0, lLength + match2.index + lastCharLength + rLength);
+ if (Math.min(lLength, rLength) % 2) {
+ const text3 = raw.slice(1, -1);
+ return {
+ type: "em",
+ raw,
+ text: text3,
+ tokens: this.lexer.inlineTokens(text3)
+ };
}
- r = this.performAction.apply(yyval, [
- yytext,
- yyleng,
- yylineno,
- sharedState.yy,
- action[1],
- vstack,
- lstack
- ].concat(args));
- if (typeof r !== "undefined") {
- return r;
- }
- if (len) {
- stack = stack.slice(0, -1 * len * 2);
- vstack = vstack.slice(0, -1 * len);
- lstack = lstack.slice(0, -1 * len);
- }
- stack.push(this.productions_[action[1]][0]);
- vstack.push(yyval.$);
- lstack.push(yyval._$);
- newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
- stack.push(newState);
- break;
- case 3:
- return true;
+ const text2 = raw.slice(2, -2);
+ return {
+ type: "strong",
+ raw,
+ text: text2,
+ tokens: this.lexer.inlineTokens(text2)
+ };
+ }
}
}
- return true;
- }
- };
- var lexer = function() {
- var lexer2 = {
- EOF: 1,
- parseError: function parseError2(str2, hash) {
- if (this.yy.parser) {
- this.yy.parser.parseError(str2, hash);
- } else {
- throw new Error(str2);
- }
- },
- // resets the lexer, sets new input
- setInput: function(input, yy) {
- this.yy = yy || this.yy || {};
- this._input = input;
- this._more = this._backtrack = this.done = false;
- this.yylineno = this.yyleng = 0;
- this.yytext = this.matched = this.match = "";
- this.conditionStack = ["INITIAL"];
- this.yylloc = {
- first_line: 1,
- first_column: 0,
- last_line: 1,
- last_column: 0
- };
- if (this.options.ranges) {
- this.yylloc.range = [0, 0];
+ codespan(src) {
+ const cap = this.rules.inline.code.exec(src);
+ if (cap) {
+ let text2 = cap[2].replace(/\n/g, " ");
+ const hasNonSpaceChars = /[^ ]/.test(text2);
+ const hasSpaceCharsOnBothEnds = /^ /.test(text2) && / $/.test(text2);
+ if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+ text2 = text2.substring(1, text2.length - 1);
+ }
+ text2 = escape$1(text2, true);
+ return {
+ type: "codespan",
+ raw: cap[0],
+ text: text2
+ };
}
- this.offset = 0;
- return this;
- },
- // consumes and returns one char from the input
- input: function() {
- var ch = this._input[0];
- this.yytext += ch;
- this.yyleng++;
- this.offset++;
- this.match += ch;
- this.matched += ch;
- var lines = ch.match(/(?:\r\n?|\n).*/g);
- if (lines) {
- this.yylineno++;
- this.yylloc.last_line++;
- } else {
- this.yylloc.last_column++;
+ }
+ br(src) {
+ const cap = this.rules.inline.br.exec(src);
+ if (cap) {
+ return {
+ type: "br",
+ raw: cap[0]
+ };
}
- if (this.options.ranges) {
- this.yylloc.range[1]++;
+ }
+ del(src) {
+ const cap = this.rules.inline.del.exec(src);
+ if (cap) {
+ return {
+ type: "del",
+ raw: cap[0],
+ text: cap[2],
+ tokens: this.lexer.inlineTokens(cap[2])
+ };
}
- this._input = this._input.slice(1);
- return ch;
- },
- // unshifts one char (or a string) into the input
- unput: function(ch) {
- var len = ch.length;
- var lines = ch.split(/(?:\r\n?|\n)/g);
- this._input = ch + this._input;
- this.yytext = this.yytext.substr(0, this.yytext.length - len);
- this.offset -= len;
- var oldLines = this.match.split(/(?:\r\n?|\n)/g);
- this.match = this.match.substr(0, this.match.length - 1);
- this.matched = this.matched.substr(0, this.matched.length - 1);
- if (lines.length - 1) {
- this.yylineno -= lines.length - 1;
- }
- var r = this.yylloc.range;
- this.yylloc = {
- first_line: this.yylloc.first_line,
- last_line: this.yylineno + 1,
- first_column: this.yylloc.first_column,
- last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
+ }
+ autolink(src) {
+ const cap = this.rules.inline.autolink.exec(src);
+ if (cap) {
+ let text2, href;
+ if (cap[2] === "@") {
+ text2 = escape$1(cap[1]);
+ href = "mailto:" + text2;
+ } else {
+ text2 = escape$1(cap[1]);
+ href = text2;
+ }
+ return {
+ type: "link",
+ raw: cap[0],
+ text: text2,
+ href,
+ tokens: [
+ {
+ type: "text",
+ raw: text2,
+ text: text2
+ }
+ ]
+ };
+ }
+ }
+ url(src) {
+ let cap;
+ if (cap = this.rules.inline.url.exec(src)) {
+ let text2, href;
+ if (cap[2] === "@") {
+ text2 = escape$1(cap[0]);
+ href = "mailto:" + text2;
+ } else {
+ let prevCapZero;
+ do {
+ prevCapZero = cap[0];
+ cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? "";
+ } while (prevCapZero !== cap[0]);
+ text2 = escape$1(cap[0]);
+ if (cap[1] === "www.") {
+ href = "http://" + cap[0];
+ } else {
+ href = cap[0];
+ }
+ }
+ return {
+ type: "link",
+ raw: cap[0],
+ text: text2,
+ href,
+ tokens: [
+ {
+ type: "text",
+ raw: text2,
+ text: text2
+ }
+ ]
+ };
+ }
+ }
+ inlineText(src) {
+ const cap = this.rules.inline.text.exec(src);
+ if (cap) {
+ let text2;
+ if (this.lexer.state.inRawBlock) {
+ text2 = cap[0];
+ } else {
+ text2 = escape$1(cap[0]);
+ }
+ return {
+ type: "text",
+ raw: cap[0],
+ text: text2
+ };
+ }
+ }
+ };
+ newline = /^(?: *(?:\n|$))+/;
+ blockCode = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/;
+ fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+ hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+ heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+ bullet = /(?:[*+-]|\d{1,9}[.)])/;
+ lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, bullet).replace(/blockCode/g, / {4}/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).getRegex();
+ _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+ blockText = /^[^\n]+/;
+ _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+ def = edit(/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+ list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+ _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|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+ _comment = /|$))/;
+ html = edit("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))", "i").replace("comment", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+ paragraph = edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+ blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex();
+ blockNormal = {
+ blockquote,
+ code: blockCode,
+ def,
+ fences,
+ heading,
+ hr,
+ html,
+ lheading,
+ list,
+ newline,
+ paragraph,
+ table: noopTest,
+ text: blockText
+ };
+ gfmTable = edit("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+ blockGfm = {
+ ...blockNormal,
+ table: gfmTable,
+ paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
+ };
+ blockPedantic = {
+ ...blockNormal,
+ html: edit(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", _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+|$)/,
+ fences: noopTest,
+ // fences not supported
+ lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+ paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+ };
+ escape3 = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+ inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+ br = /^( {2,}|\\)\n(?!\s*$)/;
+ inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\]*?>/g;
+ emStrongLDelim = edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, _punctuation).getRegex();
+ emStrongRDelimAst = edit("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, _punctuation).getRegex();
+ emStrongRDelimUnd = edit("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, _punctuation).getRegex();
+ anyPunctuation = edit(/\\([punct])/, "gu").replace(/punct/g, _punctuation).getRegex();
+ autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("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])?)+(?![-_])/).getRegex();
+ _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
+ tag = edit("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+ _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+ link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+ reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
+ nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
+ reflinkSearch = edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex();
+ inlineNormal = {
+ _backpedal: noopTest,
+ // only used for GFM url
+ anyPunctuation,
+ autolink,
+ blockSkip,
+ br,
+ code: inlineCode,
+ del: noopTest,
+ emStrongLDelim,
+ emStrongRDelimAst,
+ emStrongRDelimUnd,
+ escape: escape3,
+ link,
+ nolink,
+ punctuation,
+ reflink,
+ reflinkSearch,
+ tag,
+ text: inlineText,
+ url: noopTest
+ };
+ inlinePedantic = {
+ ...inlineNormal,
+ link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", _inlineLabel).getRegex(),
+ reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", _inlineLabel).getRegex()
+ };
+ inlineGfm = {
+ ...inlineNormal,
+ escape: edit(escape3).replace("])", "~|])").getRegex(),
+ url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
+ _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
+ del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
+ text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\ {
+ return leading + " ".repeat(tabs.length);
});
}
- return this;
- },
- // retain first n characters of the match
- less: function(n) {
- this.unput(this.match.slice(n));
- },
- // displays already matched input, i.e. for error messages
- pastInput: function() {
- var past = this.matched.substr(0, this.matched.length - this.match.length);
- return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
- },
- // displays upcoming input, i.e. for error messages
- upcomingInput: function() {
- var next2 = this.match;
- if (next2.length < 20) {
- next2 += this._input.substr(0, 20 - next2.length);
- }
- return (next2.substr(0, 20) + (next2.length > 20 ? "..." : "")).replace(/\n/g, "");
- },
- // displays the character position where the lexing error occurred, i.e. for error messages
- showPosition: function() {
- var pre = this.pastInput();
- var c2 = new Array(pre.length + 1).join("-");
- return pre + this.upcomingInput() + "\n" + c2 + "^";
- },
- // test the lexed token: return FALSE when not a match, otherwise return token
- test_match: function(match, indexed_rule) {
- var token2, lines, backup;
- if (this.options.backtrack_lexer) {
- backup = {
- yylineno: this.yylineno,
- yylloc: {
- first_line: this.yylloc.first_line,
- last_line: this.last_line,
- first_column: this.yylloc.first_column,
- last_column: this.yylloc.last_column
- },
- yytext: this.yytext,
- match: this.match,
- matches: this.matches,
- matched: this.matched,
- yyleng: this.yyleng,
- offset: this.offset,
- _more: this._more,
- _input: this._input,
- yy: this.yy,
- conditionStack: this.conditionStack.slice(0),
- done: this.done
- };
- if (this.options.ranges) {
- backup.yylloc.range = this.yylloc.range.slice(0);
+ let token2;
+ let lastToken;
+ let cutSrc;
+ while (src) {
+ if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((extTokenizer) => {
+ if (token2 = extTokenizer.call({ lexer: this }, src, tokens2)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ return true;
+ }
+ return false;
+ })) {
+ continue;
}
- }
- lines = match[0].match(/(?:\r\n?|\n).*/g);
- if (lines) {
- this.yylineno += lines.length;
- }
- this.yylloc = {
- first_line: this.yylloc.last_line,
- last_line: this.yylineno + 1,
- first_column: this.yylloc.last_column,
- last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
- };
- this.yytext += match[0];
- this.match += match[0];
- this.matches = match;
- this.yyleng = this.yytext.length;
- if (this.options.ranges) {
- this.yylloc.range = [this.offset, this.offset += this.yyleng];
- }
- this._more = false;
- this._backtrack = false;
- this._input = this._input.slice(match[0].length);
- this.matched += match[0];
- token2 = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
- if (this.done && this._input) {
- this.done = false;
- }
- if (token2) {
- return token2;
- } else if (this._backtrack) {
- for (var k in backup) {
- this[k] = backup[k];
+ if (token2 = this.tokenizer.space(src)) {
+ src = src.substring(token2.raw.length);
+ if (token2.raw.length === 1 && tokens2.length > 0) {
+ tokens2[tokens2.length - 1].raw += "\n";
+ } else {
+ tokens2.push(token2);
+ }
+ continue;
}
- return false;
- }
- return false;
- },
- // return next match in input
- next: function() {
- if (this.done) {
- return this.EOF;
- }
- if (!this._input) {
- this.done = true;
- }
- var token2, match, tempMatch, index;
- if (!this._more) {
- this.yytext = "";
- this.match = "";
- }
- var rules = this._currentRules();
- for (var i2 = 0; i2 < rules.length; i2++) {
- tempMatch = this._input.match(this.rules[rules[i2]]);
- if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
- match = tempMatch;
- index = i2;
- if (this.options.backtrack_lexer) {
- token2 = this.test_match(tempMatch, rules[i2]);
- if (token2 !== false) {
- return token2;
- } else if (this._backtrack) {
- match = false;
- continue;
- } else {
- return false;
+ if (token2 = this.tokenizer.code(src)) {
+ src = src.substring(token2.raw.length);
+ lastToken = tokens2[tokens2.length - 1];
+ if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+ lastToken.raw += "\n" + token2.raw;
+ lastToken.text += "\n" + token2.text;
+ this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+ } else {
+ tokens2.push(token2);
+ }
+ continue;
+ }
+ if (token2 = this.tokenizer.fences(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.heading(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.hr(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.blockquote(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.list(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.html(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.def(src)) {
+ src = src.substring(token2.raw.length);
+ lastToken = tokens2[tokens2.length - 1];
+ if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+ lastToken.raw += "\n" + token2.raw;
+ lastToken.text += "\n" + token2.raw;
+ this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+ } else if (!this.tokens.links[token2.tag]) {
+ this.tokens.links[token2.tag] = {
+ href: token2.href,
+ title: token2.title
+ };
+ }
+ continue;
+ }
+ if (token2 = this.tokenizer.table(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.lheading(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ cutSrc = src;
+ if (this.options.extensions && this.options.extensions.startBlock) {
+ let startIndex = Infinity;
+ const tempSrc = src.slice(1);
+ let tempStart;
+ this.options.extensions.startBlock.forEach((getStartIndex) => {
+ tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+ if (typeof tempStart === "number" && tempStart >= 0) {
+ startIndex = Math.min(startIndex, tempStart);
}
- } else if (!this.options.flex) {
+ });
+ if (startIndex < Infinity && startIndex >= 0) {
+ cutSrc = src.substring(0, startIndex + 1);
+ }
+ }
+ if (this.state.top && (token2 = this.tokenizer.paragraph(cutSrc))) {
+ lastToken = tokens2[tokens2.length - 1];
+ if (lastParagraphClipped && lastToken?.type === "paragraph") {
+ lastToken.raw += "\n" + token2.raw;
+ lastToken.text += "\n" + token2.text;
+ this.inlineQueue.pop();
+ this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+ } else {
+ tokens2.push(token2);
+ }
+ lastParagraphClipped = cutSrc.length !== src.length;
+ src = src.substring(token2.raw.length);
+ continue;
+ }
+ if (token2 = this.tokenizer.text(src)) {
+ src = src.substring(token2.raw.length);
+ lastToken = tokens2[tokens2.length - 1];
+ if (lastToken && lastToken.type === "text") {
+ lastToken.raw += "\n" + token2.raw;
+ lastToken.text += "\n" + token2.text;
+ this.inlineQueue.pop();
+ this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+ } else {
+ tokens2.push(token2);
+ }
+ 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);
}
}
}
- if (match) {
- token2 = this.test_match(match, rules[index]);
- if (token2 !== false) {
- return token2;
+ this.state.top = true;
+ return tokens2;
+ }
+ inline(src, tokens2 = []) {
+ this.inlineQueue.push({ src, tokens: tokens2 });
+ return tokens2;
+ }
+ /**
+ * Lexing/Compiling
+ */
+ inlineTokens(src, tokens2 = []) {
+ let token2, lastToken, cutSrc;
+ let maskedSrc = src;
+ let match2;
+ let keepPrevChar, prevChar;
+ if (this.tokens.links) {
+ const links3 = Object.keys(this.tokens.links);
+ if (links3.length > 0) {
+ while ((match2 = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
+ if (links3.includes(match2[0].slice(match2[0].lastIndexOf("[") + 1, -1))) {
+ maskedSrc = maskedSrc.slice(0, match2.index) + "[" + "a".repeat(match2[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+ }
+ }
}
- return false;
}
- if (this._input === "") {
- return this.EOF;
- } else {
- return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
- text: "",
- token: null,
- line: this.yylineno
- });
+ while ((match2 = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
+ maskedSrc = maskedSrc.slice(0, match2.index) + "[" + "a".repeat(match2[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
}
- },
- // return next match that has a token
- lex: function lex2() {
- var r = this.next();
- if (r) {
- return r;
- } else {
- return this.lex();
+ while ((match2 = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
+ maskedSrc = maskedSrc.slice(0, match2.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
}
- },
- // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
- begin: function begin(condition) {
- this.conditionStack.push(condition);
- },
- // pop the previously active lexer condition state off the condition stack
- popState: function popState() {
- var n = this.conditionStack.length - 1;
- if (n > 0) {
- return this.conditionStack.pop();
- } else {
- return this.conditionStack[0];
+ while (src) {
+ if (!keepPrevChar) {
+ prevChar = "";
+ }
+ keepPrevChar = false;
+ if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((extTokenizer) => {
+ if (token2 = extTokenizer.call({ lexer: this }, src, tokens2)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ return true;
+ }
+ return false;
+ })) {
+ continue;
+ }
+ if (token2 = this.tokenizer.escape(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.tag(src)) {
+ src = src.substring(token2.raw.length);
+ lastToken = tokens2[tokens2.length - 1];
+ if (lastToken && token2.type === "text" && lastToken.type === "text") {
+ lastToken.raw += token2.raw;
+ lastToken.text += token2.text;
+ } else {
+ tokens2.push(token2);
+ }
+ continue;
+ }
+ if (token2 = this.tokenizer.link(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.reflink(src, this.tokens.links)) {
+ src = src.substring(token2.raw.length);
+ lastToken = tokens2[tokens2.length - 1];
+ if (lastToken && token2.type === "text" && lastToken.type === "text") {
+ lastToken.raw += token2.raw;
+ lastToken.text += token2.text;
+ } else {
+ tokens2.push(token2);
+ }
+ continue;
+ }
+ if (token2 = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.codespan(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.br(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.del(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (token2 = this.tokenizer.autolink(src)) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ if (!this.state.inLink && (token2 = this.tokenizer.url(src))) {
+ src = src.substring(token2.raw.length);
+ tokens2.push(token2);
+ continue;
+ }
+ cutSrc = src;
+ if (this.options.extensions && this.options.extensions.startInline) {
+ let startIndex = Infinity;
+ const tempSrc = src.slice(1);
+ let tempStart;
+ this.options.extensions.startInline.forEach((getStartIndex) => {
+ tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+ if (typeof tempStart === "number" && tempStart >= 0) {
+ startIndex = Math.min(startIndex, tempStart);
+ }
+ });
+ if (startIndex < Infinity && startIndex >= 0) {
+ cutSrc = src.substring(0, startIndex + 1);
+ }
+ }
+ if (token2 = this.tokenizer.inlineText(cutSrc)) {
+ src = src.substring(token2.raw.length);
+ if (token2.raw.slice(-1) !== "_") {
+ prevChar = token2.raw.slice(-1);
+ }
+ keepPrevChar = true;
+ lastToken = tokens2[tokens2.length - 1];
+ if (lastToken && lastToken.type === "text") {
+ lastToken.raw += token2.raw;
+ lastToken.text += token2.text;
+ } else {
+ tokens2.push(token2);
+ }
+ 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);
+ }
+ }
}
- },
- // produce the lexer rule set which is active for the currently active lexer condition state
- _currentRules: function _currentRules() {
- if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
- return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
- } else {
- return this.conditions["INITIAL"].rules;
+ return tokens2;
+ }
+ };
+ _Renderer = class {
+ static {
+ __name(this, "_Renderer");
+ }
+ options;
+ parser;
+ // set by the parser
+ constructor(options3) {
+ this.options = options3 || _defaults;
+ }
+ space(token2) {
+ return "";
+ }
+ code({ text: text2, lang, escaped }) {
+ const langString = (lang || "").match(/^\S*/)?.[0];
+ const code = text2.replace(/\n$/, "") + "\n";
+ if (!langString) {
+ return "" + (escaped ? code : escape$1(code, true)) + "
\n";
}
- },
- // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
- topState: function topState(n) {
- n = this.conditionStack.length - 1 - Math.abs(n || 0);
- if (n >= 0) {
- return this.conditionStack[n];
- } else {
- return "INITIAL";
+ return '' + (escaped ? code : escape$1(code, true)) + "
\n";
+ }
+ blockquote({ tokens: tokens2 }) {
+ const body = this.parser.parse(tokens2);
+ return `
+${body}
+`;
+ }
+ html({ text: text2 }) {
+ return text2;
+ }
+ heading({ tokens: tokens2, depth }) {
+ return `${this.parser.parseInline(tokens2)}
+`;
+ }
+ hr(token2) {
+ return "
\n";
+ }
+ list(token2) {
+ const ordered = token2.ordered;
+ const start3 = token2.start;
+ let body = "";
+ for (let j2 = 0; j2 < token2.items.length; j2++) {
+ const item = token2.items[j2];
+ body += this.listitem(item);
+ }
+ const type3 = ordered ? "ol" : "ul";
+ const startAttr = ordered && start3 !== 1 ? ' start="' + start3 + '"' : "";
+ return "<" + type3 + startAttr + ">\n" + body + "\n";
+ }
+ listitem(item) {
+ let itemBody = "";
+ if (item.task) {
+ const checkbox = this.checkbox({ checked: !!item.checked });
+ if (item.loose) {
+ if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") {
+ 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",
+ raw: checkbox + " ",
+ text: checkbox + " "
+ });
+ }
+ } else {
+ itemBody += checkbox + " ";
+ }
}
- },
- // alias for begin(condition)
- pushState: function pushState(condition) {
- this.begin(condition);
- },
- // return the number of states currently on the stack
- stateStackSize: function stateStackSize() {
- return this.conditionStack.length;
- },
- options: { "case-insensitive": true },
- performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
- switch ($avoiding_name_collisions) {
- case 0:
- this.begin("acc_title");
- return 25;
- case 1:
- this.popState();
- return "acc_title_value";
- case 2:
- this.begin("acc_descr");
- return 27;
- case 3:
- this.popState();
- return "acc_descr_value";
- case 4:
- this.begin("acc_descr_multiline");
- break;
- case 5:
- this.popState();
- break;
- case 6:
- return "acc_descr_multiline_value";
- case 7:
- this.begin("open_directive");
- return 51;
- case 8:
- this.begin("type_directive");
- return 52;
- case 9:
- this.popState();
- this.begin("arg_directive");
- return 15;
- case 10:
- this.popState();
- this.popState();
- return 54;
- case 11:
- return 53;
- case 12:
- return 11;
- case 13:
- break;
- case 14:
- return 9;
- case 15:
- return 31;
- case 16:
- return 50;
- case 17:
- return 4;
- case 18:
- this.begin("block");
- return 20;
- case 19:
- return 39;
- case 20:
- break;
- case 21:
- return 40;
- case 22:
- return 37;
- case 23:
- return 37;
- case 24:
- return 41;
- case 25:
- break;
- case 26:
- this.popState();
- return 22;
- case 27:
- return yy_.yytext[0];
- case 28:
- return 44;
- case 29:
- return 46;
- case 30:
- return 46;
- case 31:
- return 46;
- case 32:
- return 44;
- case 33:
- return 44;
- case 34:
- return 45;
- case 35:
- return 45;
- case 36:
- return 45;
- case 37:
- return 45;
- case 38:
- return 45;
- case 39:
- return 46;
- case 40:
- return 45;
- case 41:
- return 46;
- case 42:
- return 47;
- case 43:
- return 47;
- case 44:
- return 47;
- case 45:
- return 47;
- case 46:
- return 44;
- case 47:
- return 45;
- case 48:
- return 46;
- case 49:
- return 48;
- case 50:
- return 49;
- case 51:
- return 49;
- case 52:
- return 48;
- case 53:
- return 48;
- case 54:
- return 48;
- case 55:
- return 30;
- case 56:
- return yy_.yytext[0];
- case 57:
- return 6;
+ itemBody += this.parser.parse(item.tokens, !!item.loose);
+ return `${itemBody}
+`;
+ }
+ checkbox({ checked }) {
+ return "';
+ }
+ paragraph({ tokens: tokens2 }) {
+ return `${this.parser.parseInline(tokens2)}
+`;
+ }
+ table(token2) {
+ let header = "";
+ let cell = "";
+ for (let j2 = 0; j2 < token2.header.length; j2++) {
+ cell += this.tablecell(token2.header[j2]);
+ }
+ header += this.tablerow({ text: cell });
+ let body = "";
+ for (let j2 = 0; j2 < token2.rows.length; j2++) {
+ const row = token2.rows[j2];
+ cell = "";
+ for (let k2 = 0; k2 < row.length; k2++) {
+ cell += this.tablecell(row[k2]);
+ }
+ body += this.tablerow({ text: cell });
+ }
+ if (body)
+ body = `${body}`;
+ return "