🗜️ build v4.3.0 [skip ci]

lib/marked.cjs

@@ -1,5 +1,5 @@
 /**
- * marked v4.2.12 - a markdown parser
+ * marked v4.3.0 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -98,6 +98,7 @@ function getDefaults() {
     headerIds: true,
     headerPrefix: '',
     highlight: null,
+    hooks: null,
     langPrefix: 'language-',
     mangle: true,
     pedantic: false,
@@ -252,20 +253,6 @@ function resolveUrl(base, href) {
 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
@@ -2371,30 +2358,83 @@ var Parser = /*#__PURE__*/function () {
   return Parser;
 }();
 
+var Hooks = /*#__PURE__*/function () {
+  function Hooks(options) {
+    this.options = options || exports.defaults;
+  }
+  var _proto = Hooks.prototype;
   /**
- * Marked
+   * Process markdown before marked
    */
-function marked(src, opt, callback) {
+  _proto.preprocess = function preprocess(markdown) {
-  // throw error in case of non string input
+    return markdown;
-  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');
+  /**
+   * 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;
     }
-  opt = merge({}, marked.defaults, opt || {});
+    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 {
-      tokens = Lexer.lex(src, opt);
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
+        }
+        tokens = lexer(src, opt);
       } catch (e) {
-      return callback(e);
+        return throwError(e);
       }
       var done = function done(err) {
         var out;
@@ -2403,13 +2443,16 @@ function marked(src, opt, callback) {
             if (opt.walkTokens) {
               marked.walkTokens(tokens, opt.walkTokens);
             }
-          out = Parser.parse(tokens, opt);
+            out = parser(tokens, opt);
+            if (opt.hooks) {
+              out = opt.hooks.postprocess(out);
+            }
           } catch (e) {
             err = e;
           }
         }
         opt.highlight = highlight;
-      return err ? callback(err) : callback(null, out);
+        return err ? throwError(err) : callback(null, out);
       };
       if (!highlight || highlight.length < 3) {
         return done();
@@ -2442,27 +2485,43 @@ function marked(src, opt, callback) {
       }
       return;
     }
-  function onError(e) {
+    if (opt.async) {
-    e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+      return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then(function (src) {
-    if (opt.silent) {
+        return lexer(src, opt);
-      return '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';
+      }).then(function (tokens) {
-    }
+        return opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(function () {
-    throw e;
+          return tokens;
+        }) : tokens;
+      }).then(function (tokens) {
+        return parser(tokens, opt);
+      }).then(function (html) {
+        return opt.hooks ? opt.hooks.postprocess(html) : html;
+      })["catch"](throwError);
     }
     try {
-    var _tokens = Lexer.lex(src, opt);
+      if (opt.hooks) {
-    if (opt.walkTokens) {
+        src = opt.hooks.preprocess(src);
-      if (opt.async) {
-        return Promise.all(marked.walkTokens(_tokens, opt.walkTokens)).then(function () {
-          return Parser.parse(_tokens, opt);
-        })["catch"](onError);
       }
+      var _tokens = lexer(src, opt);
+      if (opt.walkTokens) {
         marked.walkTokens(_tokens, opt.walkTokens);
       }
-    return Parser.parse(_tokens, opt);
+      var html = parser(_tokens, opt);
-  } catch (e) {
+      if (opt.hooks) {
-    onError(e);
+        html = opt.hooks.postprocess(html);
       }
+      return html;
+    } catch (e) {
+      return throwError(e);
+    }
+  };
+}
+
+/**
+ * Marked
+ */
+function marked(src, opt, callback) {
+  return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
 }
 
 /**
@@ -2470,7 +2529,7 @@ function marked(src, opt, callback) {
  */
 
 marked.options = marked.setOptions = function (opt) {
-  merge(marked.defaults, opt);
+  marked.defaults = _extends({}, marked.defaults, opt);
   changeDefaults(marked.defaults);
   return marked;
 };
@@ -2491,10 +2550,10 @@ marked.use = function () {
   }
   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) {
@@ -2604,6 +2663,42 @@ marked.use = function () {
       })();
     }
 
+    // ==-- 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;
@@ -2626,7 +2721,7 @@ marked.use = function () {
 
 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) {
@@ -2664,7 +2759,7 @@ marked.walkTokens = function (tokens, callback) {
     }
   };
   for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
-    _loop3();
+    _loop4();
   }
   return values;
 };
@@ -2673,30 +2768,7 @@ marked.walkTokens = function (tokens, callback) {
  * Parse Inline
  * @param {string} src
  */
-marked.parseInline = function (src, opt) {
+marked.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline);
-  // 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;
-  }
-};
 
 /**
  * Expose
@@ -2709,6 +2781,7 @@ marked.Lexer = Lexer;
 marked.lexer = Lexer.lex;
 marked.Tokenizer = Tokenizer;
 marked.Slugger = Slugger;
+marked.Hooks = Hooks;
 marked.parse = marked;
 var options = marked.options;
 var setOptions = marked.setOptions;
@@ -2719,6 +2792,7 @@ var parse = marked;
 var parser = Parser.parse;
 var lexer = Lexer.lex;
 
+exports.Hooks = Hooks;
 exports.Lexer = Lexer;
 exports.Parser = Parser;
 exports.Renderer = Renderer;

lib/marked.esm.js

@@ -1,5 +1,5 @@
 /**
- * marked v4.2.12 - a markdown parser
+ * marked v4.3.0 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -19,6 +19,7 @@ function getDefaults() {
     headerIds: true,
     headerPrefix: '',
     highlight: null,
+    hooks: null,
     langPrefix: 'language-',
     mangle: true,
     pedantic: false,
@@ -183,23 +184,6 @@ function resolveUrl(base, href) {
 
 const noopTest = { exec: function noopTest() {} };
 
-function merge(obj) {
-  let 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
@@ -2483,35 +2467,97 @@ class Parser {
   }
 }
 
-/**
+class Hooks {
- * Marked
+  constructor(options) {
- */
+    this.options = options || defaults;
-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');
   }
 
+  static passThroughHooks = new Set([
+    'preprocess',
+    'postprocess'
+  ]);
+
+  /**
+   * Process markdown before marked
+   */
+  preprocess(markdown) {
+    return markdown;
+  }
+
+  /**
+   * Process HTML after marked is finished
+   */
+  postprocess(html) {
+    return html;
+  }
+}
+
+function onError(silent, async, callback) {
+  return (e) => {
+    e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+
+    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;
+    }
+
+    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;
     }
 
-  opt = merge({}, marked.defaults, opt || {});
+    const origOpt = { ...opt };
+    opt = { ...marked.defaults, ...origOpt };
+    const 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) {
       const highlight = opt.highlight;
       let tokens;
 
       try {
-      tokens = Lexer.lex(src, opt);
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
+        }
+        tokens = lexer(src, opt);
       } catch (e) {
-      return callback(e);
+        return throwError(e);
       }
 
       const done = function(err) {
@@ -2522,7 +2568,10 @@ function marked(src, opt, callback) {
             if (opt.walkTokens) {
               marked.walkTokens(tokens, opt.walkTokens);
             }
-          out = Parser.parse(tokens, opt);
+            out = parser(tokens, opt);
+            if (opt.hooks) {
+              out = opt.hooks.postprocess(out);
+            }
           } catch (e) {
             err = e;
           }
@@ -2531,7 +2580,7 @@ function marked(src, opt, callback) {
         opt.highlight = highlight;
 
         return err
-        ? callback(err)
+          ? throwError(err)
           : callback(null, out);
       };
 
@@ -2573,32 +2622,39 @@ function marked(src, opt, callback) {
       return;
     }
 
-  function onError(e) {
+    if (opt.async) {
-    e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+      return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)
-    if (opt.silent) {
+        .then(src => lexer(src, opt))
-      return '<p>An error occurred:</p><pre>'
+        .then(tokens => opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens)
-        + escape(e.message + '', true)
+        .then(tokens => parser(tokens, opt))
-        + '</pre>';
+        .then(html => opt.hooks ? opt.hooks.postprocess(html) : html)
-    }
+        .catch(throwError);
-    throw e;
     }
 
     try {
-    const tokens = Lexer.lex(src, opt);
+      if (opt.hooks) {
-    if (opt.walkTokens) {
+        src = opt.hooks.preprocess(src);
-      if (opt.async) {
-        return Promise.all(marked.walkTokens(tokens, opt.walkTokens))
-          .then(() => {
-            return Parser.parse(tokens, opt);
-          })
-          .catch(onError);
       }
+      const tokens = lexer(src, opt);
+      if (opt.walkTokens) {
         marked.walkTokens(tokens, opt.walkTokens);
       }
-    return Parser.parse(tokens, opt);
+      let html = parser(tokens, opt);
-  } catch (e) {
+      if (opt.hooks) {
-    onError(e);
+        html = opt.hooks.postprocess(html);
       }
+      return html;
+    } catch (e) {
+      return throwError(e);
+    }
+  };
+}
+
+/**
+ * Marked
+ */
+function marked(src, opt, callback) {
+  return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
 }
 
 /**
@@ -2607,7 +2663,7 @@ function marked(src, opt, callback) {
 
 marked.options =
 marked.setOptions = function(opt) {
-  merge(marked.defaults, opt);
+  marked.defaults = { ...marked.defaults, ...opt };
   changeDefaults(marked.defaults);
   return marked;
 };
@@ -2625,10 +2681,10 @@ marked.use = function(...args) {
 
   args.forEach((pack) => {
     // copy options to new object
-    const opts = merge({}, pack);
+    const opts = { ...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) {
@@ -2715,6 +2771,35 @@ marked.use = function(...args) {
       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;
@@ -2774,35 +2859,7 @@ marked.walkTokens = function(tokens, callback) {
  * Parse Inline
  * @param {string} src
  */
-marked.parseInline = function(src, opt) {
+marked.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline);
-  // 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 {
-    const 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;
-  }
-};
 
 /**
  * Expose
@@ -2815,6 +2872,7 @@ marked.Lexer = Lexer;
 marked.lexer = Lexer.lex;
 marked.Tokenizer = Tokenizer;
 marked.Slugger = Slugger;
+marked.Hooks = Hooks;
 marked.parse = marked;
 
 const options = marked.options;
@@ -2826,4 +2884,4 @@ const parse = marked;
 const parser = Parser.parse;
 const lexer = Lexer.lex;
 
-export { Lexer, Parser, Renderer, Slugger, TextRenderer, Tokenizer, defaults, getDefaults, lexer, marked, options, parse, parseInline, parser, setOptions, use, walkTokens };
+export { Hooks, Lexer, Parser, Renderer, Slugger, TextRenderer, Tokenizer, defaults, getDefaults, lexer, marked, options, parse, parseInline, parser, setOptions, use, walkTokens };

lib/marked.umd.js

@@ -1,5 +1,5 @@
 /**
- * marked v4.2.12 - a markdown parser
+ * marked v4.3.0 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -102,6 +102,7 @@
       headerIds: true,
       headerPrefix: '',
       highlight: null,
+      hooks: null,
       langPrefix: 'language-',
       mangle: true,
       pedantic: false,
@@ -256,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
@@ -2375,30 +2362,83 @@
     return Parser;
   }();
 
+  var Hooks = /*#__PURE__*/function () {
+    function Hooks(options) {
+      this.options = options || exports.defaults;
+    }
+    var _proto = Hooks.prototype;
     /**
-   * Marked
+     * Process markdown before marked
      */
-  function marked(src, opt, callback) {
+    _proto.preprocess = function preprocess(markdown) {
-    // throw error in case of non string input
+      return markdown;
-    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');
+    /**
+     * 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;
       }
-    opt = merge({}, marked.defaults, opt || {});
+      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 {
-        tokens = Lexer.lex(src, opt);
+          if (opt.hooks) {
+            src = opt.hooks.preprocess(src);
+          }
+          tokens = lexer(src, opt);
         } catch (e) {
-        return callback(e);
+          return throwError(e);
         }
         var done = function done(err) {
           var out;
@@ -2407,13 +2447,16 @@
               if (opt.walkTokens) {
                 marked.walkTokens(tokens, opt.walkTokens);
               }
-            out = Parser.parse(tokens, opt);
+              out = parser(tokens, opt);
+              if (opt.hooks) {
+                out = opt.hooks.postprocess(out);
+              }
             } catch (e) {
               err = e;
             }
           }
           opt.highlight = highlight;
-        return err ? callback(err) : callback(null, out);
+          return err ? throwError(err) : callback(null, out);
         };
         if (!highlight || highlight.length < 3) {
           return done();
@@ -2446,27 +2489,43 @@
         }
         return;
       }
-    function onError(e) {
+      if (opt.async) {
-      e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then(function (src) {
-      if (opt.silent) {
+          return lexer(src, opt);
-        return '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';
+        }).then(function (tokens) {
-      }
+          return opt.walkTokens ? Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(function () {
-      throw e;
+            return tokens;
+          }) : tokens;
+        }).then(function (tokens) {
+          return parser(tokens, opt);
+        }).then(function (html) {
+          return opt.hooks ? opt.hooks.postprocess(html) : html;
+        })["catch"](throwError);
       }
       try {
-      var _tokens = Lexer.lex(src, opt);
+        if (opt.hooks) {
-      if (opt.walkTokens) {
+          src = opt.hooks.preprocess(src);
-        if (opt.async) {
-          return Promise.all(marked.walkTokens(_tokens, opt.walkTokens)).then(function () {
-            return Parser.parse(_tokens, opt);
-          })["catch"](onError);
         }
+        var _tokens = lexer(src, opt);
+        if (opt.walkTokens) {
           marked.walkTokens(_tokens, opt.walkTokens);
         }
-      return Parser.parse(_tokens, opt);
+        var html = parser(_tokens, opt);
-    } catch (e) {
+        if (opt.hooks) {
-      onError(e);
+          html = opt.hooks.postprocess(html);
         }
+        return html;
+      } catch (e) {
+        return throwError(e);
+      }
+    };
+  }
+
+  /**
+   * Marked
+   */
+  function marked(src, opt, callback) {
+    return parseMarkdown(Lexer.lex, Parser.parse)(src, opt, callback);
   }
 
   /**
@@ -2474,7 +2533,7 @@
    */
 
   marked.options = marked.setOptions = function (opt) {
-    merge(marked.defaults, opt);
+    marked.defaults = _extends({}, marked.defaults, opt);
     changeDefaults(marked.defaults);
     return marked;
   };
@@ -2495,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) {
@@ -2608,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;
@@ -2630,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) {
@@ -2668,7 +2763,7 @@
       }
     };
     for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
-      _loop3();
+      _loop4();
     }
     return values;
   };
@@ -2677,30 +2772,7 @@
    * Parse Inline
    * @param {string} src
    */
-  marked.parseInline = function (src, opt) {
+  marked.parseInline = parseMarkdown(Lexer.lexInline, Parser.parseInline);
-    // 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;
-    }
-  };
 
   /**
    * Expose
@@ -2713,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;
@@ -2723,6 +2796,7 @@
   var parser = Parser.parse;
   var lexer = Lexer.lex;
 
+  exports.Hooks = Hooks;
   exports.Lexer = Lexer;
   exports.Parser = Parser;
   exports.Renderer = Renderer;