"); dest.SmartHtmlEncodeAmpsAndAngles(li.def.title, 0, li.def.title.length); dest.Append("
\n"); } dest.Append(""); this.Render(dest, str); dest.Append("
\n"); } } // Format part of a string into a destination string builder p.Format2 = function (dest, str) { this.Format(dest, str, 0, str.length); } // Format part of a string into a destination string builder p.Format = function (dest, str, start, len) { // Parse the string into a list of tokens this.Tokenize(str, start, len); // Render all tokens this.Render(dest, str); } // Format a string and return it as a new string // (used in formatting the text of links) p.FormatDirect = function (str) { var dest = new StringBuilder(); this.Format(dest, str, 0, str.length); return dest.ToString(); } p.MakeID = function (str, start, len) { // Parse the string into a list of tokens this.Tokenize(str, start, len); var tokens = this.m_Tokens; var sb = new StringBuilder(); for (var i = 0; i < tokens.length; i++) { var t = tokens[i]; switch (t.type) { case TokenType_Text: sb.Append(str.substr(t.startOffset, t.length)); break; case TokenType_link: sb.Append(t.data.link_text); break; } this.FreeToken(t); } // Now clean it using the same rules as pandoc var p = this.m_Scanner; p.reset(sb.ToString()); // Skip everything up to the first letter while (!p.eof()) { if (is_alpha(p.current())) break; p.SkipForward(1); } // Process all characters sb.Clear(); while (!p.eof()) { var ch = p.current(); if (is_alphadigit(ch) || ch == '_' || ch == '-' || ch == '.') sb.Append(ch.toLowerCase()); else if (ch == ' ') sb.Append("-"); else if (is_lineend(ch)) { sb.Append("-"); p.SkipEol(); continue; } p.SkipForward(1); } return sb.ToString(); } // Render a list of tokens to a destination string builder. p.Render = function (sb, str) { var tokens = this.m_Tokens; var len = tokens.length; for (var i = 0; i < len; i++) { var t = tokens[i]; switch (t.type) { case TokenType_Text: // Append encoded text sb.HtmlEncode(str, t.startOffset, t.length); break; case TokenType_HtmlTag: // Append html as is sb.SmartHtmlEncodeAmps(str, t.startOffset, t.length); break; case TokenType_Html: case TokenType_opening_mark: case TokenType_closing_mark: case TokenType_internal_mark: // Append html as is sb.Append(str.substr(t.startOffset, t.length)); break; case TokenType_br: sb.Append("");
sb.HtmlEncode(str, t.startOffset, t.length);
sb.Append("");
break;
case TokenType_link:
var li = t.data;
var sf = new SpanFormatter(this.m_Markdown);
sf.m_DisableLinks = true;
li.def.RenderLink(this.m_Markdown, sb, sf.FormatDirect(li.link_text));
break;
case TokenType_img:
var li = t.data;
li.def.RenderImg(this.m_Markdown, sb, li.link_text);
break;
case TokenType_footnote:
var r = t.data;
sb.Append("");
sb.Append(r.index + 1);
sb.Append("");
break;
case TokenType_abbreviation:
var a = t.data;
sb.Append("");
var btemp = b;
if (m.FormatCodeBlock) {
btemp = b;
b = new StringBuilder();
}
for (var i = 0; i < this.children.length; i++) {
var line = this.children[i];
b.HtmlEncodeAndConvertTabsToSpaces(line.buf, line.contentStart, line.contentLen);
b.Append("\n");
}
if (m.FormatCodeBlock) {
btemp.Append(m.FormatCodeBlock(b.ToString(), this.data));
b = btemp;
}
b.Append("\n\n");
return;
case BlockType_quote:
b.Append("\n"); this.RenderChildren(m, b); b.Append("\n"); return; case BlockType_li: b.Append("
"); if (this.contentLen > 0) { m.m_SpanFormatter.Format(b, this.buf, this.contentStart, this.contentLen); b.Append(" "); } b.Append(this.data); b.Append("
\n"); break; } } p.RevertToPlain = function () { this.blockType = BlockType_p; this.contentStart = this.lineStart; this.contentLen = this.lineLen; } p.get_contentEnd = function () { return this.contentStart + this.contentLen; } p.set_contentEnd = function (value) { this.contentLen = value - this.contentStart; } // Count the leading spaces on a block // Used by list item evaluation to determine indent levels // irrespective of indent line type. p.get_leadingSpaces = function () { var count = 0; for (var i = this.lineStart; i < this.lineStart + this.lineLen; i++) { if (this.buf.charAt(i) == ' ') { count++; } else { break; } } return count; } p.CopyFrom = function (other) { this.blockType = other.blockType; this.buf = other.buf; this.contentStart = other.contentStart; this.contentLen = other.contentLen; this.lineStart = other.lineStart; this.lineLen = other.lineLen; return this; } ///////////////////////////////////////////////////////////////////////////// // BlockProcessor function BlockProcessor(m, MarkdownInHtml) { this.m_Markdown = m; this.m_parentType = BlockType_Blank; this.m_bMarkdownInHtml = MarkdownInHtml; } p = BlockProcessor.prototype; p.Process = function (str) { // Reset string scanner var p = new StringScanner(str); return this.ScanLines(p); } p.ProcessRange = function (str, startOffset, len) { // Reset string scanner var p = new StringScanner(str, startOffset, len); return this.ScanLines(p); } p.StartTable = function (p, spec, lines) { // Mustn't have more than 1 preceeding line if (lines.length > 1) return false; // Rewind, parse the header row then fast forward back to current pos if (lines.length == 1) { var savepos = p.m_position; p.m_position = lines[0].lineStart; spec.m_Headers = spec.ParseRow(p); if (spec.m_Headers == null) return false; p.m_position = savepos; lines.length = 0; } // Parse all .m_Rows while (true) { var savepos = p.m_position; var row = spec.ParseRow(p); if (row != null) { spec.m_Rows.push(row); continue; } p.m_position = savepos; break; } return true; } p.ScanLines = function (p) { // The final set of blocks will be collected here var blocks = []; // The current paragraph/list/codeblock etc will be accumulated here // before being collapsed into a block and store in above `blocks` list var lines = []; // Add all blocks var PrevBlockType = -1; while (!p.eof()) { // Remember if the previous line was blank var bPreviousBlank = PrevBlockType == BlockType_Blank; // Get the next block var b = this.EvaluateLine(p); PrevBlockType = b.blockType; // For dd blocks, we need to know if it was preceeded by a blank line // so store that fact as the block's data. if (b.blockType == BlockType_dd) { b.data = bPreviousBlank; } // SetExt header? if (b.blockType == BlockType_post_h1 || b.blockType == BlockType_post_h2) { if (lines.length > 0) { // Remove the previous line and collapse the current paragraph var prevline = lines.pop(); this.CollapseLines(blocks, lines); // If previous line was blank, if (prevline.blockType != BlockType_Blank) { // Convert the previous line to a heading and add to block list prevline.RevertToPlain(); prevline.blockType = b.blockType == BlockType_post_h1 ? BlockType_h1 : BlockType_h2; blocks.push(prevline); continue; } } // Couldn't apply setext header to a previous line if (b.blockType == BlockType_post_h1) { // `===` gets converted to normal paragraph b.RevertToPlain(); lines.push(b); } else { // `---` gets converted to hr if (b.contentLen >= 3) { b.blockType = BlockType_hr; blocks.push(b); } else { b.RevertToPlain(); lines.push(b); } } continue; } // Work out the current paragraph type var currentBlockType = lines.length > 0 ? lines[0].blockType : BlockType_Blank; // Starting a table? if (b.blockType == BlockType_table_spec) { // Get the table spec, save position var spec = b.data; var savepos = p.m_position; if (!this.StartTable(p, spec, lines)) { // Not a table, revert the tablespec row to plain, // fast forward back to where we were up to and continue // on as if nothing happened p.m_position = savepos; b.RevertToPlain(); } else { blocks.push(b); continue; } } // Process this line switch (b.blockType) { case BlockType_Blank: switch (currentBlockType) { case BlockType_Blank: this.FreeBlock(b); break; case BlockType_p: this.CollapseLines(blocks, lines); this.FreeBlock(b); break; case BlockType_quote: case BlockType_ol_li: case BlockType_ul_li: case BlockType_dd: case BlockType_footnote: case BlockType_indent: lines.push(b); break; } break; case BlockType_p: switch (currentBlockType) { case BlockType_Blank: case BlockType_p: lines.push(b); break; case BlockType_quote: case BlockType_ol_li: case BlockType_ul_li: case BlockType_dd: case BlockType_footnote: var prevline = lines[lines.length - 1]; if (prevline.blockType == BlockType_Blank) { this.CollapseLines(blocks, lines); lines.push(b); } else { lines.push(b); } break; case BlockType_indent: this.CollapseLines(blocks, lines); lines.push(b); break; } break; case BlockType_indent: switch (currentBlockType) { case BlockType_Blank: // Start a code block lines.push(b); break; case BlockType_p: case BlockType_quote: var prevline = lines[lines.length - 1]; if (prevline.blockType == BlockType_Blank) { // Start a code block after a paragraph this.CollapseLines(blocks, lines); lines.push(b); } else { // indented line in paragraph, just continue it b.RevertToPlain(); lines.push(b); } break; case BlockType_ol_li: case BlockType_ul_li: case BlockType_indent: case BlockType_dd: case BlockType_footnote: lines.push(b); break; } break; case BlockType_quote: if (currentBlockType != BlockType_quote) { this.CollapseLines(blocks, lines); } lines.push(b); break; case BlockType_ol_li: case BlockType_ul_li: switch (currentBlockType) { case BlockType_Blank: lines.push(b); break; case BlockType_p: case BlockType_quote: var prevline = lines[lines.length - 1]; if (prevline.blockType == BlockType_Blank || this.m_parentType == BlockType_ol_li || this.m_parentType == BlockType_ul_li || this.m_parentType == BlockType_dd) { // List starting after blank line after paragraph or quote this.CollapseLines(blocks, lines); lines.push(b); } else { // List's can't start in middle of a paragraph b.RevertToPlain(); lines.push(b); } break; case BlockType_ol_li: case BlockType_ul_li: if (b.blockType != BlockType_ol_li && b.blockType != BlockType_ul_li) { this.CollapseLines(blocks, lines); } lines.push(b); break; case BlockType_dd: case BlockType_footnote: if (b.blockType != currentBlockType) { this.CollapseLines(blocks, lines); } lines.push(b); break; case BlockType_indent: // List after code block this.CollapseLines(blocks, lines); lines.push(b); break; } break; case BlockType_dd: case BlockType_footnote: switch (currentBlockType) { case BlockType_Blank: case BlockType_p: case BlockType_dd: case BlockType_footnote: this.CollapseLines(blocks, lines); lines.push(b); break; default: b.RevertToPlain(); lines.push(b); break; } break; default: this.CollapseLines(blocks, lines); blocks.push(b); break; } } this.CollapseLines(blocks, lines); if (this.m_Markdown.ExtraMode) { this.BuildDefinitionLists(blocks); } return blocks; } p.CreateBlock = function (lineStart) { var b; if (this.m_Markdown.m_SpareBlocks.length > 1) { b = this.m_Markdown.m_SpareBlocks.pop(); } else { b = new Block(); } b.lineStart = lineStart; return b; } p.FreeBlock = function (b) { this.m_Markdown.m_SpareBlocks.push(b); } p.FreeBlocks = function (blocks) { for (var i = 0; i < blocks.length; i++) this.m_Markdown.m_SpareBlocks.push(blocks[i]); blocks.length = 0; } p.RenderLines = function (lines) { var b = this.m_Markdown.GetStringBuilder(); for (var i = 0; i < lines.length; i++) { var l = lines[i]; b.Append(l.buf.substr(l.contentStart, l.contentLen)); b.Append('\n'); } return b.ToString(); } p.CollapseLines = function (blocks, lines) { // Remove trailing blank lines while (lines.length > 0 && lines[lines.length - 1].blockType == BlockType_Blank) { this.FreeBlock(lines.pop()); } // Quit if empty if (lines.length == 0) { return; } // What sort of block? switch (lines[0].blockType) { case BlockType_p: // Collapse all lines into a single paragraph var para = this.CreateBlock(lines[0].lineStart); para.blockType = BlockType_p; para.buf = lines[0].buf; para.contentStart = lines[0].contentStart; para.set_contentEnd(lines[lines.length - 1].get_contentEnd()); blocks.push(para); this.FreeBlocks(lines); break; case BlockType_quote: // Get the content var str = this.RenderLines(lines); // Create the new block processor var bp = new BlockProcessor(this.m_Markdown, this.m_bMarkdownInHtml); bp.m_parentType = BlockType_quote; // Create a new quote block var quote = this.CreateBlock(lines[0].lineStart); quote.blockType = BlockType_quote; quote.children = bp.Process(str); this.FreeBlocks(lines); blocks.push(quote); break; case BlockType_ol_li: case BlockType_ul_li: blocks.push(this.BuildList(lines)); break; case BlockType_dd: if (blocks.length > 0) { var prev = blocks[blocks.length - 1]; switch (prev.blockType) { case BlockType_p: prev.blockType = BlockType_dt; break; case BlockType_dd: break; default: var wrapper = this.CreateBlock(prev.lineStart); wrapper.blockType = BlockType_dt; wrapper.children = []; wrapper.children.push(prev); blocks.pop(); blocks.push(wrapper); break; } } blocks.push(this.BuildDefinition(lines)); break; case BlockType_footnote: this.m_Markdown.AddFootnote(this.BuildFootnote(lines)); break; case BlockType_indent: var codeblock = this.CreateBlock(lines[0].lineStart); codeblock.blockType = BlockType_codeblock; codeblock.children = []; var firstline = lines[0].get_Content(); if (firstline.substr(0, 2) == "{{" && firstline.substr(firstline.length - 2, 2) == "}}") { codeblock.data = firstline.substr(2, firstline.length - 4); lines.splice(0, 1); } for (var i = 0; i < lines.length; i++) { codeblock.children.push(lines[i]); } blocks.push(codeblock); lines.length = 0; break; } } p.EvaluateLine = function (p) { // Create a block var b = this.CreateBlock(p.m_position); // Store line start b.buf = p.buf; // Scan the line b.contentStart = p.m_position; b.contentLen = -1; b.blockType = this.EvaluateLineInternal(p, b); // If end of line not returned, do it automatically if (b.contentLen < 0) { // Move to end of line p.SkipToEol(); b.contentLen = p.m_position - b.contentStart; } // Setup line length b.lineLen = p.m_position - b.lineStart; // Next line p.SkipEol(); // Create block return b; } p.EvaluateLineInternal = function (p, b) { // Empty line? if (p.eol()) return BlockType_Blank; // Save start of line position var line_start = p.m_position; // ## Heading ## var ch = p.current(); if (ch == '#') { // Work out heading level var level = 1; p.SkipForward(1); while (p.current() == '#') { level++; p.SkipForward(1); } // Limit of 6 if (level > 6) level = 6; // Skip any whitespace p.SkipLinespace(); // Save start position b.contentStart = p.m_position; // Jump to end p.SkipToEol(); // In extra mode, check for a trailing HTML ID if (this.m_Markdown.ExtraMode && !this.m_Markdown.SafeMode) { var res = StripHtmlID(p.buf, b.contentStart, p.m_position); if (res != null) { b.data = res.id; p.m_position = res.end; } } // Rewind over trailing hashes while (p.m_position > b.contentStart && p.CharAtOffset(-1) == '#') { p.SkipForward(-1); } // Rewind over trailing spaces while (p.m_position > b.contentStart && is_whitespace(p.CharAtOffset(-1))) { p.SkipForward(-1); } // Create the heading block b.contentLen = p.m_position - b.contentStart; p.SkipToEol(); return BlockType_h1 + (level - 1); } // Check for entire line as - or = for setext h1 and h2 if (ch == '-' || ch == '=') { // Skip all matching characters var chType = ch; while (p.current() == chType) { p.SkipForward(1); } // Trailing whitespace allowed p.SkipLinespace(); // If not at eol, must have found something other than setext header if (p.eol()) { return chType == '=' ? BlockType_post_h1 : BlockType_post_h2; } p.m_position = line_start; } if (this.m_Markdown.ExtraMode) { // MarkdownExtra Table row indicator? var spec = TableSpec_Parse(p); if (spec != null) { b.data = spec; return BlockType_table_spec; } p.m_position = line_start; // Fenced code blocks? if (ch == '~') { if (this.ProcessFencedCodeBlock(p, b)) return b.blockType; // Rewind p.m_position = line_start; } } // Scan the leading whitespace, remembering how many spaces and where the first tab is var tabPos = -1; var leadingSpaces = 0; while (!p.eol()) { if (p.current() == ' ') { if (tabPos < 0) leadingSpaces++; } else if (p.current() == '\t') { if (tabPos < 0) tabPos = p.m_position; } else { // Something else, get out break; } p.SkipForward(1); } // Blank line? if (p.eol()) { b.contentLen = 0; return BlockType_Blank; } // 4 leading spaces? if (leadingSpaces >= 4) { b.contentStart = line_start + 4; return BlockType_indent; } // Tab in the first 4 characters? if (tabPos >= 0 && tabPos - line_start < 4) { b.contentStart = tabPos + 1; return BlockType_indent; } // Treat start of line as after leading whitespace b.contentStart = p.m_position; // Get the next character ch = p.current(); // Html block? if (ch == '<') { if (this.ScanHtml(p, b)) return b.blockType; // Rewind p.m_position = b.contentStart; } // Block quotes start with '>' and have one space or one tab following if (ch == '>') { // Block quote followed by space if (is_linespace(p.CharAtOffset(1))) { // Skip it and create quote block p.SkipForward(2); b.contentStart = p.m_position; return BlockType_quote; } p.SkipForward(1); b.contentStart = p.m_position; return BlockType_quote; } // Horizontal rule - a line consisting of 3 or more '-', '_' or '*' with optional spaces and nothing else if (ch == '-' || ch == '_' || ch == '*') { var count = 0; while (!p.eol()) { var chType = p.current(); if (p.current() == ch) { count++; p.SkipForward(1); continue; } if (is_linespace(p.current())) { p.SkipForward(1); continue; } break; } if (p.eol() && count >= 3) { return BlockType_hr; } // Rewind p.m_position = b.contentStart; } // Abbreviation definition? if (this.m_Markdown.ExtraMode && ch == '*' && p.CharAtOffset(1) == '[') { p.SkipForward(2); p.SkipLinespace(); p.Mark(); while (!p.eol() && p.current() != ']') { p.SkipForward(1); } var abbr = Trim(p.Extract()); if (p.current() == ']' && p.CharAtOffset(1) == ':' && abbr) { p.SkipForward(2); p.SkipLinespace(); p.Mark(); p.SkipToEol(); var title = p.Extract(); this.m_Markdown.AddAbbreviation(abbr, title); return BlockType_Blank; } p.m_position = b.contentStart; } // Unordered list if ((ch == '*' || ch == '+' || ch == '-') && is_linespace(p.CharAtOffset(1))) { // Skip it p.SkipForward(1); p.SkipLinespace(); b.contentStart = p.m_position; return BlockType_ul_li; } // Definition if (ch == ':' && this.m_Markdown.ExtraMode && is_linespace(p.CharAtOffset(1))) { p.SkipForward(1); p.SkipLinespace(); b.contentStart = p.m_position; return BlockType_dd; } // Ordered list if (is_digit(ch)) { // Ordered list? A line starting with one or more digits, followed by a '.' and a space or tab // Skip all digits p.SkipForward(1); while (is_digit(p.current())) p.SkipForward(1); if (p.SkipChar('.') && p.SkipLinespace()) { b.contentStart = p.m_position; return BlockType_ol_li; } p.m_position = b.contentStart; } // Reference link definition? if (ch == '[') { // Footnote definition? if (this.m_Markdown.ExtraMode && p.CharAtOffset(1) == '^') { var savepos = p.m_position; p.SkipForward(2); var id = p.SkipFootnoteID(); if (id != null && p.SkipChar(']') && p.SkipChar(':')) { p.SkipLinespace(); b.contentStart = p.m_position; b.data = id; return BlockType_footnote; } p.m_position = savepos; } // Parse a link definition var l = ParseLinkDefinition(p, this.m_Markdown.ExtraMode); if (l != null) { this.m_Markdown.AddLinkDefinition(l); return BlockType_Blank; } } // Nothing special return BlockType_p; } var MarkdownInHtmlMode_NA = 0; var MarkdownInHtmlMode_Block = 1; var MarkdownInHtmlMode_Span = 2; var MarkdownInHtmlMode_Deep = 3; var MarkdownInHtmlMode_Off = 4; p.GetMarkdownMode = function (tag) { // Get the markdown attribute var md = tag.attributes["markdown"]; if (md == undefined) { if (this.m_bMarkdownInHtml) return MarkdownInHtmlMode_Deep; else return MarkdownInHtmlMode_NA; } // Remove it delete tag.attributes["markdown"]; // Parse mode if (md == "1") return (tag.get_Flags() & HtmlTagFlags_ContentAsSpan) != 0 ? MarkdownInHtmlMode_Span : MarkdownInHtmlMode_Block; if (md == "block") return MarkdownInHtmlMode_Block; if (md == "deep") return MarkdownInHtmlMode_Deep; if (md == "span") return MarkdownInHtmlMode_Span; return MarkdownInHtmlMode_Off; } p.ProcessMarkdownEnabledHtml = function (p, b, openingTag, mode) { // Current position is just after the opening tag // Scan until we find matching closing tag var inner_pos = p.m_position; var depth = 1; var bHasUnsafeContent = false; while (!p.eof()) { // Find next angle bracket if (!p.Find('<')) break; // Is it a html tag? var tagpos = p.m_position; var tag = ParseHtmlTag(p); if (tag == null) { // Nope, skip it p.SkipForward(1); continue; } // In markdown off mode, we need to check for unsafe tags if (this.m_Markdown.SafeMode && mode == MarkdownInHtmlMode_Off && !bHasUnsafeContent) { if (!tag.IsSafe()) bHasUnsafeContent = true; } // Ignore self closing tags if (tag.closed) continue; // Same tag? if (tag.name == openingTag.name) { if (tag.closing) { depth--; if (depth == 0) { // End of tag? p.SkipLinespace(); p.SkipEol(); b.blockType = BlockType_HtmlTag; b.data = openingTag; b.set_contentEnd(p.m_position); switch (mode) { case MarkdownInHtmlMode_Span: var span = this.CreateBlock(inner_pos); span.buf = p.buf; span.blockType = BlockType_span; span.contentStart = inner_pos; span.contentLen = tagpos - inner_pos; b.children = []; b.children.push(span); break; case MarkdownInHtmlMode_Block: case MarkdownInHtmlMode_Deep: // Scan the internal content var bp = new BlockProcessor(this.m_Markdown, mode == MarkdownInHtmlMode_Deep); b.children = bp.ProcessRange(p.buf, inner_pos, tagpos - inner_pos); break; case MarkdownInHtmlMode_Off: if (bHasUnsafeContent) { b.blockType = BlockType_unsafe_html; b.set_contentEnd(p.m_position); } else { var span = this.CreateBlock(inner_pos); span.buf = p.buf; span.blockType = BlockType_html; span.contentStart = inner_pos; span.contentLen = tagpos - inner_pos; b.children = []; b.children.push(span); } break; } return true; } } else { depth++; } } } // Missing closing tag(s). return false; } p.ScanHtml = function (p, b) { // Remember start of html var posStartPiece = p.m_position; // Parse a HTML tag var openingTag = ParseHtmlTag(p); if (openingTag == null) return false; // Closing tag? if (openingTag.closing) return false; // Safe mode? var bHasUnsafeContent = false; if (this.m_Markdown.SafeMode && !openingTag.IsSafe()) bHasUnsafeContent = true; var flags = openingTag.get_Flags(); // Is it a block level tag? if ((flags & HtmlTagFlags_Block) == 0) return false; // Closed tag, hr or comment? if ((flags & HtmlTagFlags_NoClosing) != 0 || openingTag.closed) { p.SkipLinespace(); p.SkipEol(); b.contentLen = p.m_position - b.contentStart; b.blockType = bHasUnsafeContent ? BlockType_unsafe_html : BlockType_html; return true; } // Can it also be an inline tag? if ((flags & HtmlTagFlags_Inline) != 0) { // Yes, opening tag must be on a line by itself p.SkipLinespace(); if (!p.eol()) return false; } // Head block extraction? var bHeadBlock = this.m_Markdown.ExtractHeadBlocks && openingTag.name.toLowerCase() == "head"; var headStart = p.m_position; // Work out the markdown mode for this element if (!bHeadBlock && this.m_Markdown.ExtraMode) { var MarkdownMode = this.GetMarkdownMode(openingTag); if (MarkdownMode != MarkdownInHtmlMode_NA) { return this.ProcessMarkdownEnabledHtml(p, b, openingTag, MarkdownMode); } } var childBlocks = null; // Now capture everything up to the closing tag and put it all in a single HTML block var depth = 1; while (!p.eof()) { if (!p.Find('<')) break; // Save position of current tag var posStartCurrentTag = p.m_position; var tag = ParseHtmlTag(p); if (tag == null) { p.SkipForward(1); continue; } // Safe mode checks if (this.m_Markdown.SafeMode && !tag.IsSafe()) bHasUnsafeContent = true; // Ignore self closing tags if (tag.closed) continue; // Markdown enabled content? if (!bHeadBlock && !tag.closing && this.m_Markdown.ExtraMode && !bHasUnsafeContent) { var MarkdownMode = this.GetMarkdownMode(tag); if (MarkdownMode != MarkdownInHtmlMode_NA) { var markdownBlock = this.CreateBlock(posStartPiece); if (this.ProcessMarkdownEnabledHtml(p, markdownBlock, tag, MarkdownMode)) { if (childBlocks == null) { childBlocks = []; } // Create a block for everything before the markdown tag if (posStartCurrentTag > posStartPiece) { var htmlBlock = this.CreateBlock(posStartPiece); htmlBlock.buf = p.buf; htmlBlock.blockType = BlockType_html; htmlBlock.contentStart = posStartPiece; htmlBlock.contentLen = posStartCurrentTag - posStartPiece; childBlocks.push(htmlBlock); } // Add the markdown enabled child block childBlocks.push(markdownBlock); // Remember start of the next piece posStartPiece = p.m_position; continue; } else { this.FreeBlock(markdownBlock); } } } // Same tag? if (tag.name == openingTag.name && !tag.closed) { if (tag.closing) { depth--; if (depth == 0) { // End of tag? p.SkipLinespace(); p.SkipEol(); // If anything unsafe detected, just encode the whole block if (bHasUnsafeContent) { b.blockType = BlockType_unsafe_html; b.set_contentEnd(p.m_position); return true; } // Did we create any child blocks if (childBlocks != null) { // Create a block for the remainder if (p.m_position > posStartPiece) { var htmlBlock = this.CreateBlock(posStartPiece); htmlBlock.buf = p.buf; htmlBlock.blockType = BlockType_html; htmlBlock.contentStart = posStartPiece; htmlBlock.contentLen = p.m_position - posStartPiece; childBlocks.push(htmlBlock); } // Return a composite block b.blockType = BlockType_Composite; b.set_contentEnd(p.m_position); b.children = childBlocks; return true; } // Extract the head block content if (bHeadBlock) { var content = p.buf.substr(headStart, posStartCurrentTag - headStart); this.m_Markdown.HeadBlockContent = this.m_Markdown.HeadBlockContent + Trim(content) + "\n"; b.blockType = BlockType_html; b.contentStart = p.position; b.contentEnd = p.position; b.lineStart = p.position; return true; } // Straight html block b.blockType = BlockType_html; b.contentLen = p.m_position - b.contentStart; return true; } } else { depth++; } } } // Missing closing tag(s). return BlockType_Blank; } /* * BuildList - build a single