// // showdown.js -- A javascript port of Markdown. // // Copyright (c) 2007 John Fraser. // // Original Markdown Copyright (c) 2004-2005 John Gruber // http://daringfireball.net/projects/markdown/ // // The full source distribution is at: // // A A L // T C A // T K B // // http://www.attacklab.net/ //

// // Wherever possible, Showdown is a straight, line-by-line port // of the Perl version of Markdown. // // This is not a normal parser design; it's basically just a // series of string substitutions. It's hard to read and // maintain this way, but keeping Showdown close to the original // design makes it easier to port new features. // // More importantly, Showdown behaves like markdown.pl in most // edge cases. So web applications can do client-side preview // in Javascript, and then build identical HTML on the server. // // This port needs the new RegExp functionality of ECMA 262, // 3rd Edition (i.e. Javascript 1.5). Most modern web browsers // should do fine. Even with the new regular expression features, // We do a lot of work to emulate Perl's regex functionality. // The tricky changes in this file mostly have the "attacklab:" // label. Major or self-explanatory changes don't. // // Smart diff tools like Araxis Merge will be able to match up // this file with markdown.pl in a useful way. A little tweaking // helps: in a copy of markdown.pl, replace "#" with "//" and // replace "$text" with "text". Be sure to ignore whitespace // and line endings. //

// // Showdown usage: // // var text = "Markdown rocks."; // // var converter = new Attacklab.showdown.converter(); // var html = converter.makeHtml(text); // // alert(html); // // Note: move the sample code to the bottom of this // file before uncommenting it. //

// // Attacklab namespace // var Attacklab = Attacklab || {}

// // Showdown namespace // Attacklab.showdown = Attacklab.showdown || {}

// // converter // // Wraps all "globals" so that the only thing // exposed is makeHtml(). // Attacklab.showdown.converter = function() {

// // Globals: //

// Global hashes, used by various utility routines var g_urls;
var g_titles;
var g_html_blocks;

// Used to track when we're inside an ordered or unordered list // (see _ProcessListItems() for details): var g_list_level = 0;

this.makeHtml = function(text) {
// // Main function. The order in which other subs are called here is // essential. Link and image substitutions need to happen before // EscapeSpecialCharsWithinTagAttributes(), so that any *'s or 's in the // and tags get encoded. //

//alert("gogo");
// Clear the global hashes. If we don't clear these, you get conflicts
// from other articles when generating a page which contains more than
// one article (e.g. an index page that shows the N most recent
// articles):
g_urls = new Array();
g_titles = new Array();
g_html_blocks = new Array();
g_repl_blocks = new Array();
// attacklab: Replace ~ with ~T
// This lets us use tilde as an escape char to avoid md5 hashes
// The choice of character is arbitray; anything that isn't
// magic in Markdown will work.
text = text.replace(/~/g,"~T");

// attacklab: Replace $ with ~D
// RegExp interprets $ as a special character
// when it's in a replacement string
text = text.replace(/\$/g,"~D");

// Standardize line endings
text = text.replace(/\r\n/g,"\n"); // DOS to Unix
text = text.replace(/\r/g,"\n"); // Mac to Unix

// Make sure text begins and ends with a couple of newlines:
text = "\n\n" + text + "\n\n";

// Convert all tabs to spaces.
text = _Detab(text);

// Strip any lines consisting only of spaces and tabs.
// This makes subsequent regexen easier to write, because we can
// match consecutive blank lines with /\n+/ instead of something
// contorted like /[ \t]*\n+/ .
text = text.replace(/^[ \t]+$/mg,"");


text = _StripLinkDefinitions(text);
// Turn block-level HTML blocks into hash entries

text = _HashHTMLBlocks(text);

// Strip link definitions, store in hashes.


text = _RunBlockGamut(text);

text = _UnescapeSpecialChars(text);

// attacklab: Restore dollar signs
text = text.replace(/~D/g,"$$");

// attacklab: Restore tildes
text = text.replace(/~T/g,"~");
//text = HTMLtoDOMSmartyPants("<div>" + text + "</div>");
text = _RunSmartyPants(text);
return text;

// Link defs are in the form: ^[id]: url "optional title"

/*
    var text = text.replace(/
            ^[ ]{0,3}\[(.+)\]:  // id = $1  attacklab: g_tab_width - 1
              [ \t]*
              \n?               // maybe *one* newline
              [ \t]*
            <?(\S+?)>?          // url = $2
              [ \t]*
              \n?               // maybe one newline
              [ \t]*
            (?:
              (\n*)             // any lines skipped = $3 attacklab: lookbehind removed
              ["(]
              (.+?)             // title = $4
              [")]
              [ \t]*
            )?                  // title is optional
            (?:\n+|$)
          /gm,
          function(){...});
*/
var text = text.replace(/^[ ]{0,3}\[(.+)\]:[ \t]*\n?[ \t]*<?(\S+?)>?[ \t]*\n?[ \t]*(?:(\n*)["(](.+?)[")][ \t]*)?(?:\n+)/gm,
    function (wholeMatch,m1,m2,m3,m4) {
        m1 = m1.toLowerCase();
        g_urls[m1] = _EncodeAmpsAndAngles(m2);  // Link IDs are case-insensitive
        if (m3) {
            // Oops, found blank lines, so it's not a title.
            // Put back the parenthetical statement we stole.
            return m3+m4;
        } else if (m4) {
            g_titles[m1] = m4.replace(/"/g,"&quot;");
        }

        // Completely remove the definition from the text
        return "";
    }
);

return text;

// attacklab: Double up blank lines to reduce lookaround
text = text.replace(/\n/g,"\n\n");

// Hashify HTML blocks:
// We only want to do this for block-level HTML tags, such as headers,
// lists, and tables. That's because we still want to wrap <p>s around
// "paragraphs" that are wrapped in non-block-level tags, such as anchors,
// phrase emphasis, and spans. The list of tags we're looking for is
// hard-coded:
var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del"
var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math"

// First, look for nested blocks, e.g.:
//   <div>
//     <div>
//     tags for inner block must be indented.
//     </div>
//   </div>
//
// The outermost tags must start at the left margin for this to match, and
// the inner nested divs must be indented.
// We need to do this before the next, more liberal match, because the next
// match will start at the first `<div>` and stop at the first `</div>`.

// attacklab: This regex can be expensive when it fails.
/*
    var text = text.replace(/
    (                       // save in $1
        ^                   // start of line  (with /m)
        <($block_tags_a)    // start tag = $2
        \b                  // word break
                            // attacklab: hack around khtml/pcre bug...
        [^\r]*?\n           // any number of lines, minimally matching
        </\2>               // the matching end tag
        [ \t]*              // trailing spaces/tabs
        (?=\n+)             // followed by a newline
    )                       // attacklab: there are sentinel newlines at end of document
    /gm,function(){...}};
*/
text = text.replace(/^(<(code|kbd|pre|script|noscript|iframe|math|ins|del)\b[^\r]*?\n<\/\2>[ \t]*(?=\n+))/gm,hashElement);

/*process text parts correctly with markdown*/  
text = text.replace(/^(<(p|div|h[1-6]|blockquote|table|dl|ol|ul|form|fieldset)\b[^\r]*?\n<\/\2>[ \t]*(?=\n+))/gm,hashAndCashElement);

//
// Now match more liberally, simply from `\n<tag>` to `</tag>\n`
//

/*
    var text = text.replace(/
    (                       // save in $1
        ^                   // start of line  (with /m)
        <($block_tags_b)    // start tag = $2
        \b                  // word break
                            // attacklab: hack around khtml/pcre bug...
        [^\r]*?             // any number of lines, minimally matching
        .*</\2>             // the matching end tag
        [ \t]*              // trailing spaces/tabs
        (?=\n+)             // followed by a newline
    )                       // attacklab: there are sentinel newlines at end of document
    /gm,function(){...}};
*/
text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math)\b[^\r]*?.*<\/\2>[ \t]*(?=\n+)\n)/gm,hashElement);

// Special case just for <hr />. It was easier to make a special case than
// to make the other regex more complicated.  

/*
    text = text.replace(/
    (                       // save in $1
        \n\n                // Starting after a blank line
        [ ]{0,3}
        (<(hr)              // start tag = $2
        \b                  // word break
        ([^<>])*?           // 
        \/?>)               // the matching end tag
        [ \t]*
        (?=\n{2,})          // followed by a blank line
    )
    /g,hashElement);
*/
text = text.replace(/(\n[ ]{0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,hashElement);

// Special case just for <img />. It was easier to make a special case than
// to make the other regex more complicated.  

/*
    text = text.replace(/
    (                       // save in $1
        \n\n                // Starting after a blank line
        [ ]{0,3}
        (<(img)             // start tag = $2
        \b                  // word break
        ([^<>])*?           // 
        \/?>)               // the matching end tag
        [ \t]*
        (?=\n{2,})          // followed by a blank line
    )
    /g,hashElement);
*/
//text = text.replace(/(([ \t\n])*<(img)\b([^<>])*?\/?>([ \t\n])*)/g,hashElement);


// Special case for standalone HTML comments:

/*
    text = text.replace(/
    (                       // save in $1
        \n\n                // Starting after a blank line
        [ ]{0,3}            // attacklab: g_tab_width - 1
        <!
        (--[^\r]*?--\s*)+
        >
        [ \t]*
        (?=\n{2,})          // followed by a blank line
    )
    /g,hashElement);
*/
text = text.replace(/(\n\n[ ]{0,3}<!(--[^\r]*?--\s*)+>[ \t]*(?=\n{2,}))/g,hashElement);

// PHP and ASP-style processor instructions (<?...?> and <%...%>)

/*
    text = text.replace(/
    (?:
        \n\n                // Starting after a blank line
    )
    (                       // save in $1
        [ ]{0,3}            // attacklab: g_tab_width - 1
        (?:
            <([?%])         // $2
            [^\r]*?
            \2>
        )
        [ \t]*
        (?=\n{2,})          // followed by a blank line
    )
    /g,hashElement);
*/
text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,hashElement);

// attacklab: Undo double lines (see comment at top of this function)
text = text.replace(/\n\n/g,"\n");
return text;

var blockText = m1;

// Undo double lines
blockText = blockText.replace(/\n\n/g,"\n");
blockText = blockText.replace(/^\n/,"");
// strip trailing blank lines
blockText = blockText.replace(/\n+$/g,"");


// Replace the element text with a marker ("~KxK" where x is its key)
blockText = "\n\n~K" + (g_html_blocks.push(blockText)-1) + "K\n\n";

return blockText;

var blockText = m1;

// Undo double lines
blockText = blockText.replace(/\n\n/g,"\n");
blockText = blockText.replace(/^\n/,"");
// strip trailing blank lines
blockText = blockText.replace(/\n+$/g,"");

/*test block level transformations*/
/*blockText = _StripLinkDefinitions(blockText);*/

//text = _FormParagraphs(text);
blockText = _RunBlockGamut(blockText);



blockText = _UnescapeSpecialChars(blockText);


/*test end*/



// Replace the element text with a marker ("~KxK" where x is its key)
blockText = "\n\n~K" + (g_html_blocks.push(blockText)-1) + "K\n\n";

return blockText;

text = _DoHeaders(text);

// Do Horizontal Rules:
var key = hashBlock("<hr />");
text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm,key);
text = text.replace(/^[ ]{0,2}([ ]?-[ ]?){3,}[ \t]*$/gm,key);
text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ \t]*$/gm,key);

text = _DoLists(text);
text = _DoCodeBlocks(text);
text = _DoBlockQuotes(text);

// We already ran _HashHTMLBlocks() before, in Markdown(), but that
// was to escape raw HTML in the original Markdown source. This time,
// we're escaping the markup we've just created, so that we don't wrap
// <p> tags around block-level tags.
text = _HashHTMLBlocks(text);
text = _FormParagraphs(text);

return text;

text = _DoCodeSpans(text);
text = _EscapeSpecialCharsWithinTagAttributes(text);
text = _EncodeBackslashEscapes(text);


// Process anchor and image tags. Images must come first,
// because ![foo][f] looks like an anchor.
text = _DoImages(text);
text = _DoAnchors(text);

// Make links out of things like `<http://example.com/>`
// Must come after _DoAnchors(), because you can use < and >
// delimiters in inline links like [this](<url>).
text = _DoAutoLinks(text);
text = _EncodeAmpsAndAngles(text);
text = _DoItalicsAndBold(text);

// Do hard breaks:
text = text.replace(/  +\n/g," <br />\n");

return text;

}

var EscapeSpecialCharsWithinTagAttributes = function(text) {
// // Within tags -- meaning between < and > -- encode [\ ` * ] so they // don't conflict with their use in Markdown for code, italics and strong. //

// Build a regex to find HTML tags and comments.  See Friedl's 
// "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|<!(--.*?--\s*)+>)/gi;

text = text.replace(regex, function(wholeMatch) {
    var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g,"$1`");
    tag = escapeCharacters(tag,"\\`*_");
    return tag;
});

return text;

}

var _DoAnchors = function(text) {
// // Turn Markdown link shortcuts into XHTML tags. //

//
// First, handle reference-style links: [link text] [id]
//

/*
    text = text.replace(/
    (                           // wrap whole match in $1
        \[
        (
            (?:
                \[[^\]]*\]      // allow brackets nested one level
                |
                [^\[]           // or anything else
            )*
        )
        \]

        [ ]?                    // one optional space
        (?:\n[ ]*)?             // one optional newline followed by spaces

        \[
        (.*?)                   // id = $3
        \]
    )()()()()                   // pad remaining backreferences
    /g,_DoAnchors_callback);
*/
text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeAnchorTag);

//
// Next, inline-style links: [link text](url "optional title")
//

/*
    text = text.replace(/
        (                       // wrap whole match in $1
            \[
            (
                (?:
                    \[[^\]]*\]  // allow brackets nested one level
                |
                [^\[\]]         // or anything else
            )
        )
        \]
        \(                      // literal paren
        [ \t]*
        ()                      // no id, so leave $3 empty
        <?(.*?)>?               // href = $4
        [ \t]*
        (                       // $5
            (['"])              // quote char = $6
            (.*?)               // Title = $7
            \6                  // matching quote
            [ \t]*              // ignore any spaces/tabs between closing quote and )
        )?                      // title is optional
        \)
    )
    /g,writeAnchorTag);
*/
text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()<?(.*?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeAnchorTag);

//
// Last, handle reference-style shortcuts: [link text]
// These must come last in case you've also got [link test][1]
// or [link test](/foo)
//

/*
    text = text.replace(/
    (                           // wrap whole match in $1
        \[
        ([^\[\]]+)              // link text = $2; can't contain '[' or ']'
        \]
    )()()()()()                 // pad rest of backreferences
    /g, writeAnchorTag);
*/
text = text.replace(/(\[([^\[\]]+)\])()()()()()/g, writeAnchorTag);

return text;

if (m7 == undefined) m7 = "";
var whole_match = m1;
var link_text   = m2;
var link_id  = m3.toLowerCase();
var url     = m4;
var title   = m7;

if (url == "") {
    if (link_id == "") {
        // lower-case and turn embedded newlines into spaces
        link_id = link_text.toLowerCase().replace(/ ?\n/g," ");
    }
    url = "#"+link_id;

    if (g_urls[link_id] != undefined) {
        url = g_urls[link_id];
        if (g_titles[link_id] != undefined) {
            title = g_titles[link_id];
        }
    }
    else {
        if (whole_match.search(/\(\s*\)$/m)>-1) {
            // Special case for explicit empty url
            url = "";
        } else {
            return whole_match;
        }
    }
}   
var result = "";
url = escapeCharacters(url,"*_");
if (url.search(/javascript/i) > -1)
{
    result = "<a href=\"" + url;// + "(" +  + "\"";
    if (title != "") {
        title = title.replace(/"/g,"&quot;");
        title = escapeCharacters(title,"*_");
        result += "(" + title + ")\"";
    }

}
else
{
    result = "<a href=\"" + url + "\"";

    if (title != "") {
        title = title.replace(/"/g,"&quot;");
        title = escapeCharacters(title,"*_");
        result +=  " title=\"" + title + "\"";
    }
}

result += ">" + link_text + "</a>";

return result;

//
// First, handle reference-style labeled images: ![alt text][id]
//

/*
    text = text.replace(/
    (                       // wrap whole match in $1
        !\[
        (.*?)               // alt text = $2
        \]

        [ ]?                // one optional space
        (?:\n[ ]*)?         // one optional newline followed by spaces

        \[
        (.*?)               // id = $3
        \]
    )()()()()               // pad rest of backreferences
    /g,writeImageTag);
*/
text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeImageTag);

//
// Next, handle inline images:  ![alt text](url "optional title")
// Don't forget: encode * and _

/*
    text = text.replace(/
    (                       // wrap whole match in $1
        !\[
        (.*?)               // alt text = $2
        \]
        \s?                 // One optional whitespace character
        \(                  // literal paren
        [ \t]*
        ()                  // no id, so leave $3 empty
        <?(\S+?)>?          // src url = $4
        [ \t]*
        (                   // $5
            (['"])          // quote char = $6
            (.*?)           // title = $7
            \6              // matching quote
            [ \t]*
        )?                  // title is optional
    \)
    )
    /g,writeImageTag);
*/
text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()<?(\S+?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeImageTag);

return text;

var whole_match = m1;
var alt_text   = m2;
var link_id  = m3.toLowerCase();
var url     = m4;
var title   = m7;

if (!title) title = "";

if (url == "") {
    if (link_id == "") {
        // lower-case and turn embedded newlines into spaces
        link_id = alt_text.toLowerCase().replace(/ ?\n/g," ");
    }
    url = "#"+link_id;

    if (g_urls[link_id] != undefined) {
        url = g_urls[link_id];
        if (g_titles[link_id] != undefined) {
            title = g_titles[link_id];
        }
    }
    else {
        return whole_match;
    }
}   

alt_text = alt_text.replace(/"/g,""");
url = escapeCharacters(url,"*_");
var result = "<img src=\"" + url + "\" alt=\"" + alt_text + "\"";

// attacklab: Markdown.pl adds empty title attributes to images.
// Replicate this bug.

//if (title != "") {
    title = title.replace(/"/g,"&quot;");
    title = escapeCharacters(title,"*_");
    result +=  " title=\"" + title + "\"";
//}

result += " />";

return result;

// Setext-style headers:
//  Header 1
//  ========
//  
//  Header 2
//  --------
//
text = text.replace(/^(.+)[ \t]*\n=+[ \t]*\n+/gm,
    function(wholeMatch,m1){return hashBlock("<h1>" + _RunSpanGamut(m1) + "</h1>");});

text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
    function(matchFound,m1){return hashBlock("<h2>" + _RunSpanGamut(m1) + "</h2>");});

// atx-style headers:
//  # Header 1
//  ## Header 2
//  ## Header 2 with closing hashes ##
//  ...
//  ###### Header 6
//

/*
    text = text.replace(/
        ^(\#{1,6})              // $1 = string of #'s
        [ \t]*
        (.+?)                   // $2 = Header text
        [ \t]*
        \#*                     // optional closing #'s (not counted)
        \n+
    /gm, function() {...});
*/

text = text.replace(/^(\#{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
    function(wholeMatch,m1,m2) {
        var h_level = m1.length;
        return hashBlock("<h" + h_level + ">" + _RunSpanGamut(m2) + "</h" + h_level + ">");
    });

return text;

// attacklab: add sentinel to hack around khtml/safari bug:
// http://bugs.webkit.org/show_bug.cgi?id=11231
text += "~0";

// Re-usable pattern to match any entirel ul or ol list:

/*
    var whole_list = /
    (                                   // $1 = whole list
        (                               // $2
            [ ]{0,3}                    // attacklab: g_tab_width - 1
            ([*+-]|\d+[.])              // $3 = first list item marker
            [ \t]+
        )
        [^\r]+?
        (                               // $4
            ~0                          // sentinel for workaround; should be $
        |
            \n{2,}
            (?=\S)
            (?!                         // Negative lookahead for another list item marker
                [ \t]*
                (?:[*+-]|\d+[.])[ \t]+
            )
        )
    )/g
*/
var whole_list = /^(([ ]{0,3}([*+\-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+\-]|\d+[.])[ \t]+)))/gm;

if (g_list_level) {
    text = text.replace(whole_list,function(wholeMatch,m1,m2) {
        var list = m1;
        var list_type = (m2.search(/[*+\-]/g)>-1) ? "ul" : "ol";

        // Turn double returns into triple returns, so that we can make a
        // paragraph for the last item in a list, if necessary:
        list = list.replace(/\n{2,}/g,"\n\n\n");;
        var result = _ProcessListItems(list);

        // Trim any trailing whitespace, to put the closing `</$list_type>`
        // up on the preceding line, to get it past the current stupid
        // HTML block parser. This is a hack to work around the terrible
        // hack that is the HTML block parser.
        result = result.replace(/\s+$/,"");
        result = "<"+list_type+">" + result + "</"+list_type+">\n";
        return result;
    });
} else {
    whole_list = /(\n\n|^\n?)(([ ]{0,3}([*+\-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+\-]|\d+[.])[ \t]+)))/g;
    text = text.replace(whole_list,function(wholeMatch,m1,m2,m3) {
        var runup = m1;
        var list = m2;

        var list_type = (m3.search(/[*+\-]/g)>-1) ? "ul" : "ol";
        // Turn double returns into triple returns, so that we can make a
        // paragraph for the last item in a list, if necessary:
        var list = list.replace(/\n{2,}/g,"\n\n\n");;
        var result = _ProcessListItems(list);
        result = runup + "<"+list_type+">\n" + result + "</"+list_type+">\n";   
        return result;
    });
}

// attacklab: strip sentinel
text = text.replace(/~0/,"");

return text;

}

_ProcessListItems = function(list_str) {
// // Process the contents of a single ordered or unordered list, splitting it // into individual list items. //

// The $g_list_level global keeps track of when we're inside a list.
// Each time we enter a list, we increment it; when we leave a list,
// we decrement. If it's zero, we're not in a list anymore.
//
// We do this because when we're not inside a list, we want to treat
// something like this:
//
//    I recommend upgrading to version
//    8. Oops, now this line is treated
//    as a sub-list.
//
// As a single paragraph, despite the fact that the second line starts
// with a digit-period-space sequence.
//
// Whereas when we're inside a list (or sub-list), that line will be
// treated as the start of a sub-list. What a kludge, huh? This is
// an aspect of Markdown's syntax that's hard to parse perfectly
// without resorting to mind-reading. Perhaps the solution is to
// change the syntax rules such that sub-lists must start with a
// starting cardinal number; e.g. "1." or "a.".

g_list_level++;

// trim trailing blank lines:
list_str = list_str.replace(/\n{2,}$/,"\n");

// attacklab: add sentinel to emulate \z
list_str += "~0";

/*
    list_str = list_str.replace(/
        (\n)?                           // leading line = $1
        (^[ \t]*)                       // leading whitespace = $2
        ([*+-]|\d+[.]) [ \t]+           // list marker = $3
        ([^\r]+?                        // list item text   = $4
        (\n{1,2}))
        (?= \n* (~0 | \2 ([*+-]|\d+[.]) [ \t]+))
    /gm, function(){...});
*/
list_str = list_str.replace(/(\n)?(^[ \t]*)([*+\-]|\d+[.])[ \t]+([^\r]+?(\n{1,2}))(?=\n*(~0|\2([*+\-]|\d+[.])[ \t]+))/gm,
    function(wholeMatch,m1,m2,m3,m4){
        var item = m4;
        var leading_line = m1;
        var leading_space = m2;

        if (leading_line || (item.search(/\n{2,}/)>-1)) {
            item = _RunBlockGamut(_Outdent(item));
        }
        else {
            // Recursion for sub-lists:
            item = _DoLists(_Outdent(item));
            item = item.replace(/\n$/,""); // chomp(item)
            item = _RunSpanGamut(item);
        }

        return  "<li>" + item + "</li>\n";
    }
);

// attacklab: strip sentinel
list_str = list_str.replace(/~0/g,"");

g_list_level--;
return list_str;

}

var _DoCodeBlocks = function(text) {
// // Process Markdown `

` blocks.
//  

    /*
        text = text.replace(text,
            /(?:\n\n|^)
            (                               // $1 = the code block -- one or more lines, starting with a space/tab
                (?:
                    (?:[ ]{4}|\t)           // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
                    .*\n+
                )+
            )
            (\n*[ ]{0,3}[^ \t\n]|(?=~0))    // attacklab: g_tab_width
        /g,function(){...});
    */

    // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
    text += "~0";
    
    text = text.replace(/(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
        function(wholeMatch,m1,m2) {
            var codeblock = m1;
            var nextChar = m2;
        
            codeblock = _EncodeCode( _Outdent(codeblock));
            codeblock = _Detab(codeblock);
            codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
            codeblock = codeblock.replace(/\n+$/g,""); // trim trailing whitespace

            codeblock = "
" + codeblock + "\n
";

            return hashBlock(codeblock) + nextChar;
        }
    );

    // attacklab: strip sentinel
    text = text.replace(/~0/,"");

    return text;
}

var hashBlock = function(text) {  
    text = text.replace(/(^\n+|\n+$)/g,"");
    return "\n\n~K" + (g_html_blocks.push(text)-1) + "K\n\n";
}


var _DoCodeSpans = function(text) {  
//
//   *  Backtick quotes are used for  spans.
// 
//   *  You can use multiple backticks as the delimiters if you want to
//   include literal backticks in the code span. So, this input:
//   
//       Just type ``foo `bar` baz`` at the prompt.
//   
//     Will translate to:
//   
//       
Just type foo `bar` baz at the prompt.
//   
//  There's no arbitrary limit to the number of backticks you
//  can use as delimters. If you need three consecutive backticks
//  in your code, use four for delimiters, etc.
//
//  *  You can use spaces to get literal backticks at the edges:
//   
//       ... type `` `bar` `` ...
//   
//     Turns to:
//   
//       ... type `bar` ...
//

    /*
        text = text.replace(/
            (^|[^\\])                   // Character before opening ` can't be a backslash
            (`+)                        // $2 = Opening run of `
            (                           // $3 = The code block
                [^\r]*?
                [^`]                    // attacklab: work around lack of lookbehind
            )
            \2                          // Matching closer
            (?!`)
        /gm, function(){...});
    */

    text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
        function(wholeMatch,m1,m2,m3,m4) {
            var c = m3;
            c = c.replace(/^([ \t]*)/g,""); // leading whitespace
            c = c.replace(/[ \t]*$/g,"");   // trailing whitespace
            c = _EncodeCode(c);
            return m1+""+c+"";
        });

    return text;
}


var _EncodeCode = function(text) {  
//
// Encode/escape certain characters inside Markdown code runs.
// The point is that in code, these characters are literals,
// and lose their special Markdown meanings.
//
    // Encode all ampersands; HTML entities are not
    // entities within a Markdown code span.
    text = text.replace(/&/g,"&");

    // Do the angle bracket song and dance:
    text = text.replace(//g,">");

    // Now, escape characters that are magic in Markdown:
    text = escapeCharacters(text,"\*_{}[]\\",false);

// jj the line above breaks this:
//---

//* Item

//   1. Subitem

//            special char: *
//---

    return text;
}


var _DoItalicsAndBold = function(text) {

    //  must go first:
    text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[\*_]*)\1/g,
        "$2");

    text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g,
        "$2");

    return text;
}


var markPants = function(wholeMatch,m1) {


    var blockText = m1;

    // Undo double lines
    blockText = blockText.replace(/\n\n/g,"\n");
    blockText = blockText.replace(/^\n/,"");
    // strip trailing blank lines
    blockText = blockText.replace(/\n+$/g,"");
    return blockText;
};

var educatePants = function(wholeMatch,m1,m2,m3,m4,m5,m6) {

    
    var blockText = m5;
    if (m5.search(/(<([a-zA-Z1-6]*)([^\r>]?)(>)([^\r]*?)(<\/\2>))/mg)>-1)
    {
        //alert(blockText);
        blockText = blockText.replace(/(<)([a-zA-Z1-6]*)([^\r>]?)(>)([^\r]*?)(<\/\2>)/mg, educatePants);
        
    }
    if (m5.search(/(<([a-zA-Z1-6]*)([^\r>]?)(>)([^\r]*?)(<\/\2>))/g)>-1)
        blockText = blockText.replace(/(<)([a-zA-Z1-6]*)([^\r>]?)(>)([^\r]*?)(<\/\2>)/g, educatePants);
    else blockText = _applyPants(blockText);
    return m1 + m2 + m3 + m4 + blockText + m6;
};


var _applyImgPant = function(wholeMatch, m1)  
{

    var blockText = m1;
    //blockText = m1.replace(/\/>/g, "");// + "";   
    blockText = blockText.replace(/&\#8220;/g, "\"");
    blockText = blockText.replace(/&\#8221;/g, "\"");
    blockText = blockText.replace(/&\#8216;/g, "'");
    blockText = blockText.replace(/&\#8217;/g, "'");
    blockText = blockText.replace(/&\#8230;/g, "...");
    
    return blockText;
}

var _applyPants = function(text)  
{
        
        text = text.replace (/^\x27(?=[!\x22#\$\%\x27()*+,\-.\/:;<=>?\@\[\\]\^_`{|}~]\B)/g, "‘");
        text = text.replace (/^\x22(?=[!\x22#\$\%\x27()*+,\-.\/:;<=>?\@\[\\]\^_`{|}~]\B)/g, "“");
        text = text.replace(/^\x22(?=\w)/g, "“");
        text = text.replace(/^\x27(?=\w)/g, "‘");
        
        text = text.replace(/\x22\x27(?=\w)/g, "“‘");
        text = text.replace(/\x27\x22(?=\w)/g, "‘“");

        //  Special case for decade abbreviations (the '80s):
        text = text.replace(/\x27(?=\d{2}s)/g, "’");


        text = text.replace(/(>|\t|\n|\s| |--|&[mn]dash;|&\#8211;|&\#8212;|&\#x201[34];)\x27(?=\w)/g, "$1‘");
        
        text = text.replace(/([^<>\\ \t\r\n\[\{\(\-])\x27(?=\s | s\b)/g, "$1’");
        

        // Any remaining single quotes should be opening ones:
        text = text.replace (/\x27/g, "’");

        text = text.replace(/(>|\t|\n|\s| |--|&[mn]dash;|&\#8211;|&\#8212;|&\#x201[34];)\x22(?=\w)/g, "$1“");

        text = text.replace (/([^<>\\ \t\r\n\[\{\(\-])\x22(?=\s | s\b)/g, "$1”");
        
        
        text = text.replace (/\x22/ig, "”");
        text.replace(/\.\.\./g, "…").replace (/\.\s\.\s\./g, "…");
        return text;

}

var _RunSmartyPants = function(text) {  
    
    
    text = text.replace(/^(<([a-zA-Z1-6]*)[^\r]?\n<\/\2>[ \t]*(?=\n+))/gm,markPants);
    text = text.replace(/(<)([a-zA-Z1-6]*)([^\r>]?)(>)([^\r]*?)(<\/\2>)/gm, educatePants);
    //clean everything inside html tags
    text = text.replace(/(<([a-zA-Z1-6]*)\b([^\r>]*?)(\/)?>)/g, _applyImgPant);
    //clean out replacements inside special tags
    text = text.replace(/((<)(code|kbd|pre|script|noscript|iframe|math|ins|del|pre)([^\r]?)(>)([^\r]*?)(<\/)(code|kbd|pre|script|noscript|iframe|math|ins|del|pre)(>))/gm, _applyImgPant);

        
    return text;
}


var _DoBlockQuotes = function(text) {

    /*
        text = text.replace(/
        (                               // Wrap whole match in $1
            (
                ^[ \t]*>[ \t]?          // '>' at the start of a line
                .+\n                    // rest of the first line
                (.+\n)*                 // subsequent consecutive lines
                \n*                     // blanks
            )+
        )
        /gm, function(){...});
    */

    text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
        function(wholeMatch,m1) {
            var bq = m1;

            // attacklab: hack around Konqueror 3.5.4 bug:
            // "----------bug".replace(/^-/g,"") == "bug"

            bq = bq.replace(/^[ \t]*>[ \t]?/gm,"~0");   // trim one level of quoting

            // attacklab: clean up hack
            bq = bq.replace(/~0/g,"");

            bq = bq.replace(/^[ \t]+$/gm,"");       // trim whitespace-only lines
            bq = _RunBlockGamut(bq);                // recurse
            
            bq = bq.replace(/(^|\n)/g,"$1  ");
            // These leading spaces screw with 
 content, so we need to fix that:
            bq = bq.replace(
                    /(\s*
[^\r]+?<\/pre>)/gm,
                function(wholeMatch,m1) {
                    var pre = m1;
                    // attacklab: hack around Konqueror 3.5.4 bug:
                    pre = pre.replace(/^  /mg,"~0");
                    pre = pre.replace(/~0/g,"");
                    return pre;
                });
            
            return hashBlock("
\n" + bq + "\n
");
        });
    return text;
}


var _FormParagraphs = function(text) {  
//
//  Params:
//    $text - string to process with html 
 tags
//

    // Strip leading and trailing lines:
    text = text.replace(/^\n+/g,"");
    text = text.replace(/\n+$/g,"");

    var grafs = text.split(/\n{2,}/g);
    var grafsOut = new Array();

    //
    // Wrap 
 tags.
    //
    var end = grafs.length;
    for (var i=0; i= 0) {
            grafsOut.push(str);
        }
        else if (str.search(/\S/) >= 0) {
            
            str = _RunSpanGamut(str);
            
            str = str.replace(/^([ \t]*)/g,"
");
            str += "
"
            grafsOut.push(str);
        }

    }

    //
    // Unhashify HTML blocks
    //
    end = grafsOut.length;
    for (var i=0; i= 0) {
            var blockText = g_html_blocks[RegExp.$1];
            blockText = blockText.replace(/\$/g,"$$$$"); // Escape any dollar signs
            grafsOut[i] = grafsOut[i].replace(/~K\d+K/,blockText);
        }
    }

    return grafsOut.join("\n\n");
}


var _EncodeAmpsAndAngles = function(text) {  
// Smart processing for ampersands and angle brackets that need to be encoded.
    
    // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
    //   http://bumppo.net/projects/amputator/
    text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g,"&");
    
    // Encode naked <'s
    text = text.replace(/<(?![a-z\/?\$!])/gi,"<");
    
    return text;
}


var _EncodeBackslashEscapes = function(text) {  
//
//   Parameter:  String.
//   Returns:   The string, with after processing the following backslash
//             escape sequences.
//

    // attacklab: The polite way to do this is with the new
    // escapeCharacters() function:
    //
    //  text = escapeCharacters(text,"\\",true);
    //  text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
    //
    // ...but we're sidestepping its use of the (slow) RegExp constructor
    // as an optimization for Firefox.  This function gets called a LOT.

    text = text.replace(/\\(\\)/g,escapeCharacters_callback);
    text = text.replace(/\\([`*_{}\[\]()>#+\-.!])/g,escapeCharacters_callback);
    return text;
}


var _DoAutoLinks = function(text) {

    text = text.replace(/<((https?|ftp|dict):[^'">\s]+)>/gi,"<a href=\"$1\">$1</a>");

    // Email addresses: <address@domain.foo>

    /*
        text = text.replace(/
            <
            (?:mailto:)?
            (
                [-.\w]+
                \@
                [-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+
            )
            >
        /gi, _DoAutoLinks_callback());
    */
    text = text.replace(/<(?:mailto:)?([-.\w]+\@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)>/gi,
        function(wholeMatch,m1) {
            return _EncodeEmailAddress( _UnescapeSpecialChars(m1) );
        }
    );

    return text;
}


var _EncodeEmailAddress = function(addr) {  
//
//  Input: an email address, e.g. "foo@example.com"
//
//  Output: the email address as a mailto link, with each character
//  of the address encoded as either a decimal or hex entity, in
//  the hopes of foiling most address harvesting spam bots. E.g.:
//
//  <a href="mailto:foo@e
//     xample.com">foo
//     @example.com</a>
//
//  Based on a filter by Matthew Wickline, posted to the BBEdit-Talk
//  mailing list: <http://tinyurl.com/yu7ue>
//

    // attacklab: why can't javascript speak hex?
    function char2hex(ch) {
        var hexDigits = '0123456789ABCDEF';
        var dec = ch.charCodeAt(0);
        return(hexDigits.charAt(dec>>4) + hexDigits.charAt(dec&15));
    }

    var encode = [
        function(ch){return "&#"+ch.charCodeAt(0)+";";},
        function(ch){return "&#x"+char2hex(ch)+";";},
        function(ch){return ch;}
    ];

    addr = "mailto:" + addr;

    addr = addr.replace(/./g, function(ch) {
        if (ch == "@") {
            // this *must* be encoded. I insist.
            ch = encode[Math.floor(Math.random()*2)](ch);
        } else if (ch !=":") {
            // leave ':' alone (to spot mailto: later)
            var r = Math.random();
            // roughly 10% raw, 45% hex, 45% dec
            ch =  (
                    r > .9  ?   encode[2](ch)   :
                    r > .45 ?   encode[1](ch)   :
                                encode[0](ch)
                );
        }
        return ch;
    });

    addr = ");
}