marked 12.0.1 → 13.0.0

package/lib/marked.umd.js

@@ -1,5 +1,5 @@
 /**
- * marked v12.0.1 - a markdown parser
+ * marked v13.0.0 - a markdown parser
  * Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -321,21 +321,82 @@
             if (cap) {
                 return {
                     type: 'hr',
-                    raw: cap[0]
+                    raw: rtrim(cap[0], '\n')
                 };
             }
         }
         blockquote(src) {
             const cap = this.rules.block.blockquote.exec(src);
             if (cap) {
-                const text = rtrim(cap[0].replace(/^ *>[ \t]?/gm, ''), '\n');
-                const top = this.lexer.state.top;
-                this.lexer.state.top = true;
-                const tokens = this.lexer.blockTokens(text);
-                this.lexer.state.top = top;
+                let lines = rtrim(cap[0], '\n').split('\n');
+                let raw = '';
+                let text = '';
+                const tokens = [];
+                while (lines.length > 0) {
+                    let inBlockquote = false;
+                    const currentLines = [];
+                    let i;
+                    for (i = 0; i < lines.length; i++) {
+                        // get lines up to a continuation
+                        if (/^ {0,3}>/.test(lines[i])) {
+                            currentLines.push(lines[i]);
+                            inBlockquote = true;
+                        }
+                        else if (!inBlockquote) {
+                            currentLines.push(lines[i]);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    lines = lines.slice(i);
+                    const currentRaw = currentLines.join('\n');
+                    const currentText = currentRaw
+                        // precede setext continuation with 4 spaces so it isn't a setext
+                        .replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, '\n    $1')
+                        .replace(/^ {0,3}>[ \t]?/gm, '');
+                    raw = raw ? `${raw}\n${currentRaw}` : currentRaw;
+                    text = text ? `${text}\n${currentText}` : currentText;
+                    // parse blockquote lines as top level tokens
+                    // merge paragraphs if this is a continuation
+                    const top = this.lexer.state.top;
+                    this.lexer.state.top = true;
+                    this.lexer.blockTokens(currentText, tokens, true);
+                    this.lexer.state.top = top;
+                    // if there is no continuation then we are done
+                    if (lines.length === 0) {
+                        break;
+                    }
+                    const lastToken = tokens[tokens.length - 1];
+                    if (lastToken?.type === 'code') {
+                        // blockquote continuation cannot be preceded by a code block
+                        break;
+                    }
+                    else if (lastToken?.type === 'blockquote') {
+                        // include continuation in nested blockquote
+                        const oldToken = lastToken;
+                        const newText = oldToken.raw + '\n' + lines.join('\n');
+                        const newToken = this.blockquote(newText);
+                        tokens[tokens.length - 1] = newToken;
+                        raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;
+                        text = text.substring(0, text.length - oldToken.text.length) + newToken.text;
+                        break;
+                    }
+                    else if (lastToken?.type === 'list') {
+                        // include continuation in nested list
+                        const oldToken = lastToken;
+                        const newText = oldToken.raw + '\n' + lines.join('\n');
+                        const newToken = this.list(newText);
+                        tokens[tokens.length - 1] = newToken;
+                        raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;
+                        text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;
+                        lines = newText.substring(tokens[tokens.length - 1].raw.length).split('\n');
+                        continue;
+                    }
+                }
                 return {
                     type: 'blockquote',
-                    raw: cap[0],
+                    raw,
                     tokens,
                     text
                 };
@@ -572,17 +633,21 @@
                     item.align.push(null);
                 }
             }
-            for (const header of headers) {
+            for (let i = 0; i < headers.length; i++) {
                 item.header.push({
-                    text: header,
-                    tokens: this.lexer.inline(header)
+                    text: headers[i],
+                    tokens: this.lexer.inline(headers[i]),
+                    header: true,
+                    align: item.align[i]
                 });
             }
             for (const row of rows) {
-                item.rows.push(splitCells(row, item.header.length).map(cell => {
+                item.rows.push(splitCells(row, item.header.length).map((cell, i) => {
                     return {
                         text: cell,
-                        tokens: this.lexer.inline(cell)
+                        tokens: this.lexer.inline(cell),
+                        header: false,
+                        align: item.align[i]
                     };
                 }));
             }
@@ -964,7 +1029,7 @@
     const paragraph = edit(_paragraph)
         .replace('hr', hr)
         .replace('heading', ' {0,3}#{1,6}(?:\\s|$)')
-        .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+        .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
         .replace('|table', '')
         .replace('blockquote', ' {0,3}>')
         .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
@@ -1014,7 +1079,7 @@
         paragraph: edit(_paragraph)
             .replace('hr', hr)
             .replace('heading', ' {0,3}#{1,6}(?:\\s|$)')
-            .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+            .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
             .replace('table', gfmTable) // interrupt paragraphs with table
             .replace('blockquote', ' {0,3}>')
             .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
@@ -1278,7 +1343,7 @@
             this.inlineQueue = [];
             return this.tokens;
         }
-        blockTokens(src, tokens = []) {
+        blockTokens(src, tokens = [], lastParagraphClipped = false) {
             if (this.options.pedantic) {
                 src = src.replace(/\t/g, '    ').replace(/^ +$/gm, '');
             }
@@ -1290,7 +1355,6 @@
             let token;
             let lastToken;
             let cutSrc;
-            let lastParagraphClipped;
             while (src) {
                 if (this.options.extensions
                     && this.options.extensions.block
@@ -1416,7 +1480,7 @@
                 }
                 if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
                     lastToken = tokens[tokens.length - 1];
-                    if (lastParagraphClipped && lastToken.type === 'paragraph') {
+                    if (lastParagraphClipped && lastToken?.type === 'paragraph') {
                         lastToken.raw += '\n' + token.raw;
                         lastToken.text += '\n' + token.text;
                         this.inlineQueue.pop();
@@ -1635,53 +1699,103 @@
      */
     class _Renderer {
         options;
+        parser; // set by the parser
         constructor(options) {
             this.options = options || exports.defaults;
         }
-        code(code, infostring, escaped) {
-            const lang = (infostring || '').match(/^\S*/)?.[0];
-            code = code.replace(/\n$/, '') + '\n';
-            if (!lang) {
+        space(token) {
+            return '';
+        }
+        code({ text, lang, escaped }) {
+            const langString = (lang || '').match(/^\S*/)?.[0];
+            const code = text.replace(/\n$/, '') + '\n';
+            if (!langString) {
                 return '<pre><code>'
                     + (escaped ? code : escape$1(code, true))
                     + '</code></pre>\n';
             }
             return '<pre><code class="language-'
-                + escape$1(lang)
+                + escape$1(langString)
                 + '">'
                 + (escaped ? code : escape$1(code, true))
                 + '</code></pre>\n';
         }
-        blockquote(quote) {
-            return `<blockquote>\n${quote}</blockquote>\n`;
+        blockquote({ tokens }) {
+            const body = this.parser.parse(tokens);
+            return `<blockquote>\n${body}</blockquote>\n`;
         }
-        html(html, block) {
-            return html;
+        html({ text }) {
+            return text;
         }
-        heading(text, level, raw) {
-            // ignore IDs
-            return `<h${level}>${text}</h${level}>\n`;
+        heading({ tokens, depth }) {
+            return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>\n`;
         }
-        hr() {
+        hr(token) {
             return '<hr>\n';
         }
-        list(body, ordered, start) {
+        list(token) {
+            const ordered = token.ordered;
+            const start = token.start;
+            let body = '';
+            for (let j = 0; j < token.items.length; j++) {
+                const item = token.items[j];
+                body += this.listitem(item);
+            }
             const type = ordered ? 'ol' : 'ul';
-            const startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
-            return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
-        }
-        listitem(text, task, checked) {
-            return `<li>${text}</li>\n`;
+            const startAttr = (ordered && start !== 1) ? (' start="' + start + '"') : '';
+            return '<' + type + startAttr + '>\n' + body + '</' + type + '>\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 + ' ';
+                }
+            }
+            itemBody += this.parser.parse(item.tokens, !!item.loose);
+            return `<li>${itemBody}</li>\n`;
         }
-        checkbox(checked) {
+        checkbox({ checked }) {
             return '<input '
                 + (checked ? 'checked="" ' : '')
                 + 'disabled="" type="checkbox">';
         }
-        paragraph(text) {
-            return `<p>${text}</p>\n`;
+        paragraph({ tokens }) {
+            return `<p>${this.parser.parseInline(tokens)}</p>\n`;
         }
-        table(header, body) {
+        table(token) {
+            let header = '';
+            // header
+            let cell = '';
+            for (let j = 0; j < token.header.length; j++) {
+                cell += this.tablecell(token.header[j]);
+            }
+            header += this.tablerow({ text: cell });
+            let body = '';
+            for (let j = 0; j < token.rows.length; j++) {
+                const row = token.rows[j];
+                cell = '';
+                for (let k = 0; k < row.length; k++) {
+                    cell += this.tablecell(row[k]);
+                }
+                body += this.tablerow({ text: cell });
+            }
             if (body)
                 body = `<tbody>${body}</tbody>`;
             return '<table>\n'
@@ -1691,35 +1805,37 @@
                 + body
                 + '</table>\n';
         }
-        tablerow(content) {
-            return `<tr>\n${content}</tr>\n`;
+        tablerow({ text }) {
+            return `<tr>\n${text}</tr>\n`;
         }
-        tablecell(content, flags) {
-            const type = flags.header ? 'th' : 'td';
-            const tag = flags.align
-                ? `<${type} align="${flags.align}">`
+        tablecell(token) {
+            const content = this.parser.parseInline(token.tokens);
+            const type = token.header ? 'th' : 'td';
+            const tag = token.align
+                ? `<${type} align="${token.align}">`
                 : `<${type}>`;
             return tag + content + `</${type}>\n`;
         }
         /**
          * span level renderer
          */
-        strong(text) {
-            return `<strong>${text}</strong>`;
+        strong({ tokens }) {
+            return `<strong>${this.parser.parseInline(tokens)}</strong>`;
         }
-        em(text) {
-            return `<em>${text}</em>`;
+        em({ tokens }) {
+            return `<em>${this.parser.parseInline(tokens)}</em>`;
         }
-        codespan(text) {
+        codespan({ text }) {
             return `<code>${text}</code>`;
         }
-        br() {
+        br(token) {
             return '<br>';
         }
-        del(text) {
-            return `<del>${text}</del>`;
+        del({ tokens }) {
+            return `<del>${this.parser.parseInline(tokens)}</del>`;
         }
-        link(href, title, text) {
+        link({ href, title, tokens }) {
+            const text = this.parser.parseInline(tokens);
             const cleanHref = cleanUrl(href);
             if (cleanHref === null) {
                 return text;
@@ -1732,7 +1848,7 @@
             out += '>' + text + '</a>';
             return out;
         }
-        image(href, title, text) {
+        image({ href, title, text }) {
             const cleanHref = cleanUrl(href);
             if (cleanHref === null) {
                 return text;
@@ -1745,8 +1861,8 @@
             out += '>';
             return out;
         }
-        text(text) {
-            return text;
+        text(token) {
+            return 'tokens' in token && token.tokens ? this.parser.parseInline(token.tokens) : token.text;
         }
     }
 
@@ -1756,28 +1872,28 @@
      */
     class _TextRenderer {
         // no need for block level renderers
-        strong(text) {
+        strong({ text }) {
             return text;
         }
-        em(text) {
+        em({ text }) {
             return text;
         }
-        codespan(text) {
+        codespan({ text }) {
             return text;
         }
-        del(text) {
+        del({ text }) {
             return text;
         }
-        html(text) {
+        html({ text }) {
             return text;
         }
-        text(text) {
+        text({ text }) {
             return text;
         }
-        link(href, title, text) {
+        link({ text }) {
             return '' + text;
         }
-        image(href, title, text) {
+        image({ text }) {
             return '' + text;
         }
         br() {
@@ -1797,6 +1913,7 @@
             this.options.renderer = this.options.renderer || new _Renderer();
             this.renderer = this.options.renderer;
             this.renderer.options = this.options;
+            this.renderer.parser = this;
             this.textRenderer = new _TextRenderer();
         }
         /**
@@ -1819,116 +1936,72 @@
         parse(tokens, top = true) {
             let out = '';
             for (let i = 0; i < tokens.length; i++) {
-                const token = tokens[i];
+                const anyToken = tokens[i];
                 // Run any renderer extensions
-                if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-                    const genericToken = token;
+                if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {
+                    const genericToken = anyToken;
                     const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
                     if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(genericToken.type)) {
                         out += ret || '';
                         continue;
                     }
                 }
+                const token = anyToken;
                 switch (token.type) {
                     case 'space': {
+                        out += this.renderer.space(token);
                         continue;
                     }
                     case 'hr': {
-                        out += this.renderer.hr();
+                        out += this.renderer.hr(token);
                         continue;
                     }
                     case 'heading': {
-                        const headingToken = token;
-                        out += this.renderer.heading(this.parseInline(headingToken.tokens), headingToken.depth, unescape(this.parseInline(headingToken.tokens, this.textRenderer)));
+                        out += this.renderer.heading(token);
                         continue;
                     }
                     case 'code': {
-                        const codeToken = token;
-                        out += this.renderer.code(codeToken.text, codeToken.lang, !!codeToken.escaped);
+                        out += this.renderer.code(token);
                         continue;
                     }
                     case 'table': {
-                        const tableToken = token;
-                        let header = '';
-                        // header
-                        let cell = '';
-                        for (let j = 0; j < tableToken.header.length; j++) {
-                            cell += this.renderer.tablecell(this.parseInline(tableToken.header[j].tokens), { header: true, align: tableToken.align[j] });
-                        }
-                        header += this.renderer.tablerow(cell);
-                        let body = '';
-                        for (let j = 0; j < tableToken.rows.length; j++) {
-                            const row = tableToken.rows[j];
-                            cell = '';
-                            for (let k = 0; k < row.length; k++) {
-                                cell += this.renderer.tablecell(this.parseInline(row[k].tokens), { header: false, align: tableToken.align[k] });
-                            }
-                            body += this.renderer.tablerow(cell);
-                        }
-                        out += this.renderer.table(header, body);
+                        out += this.renderer.table(token);
                         continue;
                     }
                     case 'blockquote': {
-                        const blockquoteToken = token;
-                        const body = this.parse(blockquoteToken.tokens);
-                        out += this.renderer.blockquote(body);
+                        out += this.renderer.blockquote(token);
                         continue;
                     }
                     case 'list': {
-                        const listToken = token;
-                        const ordered = listToken.ordered;
-                        const start = listToken.start;
-                        const loose = listToken.loose;
-                        let body = '';
-                        for (let j = 0; j < listToken.items.length; j++) {
-                            const item = listToken.items[j];
-                            const checked = item.checked;
-                            const task = item.task;
-                            let itemBody = '';
-                            if (item.task) {
-                                const checkbox = this.renderer.checkbox(!!checked);
-                                if (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',
-                                            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);
+                        out += this.renderer.list(token);
                         continue;
                     }
                     case 'html': {
-                        const htmlToken = token;
-                        out += this.renderer.html(htmlToken.text, htmlToken.block);
+                        out += this.renderer.html(token);
                         continue;
                     }
                     case 'paragraph': {
-                        const paragraphToken = token;
-                        out += this.renderer.paragraph(this.parseInline(paragraphToken.tokens));
+                        out += this.renderer.paragraph(token);
                         continue;
                     }
                     case 'text': {
                         let textToken = token;
-                        let body = textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text;
+                        let body = this.renderer.text(textToken);
                         while (i + 1 < tokens.length && tokens[i + 1].type === 'text') {
                             textToken = tokens[++i];
-                            body += '\n' + (textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text);
+                            body += '\n' + this.renderer.text(textToken);
+                        }
+                        if (top) {
+                            out += this.renderer.paragraph({
+                                type: 'paragraph',
+                                raw: body,
+                                text: body,
+                                tokens: [{ type: 'text', raw: body, text: body }]
+                            });
+                        }
+                        else {
+                            out += body;
                         }
-                        out += top ? this.renderer.paragraph(body) : body;
                         continue;
                     }
                     default: {
@@ -1952,63 +2025,55 @@
             renderer = renderer || this.renderer;
             let out = '';
             for (let i = 0; i < tokens.length; i++) {
-                const token = tokens[i];
+                const anyToken = tokens[i];
                 // Run any renderer extensions
-                if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-                    const ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
-                    if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
+                if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {
+                    const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);
+                    if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(anyToken.type)) {
                         out += ret || '';
                         continue;
                     }
                 }
+                const token = anyToken;
                 switch (token.type) {
                     case 'escape': {
-                        const escapeToken = token;
-                        out += renderer.text(escapeToken.text);
+                        out += renderer.text(token);
                         break;
                     }
                     case 'html': {
-                        const tagToken = token;
-                        out += renderer.html(tagToken.text);
+                        out += renderer.html(token);
                         break;
                     }
                     case 'link': {
-                        const linkToken = token;
-                        out += renderer.link(linkToken.href, linkToken.title, this.parseInline(linkToken.tokens, renderer));
+                        out += renderer.link(token);
                         break;
                     }
                     case 'image': {
-                        const imageToken = token;
-                        out += renderer.image(imageToken.href, imageToken.title, imageToken.text);
+                        out += renderer.image(token);
                         break;
                     }
                     case 'strong': {
-                        const strongToken = token;
-                        out += renderer.strong(this.parseInline(strongToken.tokens, renderer));
+                        out += renderer.strong(token);
                         break;
                     }
                     case 'em': {
-                        const emToken = token;
-                        out += renderer.em(this.parseInline(emToken.tokens, renderer));
+                        out += renderer.em(token);
                         break;
                     }
                     case 'codespan': {
-                        const codespanToken = token;
-                        out += renderer.codespan(codespanToken.text);
+                        out += renderer.codespan(token);
                         break;
                     }
                     case 'br': {
-                        out += renderer.br();
+                        out += renderer.br(token);
                         break;
                     }
                     case 'del': {
-                        const delToken = token;
-                        out += renderer.del(this.parseInline(delToken.tokens, renderer));
+                        out += renderer.del(token);
                         break;
                     }
                     case 'text': {
-                        const textToken = token;
-                        out += renderer.text(textToken.text);
+                        out += renderer.text(token);
                         break;
                     }
                     default: {
@@ -2184,15 +2249,19 @@
                         if (!(prop in renderer)) {
                             throw new Error(`renderer '${prop}' does not exist`);
                         }
-                        if (prop === 'options') {
+                        if (['options', 'parser'].includes(prop)) {
                             // ignore options property
                             continue;
                         }
                         const rendererProp = prop;
-                        const rendererFunc = pack.renderer[rendererProp];
+                        let rendererFunc = pack.renderer[rendererProp];
                         const prevRenderer = renderer[rendererProp];
                         // Replace renderer with func to run extension, but fall back if false
                         renderer[rendererProp] = (...args) => {
+                            if (!pack.useNewRenderer) {
+                                // TODO: Remove this in next major version
+                                rendererFunc = this.#convertRendererFunction(rendererFunc, rendererProp, renderer);
+                            }
                             let ret = rendererFunc.apply(renderer, args);
                             if (ret === false) {
                                 ret = prevRenderer.apply(renderer, args);
@@ -2283,6 +2352,215 @@
             });
             return this;
         }
+        // TODO: Remove this in next major release
+        #convertRendererFunction(func, prop, renderer) {
+            switch (prop) {
+                case 'heading':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(renderer.parser.parseInline(token.tokens), token.depth, unescape(renderer.parser.parseInline(token.tokens, renderer.parser.textRenderer)));
+                    };
+                case 'code':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(token.text, token.lang, !!token.escaped);
+                    };
+                case 'table':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        let header = '';
+                        // header
+                        let cell = '';
+                        for (let j = 0; j < token.header.length; j++) {
+                            cell += this.tablecell({
+                                text: token.header[j].text,
+                                tokens: token.header[j].tokens,
+                                header: true,
+                                align: token.align[j]
+                            });
+                        }
+                        header += this.tablerow({ text: cell });
+                        let body = '';
+                        for (let j = 0; j < token.rows.length; j++) {
+                            const row = token.rows[j];
+                            cell = '';
+                            for (let k = 0; k < row.length; k++) {
+                                cell += this.tablecell({
+                                    text: row[k].text,
+                                    tokens: row[k].tokens,
+                                    header: false,
+                                    align: token.align[k]
+                                });
+                            }
+                            body += this.tablerow({ text: cell });
+                        }
+                        return func(header, body);
+                    };
+                case 'blockquote':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        const body = this.parser.parse(token.tokens);
+                        return func(body);
+                    };
+                case 'list':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        const ordered = token.ordered;
+                        const start = token.start;
+                        const loose = token.loose;
+                        let body = '';
+                        for (let j = 0; j < token.items.length; j++) {
+                            const item = token.items[j];
+                            const checked = item.checked;
+                            const task = item.task;
+                            let itemBody = '';
+                            if (item.task) {
+                                const checkbox = this.checkbox({ checked: !!checked });
+                                if (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',
+                                            text: checkbox + ' '
+                                        });
+                                    }
+                                }
+                                else {
+                                    itemBody += checkbox + ' ';
+                                }
+                            }
+                            itemBody += this.parser.parse(item.tokens, loose);
+                            body += this.listitem({
+                                type: 'list_item',
+                                raw: itemBody,
+                                text: itemBody,
+                                task,
+                                checked: !!checked,
+                                loose,
+                                tokens: item.tokens
+                            });
+                        }
+                        return func(body, ordered, start);
+                    };
+                case 'html':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(token.text, token.block);
+                    };
+                case 'paragraph':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(this.parser.parseInline(token.tokens));
+                    };
+                case 'escape':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(token.text);
+                    };
+                case 'link':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(token.href, token.title, this.parser.parseInline(token.tokens));
+                    };
+                case 'image':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(token.href, token.title, token.text);
+                    };
+                case 'strong':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(this.parser.parseInline(token.tokens));
+                    };
+                case 'em':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(this.parser.parseInline(token.tokens));
+                    };
+                case 'codespan':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(token.text);
+                    };
+                case 'del':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(this.parser.parseInline(token.tokens));
+                    };
+                case 'text':
+                    return function (token) {
+                        if (!token.type || token.type !== prop) {
+                            // @ts-ignore
+                            // eslint-disable-next-line prefer-rest-params
+                            return func.apply(this, arguments);
+                        }
+                        return func(token.text);
+                    };
+                // do nothing
+            }
+            return func;
+        }
         setOptions(opt) {
             this.defaults = { ...this.defaults, ...opt };
             return this;