marked 13.0.3 → 14.1.0

package/lib/marked.esm.js

@@ -1,5 +1,5 @@
 /**
- * marked v13.0.3 - a markdown parser
+ * marked v14.1.0 - a markdown parser
  * Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -59,21 +59,6 @@ function escape$1(html, encode) {
     }
     return html;
 }
-const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
-function unescape(html) {
-    // explicitly match decimal, hex, and named HTML entities
-    return html.replace(unescapeTest, (_, n) => {
-        n = n.toLowerCase();
-        if (n === 'colon')
-            return ':';
-        if (n.charAt(0) === '#') {
-            return n.charAt(1) === 'x'
-                ? String.fromCharCode(parseInt(n.substring(2), 16))
-                : String.fromCharCode(+n.substring(1));
-        }
-        return '';
-    });
-}
 const caret = /(^|[^\[])\^/g;
 function edit(regex, opt) {
     let source = typeof regex === 'string' ? regex : regex.source;
@@ -2091,6 +2076,7 @@ class _Parser {
 
 class _Hooks {
     options;
+    block;
     constructor(options) {
         this.options = options || _defaults;
     }
@@ -2117,13 +2103,25 @@ class _Hooks {
     processAllTokens(tokens) {
         return tokens;
     }
+    /**
+     * Provide function to tokenize markdown
+     */
+    provideLexer() {
+        return this.block ? _Lexer.lex : _Lexer.lexInline;
+    }
+    /**
+     * Provide function to parse tokens
+     */
+    provideParser() {
+        return this.block ? _Parser.parse : _Parser.parseInline;
+    }
 }
 
 class Marked {
     defaults = _getDefaults();
     options = this.setOptions;
-    parse = this.#parseMarkdown(_Lexer.lex, _Parser.parse);
-    parseInline = this.#parseMarkdown(_Lexer.lexInline, _Parser.parseInline);
+    parse = this.parseMarkdown(true);
+    parseInline = this.parseMarkdown(false);
     Parser = _Parser;
     Renderer = _Renderer;
     TextRenderer = _TextRenderer;
@@ -2251,11 +2249,7 @@ class Marked {
                         continue;
                     }
                     const rendererProp = prop;
-                    let rendererFunc = pack.renderer[rendererProp];
-                    if (!pack.useNewRenderer) {
-                        // TODO: Remove this in next major version
-                        rendererFunc = this.#convertRendererFunction(rendererFunc, rendererProp, renderer);
-                    }
+                    const rendererFunc = pack.renderer[rendererProp];
                     const prevRenderer = renderer[rendererProp];
                     // Replace renderer with func to run extension, but fall back if false
                     renderer[rendererProp] = (...args) => {
@@ -2300,8 +2294,8 @@ class Marked {
                     if (!(prop in hooks)) {
                         throw new Error(`hook '${prop}' does not exist`);
                     }
-                    if (prop === 'options') {
-                        // ignore options property
+                    if (['options', 'block'].includes(prop)) {
+                        // ignore options and block properties
                         continue;
                     }
                     const hooksProp = prop;
@@ -2349,215 +2343,6 @@ class Marked {
         });
         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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, 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.call(this, token.text);
-                };
-            // do nothing
-        }
-        return func;
-    }
     setOptions(opt) {
         this.defaults = { ...this.defaults, ...opt };
         return this;
@@ -2568,18 +2353,16 @@ class Marked {
     parser(tokens, options) {
         return _Parser.parse(tokens, options ?? this.defaults);
     }
-    #parseMarkdown(lexer, parser) {
-        return (src, options) => {
+    parseMarkdown(blockType) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const parse = (src, options) => {
             const origOpt = { ...options };
             const opt = { ...this.defaults, ...origOpt };
-            // Show warning if an extension set async to true but the parse was called with async: false
+            const throwError = this.onError(!!opt.silent, !!opt.async);
+            // throw error if an extension set async to true but parse was called with async: false
             if (this.defaults.async === true && origOpt.async === false) {
-                if (!opt.silent) {
-                    console.warn('marked(): The async option was set to true by an extension. The async: false option sent to parse will be ignored.');
-                }
-                opt.async = true;
+                return throwError(new Error('marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise.'));
             }
-            const throwError = this.#onError(!!opt.silent, !!opt.async);
             // throw error in case of non string input
             if (typeof src === 'undefined' || src === null) {
                 return throwError(new Error('marked(): input parameter is undefined or null'));
@@ -2590,7 +2373,10 @@ class Marked {
             }
             if (opt.hooks) {
                 opt.hooks.options = opt;
+                opt.hooks.block = blockType;
             }
+            const lexer = opt.hooks ? opt.hooks.provideLexer() : (blockType ? _Lexer.lex : _Lexer.lexInline);
+            const parser = opt.hooks ? opt.hooks.provideParser() : (blockType ? _Parser.parse : _Parser.parseInline);
             if (opt.async) {
                 return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
                     .then(src => lexer(src, opt))
@@ -2621,8 +2407,9 @@ class Marked {
                 return throwError(e);
             }
         };
+        return parse;
     }
-    #onError(silent, async) {
+    onError(silent, async) {
         return (e) => {
             e.message += '\nPlease report this to https://github.com/markedjs/marked.';
             if (silent) {