marked 5.0.4 → 5.1.0

package/lib/marked.esm.js

@@ -1,5 +1,5 @@
 /**
- * marked v5.0.4 - a markdown parser
+ * marked v5.1.0 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -919,7 +919,7 @@ class Tokenizer {
 
     const nextChar = match[1] || match[2] || '';
 
-    if (!nextChar || (nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
+    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
       const lLength = match[0].length - 1;
       let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
 
@@ -953,7 +953,7 @@ class Tokenizer {
         // Remove extra characters. *a*** -> *a*
         rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
 
-        const raw = src.slice(0, lLength + match.index + (match[0].length - rDelim.length) + rLength);
+        const raw = src.slice(0, lLength + match.index + rLength + 1);
 
         // Create `em` if smallest delimiter has odd char count. *a***
         if (Math.min(lLength, rLength) % 2) {
@@ -1270,46 +1270,49 @@ const inline = {
   nolink: /^!?\[(ref)\](?:\[\])?/,
   reflinkSearch: 'reflink|nolink(?!\\()',
   emStrong: {
-    lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
-    //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
-    //          () Skip orphan inside strong                                      () Consume to delim     (1) #***                (2) a***#, a***                             (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
-    rDelimAst: /^(?:[^_*\\]|\\.)*?\_\_(?:[^_*\\]|\\.)*?\*(?:[^_*\\]|\\.)*?(?=\_\_)|(?:[^*\\]|\\.)+(?=[^*])|[punct_](\*+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|(?:[^punct*_\s\\]|\\.)(\*+)(?=[^punct*_\s])/,
-    rDelimUnd: /^(?:[^_*\\]|\\.)*?\*\*(?:[^_*\\]|\\.)*?\_(?:[^_*\\]|\\.)*?(?=\*\*)|(?:[^_\\]|\\.)+(?=[^_])|[punct*](\_+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
+    lDelim: /^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/,
+    //         (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
+    //         | Skip orphan inside strong      | Consume to delim | (1) #***              | (2) a***#, a***                    | (3) #***a, ***a                  | (4) ***#                 | (5) #***#                         | (6) a***a
+    rDelimAst: /^[^_*]*?__[^_*]*?\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\*)[punct](\*+)(?=[\s]|$)|[^punct\s](\*+)(?!\*)(?=[punct\s]|$)|(?!\*)[punct\s](\*+)(?=[^punct\s])|[\s](\*+)(?!\*)(?=[punct])|(?!\*)[punct](\*+)(?!\*)(?=[punct])|[^punct\s](\*+)(?=[^punct\s])/,
+    rDelimUnd: /^[^_*]*?\*\*[^_*]*?_[^_*]*?(?=\*\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\s]|$)|[^punct\s](_+)(?!_)(?=[punct\s]|$)|(?!_)[punct\s](_+)(?=[^punct\s])|[\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])/ // ^- Not allowed for _
   },
   code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
   br: /^( {2,}|\\)\n(?!\s*$)/,
   del: noopTest,
   text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
-  punctuation: /^([\spunctuation])/
+  punctuation: /^((?![*_])[\spunctuation])/
 };
 
-// list of punctuation marks from CommonMark spec
-// without * and _ to handle the different emphasis markers * and _
-inline._uc_punctuation = '\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u0AF0\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166D\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E42\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65';
-inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~' + inline._uc_punctuation;
-inline.punctuation = edit(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
+// list of unicode punctuation marks, plus any missing characters from CommonMark spec
+inline._punctuation = '\\p{P}$+<=>`^|~';
+inline.punctuation = edit(inline.punctuation, 'u').replace(/punctuation/g, inline._punctuation).getRegex();
 
 // sequences em should skip over [title](link), `code`, <html>
 inline.blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
-// lookbehind is not available on Safari as of version 16
-// inline.escapedEmSt = /(?<=(?:^|[^\\)(?:\\[^])*)\\[*_]/g;
-inline.escapedEmSt = /(?:^|[^\\])(?:\\\\)*\\[*_]/g;
+inline.anyPunctuation = /\\[punct]/g;
+inline._escapes = /\\([punct])/g;
 
 inline._comment = edit(block._comment).replace('(?:-->|$)', '-->').getRegex();
 
-inline.emStrong.lDelim = edit(inline.emStrong.lDelim)
+inline.emStrong.lDelim = edit(inline.emStrong.lDelim, 'u')
   .replace(/punct/g, inline._punctuation)
   .getRegex();
 
-inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'g')
+inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'gu')
   .replace(/punct/g, inline._punctuation)
   .getRegex();
 
-inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'g')
+inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'gu')
   .replace(/punct/g, inline._punctuation)
   .getRegex();
 
-inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
+inline.anyPunctuation = edit(inline.anyPunctuation, 'gu')
+  .replace(/punct/g, inline._punctuation)
+  .getRegex();
+
+inline._escapes = edit(inline._escapes, 'gu')
+  .replace(/punct/g, inline._punctuation)
+  .getRegex();
 
 inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
 inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
@@ -1756,10 +1759,9 @@ class Lexer {
       maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
     }
 
-    // Mask out escaped em & strong delimiters
-    while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
-      maskedSrc = maskedSrc.slice(0, match.index + match[0].length - 2) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
-      this.tokenizer.rules.inline.escapedEmSt.lastIndex--;
+    // Mask out escaped characters
+    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
     }
 
     while (src) {
@@ -2510,169 +2512,375 @@ class Hooks {
   }
 }
 
-function onError(silent, async, callback) {
-  return (e) => {
-    e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+class Marked {
+  defaults = getDefaults();
+  options = this.setOptions;
 
-    if (silent) {
-      const msg = '<p>An error occurred:</p><pre>'
-        + escape(e.message + '', true)
-        + '</pre>';
-      if (async) {
-        return Promise.resolve(msg);
-      }
-      if (callback) {
-        callback(null, msg);
-        return;
-      }
-      return msg;
-    }
+  parse = this.#parseMarkdown(Lexer.lex, Parser.parse);
+  parseInline = this.#parseMarkdown(Lexer.lexInline, Parser.parseInline);
 
-    if (async) {
-      return Promise.reject(e);
-    }
-    if (callback) {
-      callback(e);
-      return;
-    }
-    throw e;
-  };
-}
-
-function parseMarkdown(lexer, parser) {
-  return (src, opt, callback) => {
-    if (typeof opt === 'function') {
-      callback = opt;
-      opt = null;
-    }
+  Parser = Parser;
+  parser = Parser.parse;
+  Renderer = Renderer;
+  TextRenderer = TextRenderer;
+  Lexer = Lexer;
+  lexer = Lexer.lex;
+  Tokenizer = Tokenizer;
+  Slugger = Slugger;
+  Hooks = Hooks;
 
-    const origOpt = { ...opt };
-    opt = { ...marked.defaults, ...origOpt };
-    const throwError = onError(opt.silent, opt.async, callback);
+  constructor(...args) {
+    this.use(...args);
+  }
 
-    // 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'));
-    }
-    if (typeof src !== 'string') {
-      return throwError(new Error('marked(): input parameter is of type '
-        + Object.prototype.toString.call(src) + ', string expected'));
+  walkTokens(tokens, callback) {
+    let values = [];
+    for (const token of tokens) {
+      values = values.concat(callback.call(this, token));
+      switch (token.type) {
+        case 'table': {
+          for (const cell of token.header) {
+            values = values.concat(this.walkTokens(cell.tokens, callback));
+          }
+          for (const row of token.rows) {
+            for (const cell of row) {
+              values = values.concat(this.walkTokens(cell.tokens, callback));
+            }
+          }
+          break;
+        }
+        case 'list': {
+          values = values.concat(this.walkTokens(token.items, callback));
+          break;
+        }
+        default: {
+          if (this.defaults.extensions && this.defaults.extensions.childTokens && this.defaults.extensions.childTokens[token.type]) { // Walk any extensions
+            this.defaults.extensions.childTokens[token.type].forEach((childTokens) => {
+              values = values.concat(this.walkTokens(token[childTokens], callback));
+            });
+          } else if (token.tokens) {
+            values = values.concat(this.walkTokens(token.tokens, callback));
+          }
+        }
+      }
     }
+    return values;
+  }
 
-    checkDeprecations(opt, callback);
+  use(...args) {
+    const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
 
-    if (opt.hooks) {
-      opt.hooks.options = opt;
-    }
+    args.forEach((pack) => {
+      // copy options to new object
+      const opts = { ...pack };
 
-    if (callback) {
-      const highlight = opt.highlight;
-      let tokens;
+      // set async to true if it was set to true before
+      opts.async = this.defaults.async || opts.async || false;
 
-      try {
-        if (opt.hooks) {
-          src = opt.hooks.preprocess(src);
-        }
-        tokens = lexer(src, opt);
-      } catch (e) {
-        return throwError(e);
+      // ==-- Parse "addon" extensions --== //
+      if (pack.extensions) {
+        pack.extensions.forEach((ext) => {
+          if (!ext.name) {
+            throw new Error('extension name required');
+          }
+          if (ext.renderer) { // Renderer extensions
+            const prevRenderer = extensions.renderers[ext.name];
+            if (prevRenderer) {
+              // Replace extension with func to run new extension but fall back if false
+              extensions.renderers[ext.name] = function(...args) {
+                let ret = ext.renderer.apply(this, args);
+                if (ret === false) {
+                  ret = prevRenderer.apply(this, args);
+                }
+                return ret;
+              };
+            } else {
+              extensions.renderers[ext.name] = ext.renderer;
+            }
+          }
+          if (ext.tokenizer) { // Tokenizer Extensions
+            if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {
+              throw new Error("extension level must be 'block' or 'inline'");
+            }
+            if (extensions[ext.level]) {
+              extensions[ext.level].unshift(ext.tokenizer);
+            } else {
+              extensions[ext.level] = [ext.tokenizer];
+            }
+            if (ext.start) { // Function to check for start of token
+              if (ext.level === 'block') {
+                if (extensions.startBlock) {
+                  extensions.startBlock.push(ext.start);
+                } else {
+                  extensions.startBlock = [ext.start];
+                }
+              } else if (ext.level === 'inline') {
+                if (extensions.startInline) {
+                  extensions.startInline.push(ext.start);
+                } else {
+                  extensions.startInline = [ext.start];
+                }
+              }
+            }
+          }
+          if (ext.childTokens) { // Child tokens to be visited by walkTokens
+            extensions.childTokens[ext.name] = ext.childTokens;
+          }
+        });
+        opts.extensions = extensions;
       }
 
-      const done = function(err) {
-        let out;
-
-        if (!err) {
-          try {
-            if (opt.walkTokens) {
-              marked.walkTokens(tokens, opt.walkTokens);
+      // ==-- Parse "overwrite" extensions --== //
+      if (pack.renderer) {
+        const renderer = this.defaults.renderer || new Renderer(this.defaults);
+        for (const prop in pack.renderer) {
+          const prevRenderer = renderer[prop];
+          // Replace renderer with func to run extension, but fall back if false
+          renderer[prop] = (...args) => {
+            let ret = pack.renderer[prop].apply(renderer, args);
+            if (ret === false) {
+              ret = prevRenderer.apply(renderer, args);
             }
-            out = parser(tokens, opt);
-            if (opt.hooks) {
-              out = opt.hooks.postprocess(out);
+            return ret;
+          };
+        }
+        opts.renderer = renderer;
+      }
+      if (pack.tokenizer) {
+        const tokenizer = this.defaults.tokenizer || new Tokenizer(this.defaults);
+        for (const prop in pack.tokenizer) {
+          const prevTokenizer = tokenizer[prop];
+          // Replace tokenizer with func to run extension, but fall back if false
+          tokenizer[prop] = (...args) => {
+            let ret = pack.tokenizer[prop].apply(tokenizer, args);
+            if (ret === false) {
+              ret = prevTokenizer.apply(tokenizer, args);
             }
-          } catch (e) {
-            err = e;
+            return ret;
+          };
+        }
+        opts.tokenizer = tokenizer;
+      }
+
+      // ==-- Parse Hooks extensions --== //
+      if (pack.hooks) {
+        const hooks = this.defaults.hooks || new Hooks();
+        for (const prop in pack.hooks) {
+          const prevHook = hooks[prop];
+          if (Hooks.passThroughHooks.has(prop)) {
+            hooks[prop] = (arg) => {
+              if (this.defaults.async) {
+                return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(ret => {
+                  return prevHook.call(hooks, ret);
+                });
+              }
+
+              const ret = pack.hooks[prop].call(hooks, arg);
+              return prevHook.call(hooks, ret);
+            };
+          } else {
+            hooks[prop] = (...args) => {
+              let ret = pack.hooks[prop].apply(hooks, args);
+              if (ret === false) {
+                ret = prevHook.apply(hooks, args);
+              }
+              return ret;
+            };
           }
         }
+        opts.hooks = hooks;
+      }
 
-        opt.highlight = highlight;
+      // ==-- Parse WalkTokens extensions --== //
+      if (pack.walkTokens) {
+        const walkTokens = this.defaults.walkTokens;
+        opts.walkTokens = function(token) {
+          let values = [];
+          values.push(pack.walkTokens.call(this, token));
+          if (walkTokens) {
+            values = values.concat(walkTokens.call(this, token));
+          }
+          return values;
+        };
+      }
 
-        return err
-          ? throwError(err)
-          : callback(null, out);
-      };
+      this.defaults = { ...this.defaults, ...opts };
+    });
+
+    return this;
+  }
+
+  setOptions(opt) {
+    this.defaults = { ...this.defaults, ...opt };
+    return this;
+  }
+
+  #parseMarkdown(lexer, parser) {
+    return (src, opt, callback) => {
+      if (typeof opt === 'function') {
+        callback = opt;
+        opt = null;
+      }
+
+      const origOpt = { ...opt };
+      opt = { ...this.defaults, ...origOpt };
+      const throwError = this.#onError(opt.silent, opt.async, callback);
+
+      // 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'));
+      }
+      if (typeof src !== 'string') {
+        return throwError(new Error('marked(): input parameter is of type '
+          + Object.prototype.toString.call(src) + ', string expected'));
+      }
+
+      checkDeprecations(opt, callback);
 
-      if (!highlight || highlight.length < 3) {
-        return done();
+      if (opt.hooks) {
+        opt.hooks.options = opt;
       }
 
-      delete opt.highlight;
+      if (callback) {
+        const highlight = opt.highlight;
+        let tokens;
+
+        try {
+          if (opt.hooks) {
+            src = opt.hooks.preprocess(src);
+          }
+          tokens = lexer(src, opt);
+        } catch (e) {
+          return throwError(e);
+        }
 
-      if (!tokens.length) return done();
+        const done = (err) => {
+          let out;
 
-      let pending = 0;
-      marked.walkTokens(tokens, function(token) {
-        if (token.type === 'code') {
-          pending++;
-          setTimeout(() => {
-            highlight(token.text, token.lang, function(err, code) {
-              if (err) {
-                return done(err);
+          if (!err) {
+            try {
+              if (opt.walkTokens) {
+                this.walkTokens(tokens, opt.walkTokens);
               }
-              if (code != null && code !== token.text) {
-                token.text = code;
-                token.escaped = true;
+              out = parser(tokens, opt);
+              if (opt.hooks) {
+                out = opt.hooks.postprocess(out);
               }
+            } catch (e) {
+              err = e;
+            }
+          }
 
-              pending--;
-              if (pending === 0) {
-                done();
-              }
-            });
-          }, 0);
+          opt.highlight = highlight;
+
+          return err
+            ? throwError(err)
+            : callback(null, out);
+        };
+
+        if (!highlight || highlight.length < 3) {
+          return done();
+        }
+
+        delete opt.highlight;
+
+        if (!tokens.length) return done();
+
+        let pending = 0;
+        this.walkTokens(tokens, (token) => {
+          if (token.type === 'code') {
+            pending++;
+            setTimeout(() => {
+              highlight(token.text, token.lang, (err, code) => {
+                if (err) {
+                  return done(err);
+                }
+                if (code != null && code !== token.text) {
+                  token.text = code;
+                  token.escaped = true;
+                }
+
+                pending--;
+                if (pending === 0) {
+                  done();
+                }
+              });
+            }, 0);
+          }
+        });
+
+        if (pending === 0) {
+          done();
         }
-      });
 
-      if (pending === 0) {
-        done();
+        return;
       }
 
-      return;
-    }
+      if (opt.async) {
+        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
+          .then(src => lexer(src, opt))
+          .then(tokens => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens)
+          .then(tokens => parser(tokens, opt))
+          .then(html => opt.hooks ? opt.hooks.postprocess(html) : html)
+          .catch(throwError);
+      }
 
-    if (opt.async) {
-      return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
-        .then(src => lexer(src, opt))
-        .then(tokens => opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens)
-        .then(tokens => parser(tokens, opt))
-        .then(html => opt.hooks ? opt.hooks.postprocess(html) : html)
-        .catch(throwError);
-    }
+      try {
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
+        }
+        const tokens = lexer(src, opt);
+        if (opt.walkTokens) {
+          this.walkTokens(tokens, opt.walkTokens);
+        }
+        let html = parser(tokens, opt);
+        if (opt.hooks) {
+          html = opt.hooks.postprocess(html);
+        }
+        return html;
+      } catch (e) {
+        return throwError(e);
+      }
+    };
+  }
 
-    try {
-      if (opt.hooks) {
-        src = opt.hooks.preprocess(src);
+  #onError(silent, async, callback) {
+    return (e) => {
+      e.message += '\nPlease report this to https://github.com/markedjs/this.';
+
+      if (silent) {
+        const msg = '<p>An error occurred:</p><pre>'
+          + escape(e.message + '', true)
+          + '</pre>';
+        if (async) {
+          return Promise.resolve(msg);
+        }
+        if (callback) {
+          callback(null, msg);
+          return;
+        }
+        return msg;
       }
-      const tokens = lexer(src, opt);
-      if (opt.walkTokens) {
-        marked.walkTokens(tokens, opt.walkTokens);
+
+      if (async) {
+        return Promise.reject(e);
       }
-      let html = parser(tokens, opt);
-      if (opt.hooks) {
-        html = opt.hooks.postprocess(html);
+      if (callback) {
+        callback(e);
+        return;
       }
-      return html;
-    } catch (e) {
-      return throwError(e);
-    }
-  };
+      throw e;
+    };
+  }
 }
 
+const markedInstance = new Marked(defaults);
+
 /**
  * Marked
  */
 function marked(src, opt, callback) {
-  return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
+  return markedInstance.parse(src, opt, callback);
 }
 
 /**
@@ -2681,7 +2889,8 @@ function marked(src, opt, callback) {
 
 marked.options =
 marked.setOptions = function(opt) {
-  marked.defaults = { ...marked.defaults, ...opt };
+  markedInstance.setOptions(opt);
+  marked.defaults = markedInstance.defaults;
   changeDefaults(marked.defaults);
   return marked;
 };
@@ -2695,144 +2904,10 @@ marked.defaults = defaults;
  */
 
 marked.use = function(...args) {
-  const extensions = marked.defaults.extensions || { renderers: {}, childTokens: {} };
-
-  args.forEach((pack) => {
-    // copy options to new object
-    const opts = { ...pack };
-
-    // set async to true if it was set to true before
-    opts.async = marked.defaults.async || opts.async || false;
-
-    // ==-- Parse "addon" extensions --== //
-    if (pack.extensions) {
-      pack.extensions.forEach((ext) => {
-        if (!ext.name) {
-          throw new Error('extension name required');
-        }
-        if (ext.renderer) { // Renderer extensions
-          const prevRenderer = extensions.renderers[ext.name];
-          if (prevRenderer) {
-            // Replace extension with func to run new extension but fall back if false
-            extensions.renderers[ext.name] = function(...args) {
-              let ret = ext.renderer.apply(this, args);
-              if (ret === false) {
-                ret = prevRenderer.apply(this, args);
-              }
-              return ret;
-            };
-          } else {
-            extensions.renderers[ext.name] = ext.renderer;
-          }
-        }
-        if (ext.tokenizer) { // Tokenizer Extensions
-          if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {
-            throw new Error("extension level must be 'block' or 'inline'");
-          }
-          if (extensions[ext.level]) {
-            extensions[ext.level].unshift(ext.tokenizer);
-          } else {
-            extensions[ext.level] = [ext.tokenizer];
-          }
-          if (ext.start) { // Function to check for start of token
-            if (ext.level === 'block') {
-              if (extensions.startBlock) {
-                extensions.startBlock.push(ext.start);
-              } else {
-                extensions.startBlock = [ext.start];
-              }
-            } else if (ext.level === 'inline') {
-              if (extensions.startInline) {
-                extensions.startInline.push(ext.start);
-              } else {
-                extensions.startInline = [ext.start];
-              }
-            }
-          }
-        }
-        if (ext.childTokens) { // Child tokens to be visited by walkTokens
-          extensions.childTokens[ext.name] = ext.childTokens;
-        }
-      });
-      opts.extensions = extensions;
-    }
-
-    // ==-- Parse "overwrite" extensions --== //
-    if (pack.renderer) {
-      const renderer = marked.defaults.renderer || new Renderer();
-      for (const prop in pack.renderer) {
-        const prevRenderer = renderer[prop];
-        // Replace renderer with func to run extension, but fall back if false
-        renderer[prop] = (...args) => {
-          let ret = pack.renderer[prop].apply(renderer, args);
-          if (ret === false) {
-            ret = prevRenderer.apply(renderer, args);
-          }
-          return ret;
-        };
-      }
-      opts.renderer = renderer;
-    }
-    if (pack.tokenizer) {
-      const tokenizer = marked.defaults.tokenizer || new Tokenizer();
-      for (const prop in pack.tokenizer) {
-        const prevTokenizer = tokenizer[prop];
-        // Replace tokenizer with func to run extension, but fall back if false
-        tokenizer[prop] = (...args) => {
-          let ret = pack.tokenizer[prop].apply(tokenizer, args);
-          if (ret === false) {
-            ret = prevTokenizer.apply(tokenizer, args);
-          }
-          return ret;
-        };
-      }
-      opts.tokenizer = tokenizer;
-    }
-
-    // ==-- Parse Hooks extensions --== //
-    if (pack.hooks) {
-      const hooks = marked.defaults.hooks || new Hooks();
-      for (const prop in pack.hooks) {
-        const prevHook = hooks[prop];
-        if (Hooks.passThroughHooks.has(prop)) {
-          hooks[prop] = (arg) => {
-            if (marked.defaults.async) {
-              return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(ret => {
-                return prevHook.call(hooks, ret);
-              });
-            }
-
-            const ret = pack.hooks[prop].call(hooks, arg);
-            return prevHook.call(hooks, ret);
-          };
-        } else {
-          hooks[prop] = (...args) => {
-            let ret = pack.hooks[prop].apply(hooks, args);
-            if (ret === false) {
-              ret = prevHook.apply(hooks, args);
-            }
-            return ret;
-          };
-        }
-      }
-      opts.hooks = hooks;
-    }
-
-    // ==-- Parse WalkTokens extensions --== //
-    if (pack.walkTokens) {
-      const walkTokens = marked.defaults.walkTokens;
-      opts.walkTokens = function(token) {
-        let values = [];
-        values.push(pack.walkTokens.call(this, token));
-        if (walkTokens) {
-          values = values.concat(walkTokens.call(this, token));
-        }
-        return values;
-      };
-    }
-
-    marked.setOptions(opts);
-  });
+  markedInstance.use(...args);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
 };
 
 /**
@@ -2840,44 +2915,14 @@ marked.use = function(...args) {
  */
 
 marked.walkTokens = function(tokens, callback) {
-  let values = [];
-  for (const token of tokens) {
-    values = values.concat(callback.call(marked, token));
-    switch (token.type) {
-      case 'table': {
-        for (const cell of token.header) {
-          values = values.concat(marked.walkTokens(cell.tokens, callback));
-        }
-        for (const row of token.rows) {
-          for (const cell of row) {
-            values = values.concat(marked.walkTokens(cell.tokens, callback));
-          }
-        }
-        break;
-      }
-      case 'list': {
-        values = values.concat(marked.walkTokens(token.items, callback));
-        break;
-      }
-      default: {
-        if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) { // Walk any extensions
-          marked.defaults.extensions.childTokens[token.type].forEach(function(childTokens) {
-            values = values.concat(marked.walkTokens(token[childTokens], callback));
-          });
-        } else if (token.tokens) {
-          values = values.concat(marked.walkTokens(token.tokens, callback));
-        }
-      }
-    }
-  }
-  return values;
+  return markedInstance.walkTokens(tokens, callback);
 };
 
 /**
  * Parse Inline
  * @param {string} src
  */
-marked.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline);
+marked.parseInline = markedInstance.parseInline;
 
 /**
  * Expose
@@ -2902,4 +2947,4 @@ const parse = marked;
 const parser = Parser.parse;
 const lexer = Lexer.lex;
 
-export { Hooks, Lexer, Parser, Renderer, Slugger, TextRenderer, Tokenizer, defaults, getDefaults, lexer, marked, options, parse, parseInline, parser, setOptions, use, walkTokens };
+export { Hooks, Lexer, Marked, Parser, Renderer, Slugger, TextRenderer, Tokenizer, defaults, getDefaults, lexer, marked, options, parse, parseInline, parser, setOptions, use, walkTokens };