v1.0

只读模式
group, 分享
评论更多问题
博客标签总是存在一个

public/mdeditor/editor/Markdown.Extra.js

@@ -1,3 +1,4 @@
+// update from staceditor/pagedown/Markdown.Extra.js
 (function () {
   // A quick way to make sure we're only keeping span-level tags when we need to.
   // This isn't supposed to be foolproof. It's just a quick way to make sure we
@@ -102,13 +103,13 @@
     return result;
   }
 
-  // Convert escaped special characters to HTML decimal entity codes.
-  function processEscapes(text) {
+  // Convert escaped special characters
+  function processEscapesStep1(text) {
     // Markdown extra adds two escapable characters, `:` and `|`
-    // If escaped, we convert them to html entities so our
-    // regexes don't recognize them. Markdown doesn't support escaping
-    // the escape character, e.g. `\\`, which make this even simpler.
-    return text.replace(/\\\|/g, '|').replace(/\\:/g, ':');
+    return text.replace(/\\\|/g, '~I').replace(/\\:/g, '~i');
+  }
+  function processEscapesStep2(text) {
+    return text.replace(/~I/g, '|').replace(/~i/g, ':');
   }
 
   // Duplicated from PageDown converter
@@ -120,6 +121,15 @@
     });
     return text;
   }
+  
+  function slugify(text) {
+    return text.toLowerCase()
+    .replace(/\s+/g, '-') // Replace spaces with -
+    .replace(/[^\w\-]+/g, '') // Remove all non-word chars
+    .replace(/\-\-+/g, '-') // Replace multiple - with single -
+    .replace(/^-+/, '') // Trim - from start of text
+    .replace(/-+$/, ''); // Trim - from end of text
+  }
 
   /*****************************************************************************
    * Markdown.Extra *
@@ -135,6 +145,10 @@
     // Stores html blocks we generate in hooks so that
     // they're not destroyed if the user is using a sanitizing converter
     this.hashBlocks = [];
+    
+    // Stores footnotes
+    this.footnotes = {};
+    this.usedFootnotes = [];
 
     // Special attribute blocks for fenced code blocks and headers enabled.
     this.attributeBlocks = false;
@@ -150,33 +164,62 @@
   };
 
   Markdown.Extra.init = function(converter, options) {
+  	options = options || {};
+  	// 写死
+  	options.extensions = ["fenced_code_gfm",
+			"tables",
+			"def_list",
+			"attr_list",
+			"footnotes",
+			"smartypants",
+			"strikethrough",
+			"newlines"];
     // Each call to init creates a new instance of Markdown.Extra so it's
     // safe to have multiple converters, with different options, on a single page
     var extra = new Markdown.Extra();
     var postNormalizationTransformations = [];
     var preBlockGamutTransformations = [];
+    var postSpanGamutTransformations = [];
     var postConversionTransformations = ["unHashExtraBlocks"];
 
     options = options || {};
     options.extensions = options.extensions || ["all"];
     if (contains(options.extensions, "all")) {
-      options.extensions = ["tables", "fenced_code_gfm", "def_list", "attr_list"];
+      options.extensions = ["tables", "fenced_code_gfm", "def_list", "attr_list", "footnotes", "smartypants", "strikethrough", "newlines"];
     }
+    preBlockGamutTransformations.push("wrapHeaders");
     if (contains(options.extensions, "attr_list")) {
       postNormalizationTransformations.push("hashFcbAttributeBlocks");
       preBlockGamutTransformations.push("hashHeaderAttributeBlocks");
       postConversionTransformations.push("applyAttributeBlocks");
       extra.attributeBlocks = true;
     }
+    if (contains(options.extensions, "fenced_code_gfm")) {
+      // This step will convert fcb inside list items and blockquotes
+      preBlockGamutTransformations.push("fencedCodeBlocks");
+      // This extra step is to prevent html blocks hashing and link definition/footnotes stripping inside fcb
+      postNormalizationTransformations.push("fencedCodeBlocks");
+    }
     if (contains(options.extensions, "tables")) {
       preBlockGamutTransformations.push("tables");
     }
-    if (contains(options.extensions, "fenced_code_gfm")) {
-      postNormalizationTransformations.push("fencedCodeBlocks");
-    }
     if (contains(options.extensions, "def_list")) {
       preBlockGamutTransformations.push("definitionLists");
     }
+    if (contains(options.extensions, "footnotes")) {
+      postNormalizationTransformations.push("stripFootnoteDefinitions");
+      preBlockGamutTransformations.push("doFootnotes");
+      postConversionTransformations.push("printFootnotes");
+    }
+    if (contains(options.extensions, "smartypants")) {
+      postConversionTransformations.push("runSmartyPants");
+    }
+    if (contains(options.extensions, "strikethrough")) {
+      postSpanGamutTransformations.push("strikethrough");
+    }
+    if (contains(options.extensions, "newlines")) {
+      postSpanGamutTransformations.push("newlines");
+    }
     
     converter.hooks.chain("postNormalization", function(text) {
       return extra.doTransform(postNormalizationTransformations, text) + '\n';
@@ -185,8 +228,14 @@
     converter.hooks.chain("preBlockGamut", function(text, blockGamutHookCallback) {
       // Keep a reference to the block gamut callback to run recursively
       extra.blockGamutHookCallback = blockGamutHookCallback;
-      text = processEscapes(text);
-      return extra.doTransform(preBlockGamutTransformations, text) + '\n';
+      text = processEscapesStep1(text);
+      text = extra.doTransform(preBlockGamutTransformations, text) + '\n';
+      text = processEscapesStep2(text);
+      return text;
+    });
+
+    converter.hooks.chain("postSpanGamut", function(text) {
+      return extra.doTransform(postSpanGamutTransformations, text);
     });
 
     // Keep a reference to the hook chain running before doPostConversion to apply on hashed extra blocks
@@ -194,7 +243,9 @@
     converter.hooks.chain("postConversion", function(text) {
       text = extra.doTransform(postConversionTransformations, text);
       // Clear state vars that may use unnecessary memory
-      this.hashBlocks = [];
+      extra.hashBlocks = [];
+      extra.footnotes = {};
+      extra.usedFootnotes = [];
       return text;
     });
 
@@ -225,14 +276,17 @@
   Markdown.Extra.prototype.hashExtraBlock = function(block) {
     return '\n<p>~X' + (this.hashBlocks.push(block) - 1) + 'X</p>\n';
   };
-
+  Markdown.Extra.prototype.hashExtraInline = function(block) {
+    return '~X' + (this.hashBlocks.push(block) - 1) + 'X';
+  };
+  
   // Replace placeholder blocks in `text` with their corresponding
   // html blocks in the hashBlocks array.
   Markdown.Extra.prototype.unHashExtraBlocks = function(text) {
     var self = this;
     function recursiveUnHash() {
       var hasHash = false;
-      text = text.replace(/<p>~X(\d+)X<\/p>/g, function(wholeMatch, m1) {
+      text = text.replace(/(?:<p>)?~X(\d+)X(?:<\/p>)?/g, function(wholeMatch, m1) {
         hasHash = true;
         var key = parseInt(m1, 10);
         return self.hashBlocks[key];
@@ -244,21 +298,35 @@
     recursiveUnHash();
     return text;
   };
+  
+  // Wrap headers to make sure they won't be in def lists
+  Markdown.Extra.prototype.wrapHeaders = function(text) {
+    function wrap(text) {
+      return '\n' + text + '\n';
+    }
+    text = text.replace(/^.+[ \t]*\n=+[ \t]*\n+/gm, wrap);
+    text = text.replace(/^.+[ \t]*\n-+[ \t]*\n+/gm, wrap);
+    text = text.replace(/^\#{1,6}[ \t]*.+?[ \t]*\#*\n+/gm, wrap);
+    return text;
+  };
 
 
   /******************************************************************
    * Attribute Blocks                                               *
    *****************************************************************/
 
+  // TODO: use sentinels. Should we just add/remove them in doConversion?
+  // TODO: better matches for id / class attributes
+  var attrBlock = "\\{[ \\t]*((?:[#.][-_:a-zA-Z0-9]+[ \\t]*)+)\\}";
+  var hdrAttributesA = new RegExp("^(#{1,6}.*#{0,6})[ \\t]+" + attrBlock + "[ \\t]*(?:\\n|0x03)", "gm");
+  var hdrAttributesB = new RegExp("^(.*)[ \\t]+" + attrBlock + "[ \\t]*\\n" +
+    "(?=[\\-|=]+\\s*(?:\\n|0x03))", "gm"); // underline lookahead
+  var fcbAttributes =  new RegExp("^(```[^`\\n]*)[ \\t]+" + attrBlock + "[ \\t]*\\n" +
+    "(?=([\\s\\S]*?)\\n```[ \\t]*(\\n|0x03))", "gm");
+      
   // Extract headers attribute blocks, move them above the element they will be
   // applied to, and hash them for later.
   Markdown.Extra.prototype.hashHeaderAttributeBlocks = function(text) {
-    // TODO: use sentinels. Should we just add/remove them in doConversion?
-    // TODO: better matches for id / class attributes
-    var attrBlock = "\\{\\s*[.|#][^}]+\\}";
-    var hdrAttributesA = new RegExp("^(#{1,6}.*#{0,6})\\s+(" + attrBlock + ")[ \\t]*(\\n|0x03)", "gm");
-    var hdrAttributesB = new RegExp("^(.*)\\s+(" + attrBlock + ")[ \\t]*\\n" +
-      "(?=[\\-|=]+\\s*(\\n|0x03))", "gm"); // underline lookahead
     
     var self = this;
     function attributeCallback(wholeMatch, pre, attr) {
@@ -275,9 +343,6 @@
   Markdown.Extra.prototype.hashFcbAttributeBlocks = function(text) {
     // TODO: use sentinels. Should we just add/remove them in doConversion?
     // TODO: better matches for id / class attributes
-    var attrBlock = "\\{\\s*[.|#][^}]+\\}";
-    var fcbAttributes =  new RegExp("^(```[^{]*)\\s+(" + attrBlock + ")[ \\t]*\\n" +
-                                    "(?=([\\s\\S]*?)\\n```\\s*(\\n|0x03))", "gm");
 
     var self = this;
     function attributeCallback(wholeMatch, pre, attr) {
@@ -300,11 +365,11 @@
       var attributes = self.hashBlocks[key];
 
       // get id
-      var id = attributes.match(/#[^\s{}]+/g) || [];
+      var id = attributes.match(/#[^\s#.]+/g) || [];
       var idStr = id[0] ? ' id="' + id[0].substr(1, id[0].length - 1) + '"' : '';
 
       // get classes and merge with existing classes
-      var classes = attributes.match(/\.[^\s{}]+/g) || [];
+      var classes = attributes.match(/\.[^\s#.]+/g) || [];
       for (var i = 0; i < classes.length; i++) // Remove leading dot
         classes[i] = classes[i].substr(1, classes[i].length - 1);
 
@@ -383,11 +448,11 @@
       for (var i = 0; i < alignspecs.length; i++) {
         var spec = alignspecs[i];
         if (spec.match(/^ *-+: *$/m))
-          align[i] = ' style="text-align:right;"';
+          align[i] = ' align="right"';
         else if (spec.match(/^ *:-+: *$/m))
-          align[i] = ' style="text-align:center;"';
+          align[i] = ' align="center"';
         else if (spec.match(/^ *:-+ *$/m))
-          align[i] = ' style="text-align:left;"';
+          align[i] = ' align="left"';
         else align[i] = '';
       }
 
@@ -437,6 +502,81 @@
   };
 
 
+  /******************************************************************
+   * Footnotes                                                      *
+   *****************************************************************/
+  
+  // Strip footnote, store in hashes.
+  Markdown.Extra.prototype.stripFootnoteDefinitions = function(text) {
+    var self = this;
+
+    text = text.replace(
+      /\n[ ]{0,3}\[\^(.+?)\]\:[ \t]*\n?([\s\S]*?)\n{1,2}((?=\n[ ]{0,3}\S)|$)/g,
+      function(wholeMatch, m1, m2) {
+        m1 = slugify(m1);
+        m2 += "\n";
+        m2 = m2.replace(/^[ ]{0,3}/g, "");
+        self.footnotes[m1] = m2;
+        return "\n";
+      });
+
+    return text;
+  };
+  
+
+  // Find and convert footnotes references.
+  Markdown.Extra.prototype.doFootnotes = function(text) {
+    var self = this;
+    if(self.isConvertingFootnote === true) {
+      return text;
+    }
+
+    var footnoteCounter = 0;
+    text = text.replace(/\[\^(.+?)\]/g, function(wholeMatch, m1) {
+      var id = slugify(m1);
+      var footnote = self.footnotes[id];
+      if (footnote === undefined) {
+        return wholeMatch;
+      }
+      footnoteCounter++;
+      self.usedFootnotes.push(id);
+      var html = '<a href="#fn:' + id + '" id="fnref:' + id
+      + '" title="See footnote" class="footnote">' + footnoteCounter
+      + '</a>';
+      return self.hashExtraInline(html);
+    });
+
+    return text;
+  };
+
+  // Print footnotes at the end of the document
+  Markdown.Extra.prototype.printFootnotes = function(text) {
+    var self = this;
+
+    if (self.usedFootnotes.length === 0) {
+      return text;
+    }
+
+    text += '\n\n<div class="footnotes">\n<hr>\n<ol>\n\n';
+    for(var i=0; i<self.usedFootnotes.length; i++) {
+      var id = self.usedFootnotes[i];
+      var footnote = self.footnotes[id];
+      self.isConvertingFootnote = true;
+      var formattedfootnote = convertSpans(footnote, self);
+      delete self.isConvertingFootnote;
+      text += '<li id="fn:'
+        + id
+        + '">'
+        + formattedfootnote
+        + ' <a href="#fnref:'
+        + id
+        + '" title="Return to article" class="reversefootnote">&#8617;</a></li>\n\n';
+    }
+    text += '</ol>\n</div>';
+    return text;
+  };
+  
+  
   /******************************************************************
   * Fenced Code Blocks  (gfm)                                       *
   ******************************************************************/
@@ -454,8 +594,8 @@
     }
 
     var self = this;
-    text = text.replace(/(?:^|\n)```(.*)\n([\s\S]*?)\n```/g, function(match, m1, m2) {
-      var language = m1, codeblock = m2;
+    text = text.replace(/(?:^|\n)```([^`\n]*)\n([\s\S]*?)\n```[ \t]*(?=\n)/g, function(match, m1, m2) {
+      var language = trim(m1), codeblock = m2;
 
       // adhere to specified options
       var preclass = self.googleCodePrettify ? ' class="prettyprint"' : '';
@@ -480,6 +620,119 @@
   };
 
 
+  /******************************************************************
+  * SmartyPants                                                     *
+  ******************************************************************/
+  
+  Markdown.Extra.prototype.educatePants = function(text) {
+    var self = this;
+    var result = '';
+    var blockOffset = 0;
+    // Here we parse HTML in a very bad manner
+    text.replace(/(?:<!--[\s\S]*?-->)|(<)([a-zA-Z1-6]+)([^\n]*?>)([\s\S]*?)(<\/\2>)/g, function(wholeMatch, m1, m2, m3, m4, m5, offset) {
+      var token = text.substring(blockOffset, offset);
+      result += self.applyPants(token);
+      self.smartyPantsLastChar = result.substring(result.length - 1);
+      blockOffset = offset + wholeMatch.length;
+      if(!m1) {
+        // Skip commentary
+        result += wholeMatch;
+        return;
+      }
+      // Skip special tags
+      if(!/code|kbd|pre|script|noscript|iframe|math|ins|del|pre/i.test(m2)) {
+        m4 = self.educatePants(m4);
+      }
+      else {
+        self.smartyPantsLastChar = m4.substring(m4.length - 1);
+      }
+      result += m1 + m2 + m3 + m4 + m5;
+    });
+    var lastToken = text.substring(blockOffset);
+    result += self.applyPants(lastToken);
+    self.smartyPantsLastChar = result.substring(result.length - 1);
+    return result;
+  };
+    
+  function revertPants(wholeMatch, m1) {
+    var blockText = m1;
+    blockText = blockText.replace(/&\#8220;/g, "\"");
+    blockText = blockText.replace(/&\#8221;/g, "\"");
+    blockText = blockText.replace(/&\#8216;/g, "'");
+    blockText = blockText.replace(/&\#8217;/g, "'");
+    blockText = blockText.replace(/&\#8212;/g, "---");
+    blockText = blockText.replace(/&\#8211;/g, "--");
+    blockText = blockText.replace(/&\#8230;/g, "...");
+    return blockText;
+  }
+  
+  Markdown.Extra.prototype.applyPants = function(text) {
+    // Dashes
+    text = text.replace(/---/g, "&#8212;").replace(/--/g, "&#8211;");
+    // Ellipses
+    text = text.replace(/\.\.\./g, "&#8230;").replace(/\.\s\.\s\./g, "&#8230;");
+    // Backticks
+    text = text.replace(/``/g, "&#8220;").replace (/''/g, "&#8221;");
+    
+    if(/^'$/.test(text)) {
+      // Special case: single-character ' token
+      if(/\S/.test(this.smartyPantsLastChar)) {
+        return "&#8217;";
+      }
+      return "&#8216;";
+    }
+    if(/^"$/.test(text)) {
+      // Special case: single-character " token
+      if(/\S/.test(this.smartyPantsLastChar)) {
+        return "&#8221;";
+      }
+      return "&#8220;";
+    }
+
+    // Special case if the very first character is a quote
+    // followed by punctuation at a non-word-break. Close the quotes by brute force:
+    text = text.replace (/^'(?=[!"#\$\%'()*+,\-.\/:;<=>?\@\[\\]\^_`{|}~]\B)/, "&#8217;");
+    text = text.replace (/^"(?=[!"#\$\%'()*+,\-.\/:;<=>?\@\[\\]\^_`{|}~]\B)/, "&#8221;");
+
+    // Special case for double sets of quotes, e.g.:
+    //   <p>He said, "'Quoted' words in a larger quote."</p>
+    text = text.replace(/"'(?=\w)/g, "&#8220;&#8216;");
+    text = text.replace(/'"(?=\w)/g, "&#8216;&#8220;");
+
+    // Special case for decade abbreviations (the '80s):
+    text = text.replace(/'(?=\d{2}s)/g, "&#8217;");
+    
+    // Get most opening single quotes:
+    text = text.replace(/(\s|&nbsp;|--|&[mn]dash;|&\#8211;|&\#8212;|&\#x201[34];)'(?=\w)/g, "$1&#8216;");
+    
+    // Single closing quotes:
+    text = text.replace(/([^\s\[\{\(\-])'/g, "$1&#8217;");
+    text = text.replace(/'(?=\s|s\b)/g, "&#8217;");
+
+    // Any remaining single quotes should be opening ones:
+    text = text.replace(/'/g, "&#8216;");
+    
+    // Get most opening double quotes:
+    text = text.replace(/(\s|&nbsp;|--|&[mn]dash;|&\#8211;|&\#8212;|&\#x201[34];)"(?=\w)/g, "$1&#8220;");
+    
+    // Double closing quotes:
+    text = text.replace(/([^\s\[\{\(\-])"/g, "$1&#8221;");
+    text = text.replace(/"(?=\s)/g, "&#8221;");
+    
+    // Any remaining quotes should be opening ones.
+    text = text.replace(/"/ig, "&#8220;");
+    return text;
+  };
+
+  // Find and convert markdown extra definition lists into html.
+  Markdown.Extra.prototype.runSmartyPants = function(text) {
+    this.smartyPantsLastChar = '';
+    text = this.educatePants(text);
+    // Clean everything inside html tags (some of them may have been converted due to our rough html parsing)
+    text = text.replace(/(<([a-zA-Z1-6]+)\b([^\n>]*?)(\/)?>)/g, revertPants);
+    return text;
+  };
+  
   /******************************************************************
   * Definition Lists                                                *
   ******************************************************************/
@@ -605,5 +858,28 @@
     return removeAnchors(listStr);
   };
 
+
+  /***********************************************************
+  * Strikethrough                                            *
+  ************************************************************/
+
+  Markdown.Extra.prototype.strikethrough = function(text) {
+    // Pretty much duplicated from _DoItalicsAndBold
+    return text.replace(/([\W_]|^)~T~T(?=\S)([^\r]*?\S[\*_]*)~T~T([\W_]|$)/g,
+      "$1<del>$2</del>$3");
+  };
+
+
+  /***********************************************************
+  * New lines                                                *
+  ************************************************************/
+
+  Markdown.Extra.prototype.newlines = function(text) {
+    // We have to ignore already converted newlines and line breaks in sub-list items
+    return text.replace(/(<(?:br|\/li)>)?\n/g, function(wholeMatch, previousTag) {
+      return previousTag ? wholeMatch : " <br>\n";
+    });
+  };
+  
 })();