|
|
@ -1,874 +0,0 @@ |
|
|
(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
|
|
|
|
|
|
// keep all span-level tags returned by a pagedown converter. It should allow
|
|
|
|
|
|
// all span-level tags through, with or without attributes.
|
|
|
|
|
|
var inlineTags = new RegExp(['^(<\\/?(a|abbr|acronym|applet|area|b|basefont|', |
|
|
|
|
|
'bdo|big|button|cite|code|del|dfn|em|figcaption|', |
|
|
|
|
|
'font|i|iframe|img|input|ins|kbd|label|map|', |
|
|
|
|
|
'mark|meter|object|param|progress|q|ruby|rp|rt|s|', |
|
|
|
|
|
'samp|script|select|small|span|strike|strong|', |
|
|
|
|
|
'sub|sup|textarea|time|tt|u|var|wbr)[^>]*>|', |
|
|
|
|
|
'<(br)\\s?\\/?>)$'].join(''), 'i'); |
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************** |
|
|
|
|
|
* Utility Functions * |
|
|
|
|
|
*****************************************************************/ |
|
|
|
|
|
|
|
|
|
|
|
// patch for ie7
|
|
|
|
|
|
if (!Array.indexOf) { |
|
|
|
|
|
Array.prototype.indexOf = function(obj) { |
|
|
|
|
|
for (var i = 0; i < this.length; i++) { |
|
|
|
|
|
if (this[i] == obj) { |
|
|
|
|
|
return i; |
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
return -1; |
|
|
|
|
|
}; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function trim(str) { |
|
|
|
|
|
return str.replace(/^\s+|\s+$/g, ''); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function rtrim(str) { |
|
|
|
|
|
return str.replace(/\s+$/g, ''); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Remove one level of indentation from text. Indent is 4 spaces.
|
|
|
|
|
|
function outdent(text) { |
|
|
|
|
|
return text.replace(new RegExp('^(\\t|[ ]{1,4})', 'gm'), ''); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
function contains(str, substr) { |
|
|
|
|
|
return str.indexOf(substr) != -1; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Sanitize html, removing tags that aren't in the whitelist
|
|
|
|
|
|
function sanitizeHtml(html, whitelist) { |
|
|
|
|
|
return html.replace(/<[^>]*>?/gi, function(tag) { |
|
|
|
|
|
return tag.match(whitelist) ? tag : ''; |
|
|
|
|
|
}); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Merge two arrays, keeping only unique elements.
|
|
|
|
|
|
function union(x, y) { |
|
|
|
|
|
var obj = {}; |
|
|
|
|
|
for (var i = 0; i < x.length; i++) |
|
|
|
|
|
obj[x[i]] = x[i]; |
|
|
|
|
|
for (i = 0; i < y.length; i++) |
|
|
|
|
|
obj[y[i]] = y[i]; |
|
|
|
|
|
var res = []; |
|
|
|
|
|
for (var k in obj) { |
|
|
|
|
|
if (obj.hasOwnProperty(k)) |
|
|
|
|
|
res.push(obj[k]); |
|
|
|
|
|
} |
|
|
|
|
|
return res; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// JS regexes don't support \A or \Z, so we add sentinels, as Pagedown
|
|
|
|
|
|
// does. In this case, we add the ascii codes for start of text (STX) and
|
|
|
|
|
|
// end of text (ETX), an idea borrowed from:
|
|
|
|
|
|
// https://github.com/tanakahisateru/js-markdown-extra
|
|
|
|
|
|
function addAnchors(text) { |
|
|
|
|
|
if(text.charAt(0) != '\x02') |
|
|
|
|
|
text = '\x02' + text; |
|
|
|
|
|
if(text.charAt(text.length - 1) != '\x03') |
|
|
|
|
|
text = text + '\x03'; |
|
|
|
|
|
return text; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Remove STX and ETX sentinels.
|
|
|
|
|
|
function removeAnchors(text) { |
|
|
|
|
|
if(text.charAt(0) == '\x02') |
|
|
|
|
|
text = text.substr(1); |
|
|
|
|
|
if(text.charAt(text.length - 1) == '\x03') |
|
|
|
|
|
text = text.substr(0, text.length - 1); |
|
|
|
|
|
return text; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Convert markdown within an element, retaining only span-level tags
|
|
|
|
|
|
function convertSpans(text, extra) { |
|
|
|
|
|
return sanitizeHtml(convertAll(text, extra), inlineTags); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Convert internal markdown using the stock pagedown converter
|
|
|
|
|
|
function convertAll(text, extra) { |
|
|
|
|
|
var result = extra.blockGamutHookCallback(text); |
|
|
|
|
|
// We need to perform these operations since we skip the steps in the converter
|
|
|
|
|
|
result = unescapeSpecialChars(result); |
|
|
|
|
|
result = result.replace(/~D/g, "$$").replace(/~T/g, "~"); |
|
|
|
|
|
result = extra.previousPostConversion(result); |
|
|
|
|
|
return result; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Convert escaped special characters
|
|
|
|
|
|
function processEscapesStep1(text) { |
|
|
|
|
|
// Markdown extra adds two escapable characters, `:` and `|`
|
|
|
|
|
|
return text.replace(/\\\|/g, '~I').replace(/\\:/g, '~i'); |
|
|
|
|
|
} |
|
|
|
|
|
function processEscapesStep2(text) { |
|
|
|
|
|
return text.replace(/~I/g, '|').replace(/~i/g, ':'); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// Duplicated from PageDown converter
|
|
|
|
|
|
function unescapeSpecialChars(text) { |
|
|
|
|
|
// Swap back in all the special characters we've hidden.
|
|
|
|
|
|
text = text.replace(/~E(\d+)E/g, function(wholeMatch, m1) { |
|
|
|
|
|
var charCodeToReplace = parseInt(m1); |
|
|
|
|
|
return String.fromCharCode(charCodeToReplace); |
|
|
|
|
|
}); |
|
|
|
|
|
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 * |
|
|
|
|
|
****************************************************************************/ |
|
|
|
|
|
|
|
|
|
|
|
Markdown.Extra = function() { |
|
|
|
|
|
// For converting internal markdown (in tables for instance).
|
|
|
|
|
|
// This is necessary since these methods are meant to be called as
|
|
|
|
|
|
// preConversion hooks, and the Markdown converter passed to init()
|
|
|
|
|
|
// won't convert any markdown contained in the html tags we return.
|
|
|
|
|
|
this.converter = null; |
|
|
|
|
|
|
|
|
|
|
|
// 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; |
|
|
|
|
|
|
|
|
|
|
|
// Fenced code block options
|
|
|
|
|
|
this.googleCodePrettify = false; |
|
|
|
|
|
this.highlightJs = false; |
|
|
|
|
|
|
|
|
|
|
|
// Table options
|
|
|
|
|
|
this.tableClass = ''; |
|
|
|
|
|
|
|
|
|
|
|
this.tabWidth = 4; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
Markdown.Extra.init = function(converter, options) { |
|
|
|
|
|
// 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", "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, "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'; |
|
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
converter.hooks.chain("preBlockGamut", function(text, blockGamutHookCallback) { |
|
|
|
|
|
// Keep a reference to the block gamut callback to run recursively
|
|
|
|
|
|
extra.blockGamutHookCallback = blockGamutHookCallback; |
|
|
|
|
|
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
|
|
|
|
|
|
extra.previousPostConversion = converter.hooks.postConversion; |
|
|
|
|
|
converter.hooks.chain("postConversion", function(text) { |
|
|
|
|
|
text = extra.doTransform(postConversionTransformations, text); |
|
|
|
|
|
// Clear state vars that may use unnecessary memory
|
|
|
|
|
|
extra.hashBlocks = []; |
|
|
|
|
|
extra.footnotes = {}; |
|
|
|
|
|
extra.usedFootnotes = []; |
|
|
|
|
|
return text; |
|
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
if ("highlighter" in options) { |
|
|
|
|
|
extra.googleCodePrettify = options.highlighter === 'prettify'; |
|
|
|
|
|
extra.highlightJs = options.highlighter === 'highlight'; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if ("table_class" in options) { |
|
|
|
|
|
extra.tableClass = options.table_class; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
extra.converter = converter; |
|
|
|
|
|
|
|
|
|
|
|
// Caller usually won't need this, but it's handy for testing.
|
|
|
|
|
|
return extra; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
// Do transformations
|
|
|
|
|
|
Markdown.Extra.prototype.doTransform = function(transformations, text) { |
|
|
|
|
|
for(var i = 0; i < transformations.length; i++) |
|
|
|
|
|
text = this[transformations[i]](text); |
|
|
|
|
|
return text; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
// Return a placeholder containing a key, which is the block's index in the
|
|
|
|
|
|
// hashBlocks array. We wrap our output in a <p> tag here so Pagedown won't.
|
|
|
|
|
|
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) { |
|
|
|
|
|
hasHash = true; |
|
|
|
|
|
var key = parseInt(m1, 10); |
|
|
|
|
|
return self.hashBlocks[key]; |
|
|
|
|
|
}); |
|
|
|
|
|
if(hasHash === true) { |
|
|
|
|
|
recursiveUnHash(); |
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
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) { |
|
|
|
|
|
|
|
|
|
|
|
var self = this; |
|
|
|
|
|
function attributeCallback(wholeMatch, pre, attr) { |
|
|
|
|
|
return '<p>~XX' + (self.hashBlocks.push(attr) - 1) + 'XX</p>\n' + pre + "\n"; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
text = text.replace(hdrAttributesA, attributeCallback); // ## headers
|
|
|
|
|
|
text = text.replace(hdrAttributesB, attributeCallback); // underline headers
|
|
|
|
|
|
return text; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
// Extract FCB attribute blocks, move them above the element they will be
|
|
|
|
|
|
// applied to, and hash them for later.
|
|
|
|
|
|
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 self = this; |
|
|
|
|
|
function attributeCallback(wholeMatch, pre, attr) { |
|
|
|
|
|
return '<p>~XX' + (self.hashBlocks.push(attr) - 1) + 'XX</p>\n' + pre + "\n"; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
return text.replace(fcbAttributes, attributeCallback); |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
Markdown.Extra.prototype.applyAttributeBlocks = function(text) { |
|
|
|
|
|
var self = this; |
|
|
|
|
|
var blockRe = new RegExp('<p>~XX(\\d+)XX</p>[\\s]*' + |
|
|
|
|
|
'(?:<(h[1-6]|pre)(?: +class="(\\S+)")?(>[\\s\\S]*?</\\2>))', "gm"); |
|
|
|
|
|
text = text.replace(blockRe, function(wholeMatch, k, tag, cls, rest) { |
|
|
|
|
|
if (!tag) // no following header or fenced code block.
|
|
|
|
|
|
return ''; |
|
|
|
|
|
|
|
|
|
|
|
// get attributes list from hash
|
|
|
|
|
|
var key = parseInt(k, 10); |
|
|
|
|
|
var attributes = self.hashBlocks[key]; |
|
|
|
|
|
|
|
|
|
|
|
// get id
|
|
|
|
|
|
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) || []; |
|
|
|
|
|
for (var i = 0; i < classes.length; i++) // Remove leading dot
|
|
|
|
|
|
classes[i] = classes[i].substr(1, classes[i].length - 1); |
|
|
|
|
|
|
|
|
|
|
|
var classStr = ''; |
|
|
|
|
|
if (cls) |
|
|
|
|
|
classes = union(classes, [cls]); |
|
|
|
|
|
|
|
|
|
|
|
if (classes.length > 0) |
|
|
|
|
|
classStr = ' class="' + classes.join(' ') + '"'; |
|
|
|
|
|
|
|
|
|
|
|
return "<" + tag + idStr + classStr + rest; |
|
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
return text; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************** |
|
|
|
|
|
* Tables * |
|
|
|
|
|
*****************************************************************/ |
|
|
|
|
|
|
|
|
|
|
|
// Find and convert Markdown Extra tables into html.
|
|
|
|
|
|
Markdown.Extra.prototype.tables = function(text) { |
|
|
|
|
|
var self = this; |
|
|
|
|
|
|
|
|
|
|
|
var leadingPipe = new RegExp( |
|
|
|
|
|
['^' , |
|
|
|
|
|
'[ ]{0,3}' , // Allowed whitespace
|
|
|
|
|
|
'[|]' , // Initial pipe
|
|
|
|
|
|
'(.+)\\n' , // $1: Header Row
|
|
|
|
|
|
|
|
|
|
|
|
'[ ]{0,3}' , // Allowed whitespace
|
|
|
|
|
|
'[|]([ ]*[-:]+[-| :]*)\\n' , // $2: Separator
|
|
|
|
|
|
|
|
|
|
|
|
'(' , // $3: Table Body
|
|
|
|
|
|
'(?:[ ]*[|].*\\n?)*' , // Table rows
|
|
|
|
|
|
')', |
|
|
|
|
|
'(?:\\n|$)' // Stop at final newline
|
|
|
|
|
|
].join(''), |
|
|
|
|
|
'gm' |
|
|
|
|
|
); |
|
|
|
|
|
|
|
|
|
|
|
var noLeadingPipe = new RegExp( |
|
|
|
|
|
['^' , |
|
|
|
|
|
'[ ]{0,3}' , // Allowed whitespace
|
|
|
|
|
|
'(\\S.*[|].*)\\n' , // $1: Header Row
|
|
|
|
|
|
|
|
|
|
|
|
'[ ]{0,3}' , // Allowed whitespace
|
|
|
|
|
|
'([-:]+[ ]*[|][-| :]*)\\n' , // $2: Separator
|
|
|
|
|
|
|
|
|
|
|
|
'(' , // $3: Table Body
|
|
|
|
|
|
'(?:.*[|].*\\n?)*' , // Table rows
|
|
|
|
|
|
')' , |
|
|
|
|
|
'(?:\\n|$)' // Stop at final newline
|
|
|
|
|
|
].join(''), |
|
|
|
|
|
'gm' |
|
|
|
|
|
); |
|
|
|
|
|
|
|
|
|
|
|
text = text.replace(leadingPipe, doTable); |
|
|
|
|
|
text = text.replace(noLeadingPipe, doTable); |
|
|
|
|
|
|
|
|
|
|
|
// $1 = header, $2 = separator, $3 = body
|
|
|
|
|
|
function doTable(match, header, separator, body, offset, string) { |
|
|
|
|
|
// remove any leading pipes and whitespace
|
|
|
|
|
|
header = header.replace(/^ *[|]/m, ''); |
|
|
|
|
|
separator = separator.replace(/^ *[|]/m, ''); |
|
|
|
|
|
body = body.replace(/^ *[|]/gm, ''); |
|
|
|
|
|
|
|
|
|
|
|
// remove trailing pipes and whitespace
|
|
|
|
|
|
header = header.replace(/[|] *$/m, ''); |
|
|
|
|
|
separator = separator.replace(/[|] *$/m, ''); |
|
|
|
|
|
body = body.replace(/[|] *$/gm, ''); |
|
|
|
|
|
|
|
|
|
|
|
// determine column alignments
|
|
|
|
|
|
var alignspecs = separator.split(/ *[|] */); |
|
|
|
|
|
var align = []; |
|
|
|
|
|
for (var i = 0; i < alignspecs.length; i++) { |
|
|
|
|
|
var spec = alignspecs[i]; |
|
|
|
|
|
if (spec.match(/^ *-+: *$/m)) |
|
|
|
|
|
align[i] = ' align="right"'; |
|
|
|
|
|
else if (spec.match(/^ *:-+: *$/m)) |
|
|
|
|
|
align[i] = ' align="center"'; |
|
|
|
|
|
else if (spec.match(/^ *:-+ *$/m)) |
|
|
|
|
|
align[i] = ' align="left"'; |
|
|
|
|
|
else align[i] = ''; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// TODO: parse spans in header and rows before splitting, so that pipes
|
|
|
|
|
|
// inside of tags are not interpreted as separators
|
|
|
|
|
|
var headers = header.split(/ *[|] */); |
|
|
|
|
|
var colCount = headers.length; |
|
|
|
|
|
|
|
|
|
|
|
// build html
|
|
|
|
|
|
var cls = self.tableClass ? ' class="' + self.tableClass + '"' : ''; |
|
|
|
|
|
var html = ['<table', cls, '>\n', '<thead>\n', '<tr>\n'].join(''); |
|
|
|
|
|
|
|
|
|
|
|
// build column headers.
|
|
|
|
|
|
for (i = 0; i < colCount; i++) { |
|
|
|
|
|
var headerHtml = convertSpans(trim(headers[i]), self); |
|
|
|
|
|
html += [" <th", align[i], ">", headerHtml, "</th>\n"].join(''); |
|
|
|
|
|
} |
|
|
|
|
|
html += "</tr>\n</thead>\n"; |
|
|
|
|
|
|
|
|
|
|
|
// build rows
|
|
|
|
|
|
var rows = body.split('\n'); |
|
|
|
|
|
for (i = 0; i < rows.length; i++) { |
|
|
|
|
|
if (rows[i].match(/^\s*$/)) // can apply to final row
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
|
|
|
|
// ensure number of rowCells matches colCount
|
|
|
|
|
|
var rowCells = rows[i].split(/ *[|] */); |
|
|
|
|
|
var lenDiff = colCount - rowCells.length; |
|
|
|
|
|
for (var j = 0; j < lenDiff; j++) |
|
|
|
|
|
rowCells.push(''); |
|
|
|
|
|
|
|
|
|
|
|
html += "<tr>\n"; |
|
|
|
|
|
for (j = 0; j < colCount; j++) { |
|
|
|
|
|
var colHtml = convertSpans(trim(rowCells[j]), self); |
|
|
|
|
|
html += [" <td", align[j], ">", colHtml, "</td>\n"].join(''); |
|
|
|
|
|
} |
|
|
|
|
|
html += "</tr>\n"; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
html += "</table>\n"; |
|
|
|
|
|
|
|
|
|
|
|
// replace html with placeholder until postConversion step
|
|
|
|
|
|
return self.hashExtraBlock(html); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
return text; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************** |
|
|
|
|
|
* 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">↩</a></li>\n\n'; |
|
|
|
|
|
} |
|
|
|
|
|
text += '</ol>\n</div>'; |
|
|
|
|
|
return text; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************** |
|
|
|
|
|
* Fenced Code Blocks (gfm) * |
|
|
|
|
|
******************************************************************/ |
|
|
|
|
|
|
|
|
|
|
|
// Find and convert gfm-inspired fenced code blocks into html.
|
|
|
|
|
|
Markdown.Extra.prototype.fencedCodeBlocks = function(text) { |
|
|
|
|
|
function encodeCode(code) { |
|
|
|
|
|
code = code.replace(/&/g, "&"); |
|
|
|
|
|
code = code.replace(/</g, "<"); |
|
|
|
|
|
code = code.replace(/>/g, ">"); |
|
|
|
|
|
// These were escaped by PageDown before postNormalization
|
|
|
|
|
|
code = code.replace(/~D/g, "$$"); |
|
|
|
|
|
code = code.replace(/~T/g, "~"); |
|
|
|
|
|
return code; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
var self = this; |
|
|
|
|
|
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"' : ''; |
|
|
|
|
|
var codeclass = ''; |
|
|
|
|
|
if (language) { |
|
|
|
|
|
if (self.googleCodePrettify || self.highlightJs) { |
|
|
|
|
|
// use html5 language- class names. supported by both prettify and highlight.js
|
|
|
|
|
|
codeclass = ' class="language-' + language + '"'; |
|
|
|
|
|
} else { |
|
|
|
|
|
codeclass = ' class="' + language + '"'; |
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
var html = ['<pre', preclass, '><code', codeclass, '>', |
|
|
|
|
|
encodeCode(codeblock), '</code></pre>'].join(''); |
|
|
|
|
|
|
|
|
|
|
|
// replace codeblock with placeholder until postConversion step
|
|
|
|
|
|
return self.hashExtraBlock(html); |
|
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
return text; |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************** |
|
|
|
|
|
* 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, "—").replace(/--/g, "–"); |
|
|
|
|
|
// Ellipses
|
|
|
|
|
|
text = text.replace(/\.\.\./g, "…").replace(/\.\s\.\s\./g, "…"); |
|
|
|
|
|
// Backticks
|
|
|
|
|
|
text = text.replace(/``/g, "“").replace (/''/g, "”"); |
|
|
|
|
|
|
|
|
|
|
|
if(/^'$/.test(text)) { |
|
|
|
|
|
// Special case: single-character ' token
|
|
|
|
|
|
if(/\S/.test(this.smartyPantsLastChar)) { |
|
|
|
|
|
return "’"; |
|
|
|
|
|
} |
|
|
|
|
|
return "‘"; |
|
|
|
|
|
} |
|
|
|
|
|
if(/^"$/.test(text)) { |
|
|
|
|
|
// Special case: single-character " token
|
|
|
|
|
|
if(/\S/.test(this.smartyPantsLastChar)) { |
|
|
|
|
|
return "”"; |
|
|
|
|
|
} |
|
|
|
|
|
return "“"; |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// 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)/, "’"); |
|
|
|
|
|
text = text.replace (/^"(?=[!"#\$\%'()*+,\-.\/:;<=>?\@\[\\]\^_`{|}~]\B)/, "”"); |
|
|
|
|
|
|
|
|
|
|
|
// Special case for double sets of quotes, e.g.:
|
|
|
|
|
|
// <p>He said, "'Quoted' words in a larger quote."</p>
|
|
|
|
|
|
text = text.replace(/"'(?=\w)/g, "“‘"); |
|
|
|
|
|
text = text.replace(/'"(?=\w)/g, "‘“"); |
|
|
|
|
|
|
|
|
|
|
|
// Special case for decade abbreviations (the '80s):
|
|
|
|
|
|
text = text.replace(/'(?=\d{2}s)/g, "’"); |
|
|
|
|
|
|
|
|
|
|
|
// Get most opening single quotes:
|
|
|
|
|
|
text = text.replace(/(\s| |--|&[mn]dash;|&\#8211;|&\#8212;|&\#x201[34];)'(?=\w)/g, "$1‘"); |
|
|
|
|
|
|
|
|
|
|
|
// Single closing quotes:
|
|
|
|
|
|
text = text.replace(/([^\s\[\{\(\-])'/g, "$1’"); |
|
|
|
|
|
text = text.replace(/'(?=\s|s\b)/g, "’"); |
|
|
|
|
|
|
|
|
|
|
|
// Any remaining single quotes should be opening ones:
|
|
|
|
|
|
text = text.replace(/'/g, "‘"); |
|
|
|
|
|
|
|
|
|
|
|
// Get most opening double quotes:
|
|
|
|
|
|
text = text.replace(/(\s| |--|&[mn]dash;|&\#8211;|&\#8212;|&\#x201[34];)"(?=\w)/g, "$1“"); |
|
|
|
|
|
|
|
|
|
|
|
// Double closing quotes:
|
|
|
|
|
|
text = text.replace(/([^\s\[\{\(\-])"/g, "$1”"); |
|
|
|
|
|
text = text.replace(/"(?=\s)/g, "”"); |
|
|
|
|
|
|
|
|
|
|
|
// Any remaining quotes should be opening ones.
|
|
|
|
|
|
text = text.replace(/"/ig, "“"); |
|
|
|
|
|
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 * |
|
|
|
|
|
******************************************************************/ |
|
|
|
|
|
|
|
|
|
|
|
// Find and convert markdown extra definition lists into html.
|
|
|
|
|
|
Markdown.Extra.prototype.definitionLists = function(text) { |
|
|
|
|
|
var wholeList = new RegExp( |
|
|
|
|
|
['(\\x02\\n?|\\n\\n)' , |
|
|
|
|
|
'(?:' , |
|
|
|
|
|
'(' , // $1 = whole list
|
|
|
|
|
|
'(' , // $2
|
|
|
|
|
|
'[ ]{0,3}' , |
|
|
|
|
|
'((?:[ \\t]*\\S.*\\n)+)', // $3 = defined term
|
|
|
|
|
|
'\\n?' , |
|
|
|
|
|
'[ ]{0,3}:[ ]+' , // colon starting definition
|
|
|
|
|
|
')' , |
|
|
|
|
|
'([\\s\\S]+?)' , |
|
|
|
|
|
'(' , // $4
|
|
|
|
|
|
'(?=\\0x03)' , // \z
|
|
|
|
|
|
'|' , |
|
|
|
|
|
'(?=' , |
|
|
|
|
|
'\\n{2,}' , |
|
|
|
|
|
'(?=\\S)' , |
|
|
|
|
|
'(?!' , // Negative lookahead for another term
|
|
|
|
|
|
'[ ]{0,3}' , |
|
|
|
|
|
'(?:\\S.*\\n)+?' , // defined term
|
|
|
|
|
|
'\\n?' , |
|
|
|
|
|
'[ ]{0,3}:[ ]+' , // colon starting definition
|
|
|
|
|
|
')' , |
|
|
|
|
|
'(?!' , // Negative lookahead for another definition
|
|
|
|
|
|
'[ ]{0,3}:[ ]+' , // colon starting definition
|
|
|
|
|
|
')' , |
|
|
|
|
|
')' , |
|
|
|
|
|
')' , |
|
|
|
|
|
')' , |
|
|
|
|
|
')' |
|
|
|
|
|
].join(''), |
|
|
|
|
|
'gm' |
|
|
|
|
|
); |
|
|
|
|
|
|
|
|
|
|
|
var self = this; |
|
|
|
|
|
text = addAnchors(text); |
|
|
|
|
|
|
|
|
|
|
|
text = text.replace(wholeList, function(match, pre, list) { |
|
|
|
|
|
var result = trim(self.processDefListItems(list)); |
|
|
|
|
|
result = "<dl>\n" + result + "\n</dl>"; |
|
|
|
|
|
return pre + self.hashExtraBlock(result) + "\n\n"; |
|
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
return removeAnchors(text); |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
// Process the contents of a single definition list, splitting it
|
|
|
|
|
|
// into individual term and definition list items.
|
|
|
|
|
|
Markdown.Extra.prototype.processDefListItems = function(listStr) { |
|
|
|
|
|
var self = this; |
|
|
|
|
|
|
|
|
|
|
|
var dt = new RegExp( |
|
|
|
|
|
['(\\x02\\n?|\\n\\n+)' , // leading line
|
|
|
|
|
|
'(' , // definition terms = $1
|
|
|
|
|
|
'[ ]{0,3}' , // leading whitespace
|
|
|
|
|
|
'(?![:][ ]|[ ])' , // negative lookahead for a definition
|
|
|
|
|
|
// mark (colon) or more whitespace
|
|
|
|
|
|
'(?:\\S.*\\n)+?' , // actual term (not whitespace)
|
|
|
|
|
|
')' , |
|
|
|
|
|
'(?=\\n?[ ]{0,3}:[ ])' // lookahead for following line feed
|
|
|
|
|
|
].join(''), // with a definition mark
|
|
|
|
|
|
'gm' |
|
|
|
|
|
); |
|
|
|
|
|
|
|
|
|
|
|
var dd = new RegExp( |
|
|
|
|
|
['\\n(\\n+)?' , // leading line = $1
|
|
|
|
|
|
'(' , // marker space = $2
|
|
|
|
|
|
'[ ]{0,3}' , // whitespace before colon
|
|
|
|
|
|
'[:][ ]+' , // definition mark (colon)
|
|
|
|
|
|
')' , |
|
|
|
|
|
'([\\s\\S]+?)' , // definition text = $3
|
|
|
|
|
|
'(?=\\n*' , // stop at next definition mark,
|
|
|
|
|
|
'(?:' , // next term or end of text
|
|
|
|
|
|
'\\n[ ]{0,3}[:][ ]|' , |
|
|
|
|
|
'<dt>|\\x03' , // \z
|
|
|
|
|
|
')' , |
|
|
|
|
|
')' |
|
|
|
|
|
].join(''), |
|
|
|
|
|
'gm' |
|
|
|
|
|
); |
|
|
|
|
|
|
|
|
|
|
|
listStr = addAnchors(listStr); |
|
|
|
|
|
// trim trailing blank lines:
|
|
|
|
|
|
listStr = listStr.replace(/\n{2,}(?=\\x03)/, "\n"); |
|
|
|
|
|
|
|
|
|
|
|
// Process definition terms.
|
|
|
|
|
|
listStr = listStr.replace(dt, function(match, pre, termsStr) { |
|
|
|
|
|
var terms = trim(termsStr).split("\n"); |
|
|
|
|
|
var text = ''; |
|
|
|
|
|
for (var i = 0; i < terms.length; i++) { |
|
|
|
|
|
var term = terms[i]; |
|
|
|
|
|
// process spans inside dt
|
|
|
|
|
|
term = convertSpans(trim(term), self); |
|
|
|
|
|
text += "\n<dt>" + term + "</dt>"; |
|
|
|
|
|
} |
|
|
|
|
|
return text + "\n"; |
|
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
// Process actual definitions.
|
|
|
|
|
|
listStr = listStr.replace(dd, function(match, leadingLine, markerSpace, def) { |
|
|
|
|
|
if (leadingLine || def.match(/\n{2,}/)) { |
|
|
|
|
|
// replace marker with the appropriate whitespace indentation
|
|
|
|
|
|
def = Array(markerSpace.length + 1).join(' ') + def; |
|
|
|
|
|
// process markdown inside definition
|
|
|
|
|
|
// TODO?: currently doesn't apply extensions
|
|
|
|
|
|
def = outdent(def) + "\n\n"; |
|
|
|
|
|
def = "\n" + convertAll(def, self) + "\n"; |
|
|
|
|
|
} else { |
|
|
|
|
|
// convert span-level markdown inside definition
|
|
|
|
|
|
def = rtrim(def); |
|
|
|
|
|
def = convertSpans(outdent(def), self); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
return "\n<dd>" + def + "</dd>\n"; |
|
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
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"; |
|
|
|
|
|
}); |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
})(); |
|
|
|
|
|
|
|
|
|
anasfanani
1 year ago