🗜️ build [skip ci]

lib/marked.esm.js

@@ -32,6 +32,7 @@ function getDefaults() {
     smartLists: false,
     smartypants: false,
     tokenizer: null,
+    walkTokens: null,
     xhtml: false
   };
 }
@@ -565,6 +566,7 @@ var Tokenizer_1 = class Tokenizer {
         }
 
         list.items.push({
+          type: 'list_item',
           raw,
           task: istask,
           checked: ischecked,
@@ -2145,18 +2147,17 @@ function marked(src, opt, callback) {
       + Object.prototype.toString.call(src) + ', string expected');
   }
 
-  if (callback || typeof opt === 'function') {
+  if (typeof opt === 'function') {
-    if (!callback) {
+    callback = opt;
-      callback = opt;
+    opt = null;
-      opt = null;
+  }
-    }
 
-    opt = merge$2({}, marked.defaults, opt || {});
+  opt = merge$2({}, marked.defaults, opt || {});
-    checkSanitizeDeprecation$1(opt);
+  checkSanitizeDeprecation$1(opt);
+
+  if (callback) {
     const highlight = opt.highlight;
-    let tokens,
+    let tokens;
-      pending,
-      i = 0;
 
     try {
       tokens = Lexer_1.lex(src, opt);
@@ -2164,20 +2165,15 @@ function marked(src, opt, callback) {
       return callback(e);
     }
 
-    pending = tokens.length;
-
     const done = function(err) {
-      if (err) {
-        opt.highlight = highlight;
-        return callback(err);
-      }
-
       let out;
 
-      try {
+      if (!err) {
-        out = Parser_1.parse(tokens, opt);
+        try {
-      } catch (e) {
+          out = Parser_1.parse(tokens, opt);
-        err = e;
+        } catch (e) {
+          err = e;
+        }
       }
 
       opt.highlight = highlight;
@@ -2193,34 +2189,45 @@ function marked(src, opt, callback) {
 
     delete opt.highlight;
 
-    if (!pending) return done();
+    if (!tokens.length) return done();
 
-    for (; i < tokens.length; i++) {
+    let pending = 0;
-      (function(token) {
+    marked.walkTokens(tokens, function(token) {
-        if (token.type !== 'code') {
+      if (token.type === 'code') {
-          return --pending || done();
+        pending++;
-        }
+        highlight(token.text, token.lang, function(err, code) {
-        return highlight(token.text, token.lang, function(err, code) {
+          if (err) {
-          if (err) return done(err);
+            return done(err);
-          if (code == null || code === token.text) {
+          }
-            return --pending || done();
+          if (code != null && code !== token.text) {
+            token.text = code;
+            token.escaped = true;
+          }
+
+          pending--;
+          if (pending === 0) {
+            done();
           }
-          token.text = code;
-          token.escaped = true;
-          --pending || done();
         });
-      })(tokens[i]);
+      }
+    });
+
+    if (pending === 0) {
+      done();
     }
 
     return;
   }
+
   try {
-    opt = merge$2({}, marked.defaults, opt || {});
+    const tokens = Lexer_1.lex(src, opt);
-    checkSanitizeDeprecation$1(opt);
+    if (opt.walkTokens) {
-    return Parser_1.parse(Lexer_1.lex(src, opt), opt);
+      marked.walkTokens(tokens, opt.walkTokens);
+    }
+    return Parser_1.parse(tokens, opt);
   } catch (e) {
     e.message += '\nPlease report this to https://github.com/markedjs/marked.';
-    if ((opt || marked.defaults).silent) {
+    if (opt.silent) {
       return '<p>An error occurred:</p><pre>'
         + escape$3(e.message + '', true)
         + '</pre>';
@@ -2278,9 +2285,50 @@ marked.use = function(extension) {
     }
     opts.tokenizer = tokenizer;
   }
+  if (extension.walkTokens) {
+    const walkTokens = marked.defaults.walkTokens;
+    opts.walkTokens = (token) => {
+      extension.walkTokens(token);
+      if (walkTokens) {
+        walkTokens(token);
+      }
+    };
+  }
   marked.setOptions(opts);
 };
 
+/**
+ * Run callback for every token
+ */
+
+marked.walkTokens = function(tokens, callback) {
+  for (const token of tokens) {
+    callback(token);
+    switch (token.type) {
+      case 'table': {
+        for (const cell of token.tokens.header) {
+          marked.walkTokens(cell, callback);
+        }
+        for (const row of token.tokens.cells) {
+          for (const cell of row) {
+            marked.walkTokens(cell, callback);
+          }
+        }
+        break;
+      }
+      case 'list': {
+        marked.walkTokens(token.items, callback);
+        break;
+      }
+      default: {
+        if (token.tokens) {
+          marked.walkTokens(token.tokens, callback);
+        }
+      }
+    }
+  }
+};
+
 /**
  * Expose
  */

lib/marked.js

@@ -31,6 +31,43 @@
     return Constructor;
   }
 
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+
+  function _createForOfIteratorHelperLoose(o) {
+    var i = 0;
+
+    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+      if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) return function () {
+        if (i >= o.length) return {
+          done: true
+        };
+        return {
+          done: false,
+          value: o[i++]
+        };
+      };
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+
+    i = o[Symbol.iterator]();
+    return i.next.bind(i);
+  }
+
   function createCommonjsModule(fn, module) {
   	return module = { exports: {} }, fn(module, module.exports), module.exports;
   }
@@ -54,6 +91,7 @@
         smartLists: false,
         smartypants: false,
         tokenizer: null,
+        walkTokens: null,
         xhtml: false
       };
     }
@@ -616,6 +654,7 @@
           }
 
           list.items.push({
+            type: 'list_item',
             raw: raw,
             task: istask,
             checked: ischecked,
@@ -2208,95 +2247,87 @@
       throw new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected');
     }
 
-    if (callback || typeof opt === 'function') {
+    if (typeof opt === 'function') {
-      var _ret = function () {
+      callback = opt;
-        if (!callback) {
+      opt = null;
-          callback = opt;
+    }
-          opt = null;
-        }
 
-        opt = merge$2({}, marked.defaults, opt || {});
+    opt = merge$2({}, marked.defaults, opt || {});
-        checkSanitizeDeprecation$1(opt);
+    checkSanitizeDeprecation$1(opt);
-        var highlight = opt.highlight;
-        var tokens,
-            pending,
-            i = 0;
 
-        try {
+    if (callback) {
-          tokens = Lexer_1.lex(src, opt);
+      var highlight = opt.highlight;
-        } catch (e) {
+      var tokens;
-          return {
-            v: callback(e)
-          };
-        }
 
-        pending = tokens.length;
+      try {
+        tokens = Lexer_1.lex(src, opt);
+      } catch (e) {
+        return callback(e);
+      }
 
-        var done = function done(err) {
+      var done = function done(err) {
-          if (err) {
+        var out;
-            opt.highlight = highlight;
-            return callback(err);
-          }
-
-          var out;
 
+        if (!err) {
           try {
             out = Parser_1.parse(tokens, opt);
           } catch (e) {
             err = e;
           }
-
-          opt.highlight = highlight;
-          return err ? callback(err) : callback(null, out);
-        };
-
-        if (!highlight || highlight.length < 3) {
-          return {
-            v: done()
-          };
         }
 
-        delete opt.highlight;
+        opt.highlight = highlight;
-        if (!pending) return {
+        return err ? callback(err) : callback(null, out);
-          v: done()
+      };
-        };
 
-        for (; i < tokens.length; i++) {
+      if (!highlight || highlight.length < 3) {
-          (function (token) {
+        return done();
-            if (token.type !== 'code') {
+      }
-              return --pending || done();
+
+      delete opt.highlight;
+      if (!tokens.length) return done();
+      var pending = 0;
+      marked.walkTokens(tokens, function (token) {
+        if (token.type === 'code') {
+          pending++;
+          highlight(token.text, token.lang, function (err, code) {
+            if (err) {
+              return done(err);
             }
 
-            return highlight(token.text, token.lang, function (err, code) {
+            if (code != null && code !== token.text) {
-              if (err) return done(err);
-
-              if (code == null || code === token.text) {
-                return --pending || done();
-              }
-
               token.text = code;
               token.escaped = true;
-              --pending || done();
+            }
-            });
+
-          })(tokens[i]);
+            pending--;
+
+            if (pending === 0) {
+              done();
+            }
+          });
         }
+      });
 
-        return {
+      if (pending === 0) {
-          v: void 0
+        done();
-        };
+      }
-      }();
 
-      if (typeof _ret === "object") return _ret.v;
+      return;
     }
 
     try {
-      opt = merge$2({}, marked.defaults, opt || {});
+      var _tokens = Lexer_1.lex(src, opt);
-      checkSanitizeDeprecation$1(opt);
+
-      return Parser_1.parse(Lexer_1.lex(src, opt), opt);
+      if (opt.walkTokens) {
+        marked.walkTokens(_tokens, opt.walkTokens);
+      }
+
+      return Parser_1.parse(_tokens, opt);
     } catch (e) {
       e.message += '\nPlease report this to https://github.com/markedjs/marked.';
 
-      if ((opt || marked.defaults).silent) {
+      if (opt.silent) {
         return '<p>An error occurred:</p><pre>' + escape$2(e.message + '', true) + '</pre>';
       }
 
@@ -2383,8 +2414,65 @@
       })();
     }
 
+    if (extension.walkTokens) {
+      var walkTokens = marked.defaults.walkTokens;
+
+      opts.walkTokens = function (token) {
+        extension.walkTokens(token);
+
+        if (walkTokens) {
+          walkTokens(token);
+        }
+      };
+    }
+
     marked.setOptions(opts);
   };
+  /**
+   * Run callback for every token
+   */
+
+
+  marked.walkTokens = function (tokens, callback) {
+    for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
+      var token = _step.value;
+      callback(token);
+
+      switch (token.type) {
+        case 'table':
+          {
+            for (var _iterator2 = _createForOfIteratorHelperLoose(token.tokens.header), _step2; !(_step2 = _iterator2()).done;) {
+              var cell = _step2.value;
+              marked.walkTokens(cell, callback);
+            }
+
+            for (var _iterator3 = _createForOfIteratorHelperLoose(token.tokens.cells), _step3; !(_step3 = _iterator3()).done;) {
+              var row = _step3.value;
+
+              for (var _iterator4 = _createForOfIteratorHelperLoose(row), _step4; !(_step4 = _iterator4()).done;) {
+                var _cell = _step4.value;
+                marked.walkTokens(_cell, callback);
+              }
+            }
+
+            break;
+          }
+
+        case 'list':
+          {
+            marked.walkTokens(token.items, callback);
+            break;
+          }
+
+        default:
+          {
+            if (token.tokens) {
+              marked.walkTokens(token.tokens, callback);
+            }
+          }
+      }
+    }
+  };
   /**
    * Expose
    */