marked 2.0.7 → 2.1.3

package/lib/marked.js

@@ -75,6 +75,7 @@
     return {
       baseUrl: null,
       breaks: false,
+      extensions: null,
       gfm: true,
       headerIds: true,
       headerPrefix: '',
@@ -1165,14 +1166,14 @@
     blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
     list: /^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?! {0,3}bull )\n*|\s*$)/,
     html: '^ {0,3}(?:' // optional indentation
-    + '<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
+    + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
     + '|comment[^\\n]*(\\n+|$)' // (2)
     + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
     + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
     + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
     + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (6)
-    + '|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
-    + '|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
+    + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) open tag
+    + '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)' // (7) closing tag
     + ')',
     def: /^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,
     nptable: noopTest,
@@ -1196,7 +1197,7 @@
   block$1.html = edit(block$1.html, 'i').replace('comment', block$1._comment).replace('tag', block$1._tag).replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
   block$1.paragraph = edit(block$1._paragraph).replace('hr', block$1.hr).replace('heading', ' {0,3}#{1,6} ').replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
   .replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)').replace('tag', block$1._tag) // pars can be interrupted by type (6) html blocks
+  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', block$1._tag) // pars can be interrupted by type (6) html blocks
   .getRegex();
   block$1.blockquote = edit(block$1.blockquote).replace('paragraph', block$1.paragraph).getRegex();
   /**
@@ -1219,10 +1220,10 @@
 
   });
   block$1.gfm.nptable = edit(block$1.gfm.nptable).replace('hr', block$1.hr).replace('heading', ' {0,3}#{1,6} ').replace('blockquote', ' {0,3}>').replace('code', ' {4}[^\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)').replace('tag', block$1._tag) // tables can be interrupted by type (6) html blocks
+  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', block$1._tag) // tables can be interrupted by type (6) html blocks
   .getRegex();
   block$1.gfm.table = edit(block$1.gfm.table).replace('hr', block$1.hr).replace('heading', ' {0,3}#{1,6} ').replace('blockquote', ' {0,3}>').replace('code', ' {4}[^\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)').replace('tag', block$1._tag) // tables can be interrupted by type (6) html blocks
+  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', block$1._tag) // tables can be interrupted by type (6) html blocks
   .getRegex();
   /**
    * Pedantic grammar (original John Gruber's loose markdown specification)
@@ -1458,6 +1459,8 @@
     ;
 
     _proto.blockTokens = function blockTokens(src, tokens, top) {
+      var _this = this;
+
       if (tokens === void 0) {
         tokens = [];
       }
@@ -1470,10 +1473,22 @@
         src = src.replace(/^ +$/gm, '');
       }
 
-      var token, i, l, lastToken;
+      var token, i, l, lastToken, cutSrc, lastParagraphClipped;
 
       while (src) {
-        // newline
+        if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some(function (extTokenizer) {
+          if (token = extTokenizer.call(_this, src, tokens)) {
+            src = src.substring(token.raw.length);
+            tokens.push(token);
+            return true;
+          }
+
+          return false;
+        })) {
+          continue;
+        } // newline
+
+
         if (token = this.tokenizer.space(src)) {
           src = src.substring(token.raw.length);
 
@@ -1582,11 +1597,43 @@
           tokens.push(token);
           continue;
         } // top-level paragraph
+        // prevent paragraph consuming extensions by clipping 'src' to extension start
+
+
+        cutSrc = src;
+
+        if (this.options.extensions && this.options.extensions.startBlock) {
+          (function () {
+            var startIndex = Infinity;
+            var tempSrc = src.slice(1);
+            var tempStart = void 0;
+
+            _this.options.extensions.startBlock.forEach(function (getStartIndex) {
+              tempStart = getStartIndex.call(this, tempSrc);
+
+              if (typeof tempStart === 'number' && tempStart >= 0) {
+                startIndex = Math.min(startIndex, tempStart);
+              }
+            });
+
+            if (startIndex < Infinity && startIndex >= 0) {
+              cutSrc = src.substring(0, startIndex + 1);
+            }
+          })();
+        }
 
+        if (top && (token = this.tokenizer.paragraph(cutSrc))) {
+          lastToken = tokens[tokens.length - 1];
 
-        if (top && (token = this.tokenizer.paragraph(src))) {
+          if (lastParagraphClipped && lastToken.type === 'paragraph') {
+            lastToken.raw += '\n' + token.raw;
+            lastToken.text += '\n' + token.text;
+          } else {
+            tokens.push(token);
+          }
+
+          lastParagraphClipped = cutSrc.length !== src.length;
           src = src.substring(token.raw.length);
-          tokens.push(token);
           continue;
         } // text
 
@@ -1694,6 +1741,8 @@
     ;
 
     _proto.inlineTokens = function inlineTokens(src, tokens, inLink, inRawBlock) {
+      var _this2 = this;
+
       if (tokens === void 0) {
         tokens = [];
       }
@@ -1706,7 +1755,7 @@
         inRawBlock = false;
       }
 
-      var token, lastToken; // String with links masked to avoid interference with em and strong
+      var token, lastToken, cutSrc; // String with links masked to avoid interference with em and strong
 
       var maskedSrc = src;
       var match;
@@ -1739,7 +1788,20 @@
           prevChar = '';
         }
 
-        keepPrevChar = false; // escape
+        keepPrevChar = false; // extensions
+
+        if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some(function (extTokenizer) {
+          if (token = extTokenizer.call(_this2, src, tokens)) {
+            src = src.substring(token.raw.length);
+            tokens.push(token);
+            return true;
+          }
+
+          return false;
+        })) {
+          continue;
+        } // escape
+
 
         if (token = this.tokenizer.escape(src)) {
           src = src.substring(token.raw.length);
@@ -1752,11 +1814,11 @@
           src = src.substring(token.raw.length);
           inLink = token.inLink;
           inRawBlock = token.inRawBlock;
-          var _lastToken = tokens[tokens.length - 1];
+          lastToken = tokens[tokens.length - 1];
 
-          if (_lastToken && token.type === 'text' && _lastToken.type === 'text') {
-            _lastToken.raw += token.raw;
-            _lastToken.text += token.text;
+          if (lastToken && token.type === 'text' && lastToken.type === 'text') {
+            lastToken.raw += token.raw;
+            lastToken.text += token.text;
           } else {
             tokens.push(token);
           }
@@ -1779,14 +1841,14 @@
 
         if (token = this.tokenizer.reflink(src, this.tokens.links)) {
           src = src.substring(token.raw.length);
-          var _lastToken2 = tokens[tokens.length - 1];
+          lastToken = tokens[tokens.length - 1];
 
           if (token.type === 'link') {
             token.tokens = this.inlineTokens(token.text, [], true, inRawBlock);
             tokens.push(token);
-          } else if (_lastToken2 && token.type === 'text' && _lastToken2.type === 'text') {
-            _lastToken2.raw += token.raw;
-            _lastToken2.text += token.text;
+          } else if (lastToken && token.type === 'text' && lastToken.type === 'text') {
+            lastToken.raw += token.raw;
+            lastToken.text += token.text;
           } else {
             tokens.push(token);
           }
@@ -1837,9 +1899,32 @@
           tokens.push(token);
           continue;
         } // text
+        // prevent inlineText consuming extensions by clipping 'src' to extension start
 
 
-        if (token = this.tokenizer.inlineText(src, inRawBlock, smartypants)) {
+        cutSrc = src;
+
+        if (this.options.extensions && this.options.extensions.startInline) {
+          (function () {
+            var startIndex = Infinity;
+            var tempSrc = src.slice(1);
+            var tempStart = void 0;
+
+            _this2.options.extensions.startInline.forEach(function (getStartIndex) {
+              tempStart = getStartIndex.call(this, tempSrc);
+
+              if (typeof tempStart === 'number' && tempStart >= 0) {
+                startIndex = Math.min(startIndex, tempStart);
+              }
+            });
+
+            if (startIndex < Infinity && startIndex >= 0) {
+              cutSrc = src.substring(0, startIndex + 1);
+            }
+          })();
+        }
+
+        if (token = this.tokenizer.inlineText(cutSrc, inRawBlock, smartypants)) {
           src = src.substring(token.raw.length);
 
           if (token.raw.slice(-1) !== '_') {
@@ -2215,11 +2300,21 @@
           item,
           checked,
           task,
-          checkbox;
+          checkbox,
+          ret;
       var l = tokens.length;
 
       for (i = 0; i < l; i++) {
-        token = tokens[i];
+        token = tokens[i]; // Run any renderer extensions
+
+        if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+          ret = this.options.extensions.renderers[token.type].call(this, token);
+
+          if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {
+            out += ret || '';
+            continue;
+          }
+        }
 
         switch (token.type) {
           case 'space':
@@ -2383,11 +2478,21 @@
       renderer = renderer || this.renderer;
       var out = '',
           i,
-          token;
+          token,
+          ret;
       var l = tokens.length;
 
       for (i = 0; i < l; i++) {
-        token = tokens[i];
+        token = tokens[i]; // Run any renderer extensions
+
+        if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+          ret = this.options.extensions.renderers[token.type].call(this, token);
+
+          if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
+            out += ret || '';
+            continue;
+          }
+        }
 
         switch (token.type) {
           case 'escape':
@@ -2606,82 +2711,169 @@
    * Use Extension
    */
 
-  marked.use = function (extension) {
-    var opts = merge({}, extension);
+  marked.use = function () {
+    var _this = this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var opts = merge.apply(void 0, [{}].concat(args));
+    var extensions = marked.defaults.extensions || {
+      renderers: {},
+      childTokens: {}
+    };
+    var hasExtensions;
+    args.forEach(function (pack) {
+      // ==-- Parse "addon" extensions --== //
+      if (pack.extensions) {
+        hasExtensions = true;
+        pack.extensions.forEach(function (ext) {
+          if (!ext.name) {
+            throw new Error('extension name required');
+          }
 
-    if (extension.renderer) {
-      (function () {
-        var renderer = marked.defaults.renderer || new Renderer();
+          if (ext.renderer) {
+            // Renderer extensions
+            var prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;
+
+            if (prevRenderer) {
+              // Replace extension with func to run new extension but fall back if false
+              extensions.renderers[ext.name] = function () {
+                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                  args[_key2] = arguments[_key2];
+                }
 
-        var _loop = function _loop(prop) {
-          var prevRenderer = renderer[prop];
+                var ret = ext.renderer.apply(this, args);
 
-          renderer[prop] = function () {
-            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-              args[_key] = arguments[_key];
+                if (ret === false) {
+                  ret = prevRenderer.apply(this, args);
+                }
+
+                return ret;
+              };
+            } else {
+              extensions.renderers[ext.name] = ext.renderer;
             }
+          }
 
-            var ret = extension.renderer[prop].apply(renderer, args);
+          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 (ret === false) {
-              ret = prevRenderer.apply(renderer, args);
+            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;
+          }
+        });
+      } // ==-- Parse "overwrite" extensions --== //
+
+
+      if (pack.renderer) {
+        (function () {
+          var renderer = marked.defaults.renderer || new Renderer();
+
+          var _loop = function _loop(prop) {
+            var prevRenderer = renderer[prop]; // Replace renderer with func to run extension, but fall back if false
+
+            renderer[prop] = function () {
+              for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                args[_key3] = arguments[_key3];
+              }
+
+              var ret = pack.renderer[prop].apply(renderer, args);
+
+              if (ret === false) {
+                ret = prevRenderer.apply(renderer, args);
+              }
 
-            return ret;
+              return ret;
+            };
           };
-        };
 
-        for (var prop in extension.renderer) {
-          _loop(prop);
-        }
+          for (var prop in pack.renderer) {
+            _loop(prop);
+          }
 
-        opts.renderer = renderer;
-      })();
-    }
+          opts.renderer = renderer;
+        })();
+      }
 
-    if (extension.tokenizer) {
-      (function () {
-        var tokenizer = marked.defaults.tokenizer || new Tokenizer();
+      if (pack.tokenizer) {
+        (function () {
+          var tokenizer = marked.defaults.tokenizer || new Tokenizer();
 
-        var _loop2 = function _loop2(prop) {
-          var prevTokenizer = tokenizer[prop];
+          var _loop2 = function _loop2(prop) {
+            var prevTokenizer = tokenizer[prop]; // Replace tokenizer with func to run extension, but fall back if false
 
-          tokenizer[prop] = function () {
-            for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-              args[_key2] = arguments[_key2];
-            }
+            tokenizer[prop] = function () {
+              for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+                args[_key4] = arguments[_key4];
+              }
 
-            var ret = extension.tokenizer[prop].apply(tokenizer, args);
+              var ret = pack.tokenizer[prop].apply(tokenizer, args);
 
-            if (ret === false) {
-              ret = prevTokenizer.apply(tokenizer, args);
-            }
+              if (ret === false) {
+                ret = prevTokenizer.apply(tokenizer, args);
+              }
 
-            return ret;
+              return ret;
+            };
           };
-        };
 
-        for (var prop in extension.tokenizer) {
-          _loop2(prop);
-        }
+          for (var prop in pack.tokenizer) {
+            _loop2(prop);
+          }
 
-        opts.tokenizer = tokenizer;
-      })();
-    }
+          opts.tokenizer = tokenizer;
+        })();
+      } // ==-- Parse WalkTokens extensions --== //
 
-    if (extension.walkTokens) {
-      var walkTokens = marked.defaults.walkTokens;
 
-      opts.walkTokens = function (token) {
-        extension.walkTokens(token);
+      if (pack.walkTokens) {
+        var walkTokens = marked.defaults.walkTokens;
 
-        if (walkTokens) {
-          walkTokens(token);
-        }
-      };
-    }
+        opts.walkTokens = function (token) {
+          pack.walkTokens.call(_this, token);
+
+          if (walkTokens) {
+            walkTokens(token);
+          }
+        };
+      }
 
-    marked.setOptions(opts);
+      if (hasExtensions) {
+        opts.extensions = extensions;
+      }
+
+      marked.setOptions(opts);
+    });
   };
   /**
    * Run callback for every token
@@ -2689,7 +2881,7 @@
 
 
   marked.walkTokens = function (tokens, callback) {
-    for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
+    var _loop3 = function _loop3() {
       var token = _step.value;
       callback(token);
 
@@ -2721,11 +2913,20 @@
 
         default:
           {
-            if (token.tokens) {
+            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) {
+                marked.walkTokens(token[childTokens], callback);
+              });
+            } else if (token.tokens) {
               marked.walkTokens(token.tokens, callback);
             }
           }
       }
+    };
+
+    for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {
+      _loop3();
     }
   };
   /**