Markdown parser, done right. 100% CommonMark support, extensions, syntax plugins & high speed
https://markdown-it.github.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1547 lines
46 KiB
1547 lines
46 KiB
// stmd.js - CommomMark in javascript
|
|
// Copyright (C) 2014 John MacFarlane
|
|
// License: BSD3.
|
|
|
|
// Basic usage:
|
|
//
|
|
// var stmd = require('stmd');
|
|
// var parser = new stmd.DocParser();
|
|
// var renderer = new stmd.HtmlRenderer();
|
|
// console.log(renderer.render(parser.parse('Hello *world*')));
|
|
|
|
(function(exports) {
|
|
|
|
// Some regexps used in inline parser:
|
|
|
|
var ESCAPABLE = '[!"#$%&\'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]';
|
|
var ESCAPED_CHAR = '\\\\' + ESCAPABLE;
|
|
var IN_DOUBLE_QUOTES = '"(' + ESCAPED_CHAR + '|[^"\\x00])*"';
|
|
var IN_SINGLE_QUOTES = '\'(' + ESCAPED_CHAR + '|[^\'\\x00])*\'';
|
|
var IN_PARENS = '\\((' + ESCAPED_CHAR + '|[^)\\x00])*\\)';
|
|
var REG_CHAR = '[^\\\\()\\x00-\\x20]';
|
|
var IN_PARENS_NOSP = '\\((' + REG_CHAR + '|' + ESCAPED_CHAR + ')*\\)';
|
|
var TAGNAME = '[A-Za-z][A-Za-z0-9]*';
|
|
var BLOCKTAGNAME = '(?:article|header|aside|hgroup|iframe|blockquote|hr|body|li|map|button|object|canvas|ol|caption|output|col|p|colgroup|pre|dd|progress|div|section|dl|table|td|dt|tbody|embed|textarea|fieldset|tfoot|figcaption|th|figure|thead|footer|footer|tr|form|ul|h1|h2|h3|h4|h5|h6|video|script|style)';
|
|
var ATTRIBUTENAME = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
|
|
var UNQUOTEDVALUE = "[^\"'=<>`\\x00-\\x20]+";
|
|
var SINGLEQUOTEDVALUE = "'[^']*'";
|
|
var DOUBLEQUOTEDVALUE = '"[^"]*"';
|
|
var ATTRIBUTEVALUE = "(?:" + UNQUOTEDVALUE + "|" + SINGLEQUOTEDVALUE + "|" + DOUBLEQUOTEDVALUE + ")";
|
|
var ATTRIBUTEVALUESPEC = "(?:" + "\\s*=" + "\\s*" + ATTRIBUTEVALUE + ")";
|
|
var ATTRIBUTE = "(?:" + "\\s+" + ATTRIBUTENAME + ATTRIBUTEVALUESPEC + "?)";
|
|
var OPENTAG = "<" + TAGNAME + ATTRIBUTE + "*" + "\\s*/?>";
|
|
var CLOSETAG = "</" + TAGNAME + "\\s*[>]";
|
|
var OPENBLOCKTAG = "<" + BLOCKTAGNAME + ATTRIBUTE + "*" + "\\s*/?>";
|
|
var CLOSEBLOCKTAG = "</" + BLOCKTAGNAME + "\\s*[>]";
|
|
var HTMLCOMMENT = "<!--([^-]+|[-][^-]+)*-->";
|
|
var PROCESSINGINSTRUCTION = "[<][?].*?[?][>]";
|
|
var DECLARATION = "<![A-Z]+" + "\\s+[^>]*>";
|
|
var CDATA = "<!\\[CDATA\\[([^\\]]+|\\][^\\]]|\\]\\][^>])*\\]\\]>";
|
|
var HTMLTAG = "(?:" + OPENTAG + "|" + CLOSETAG + "|" + HTMLCOMMENT + "|" +
|
|
PROCESSINGINSTRUCTION + "|" + DECLARATION + "|" + CDATA + ")";
|
|
var HTMLBLOCKOPEN = "<(?:" + BLOCKTAGNAME + "[\\s/>]" + "|" +
|
|
"/" + BLOCKTAGNAME + "[\\s>]" + "|" + "[?!])";
|
|
|
|
var reHtmlTag = new RegExp('^' + HTMLTAG, 'i');
|
|
|
|
var reHtmlBlockOpen = new RegExp('^' + HTMLBLOCKOPEN, 'i');
|
|
|
|
var reLinkTitle = new RegExp(
|
|
'^(?:"(' + ESCAPED_CHAR + '|[^"\\x00])*"' +
|
|
'|' +
|
|
'\'(' + ESCAPED_CHAR + '|[^\'\\x00])*\'' +
|
|
'|' +
|
|
'\\((' + ESCAPED_CHAR + '|[^)\\x00])*\\))');
|
|
|
|
var reLinkDestinationBraces = new RegExp(
|
|
'^(?:[<](?:[^<>\\n\\\\\\x00]' + '|' + ESCAPED_CHAR + '|' + '\\\\)*[>])');
|
|
|
|
var reLinkDestination = new RegExp(
|
|
'^(?:' + REG_CHAR + '+|' + ESCAPED_CHAR + '|' + IN_PARENS_NOSP + ')*');
|
|
|
|
var reEscapable = new RegExp(ESCAPABLE);
|
|
|
|
var reAllEscapedChar = new RegExp('\\\\(' + ESCAPABLE + ')', 'g');
|
|
|
|
var reEscapedChar = new RegExp('^\\\\(' + ESCAPABLE + ')');
|
|
|
|
var reAllTab = /\t/g;
|
|
|
|
var reHrule = /^(?:(?:\* *){3,}|(?:_ *){3,}|(?:- *){3,}) *$/;
|
|
|
|
// Matches a character with a special meaning in markdown,
|
|
// or a string of non-special characters.
|
|
var reMain = /^(?:[\n`\[\]\\!<&*_]|[^\n`\[\]\\!<&*_]+)/m;
|
|
|
|
// UTILITY FUNCTIONS
|
|
|
|
// Replace backslash escapes with literal characters.
|
|
var unescape = function(s) {
|
|
return s.replace(reAllEscapedChar, '$1');
|
|
};
|
|
|
|
// Returns true if string contains only space characters.
|
|
var isBlank = function(s) {
|
|
return /^\s*$/.test(s);
|
|
};
|
|
|
|
// Normalize reference label: collapse internal whitespace
|
|
// to single space, remove leading/trailing whitespace, case fold.
|
|
var normalizeReference = function(s) {
|
|
return s.trim()
|
|
.replace(/\s+/,' ')
|
|
.toUpperCase();
|
|
};
|
|
|
|
// Attempt to match a regex in string s at offset offset.
|
|
// Return index of match or null.
|
|
var matchAt = function(re, s, offset) {
|
|
var res = s.slice(offset).match(re);
|
|
if (res) {
|
|
return offset + res.index;
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
// Convert tabs to spaces on each line using a 4-space tab stop.
|
|
var detabLine = function(text) {
|
|
if (text.indexOf('\t') == -1) {
|
|
return text;
|
|
} else {
|
|
var lastStop = 0;
|
|
return text.replace(reAllTab, function(match, offset) {
|
|
var result = ' '.slice((offset - lastStop) % 4);
|
|
lastStop = offset + 1;
|
|
return result;
|
|
});
|
|
}
|
|
};
|
|
|
|
// INLINE PARSER
|
|
|
|
// These are methods of an InlineParser object, defined below.
|
|
// An InlineParser keeps track of a subject (a string to be
|
|
// parsed) and a position in that subject.
|
|
|
|
// If re matches at current position in the subject, advance
|
|
// position in subject and return the match; otherwise return null.
|
|
var match = function(re) {
|
|
var match = re.exec(this.subject.slice(this.pos));
|
|
if (match) {
|
|
this.pos += match.index + match[0].length;
|
|
return match[0];
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
// Returns the character at the current subject position, or null if
|
|
// there are no more characters.
|
|
var peek = function() {
|
|
return this.subject[this.pos] || null;
|
|
};
|
|
|
|
// Parse zero or more space characters, including at most one newline
|
|
var spnl = function() {
|
|
this.match(/^ *(?:\n *)?/);
|
|
return 1;
|
|
};
|
|
|
|
// All of the parsers below try to match something at the current position
|
|
// in the subject. If they succeed in matching anything, they
|
|
// push an inline element onto the 'inlines' list. They return the
|
|
// number of characters parsed (possibly 0).
|
|
|
|
// Attempt to parse backticks, adding either a backtick code span or a
|
|
// literal sequence of backticks to the 'inlines' list.
|
|
var parseBackticks = function(inlines) {
|
|
var startpos = this.pos;
|
|
var ticks = this.match(/^`+/);
|
|
if (!ticks) {
|
|
return 0;
|
|
}
|
|
var afterOpenTicks = this.pos;
|
|
var foundCode = false;
|
|
var match;
|
|
while (!foundCode && (match = this.match(/`+/m))) {
|
|
if (match == ticks) {
|
|
inlines.push({ t: 'Code', c: this.subject.slice(afterOpenTicks,
|
|
this.pos - ticks.length)
|
|
.replace(/[ \n]+/g,' ')
|
|
.trim() });
|
|
return (this.pos - startpos);
|
|
}
|
|
}
|
|
// If we got here, we didn't match a closing backtick sequence.
|
|
inlines.push({ t: 'Str', c: ticks });
|
|
this.pos = afterOpenTicks;
|
|
return (this.pos - startpos);
|
|
};
|
|
|
|
// Parse a backslash-escaped special character, adding either the escaped
|
|
// character, a hard line break (if the backslash is followed by a newline),
|
|
// or a literal backslash to the 'inlines' list.
|
|
var parseEscaped = function(inlines) {
|
|
var subj = this.subject,
|
|
pos = this.pos;
|
|
if (subj[pos] === '\\') {
|
|
if (subj[pos + 1] === '\n') {
|
|
inlines.push({ t: 'Hardbreak' });
|
|
this.pos = this.pos + 2;
|
|
return 2;
|
|
} else if (reEscapable.test(subj[pos + 1])) {
|
|
inlines.push({ t: 'Str', c: subj[pos + 1] });
|
|
this.pos = this.pos + 2;
|
|
return 2;
|
|
} else {
|
|
this.pos++;
|
|
inlines.push({t: 'Str', c: '\\'});
|
|
return 1;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Attempt to parse an autolink (URL or email in pointy brackets).
|
|
var parseAutolink = function(inlines) {
|
|
var m;
|
|
var dest;
|
|
if ((m = this.match(/^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/))) { // email autolink
|
|
dest = m.slice(1,-1);
|
|
inlines.push({ t: 'Link', label: [{ t: 'Str', c: dest }],
|
|
destination: 'mailto:' + dest });
|
|
return m.length;
|
|
} else if ((m = this.match(/^<(?:coap|doi|javascript|aaa|aaas|about|acap|cap|cid|crid|data|dav|dict|dns|file|ftp|geo|go|gopher|h323|http|https|iax|icap|im|imap|info|ipp|iris|iris.beep|iris.xpc|iris.xpcs|iris.lwz|ldap|mailto|mid|msrp|msrps|mtqp|mupdate|news|nfs|ni|nih|nntp|opaquelocktoken|pop|pres|rtsp|service|session|shttp|sieve|sip|sips|sms|snmp|soap.beep|soap.beeps|tag|tel|telnet|tftp|thismessage|tn3270|tip|tv|urn|vemmi|ws|wss|xcon|xcon-userid|xmlrpc.beep|xmlrpc.beeps|xmpp|z39.50r|z39.50s|adiumxtra|afp|afs|aim|apt|attachment|aw|beshare|bitcoin|bolo|callto|chrome|chrome-extension|com-eventbrite-attendee|content|cvs|dlna-playsingle|dlna-playcontainer|dtn|dvb|ed2k|facetime|feed|finger|fish|gg|git|gizmoproject|gtalk|hcp|icon|ipn|irc|irc6|ircs|itms|jar|jms|keyparc|lastfm|ldaps|magnet|maps|market|message|mms|ms-help|msnim|mumble|mvn|notes|oid|palm|paparazzi|platform|proxy|psyc|query|res|resource|rmi|rsync|rtmp|secondlife|sftp|sgn|skype|smb|soldat|spotify|ssh|steam|svn|teamspeak|things|udp|unreal|ut2004|ventrilo|view-source|webcal|wtai|wyciwyg|xfire|xri|ymsgr):[^<>\x00-\x20]*>/i))) {
|
|
dest = m.slice(1,-1);
|
|
inlines.push({ t: 'Link', label: [{ t: 'Str', c: dest }],
|
|
destination: dest });
|
|
return m.length;
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Attempt to parse a raw HTML tag.
|
|
var parseHtmlTag = function(inlines) {
|
|
var m = this.match(reHtmlTag);
|
|
if (m) {
|
|
inlines.push({ t: 'Html', c: m });
|
|
return m.length;
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Scan a sequence of characters == c, and return information about
|
|
// the number of delimiters and whether they are positioned such that
|
|
// they can open and/or close emphasis or strong emphasis. A utility
|
|
// function for strong/emph parsing.
|
|
var scanDelims = function(c) {
|
|
var numdelims = 0;
|
|
var first_close_delims = 0;
|
|
var char_before, char_after;
|
|
var startpos = this.pos;
|
|
|
|
char_before = this.pos === 0 ? '\n' :
|
|
this.subject[this.pos - 1];
|
|
|
|
while (this.peek() === c) {
|
|
numdelims++;
|
|
this.pos++;
|
|
}
|
|
|
|
char_after = this.peek() || '\n';
|
|
|
|
var can_open = numdelims > 0 && numdelims <= 3 && !(/\s/.test(char_after));
|
|
var can_close = numdelims > 0 && numdelims <= 3 && !(/\s/.test(char_before));
|
|
if (c === '_') {
|
|
can_open = can_open && !((/[a-z0-9]/i).test(char_before));
|
|
can_close = can_close && !((/[a-z0-9]/i).test(char_after));
|
|
}
|
|
this.pos = startpos;
|
|
return { numdelims: numdelims,
|
|
can_open: can_open,
|
|
can_close: can_close };
|
|
};
|
|
|
|
// Attempt to parse emphasis or strong emphasis in an efficient way,
|
|
// with no backtracking.
|
|
var parseEmphasis = function(inlines) {
|
|
var startpos = this.pos;
|
|
var c ;
|
|
var first_close = 0;
|
|
var nxt = this.peek();
|
|
if (nxt == '*' || nxt == '_') {
|
|
c = nxt;
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
var numdelims;
|
|
var delimpos;
|
|
|
|
// Get opening delimiters.
|
|
res = this.scanDelims(c);
|
|
numdelims = res.numdelims;
|
|
this.pos += numdelims;
|
|
// We provisionally add a literal string. If we match appropriate
|
|
// closing delimiters, we'll change this to Strong or Emph.
|
|
inlines.push({t: 'Str',
|
|
c: this.subject.substr(this.pos - numdelims, numdelims)});
|
|
// Record the position of this opening delimiter:
|
|
delimpos = inlines.length - 1;
|
|
|
|
if (!res.can_open || numdelims === 0) {
|
|
return 0;
|
|
}
|
|
|
|
var first_close_delims = 0;
|
|
|
|
switch (numdelims) {
|
|
case 1: // we started with * or _
|
|
while (true) {
|
|
res = this.scanDelims(c);
|
|
if (res.numdelims >= 1 && res.can_close) {
|
|
this.pos += 1;
|
|
// Convert the inline at delimpos, currently a string with the delim,
|
|
// into an Emph whose contents are the succeeding inlines
|
|
inlines[delimpos].t = 'Emph';
|
|
inlines[delimpos].c = inlines.slice(delimpos + 1);
|
|
inlines.splice(delimpos + 1);
|
|
break;
|
|
} else {
|
|
if (this.parseInline(inlines) === 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return (this.pos - startpos);
|
|
|
|
case 2: // We started with ** or __
|
|
while (true) {
|
|
res = this.scanDelims(c);
|
|
if (res.numdelims >= 2 && res.can_close) {
|
|
this.pos += 2;
|
|
inlines[delimpos].t = 'Strong';
|
|
inlines[delimpos].c = inlines.slice(delimpos + 1);
|
|
inlines.splice(delimpos + 1);
|
|
break;
|
|
} else {
|
|
if (this.parseInline(inlines) === 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return (this.pos - startpos);
|
|
|
|
case 3: // We started with *** or ___
|
|
while (true) {
|
|
res = this.scanDelims(c);
|
|
if (res.numdelims >= 1 && res.numdelims <= 3 && res.can_close &&
|
|
res.numdelims != first_close_delims) {
|
|
|
|
if (first_close_delims === 1 && numdelims > 2) {
|
|
res.numdelims = 2;
|
|
} else if (first_close_delims === 2) {
|
|
res.numdelims = 1;
|
|
} else if (res.numdelims === 3) {
|
|
// If we opened with ***, then we interpret *** as ** followed by *
|
|
// giving us <strong><em>
|
|
res.numdelims = 1;
|
|
}
|
|
|
|
this.pos += res.numdelims;
|
|
|
|
if (first_close > 0) { // if we've already passed the first closer:
|
|
inlines[delimpos].t = first_close_delims === 1 ? 'Strong' : 'Emph';
|
|
inlines[delimpos].c = [
|
|
{ t: first_close_delims === 1 ? 'Emph' : 'Strong',
|
|
c: inlines.slice(delimpos + 1, first_close)}
|
|
].concat(inlines.slice(first_close + 1));
|
|
inlines.splice(delimpos + 1);
|
|
break;
|
|
} else { // this is the first closer; for now, add literal string;
|
|
// we'll change this when he hit the second closer
|
|
inlines.push({t: 'Str',
|
|
c: this.subject.slice(this.pos - res.numdelims,
|
|
this.pos) });
|
|
first_close = inlines.length - 1;
|
|
first_close_delims = res.numdelims;
|
|
}
|
|
} else { // parse another inline element, til we hit the end
|
|
if (this.parseInline(inlines) === 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return (this.pos - startpos);
|
|
|
|
default:
|
|
return res;
|
|
}
|
|
|
|
return 0;
|
|
};
|
|
|
|
// Attempt to parse link title (sans quotes), returning the string
|
|
// or null if no match.
|
|
var parseLinkTitle = function() {
|
|
var title = this.match(reLinkTitle);
|
|
if (title) {
|
|
// chop off quotes from title and unescape:
|
|
return unescape(title.substr(1, title.length - 2));
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
// Attempt to parse link destination, returning the string or
|
|
// null if no match.
|
|
var parseLinkDestination = function() {
|
|
var res = this.match(reLinkDestinationBraces);
|
|
if (res) { // chop off surrounding <..>:
|
|
return unescape(res.substr(1, res.length - 2));
|
|
} else {
|
|
res = this.match(reLinkDestination);
|
|
if (res !== null) {
|
|
return unescape(res);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
|
|
// Attempt to parse a link label, returning number of characters parsed.
|
|
var parseLinkLabel = function() {
|
|
if (this.peek() != '[') {
|
|
return 0;
|
|
}
|
|
var startpos = this.pos;
|
|
var nest_level = 0;
|
|
if (this.label_nest_level > 0) {
|
|
// If we've already checked to the end of this subject
|
|
// for a label, even with a different starting [, we
|
|
// know we won't find one here and we can just return.
|
|
// This avoids lots of backtracking.
|
|
// Note: nest level 1 would be: [foo [bar]
|
|
// nest level 2 would be: [foo [bar [baz]
|
|
this.label_nest_level--;
|
|
return 0;
|
|
}
|
|
this.pos++; // advance past [
|
|
var c;
|
|
while ((c = this.peek()) && (c != ']' || nest_level > 0)) {
|
|
switch (c) {
|
|
case '`':
|
|
this.parseBackticks([]);
|
|
break;
|
|
case '<':
|
|
this.parseAutolink([]) || this.parseHtmlTag([]) || this.parseString([]);
|
|
break;
|
|
case '[': // nested []
|
|
nest_level++;
|
|
this.pos++;
|
|
break;
|
|
case ']': // nested []
|
|
nest_level--;
|
|
this.pos++;
|
|
break;
|
|
case '\\':
|
|
this.parseEscaped([]);
|
|
break;
|
|
default:
|
|
this.parseString([]);
|
|
}
|
|
}
|
|
if (c === ']') {
|
|
this.label_nest_level = 0;
|
|
this.pos++; // advance past ]
|
|
return this.pos - startpos;
|
|
} else {
|
|
if (!c) {
|
|
this.label_nest_level = nest_level;
|
|
}
|
|
this.pos = startpos;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Parse raw link label, including surrounding [], and return
|
|
// inline contents. (Note: this is not a method of InlineParser.)
|
|
var parseRawLabel = function(s) {
|
|
// note: parse without a refmap; we don't want links to resolve
|
|
// in nested brackets!
|
|
return new InlineParser().parse(s.substr(1, s.length - 2), {});
|
|
};
|
|
|
|
// Attempt to parse a link. If successful, add the link to
|
|
// inlines.
|
|
var parseLink = function(inlines) {
|
|
var startpos = this.pos;
|
|
var reflabel;
|
|
var n;
|
|
var dest;
|
|
var title;
|
|
|
|
n = this.parseLinkLabel();
|
|
if (n === 0) {
|
|
return 0;
|
|
}
|
|
var afterlabel = this.pos;
|
|
var rawlabel = this.subject.substr(startpos, n);
|
|
|
|
// if we got this far, we've parsed a label.
|
|
// Try to parse an explicit link: [label](url "title")
|
|
if (this.peek() == '(') {
|
|
this.pos++;
|
|
if (this.spnl() &&
|
|
((dest = this.parseLinkDestination()) !== null) &&
|
|
this.spnl() &&
|
|
// make sure there's a space before the title:
|
|
(/^\s/.test(this.subject[this.pos - 1]) &&
|
|
(title = this.parseLinkTitle() || '') || true) &&
|
|
this.spnl() &&
|
|
this.match(/^\)/)) {
|
|
inlines.push({ t: 'Link',
|
|
destination: dest,
|
|
title: title,
|
|
label: parseRawLabel(rawlabel) });
|
|
return this.pos - startpos;
|
|
} else {
|
|
this.pos = startpos;
|
|
return 0;
|
|
}
|
|
}
|
|
// If we're here, it wasn't an explicit link. Try to parse a reference link.
|
|
// first, see if there's another label
|
|
var savepos = this.pos;
|
|
this.spnl();
|
|
var beforelabel = this.pos;
|
|
n = this.parseLinkLabel();
|
|
if (n == 2) {
|
|
// empty second label
|
|
reflabel = rawlabel;
|
|
} else if (n > 0) {
|
|
reflabel = this.subject.slice(beforelabel, beforelabel + n);
|
|
} else {
|
|
this.pos = savepos;
|
|
reflabel = rawlabel;
|
|
}
|
|
// lookup rawlabel in refmap
|
|
var link = this.refmap[normalizeReference(reflabel)];
|
|
if (link) {
|
|
inlines.push({t: 'Link',
|
|
destination: link.destination,
|
|
title: link.title,
|
|
label: parseRawLabel(rawlabel) });
|
|
return this.pos - startpos;
|
|
} else {
|
|
this.pos = startpos;
|
|
return 0;
|
|
}
|
|
// Nothing worked, rewind:
|
|
this.pos = startpos;
|
|
return 0;
|
|
};
|
|
|
|
// Attempt to parse an entity, adding to inlines if successful.
|
|
var parseEntity = function(inlines) {
|
|
var m;
|
|
if ((m = this.match(/^&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});/i))) {
|
|
inlines.push({ t: 'Entity', c: m });
|
|
return m.length;
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Parse a run of ordinary characters, or a single character with
|
|
// a special meaning in markdown, as a plain string, adding to inlines.
|
|
var parseString = function(inlines) {
|
|
var m;
|
|
if ((m = this.match(reMain))) {
|
|
inlines.push({ t: 'Str', c: m });
|
|
return m.length;
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Parse a newline. If it was preceded by two spaces, return a hard
|
|
// line break; otherwise a soft line break.
|
|
var parseNewline = function(inlines) {
|
|
if (this.peek() == '\n') {
|
|
this.pos++;
|
|
var last = inlines[inlines.length - 1];
|
|
if (last && last.t == 'Str' && last.c.slice(-2) == ' ') {
|
|
last.c = last.c.replace(/ *$/,'');
|
|
inlines.push({ t: 'Hardbreak' });
|
|
} else {
|
|
if (last && last.t == 'Str' && last.c.slice(-1) == ' ') {
|
|
last.c = last.c.slice(0, -1);
|
|
}
|
|
inlines.push({ t: 'Softbreak' });
|
|
}
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Attempt to parse an image. If the opening '!' is not followed
|
|
// by a link, add a literal '!' to inlines.
|
|
var parseImage = function(inlines) {
|
|
if (this.match(/^!/)) {
|
|
var n = this.parseLink(inlines);
|
|
if (n === 0) {
|
|
inlines.push({ t: 'Str', c: '!' });
|
|
return 1;
|
|
} else if (inlines[inlines.length - 1] &&
|
|
inlines[inlines.length - 1].t == 'Link') {
|
|
inlines[inlines.length - 1].t = 'Image';
|
|
return n+1;
|
|
} else {
|
|
throw "Shouldn't happen";
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
// Attempt to parse a link reference, modifying refmap.
|
|
var parseReference = function(s, refmap) {
|
|
this.subject = s;
|
|
this.pos = 0;
|
|
var rawlabel;
|
|
var dest;
|
|
var title;
|
|
var matchChars;
|
|
var startpos = this.pos;
|
|
var match;
|
|
|
|
// label:
|
|
matchChars = this.parseLinkLabel();
|
|
if (matchChars === 0) {
|
|
return 0;
|
|
} else {
|
|
rawlabel = this.subject.substr(0, matchChars);
|
|
}
|
|
|
|
// colon:
|
|
if (this.peek() === ':') {
|
|
this.pos++;
|
|
} else {
|
|
this.pos = startpos;
|
|
return 0;
|
|
}
|
|
|
|
// link url
|
|
this.spnl();
|
|
|
|
dest = this.parseLinkDestination();
|
|
if (dest === null || dest.length === 0) {
|
|
this.pos = startpos;
|
|
return 0;
|
|
}
|
|
|
|
var beforetitle = this.pos;
|
|
this.spnl();
|
|
title = this.parseLinkTitle();
|
|
if (title === null) {
|
|
title = '';
|
|
// rewind before spaces
|
|
this.pos = beforetitle;
|
|
}
|
|
|
|
// make sure we're at line end:
|
|
if (this.match(/^ *(?:\n|$)/) === null) {
|
|
this.pos = startpos;
|
|
return 0;
|
|
}
|
|
|
|
var normlabel = normalizeReference(rawlabel);
|
|
|
|
if (!refmap[normlabel]) {
|
|
refmap[normlabel] = { destination: dest, title: title };
|
|
}
|
|
return this.pos - startpos;
|
|
};
|
|
|
|
// Parse the next inline element in subject, advancing subject position
|
|
// and adding the result to 'inlines'.
|
|
var parseInline = function(inlines) {
|
|
var c = this.peek();
|
|
var res;
|
|
switch(c) {
|
|
case '\n':
|
|
res = this.parseNewline(inlines);
|
|
break;
|
|
case '\\':
|
|
res = this.parseEscaped(inlines);
|
|
break;
|
|
case '`':
|
|
res = this.parseBackticks(inlines);
|
|
break;
|
|
case '*':
|
|
case '_':
|
|
res = this.parseEmphasis(inlines);
|
|
break;
|
|
case '[':
|
|
res = this.parseLink(inlines);
|
|
break;
|
|
case '!':
|
|
res = this.parseImage(inlines);
|
|
break;
|
|
case '<':
|
|
res = this.parseAutolink(inlines) ||
|
|
this.parseHtmlTag(inlines);
|
|
break;
|
|
case '&':
|
|
res = this.parseEntity(inlines);
|
|
break;
|
|
default:
|
|
}
|
|
return res || this.parseString(inlines);
|
|
};
|
|
|
|
// Parse s as a list of inlines, using refmap to resolve references.
|
|
var parseInlines = function(s, refmap) {
|
|
this.subject = s;
|
|
this.pos = 0;
|
|
this.refmap = refmap || {};
|
|
var inlines = [];
|
|
while (this.parseInline(inlines)) ;
|
|
return inlines;
|
|
};
|
|
|
|
// The InlineParser object.
|
|
function InlineParser(){
|
|
return {
|
|
subject: '',
|
|
label_nest_level: 0, // used by parseLinkLabel method
|
|
pos: 0,
|
|
refmap: {},
|
|
match: match,
|
|
peek: peek,
|
|
spnl: spnl,
|
|
parseBackticks: parseBackticks,
|
|
parseEscaped: parseEscaped,
|
|
parseAutolink: parseAutolink,
|
|
parseHtmlTag: parseHtmlTag,
|
|
scanDelims: scanDelims,
|
|
parseEmphasis: parseEmphasis,
|
|
parseLinkTitle: parseLinkTitle,
|
|
parseLinkDestination: parseLinkDestination,
|
|
parseLinkLabel: parseLinkLabel,
|
|
parseLink: parseLink,
|
|
parseEntity: parseEntity,
|
|
parseString: parseString,
|
|
parseNewline: parseNewline,
|
|
parseImage: parseImage,
|
|
parseReference: parseReference,
|
|
parseInline: parseInline,
|
|
parse: parseInlines
|
|
};
|
|
}
|
|
|
|
// DOC PARSER
|
|
|
|
// These are methods of a DocParser object, defined below.
|
|
|
|
var makeBlock = function(tag, start_line, start_column) {
|
|
return { t: tag,
|
|
open: true,
|
|
last_line_blank: false,
|
|
start_line: start_line,
|
|
start_column: start_column,
|
|
end_line: start_line,
|
|
children: [],
|
|
parent: null,
|
|
// string_content is formed by concatenating strings, in finalize:
|
|
string_content: "",
|
|
strings: [],
|
|
inline_content: []
|
|
};
|
|
};
|
|
|
|
// Returns true if parent block can contain child block.
|
|
var canContain = function(parent_type, child_type) {
|
|
return ( parent_type == 'Document' ||
|
|
parent_type == 'BlockQuote' ||
|
|
parent_type == 'ListItem' ||
|
|
(parent_type == 'List' && child_type == 'ListItem') );
|
|
};
|
|
|
|
// Returns true if block type can accept lines of text.
|
|
var acceptsLines = function(block_type) {
|
|
return ( block_type == 'Paragraph' ||
|
|
block_type == 'IndentedCode' ||
|
|
block_type == 'FencedCode' );
|
|
};
|
|
|
|
// Returns true if block ends with a blank line, descending if needed
|
|
// into lists and sublists.
|
|
var endsWithBlankLine = function(block) {
|
|
if (block.last_line_blank) {
|
|
return true;
|
|
}
|
|
if ((block.t == 'List' || block.t == 'ListItem') && block.children.length > 0) {
|
|
return endsWithBlankLine(block.children[block.children.length - 1]);
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Break out of all containing lists, resetting the tip of the
|
|
// document to the parent of the highest list, and finalizing
|
|
// all the lists. (This is used to implement the "two blank lines
|
|
// break of of all lists" feature.)
|
|
var breakOutOfLists = function(block, line_number) {
|
|
var b = block;
|
|
var last_list = null;
|
|
do {
|
|
if (b.t === 'List') {
|
|
last_list = b;
|
|
}
|
|
b = b.parent;
|
|
} while (b);
|
|
|
|
if (last_list) {
|
|
while (block != last_list) {
|
|
this.finalize(block, line_number);
|
|
block = block.parent;
|
|
}
|
|
this.finalize(last_list, line_number);
|
|
this.tip = last_list.parent;
|
|
}
|
|
};
|
|
|
|
// Add a line to the block at the tip. We assume the tip
|
|
// can accept lines -- that check should be done before calling this.
|
|
var addLine = function(ln, offset) {
|
|
var s = ln.slice(offset);
|
|
if (!(this.tip.open)) {
|
|
throw({ msg: "Attempted to add line (" + ln + ") to closed container." });
|
|
}
|
|
this.tip.strings.push(s);
|
|
};
|
|
|
|
// Add block of type tag as a child of the tip. If the tip can't
|
|
// accept children, close and finalize it and try its parent,
|
|
// and so on til we find a block that can accept children.
|
|
var addChild = function(tag, line_number, offset) {
|
|
while (!canContain(this.tip.t, tag)) {
|
|
this.finalize(this.tip, line_number);
|
|
}
|
|
|
|
var column_number = offset + 1; // offset 0 = column 1
|
|
var newBlock = makeBlock(tag, line_number, column_number);
|
|
this.tip.children.push(newBlock);
|
|
newBlock.parent = this.tip;
|
|
this.tip = newBlock;
|
|
return newBlock;
|
|
};
|
|
|
|
// Parse a list marker and return data on the marker (type,
|
|
// start, delimiter, bullet character, padding) or null.
|
|
var parseListMarker = function(ln, offset) {
|
|
var rest = ln.slice(offset);
|
|
var match;
|
|
var spaces_after_marker;
|
|
var data = {};
|
|
if (rest.match(reHrule)) {
|
|
return null;
|
|
}
|
|
if ((match = rest.match(/^[*+-]( +|$)/))) {
|
|
spaces_after_marker = match[1].length;
|
|
data.type = 'Bullet';
|
|
data.bullet_char = match[0][0];
|
|
|
|
} else if ((match = rest.match(/^(\d+)([.)])( +|$)/))) {
|
|
spaces_after_marker = match[3].length;
|
|
data.type = 'Ordered';
|
|
data.start = parseInt(match[1]);
|
|
data.delimiter = match[2];
|
|
} else {
|
|
return null;
|
|
}
|
|
var blank_item = match[0].length === rest.length;
|
|
if (spaces_after_marker >= 5 ||
|
|
spaces_after_marker < 1 ||
|
|
blank_item) {
|
|
data.padding = match[0].length - spaces_after_marker + 1;
|
|
} else {
|
|
data.padding = match[0].length;
|
|
}
|
|
return data;
|
|
};
|
|
|
|
// Returns true if the two list items are of the same type,
|
|
// with the same delimiter and bullet character. This is used
|
|
// in agglomerating list items into lists.
|
|
var listsMatch = function(list_data, item_data) {
|
|
return (list_data.type === item_data.type &&
|
|
list_data.delimiter === item_data.delimiter &&
|
|
list_data.bullet_char === item_data.bullet_char);
|
|
};
|
|
|
|
// Analyze a line of text and update the document appropriately.
|
|
// We parse markdown text by calling this on each line of input,
|
|
// then finalizing the document.
|
|
var incorporateLine = function(ln, line_number) {
|
|
|
|
var all_matched = true;
|
|
var last_child;
|
|
var first_nonspace;
|
|
var offset = 0;
|
|
var match;
|
|
var data;
|
|
var blank;
|
|
var indent;
|
|
var last_matched_container;
|
|
var i;
|
|
var CODE_INDENT = 4;
|
|
|
|
var container = this.doc;
|
|
var oldtip = this.tip;
|
|
|
|
// Convert tabs to spaces:
|
|
ln = detabLine(ln);
|
|
|
|
// For each containing block, try to parse the associated line start.
|
|
// Bail out on failure: container will point to the last matching block.
|
|
// Set all_matched to false if not all containers match.
|
|
while (container.children.length > 0) {
|
|
last_child = container.children[container.children.length - 1];
|
|
if (!last_child.open) {
|
|
break;
|
|
}
|
|
container = last_child;
|
|
|
|
match = matchAt(/[^ ]/, ln, offset);
|
|
if (match === null) {
|
|
first_nonspace = ln.length;
|
|
blank = true;
|
|
} else {
|
|
first_nonspace = match;
|
|
blank = false;
|
|
}
|
|
indent = first_nonspace - offset;
|
|
|
|
switch (container.t) {
|
|
case 'BlockQuote':
|
|
var matched = indent <= 3 && ln[first_nonspace] === '>';
|
|
if (matched) {
|
|
offset = first_nonspace + 1;
|
|
if (ln[offset] === ' ') {
|
|
offset++;
|
|
}
|
|
} else {
|
|
all_matched = false;
|
|
}
|
|
break;
|
|
|
|
case 'ListItem':
|
|
if (indent >= container.list_data.marker_offset +
|
|
container.list_data.padding) {
|
|
offset += container.list_data.marker_offset +
|
|
container.list_data.padding;
|
|
} else if (blank) {
|
|
offset = first_nonspace;
|
|
} else {
|
|
all_matched = false;
|
|
}
|
|
break;
|
|
|
|
case 'IndentedCode':
|
|
if (indent >= CODE_INDENT) {
|
|
offset += CODE_INDENT;
|
|
} else if (blank) {
|
|
offset = first_nonspace;
|
|
} else {
|
|
all_matched = false;
|
|
}
|
|
break;
|
|
|
|
case 'ATXHeader':
|
|
case 'SetextHeader':
|
|
case 'HorizontalRule':
|
|
// a header can never container > 1 line, so fail to match:
|
|
all_matched = false;
|
|
break;
|
|
|
|
case 'FencedCode':
|
|
// skip optional spaces of fence offset
|
|
i = container.fence_offset;
|
|
while (i > 0 && ln[offset] === ' ') {
|
|
offset++;
|
|
i--;
|
|
}
|
|
break;
|
|
|
|
case 'HtmlBlock':
|
|
if (blank) {
|
|
all_matched = false;
|
|
}
|
|
break;
|
|
|
|
case 'Paragraph':
|
|
if (blank) {
|
|
container.last_line_blank = true;
|
|
all_matched = false;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
}
|
|
|
|
if (!all_matched) {
|
|
container = container.parent; // back up to last matching block
|
|
break;
|
|
}
|
|
}
|
|
|
|
last_matched_container = container;
|
|
|
|
// This function is used to finalize and close any unmatched
|
|
// blocks. We aren't ready to do this now, because we might
|
|
// have a lazy paragraph continuation, in which case we don't
|
|
// want to close unmatched blocks. So we store this closure for
|
|
// use later, when we have more information.
|
|
var closeUnmatchedBlocks = function(mythis) {
|
|
// finalize any blocks not matched
|
|
while (!already_done && oldtip != last_matched_container) {
|
|
mythis.finalize(oldtip, line_number);
|
|
oldtip = oldtip.parent;
|
|
}
|
|
var already_done = true;
|
|
};
|
|
|
|
// Check to see if we've hit 2nd blank line; if so break out of list:
|
|
if (blank && container.last_line_blank) {
|
|
this.breakOutOfLists(container, line_number);
|
|
}
|
|
|
|
// Unless last matched container is a code block, try new container starts,
|
|
// adding children to the last matched container:
|
|
while (container.t != 'FencedCode' &&
|
|
container.t != 'IndentedCode' &&
|
|
container.t != 'HtmlBlock' &&
|
|
// this is a little performance optimization:
|
|
matchAt(/^[ #`~*+_=<>0-9-]/,ln,offset) !== null) {
|
|
|
|
match = matchAt(/[^ ]/, ln, offset);
|
|
if (match === null) {
|
|
first_nonspace = ln.length;
|
|
blank = true;
|
|
} else {
|
|
first_nonspace = match;
|
|
blank = false;
|
|
}
|
|
indent = first_nonspace - offset;
|
|
|
|
if (indent >= CODE_INDENT) {
|
|
// indented code
|
|
if (this.tip.t != 'Paragraph' && !blank) {
|
|
offset += CODE_INDENT;
|
|
closeUnmatchedBlocks(this);
|
|
container = this.addChild('IndentedCode', line_number, offset);
|
|
} else { // indent > 4 in a lazy paragraph continuation
|
|
break;
|
|
}
|
|
|
|
} else if (ln[first_nonspace] === '>') {
|
|
// blockquote
|
|
offset = first_nonspace + 1;
|
|
// optional following space
|
|
if (ln[offset] === ' ') {
|
|
offset++;
|
|
}
|
|
closeUnmatchedBlocks(this);
|
|
container = this.addChild('BlockQuote', line_number, offset);
|
|
|
|
} else if ((match = ln.slice(first_nonspace).match(/^#{1,6}(?: +|$)/))) {
|
|
// ATX header
|
|
offset = first_nonspace + match[0].length;
|
|
closeUnmatchedBlocks(this);
|
|
container = this.addChild('ATXHeader', line_number, first_nonspace);
|
|
container.level = match[0].trim().length; // number of #s
|
|
// remove trailing ###s:
|
|
container.strings =
|
|
[ln.slice(offset).replace(/(?:(\\#) *#*| *#+) *$/,'$1')];
|
|
break;
|
|
|
|
} else if ((match = ln.slice(first_nonspace).match(/^`{3,}(?!.*`)|^~{3,}(?!.*~)/))) {
|
|
// fenced code block
|
|
var fence_length = match[0].length;
|
|
closeUnmatchedBlocks(this);
|
|
container = this.addChild('FencedCode', line_number, first_nonspace);
|
|
container.fence_length = fence_length;
|
|
container.fence_char = match[0][0];
|
|
container.fence_offset = first_nonspace - offset;
|
|
offset = first_nonspace + fence_length;
|
|
break;
|
|
|
|
} else if (matchAt(reHtmlBlockOpen, ln, first_nonspace) !== null) {
|
|
// html block
|
|
closeUnmatchedBlocks(this);
|
|
container = this.addChild('HtmlBlock', line_number, first_nonspace);
|
|
// note, we don't adjust offset because the tag is part of the text
|
|
break;
|
|
|
|
} else if (container.t == 'Paragraph' &&
|
|
container.strings.length === 1 &&
|
|
((match = ln.slice(first_nonspace).match(/^(?:=+|-+) *$/)))) {
|
|
// setext header line
|
|
closeUnmatchedBlocks(this);
|
|
container.t = 'SetextHeader'; // convert Paragraph to SetextHeader
|
|
container.level = match[0][0] === '=' ? 1 : 2;
|
|
offset = ln.length;
|
|
|
|
} else if (matchAt(reHrule, ln, first_nonspace) !== null) {
|
|
// hrule
|
|
closeUnmatchedBlocks(this);
|
|
container = this.addChild('HorizontalRule', line_number, first_nonspace);
|
|
offset = ln.length - 1;
|
|
break;
|
|
|
|
} else if ((data = parseListMarker(ln, first_nonspace))) {
|
|
// list item
|
|
closeUnmatchedBlocks(this);
|
|
data.marker_offset = indent;
|
|
offset = first_nonspace + data.padding;
|
|
|
|
// add the list if needed
|
|
if (container.t !== 'List' ||
|
|
!(listsMatch(container.list_data, data))) {
|
|
container = this.addChild('List', line_number, first_nonspace);
|
|
container.list_data = data;
|
|
}
|
|
|
|
// add the list item
|
|
container = this.addChild('ListItem', line_number, first_nonspace);
|
|
container.list_data = data;
|
|
|
|
} else {
|
|
break;
|
|
|
|
}
|
|
|
|
if (acceptsLines(container.t)) {
|
|
// if it's a line container, it can't contain other containers
|
|
break;
|
|
}
|
|
}
|
|
|
|
// What remains at the offset is a text line. Add the text to the
|
|
// appropriate container.
|
|
|
|
match = matchAt(/[^ ]/, ln, offset);
|
|
if (match === null) {
|
|
first_nonspace = ln.length;
|
|
blank = true;
|
|
} else {
|
|
first_nonspace = match;
|
|
blank = false;
|
|
}
|
|
indent = first_nonspace - offset;
|
|
|
|
// First check for a lazy paragraph continuation:
|
|
if (this.tip !== last_matched_container &&
|
|
!blank &&
|
|
this.tip.t == 'Paragraph' &&
|
|
this.tip.strings.length > 0) {
|
|
// lazy paragraph continuation
|
|
|
|
this.last_line_blank = false;
|
|
this.addLine(ln, offset);
|
|
|
|
} else { // not a lazy continuation
|
|
|
|
// finalize any blocks not matched
|
|
closeUnmatchedBlocks(this);
|
|
|
|
// Block quote lines are never blank as they start with >
|
|
// and we don't count blanks in fenced code for purposes of tight/loose
|
|
// lists or breaking out of lists. We also don't set last_line_blank
|
|
// on an empty list item.
|
|
container.last_line_blank = blank &&
|
|
!(container.t == 'BlockQuote' ||
|
|
container.t == 'FencedCode' ||
|
|
(container.t == 'ListItem' &&
|
|
container.children.length === 0 &&
|
|
container.start_line == line_number));
|
|
|
|
var cont = container;
|
|
while (cont.parent) {
|
|
cont.parent.last_line_blank = false;
|
|
cont = cont.parent;
|
|
}
|
|
|
|
switch (container.t) {
|
|
case 'IndentedCode':
|
|
case 'HtmlBlock':
|
|
this.addLine(ln, offset);
|
|
break;
|
|
|
|
case 'FencedCode':
|
|
// check for closing code fence:
|
|
match = (indent <= 3 &&
|
|
ln[first_nonspace] == container.fence_char &&
|
|
ln.slice(first_nonspace).match(/^(?:`{3,}|~{3,})(?= *$)/));
|
|
if (match && match[0].length >= container.fence_length) {
|
|
// don't add closing fence to container; instead, close it:
|
|
this.finalize(container, line_number);
|
|
} else {
|
|
this.addLine(ln, offset);
|
|
}
|
|
break;
|
|
|
|
case 'ATXHeader':
|
|
case 'SetextHeader':
|
|
case 'HorizontalRule':
|
|
// nothing to do; we already added the contents.
|
|
break;
|
|
|
|
default:
|
|
if (acceptsLines(container.t)) {
|
|
this.addLine(ln, first_nonspace);
|
|
} else if (blank) {
|
|
// do nothing
|
|
} else if (container.t != 'HorizontalRule' &&
|
|
container.t != 'SetextHeader') {
|
|
// create paragraph container for line
|
|
container = this.addChild('Paragraph', line_number, first_nonspace);
|
|
this.addLine(ln, first_nonspace);
|
|
} else {
|
|
console.log("Line " + line_number.toString() +
|
|
" with container type " + container.t +
|
|
" did not match any condition.");
|
|
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Finalize a block. Close it and do any necessary postprocessing,
|
|
// e.g. creating string_content from strings, setting the 'tight'
|
|
// or 'loose' status of a list, and parsing the beginnings
|
|
// of paragraphs for reference definitions. Reset the tip to the
|
|
// parent of the closed block.
|
|
var finalize = function(block, line_number) {
|
|
var pos;
|
|
// don't do anything if the block is already closed
|
|
if (!block.open) {
|
|
return 0;
|
|
}
|
|
block.open = false;
|
|
if (line_number > block.start_line) {
|
|
block.end_line = line_number - 1;
|
|
} else {
|
|
block.end_line = line_number;
|
|
}
|
|
|
|
switch (block.t) {
|
|
case 'Paragraph':
|
|
block.string_content = block.strings.join('\n').replace(/^ */m,'');
|
|
|
|
// try parsing the beginning as link reference definitions:
|
|
while (block.string_content[0] === '[' &&
|
|
(pos = this.inlineParser.parseReference(block.string_content,
|
|
this.refmap))) {
|
|
block.string_content = block.string_content.slice(pos);
|
|
if (isBlank(block.string_content)) {
|
|
block.t = 'ReferenceDef';
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'ATXHeader':
|
|
case 'SetextHeader':
|
|
case 'HtmlBlock':
|
|
block.string_content = block.strings.join('\n');
|
|
break;
|
|
|
|
case 'IndentedCode':
|
|
block.string_content = block.strings.join('\n').replace(/(\n *)*$/,'\n');
|
|
break;
|
|
|
|
case 'FencedCode':
|
|
// first line becomes info string
|
|
block.info = unescape(block.strings[0].trim());
|
|
if (block.strings.length == 1) {
|
|
block.string_content = '';
|
|
} else {
|
|
block.string_content = block.strings.slice(1).join('\n') + '\n';
|
|
}
|
|
break;
|
|
|
|
case 'List':
|
|
block.tight = true; // tight by default
|
|
|
|
var numitems = block.children.length;
|
|
var i = 0;
|
|
while (i < numitems) {
|
|
var item = block.children[i];
|
|
// check for non-final list item ending with blank line:
|
|
var last_item = i == numitems - 1;
|
|
if (endsWithBlankLine(item) && !last_item) {
|
|
block.tight = false;
|
|
break;
|
|
}
|
|
// recurse into children of list item, to see if there are
|
|
// spaces between any of them:
|
|
var numsubitems = item.children.length;
|
|
var j = 0;
|
|
while (j < numsubitems) {
|
|
var subitem = item.children[j];
|
|
var last_subitem = j == numsubitems - 1;
|
|
if (endsWithBlankLine(subitem) && !(last_item && last_subitem)) {
|
|
block.tight = false;
|
|
break;
|
|
}
|
|
j++;
|
|
}
|
|
i++;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
this.tip = block.parent || this.top;
|
|
};
|
|
|
|
// Walk through a block & children recursively, parsing string content
|
|
// into inline content where appropriate.
|
|
var processInlines = function(block) {
|
|
switch(block.t) {
|
|
case 'Paragraph':
|
|
case 'SetextHeader':
|
|
case 'ATXHeader':
|
|
block.inline_content =
|
|
this.inlineParser.parse(block.string_content.trim(), this.refmap);
|
|
block.string_content = "";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (block.children) {
|
|
for (var i = 0; i < block.children.length; i++) {
|
|
this.processInlines(block.children[i]);
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
// The main parsing function. Returns a parsed document AST.
|
|
var parse = function(input) {
|
|
this.doc = makeBlock('Document', 1, 1);
|
|
this.tip = this.doc;
|
|
this.refmap = {};
|
|
var lines = input.replace(/\n$/,'').split(/\r\n|\n|\r/);
|
|
var len = lines.length;
|
|
for (var i = 0; i < len; i++) {
|
|
this.incorporateLine(lines[i], i+1);
|
|
}
|
|
while (this.tip) {
|
|
this.finalize(this.tip, len - 1);
|
|
}
|
|
this.processInlines(this.doc);
|
|
return this.doc;
|
|
};
|
|
|
|
|
|
// The DocParser object.
|
|
function DocParser(){
|
|
return {
|
|
doc: makeBlock('Document', 1, 1),
|
|
tip: this.doc,
|
|
refmap: {},
|
|
inlineParser: new InlineParser(),
|
|
breakOutOfLists: breakOutOfLists,
|
|
addLine: addLine,
|
|
addChild: addChild,
|
|
incorporateLine: incorporateLine,
|
|
finalize: finalize,
|
|
processInlines: processInlines,
|
|
parse: parse
|
|
};
|
|
}
|
|
|
|
// HTML RENDERER
|
|
|
|
// Helper function to produce content in a pair of HTML tags.
|
|
var inTags = function(tag, attribs, contents, selfclosing) {
|
|
var result = '<' + tag;
|
|
if (attribs) {
|
|
var i = 0;
|
|
var attrib;
|
|
while ((attrib = attribs[i]) !== undefined) {
|
|
result = result.concat(' ', attrib[0], '="', attrib[1], '"');
|
|
i++;
|
|
}
|
|
}
|
|
if (contents) {
|
|
result = result.concat('>', contents, '</', tag, '>');
|
|
} else if (selfclosing) {
|
|
result = result + ' />';
|
|
} else {
|
|
result = result.concat('></', tag, '>');
|
|
}
|
|
return result;
|
|
};
|
|
|
|
// Render an inline element as HTML.
|
|
var renderInline = function(inline) {
|
|
var attrs;
|
|
switch (inline.t) {
|
|
case 'Str':
|
|
return this.escape(inline.c);
|
|
case 'Softbreak':
|
|
return this.softbreak;
|
|
case 'Hardbreak':
|
|
return inTags('br',[],"",true) + '\n';
|
|
case 'Emph':
|
|
return inTags('em', [], this.renderInlines(inline.c));
|
|
case 'Strong':
|
|
return inTags('strong', [], this.renderInlines(inline.c));
|
|
case 'Html':
|
|
return inline.c;
|
|
case 'Entity':
|
|
return inline.c;
|
|
case 'Link':
|
|
attrs = [['href', this.escape(inline.destination, true)]];
|
|
if (inline.title) {
|
|
attrs.push(['title', this.escape(inline.title, true)]);
|
|
}
|
|
return inTags('a', attrs, this.renderInlines(inline.label));
|
|
case 'Image':
|
|
attrs = [['src', this.escape(inline.destination, true)],
|
|
['alt', this.escape(this.renderInlines(inline.label))]];
|
|
if (inline.title) {
|
|
attrs.push(['title', this.escape(inline.title, true)]);
|
|
}
|
|
return inTags('img', attrs, "", true);
|
|
case 'Code':
|
|
return inTags('code', [], this.escape(inline.c));
|
|
default:
|
|
console.log("Uknown inline type " + inline.t);
|
|
return "";
|
|
}
|
|
};
|
|
|
|
// Render a list of inlines.
|
|
var renderInlines = function(inlines) {
|
|
var result = '';
|
|
for (var i=0; i < inlines.length; i++) {
|
|
result = result + this.renderInline(inlines[i]);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
// Render a single block element.
|
|
var renderBlock = function(block, in_tight_list) {
|
|
var tag;
|
|
var attr;
|
|
var info_words;
|
|
switch (block.t) {
|
|
case 'Document':
|
|
var whole_doc = this.renderBlocks(block.children);
|
|
return (whole_doc === '' ? '' : whole_doc + '\n');
|
|
case 'Paragraph':
|
|
if (in_tight_list) {
|
|
return this.renderInlines(block.inline_content);
|
|
} else {
|
|
return inTags('p', [], this.renderInlines(block.inline_content));
|
|
}
|
|
break;
|
|
case 'BlockQuote':
|
|
var filling = this.renderBlocks(block.children);
|
|
return inTags('blockquote', [], filling === '' ? this.innersep :
|
|
this.innersep + this.renderBlocks(block.children) + this.innersep);
|
|
case 'ListItem':
|
|
return inTags('li', [], this.renderBlocks(block.children, in_tight_list).trim());
|
|
case 'List':
|
|
tag = block.list_data.type == 'Bullet' ? 'ul' : 'ol';
|
|
attr = (!block.list_data.start || block.list_data.start == 1) ?
|
|
[] : [['start', block.list_data.start.toString()]];
|
|
return inTags(tag, attr, this.innersep +
|
|
this.renderBlocks(block.children, block.tight) +
|
|
this.innersep);
|
|
case 'ATXHeader':
|
|
case 'SetextHeader':
|
|
tag = 'h' + block.level;
|
|
return inTags(tag, [], this.renderInlines(block.inline_content));
|
|
case 'IndentedCode':
|
|
return inTags('pre', [],
|
|
inTags('code', [], this.escape(block.string_content)));
|
|
case 'FencedCode':
|
|
info_words = block.info.split(/ +/);
|
|
attr = info_words.length === 0 || info_words[0].length === 0 ?
|
|
[] : [['class','language-' +
|
|
this.escape(info_words[0],true)]];
|
|
return inTags('pre', [],
|
|
inTags('code', attr, this.escape(block.string_content)));
|
|
case 'HtmlBlock':
|
|
return block.string_content;
|
|
case 'ReferenceDef':
|
|
return "";
|
|
case 'HorizontalRule':
|
|
return inTags('hr',[],"",true);
|
|
default:
|
|
console.log("Uknown block type " + block.t);
|
|
return "";
|
|
}
|
|
};
|
|
|
|
// Render a list of block elements, separated by this.blocksep.
|
|
var renderBlocks = function(blocks, in_tight_list) {
|
|
var result = [];
|
|
for (var i=0; i < blocks.length; i++) {
|
|
if (blocks[i].t !== 'ReferenceDef') {
|
|
result.push(this.renderBlock(blocks[i], in_tight_list));
|
|
}
|
|
}
|
|
return result.join(this.blocksep);
|
|
};
|
|
|
|
// The HtmlRenderer object.
|
|
function HtmlRenderer(){
|
|
return {
|
|
// default options:
|
|
blocksep: '\n', // space between blocks
|
|
innersep: '\n', // space between block container tag and contents
|
|
softbreak: '\n', // by default, soft breaks are rendered as newlines in HTML
|
|
// set to "<br />" to make them hard breaks
|
|
// set to " " if you want to ignore line wrapping in source
|
|
escape: function(s, preserve_entities) {
|
|
if (preserve_entities) {
|
|
return s.replace(/[&](?;|[a-z][a-z0-9]{1,31};)/gi,'&')
|
|
.replace(/[<]/g,'<')
|
|
.replace(/[>]/g,'>')
|
|
.replace(/["]/g,'"');
|
|
} else {
|
|
return s.replace(/[&]/g,'&')
|
|
.replace(/[<]/g,'<')
|
|
.replace(/[>]/g,'>')
|
|
.replace(/["]/g,'"');
|
|
}
|
|
},
|
|
renderInline: renderInline,
|
|
renderInlines: renderInlines,
|
|
renderBlock: renderBlock,
|
|
renderBlocks: renderBlocks,
|
|
render: renderBlock
|
|
};
|
|
}
|
|
|
|
exports.DocParser = DocParser;
|
|
exports.HtmlRenderer = HtmlRenderer;
|
|
|
|
})(typeof exports === 'undefined' ? this.stmd = {} : exports);
|
|
|