marked 4.2.11 → 4.3.0

package/lib/marked.umd.js

@@ -1,5 +1,5 @@
 /**
- * marked v4.2.11 - a markdown parser
+ * marked v4.3.0 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -32,6 +32,20 @@
     });
     return Constructor;
   }
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
   function _unsupportedIterableToArray(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -88,6 +102,7 @@
       headerIds: true,
       headerPrefix: '',
       highlight: null,
+      hooks: null,
       langPrefix: 'language-',
       mangle: true,
       pedantic: false,
@@ -242,20 +257,6 @@
   var noopTest = {
     exec: function noopTest() {}
   };
-  function merge(obj) {
-    var i = 1,
-      target,
-      key;
-    for (; i < arguments.length; i++) {
-      target = arguments[i];
-      for (key in target) {
-        if (Object.prototype.hasOwnProperty.call(target, key)) {
-          obj[key] = target[key];
-        }
-      }
-    }
-    return obj;
-  }
   function splitCells(tableRow, count) {
     // ensure that every cell-delimiting pipe has a space
     // before it to distinguish it from an escaped pipe
@@ -1105,7 +1106,7 @@
   var block = {
     newline: /^(?: *(?:\n|$))+/,
     code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
-    fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?=\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+|$)/,
     blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
@@ -1147,13 +1148,13 @@
    * Normal Block Grammar
    */
 
-  block.normal = merge({}, block);
+  block.normal = _extends({}, block);
 
   /**
    * GFM Block Grammar
    */
 
-  block.gfm = merge({}, block.normal, {
+  block.gfm = _extends({}, block.normal, {
     table: '^ *([^\\n ].*\\|.*)\\n' // Header
     + ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' // Align
     + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
@@ -1171,7 +1172,7 @@
    * Pedantic grammar (original John Gruber's loose markdown specification)
    */
 
-  block.pedantic = merge({}, block.normal, {
+  block.pedantic = _extends({}, block.normal, {
     html: edit('^ *(?:comment *(?:\\n|\\s*$)' + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
     + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))').replace('comment', block._comment).replace(/tag/g, '(?!(?:' + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub' + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)' + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b').getRegex(),
     def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
@@ -1246,13 +1247,13 @@
    * Normal Inline Grammar
    */
 
-  inline.normal = merge({}, inline);
+  inline.normal = _extends({}, inline);
 
   /**
    * Pedantic Inline Grammar
    */
 
-  inline.pedantic = merge({}, inline.normal, {
+  inline.pedantic = _extends({}, inline.normal, {
     strong: {
       start: /^__|\*\*/,
       middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
@@ -1273,7 +1274,7 @@
    * GFM Inline Grammar
    */
 
-  inline.gfm = merge({}, inline.normal, {
+  inline.gfm = _extends({}, inline.normal, {
     escape: edit(inline.escape).replace('])', '~|])').getRegex(),
     _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
     url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
@@ -1286,7 +1287,7 @@
    * GFM + Line Breaks Inline Grammar
    */
 
-  inline.breaks = merge({}, inline.gfm, {
+  inline.breaks = _extends({}, inline.gfm, {
     br: edit(inline.br).replace('{2,}', '*').getRegex(),
     text: edit(inline.gfm.text).replace('\\b_', '\\b_| {2,}\\n').replace(/\{2,\}/g, '*').getRegex()
   });
@@ -2361,98 +2362,170 @@
     return Parser;
   }();
 
-  /**
-   * Marked
-   */
-  function marked(src, opt, callback) {
-    // throw error in case of non string input
-    if (typeof src === 'undefined' || src === null) {
-      throw new Error('marked(): input parameter is undefined or null');
-    }
-    if (typeof src !== 'string') {
-      throw new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
+  var Hooks = /*#__PURE__*/function () {
+    function Hooks(options) {
+      this.options = options || exports.defaults;
     }
-    if (typeof opt === 'function') {
-      callback = opt;
-      opt = null;
+    var _proto = Hooks.prototype;
+    /**
+     * Process markdown before marked
+     */
+    _proto.preprocess = function preprocess(markdown) {
+      return markdown;
     }
-    opt = merge({}, marked.defaults, opt || {});
-    checkSanitizeDeprecation(opt);
-    if (callback) {
-      var highlight = opt.highlight;
-      var tokens;
-      try {
-        tokens = Lexer.lex(src, opt);
-      } catch (e) {
-        return callback(e);
-      }
-      var done = function done(err) {
-        var out;
-        if (!err) {
-          try {
-            if (opt.walkTokens) {
-              marked.walkTokens(tokens, opt.walkTokens);
-            }
-            out = Parser.parse(tokens, opt);
-          } catch (e) {
-            err = e;
+
+    /**
+     * Process HTML after marked is finished
+     */;
+    _proto.postprocess = function postprocess(html) {
+      return html;
+    };
+    return Hooks;
+  }();
+  Hooks.passThroughHooks = new Set(['preprocess', 'postprocess']);
+
+  function onError(silent, async, callback) {
+    return function (e) {
+      e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+      if (silent) {
+        var 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;
+      }
+      if (async) {
+        return Promise.reject(e);
+      }
+      if (callback) {
+        callback(e);
+        return;
+      }
+      throw e;
+    };
+  }
+  function parseMarkdown(lexer, parser) {
+    return function (src, opt, callback) {
+      if (typeof opt === 'function') {
+        callback = opt;
+        opt = null;
+      }
+      var origOpt = _extends({}, opt);
+      opt = _extends({}, marked.defaults, origOpt);
+      var throwError = 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'));
+      }
+      checkSanitizeDeprecation(opt);
+      if (opt.hooks) {
+        opt.hooks.options = opt;
+      }
+      if (callback) {
+        var highlight = opt.highlight;
+        var tokens;
+        try {
+          if (opt.hooks) {
+            src = opt.hooks.preprocess(src);
           }
+          tokens = lexer(src, opt);
+        } catch (e) {
+          return throwError(e);
         }
-        opt.highlight = highlight;
-        return err ? callback(err) : callback(null, out);
-      };
-      if (!highlight || highlight.length < 3) {
-        return done();
-      }
-      delete opt.highlight;
-      if (!tokens.length) return done();
-      var pending = 0;
-      marked.walkTokens(tokens, function (token) {
-        if (token.type === 'code') {
-          pending++;
-          setTimeout(function () {
-            highlight(token.text, token.lang, function (err, code) {
-              if (err) {
-                return done(err);
-              }
-              if (code != null && code !== token.text) {
-                token.text = code;
-                token.escaped = true;
+        var done = function done(err) {
+          var out;
+          if (!err) {
+            try {
+              if (opt.walkTokens) {
+                marked.walkTokens(tokens, opt.walkTokens);
               }
-              pending--;
-              if (pending === 0) {
-                done();
+              out = parser(tokens, opt);
+              if (opt.hooks) {
+                out = opt.hooks.postprocess(out);
               }
-            });
-          }, 0);
+            } catch (e) {
+              err = e;
+            }
+          }
+          opt.highlight = highlight;
+          return err ? throwError(err) : callback(null, out);
+        };
+        if (!highlight || highlight.length < 3) {
+          return done();
         }
-      });
-      if (pending === 0) {
-        done();
-      }
-      return;
-    }
-    function onError(e) {
-      e.message += '\nPlease report this to https://github.com/markedjs/marked.';
-      if (opt.silent) {
-        return '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';
+        delete opt.highlight;
+        if (!tokens.length) return done();
+        var pending = 0;
+        marked.walkTokens(tokens, function (token) {
+          if (token.type === 'code') {
+            pending++;
+            setTimeout(function () {
+              highlight(token.text, token.lang, function (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();
+        }
+        return;
+      }
+      if (opt.async) {
+        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then(function (src) {
+          return lexer(src, opt);
+        }).then(function (tokens) {
+          return opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(function () {
+            return tokens;
+          }) : tokens;
+        }).then(function (tokens) {
+          return parser(tokens, opt);
+        }).then(function (html) {
+          return opt.hooks ? opt.hooks.postprocess(html) : html;
+        })["catch"](throwError);
       }
-      throw e;
-    }
-    try {
-      var _tokens = Lexer.lex(src, opt);
-      if (opt.walkTokens) {
-        if (opt.async) {
-          return Promise.all(marked.walkTokens(_tokens, opt.walkTokens)).then(function () {
-            return Parser.parse(_tokens, opt);
-          })["catch"](onError);
+      try {
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
         }
-        marked.walkTokens(_tokens, opt.walkTokens);
+        var _tokens = lexer(src, opt);
+        if (opt.walkTokens) {
+          marked.walkTokens(_tokens, opt.walkTokens);
+        }
+        var html = parser(_tokens, opt);
+        if (opt.hooks) {
+          html = opt.hooks.postprocess(html);
+        }
+        return html;
+      } catch (e) {
+        return throwError(e);
       }
-      return Parser.parse(_tokens, opt);
-    } catch (e) {
-      onError(e);
-    }
+    };
+  }
+
+  /**
+   * Marked
+   */
+  function marked(src, opt, callback) {
+    return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
   }
 
   /**
@@ -2460,7 +2533,7 @@
    */
 
   marked.options = marked.setOptions = function (opt) {
-    merge(marked.defaults, opt);
+    marked.defaults = _extends({}, marked.defaults, opt);
     changeDefaults(marked.defaults);
     return marked;
   };
@@ -2481,10 +2554,10 @@
     }
     args.forEach(function (pack) {
       // copy options to new object
-      var opts = merge({}, pack);
+      var opts = _extends({}, pack);
 
       // set async to true if it was set to true before
-      opts.async = marked.defaults.async || opts.async;
+      opts.async = marked.defaults.async || opts.async || false;
 
       // ==-- Parse "addon" extensions --== //
       if (pack.extensions) {
@@ -2594,6 +2667,42 @@
         })();
       }
 
+      // ==-- Parse Hooks extensions --== //
+      if (pack.hooks) {
+        (function () {
+          var hooks = marked.defaults.hooks || new Hooks();
+          var _loop3 = function _loop3(prop) {
+            var prevHook = hooks[prop];
+            if (Hooks.passThroughHooks.has(prop)) {
+              hooks[prop] = function (arg) {
+                if (marked.defaults.async) {
+                  return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(function (ret) {
+                    return prevHook.call(hooks, ret);
+                  });
+                }
+                var ret = pack.hooks[prop].call(hooks, arg);
+                return prevHook.call(hooks, ret);
+              };
+            } else {
+              hooks[prop] = function () {
+                for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+                  args[_key5] = arguments[_key5];
+                }
+                var ret = pack.hooks[prop].apply(hooks, args);
+                if (ret === false) {
+                  ret = prevHook.apply(hooks, args);
+                }
+                return ret;
+              };
+            }
+          };
+          for (var prop in pack.hooks) {
+            _loop3(prop);
+          }
+          opts.hooks = hooks;
+        })();
+      }
+
       // ==-- Parse WalkTokens extensions --== //
       if (pack.walkTokens) {
         var _walkTokens = marked.defaults.walkTokens;
@@ -2616,7 +2725,7 @@
 
   marked.walkTokens = function (tokens, callback) {
     var values = [];
-    var _loop3 = function _loop3() {
+    var _loop4 = function _loop4() {
       var token = _step.value;
       values = values.concat(callback.call(marked, token));
       switch (token.type) {
@@ -2654,7 +2763,7 @@
       }
     };
     for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
-      _loop3();
+      _loop4();
     }
     return values;
   };
@@ -2663,30 +2772,7 @@
    * Parse Inline
    * @param {string} src
    */
-  marked.parseInline = function (src, opt) {
-    // throw error in case of non string input
-    if (typeof src === 'undefined' || src === null) {
-      throw new Error('marked.parseInline(): input parameter is undefined or null');
-    }
-    if (typeof src !== 'string') {
-      throw new Error('marked.parseInline(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
-    }
-    opt = merge({}, marked.defaults, opt || {});
-    checkSanitizeDeprecation(opt);
-    try {
-      var tokens = Lexer.lexInline(src, opt);
-      if (opt.walkTokens) {
-        marked.walkTokens(tokens, opt.walkTokens);
-      }
-      return Parser.parseInline(tokens, opt);
-    } catch (e) {
-      e.message += '\nPlease report this to https://github.com/markedjs/marked.';
-      if (opt.silent) {
-        return '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';
-      }
-      throw e;
-    }
-  };
+  marked.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline);
 
   /**
    * Expose
@@ -2699,6 +2785,7 @@
   marked.lexer = Lexer.lex;
   marked.Tokenizer = Tokenizer;
   marked.Slugger = Slugger;
+  marked.Hooks = Hooks;
   marked.parse = marked;
   var options = marked.options;
   var setOptions = marked.setOptions;
@@ -2709,6 +2796,7 @@
   var parser = Parser.parse;
   var lexer = Lexer.lex;
 
+  exports.Hooks = Hooks;
   exports.Lexer = Lexer;
   exports.Parser = Parser;
   exports.Renderer = Renderer;