☰

Greasy Fork 支持简体中文。

Markdown textarea

Add Markdown convert button to textarea

  1. // ==UserScript==
  2. // @name            Markdown textarea
  3. // @namespace       http://userscripts.org/scripts/show/91369
  4. // @description     Add Markdown convert button to textarea
  5. // @version         0.9.5
  6. // @author          mozillazg
  7. // @run-at          document-end
  8. // @include         *
  9. // @exclude         http://*.tudou.com/*
  10. // @exclude         http://www.codecademy.com/courses/*
  11. // @grant           none
  12. // @icon            https://github.com/mozillazg/my-blog-file/raw/master/imgs/markdown-textarea.png
  13. // ==/UserScript==
  14.  
  15. window.addEventListener(
  16. 'load',
  17. (function () {
  18.     var button, div;
  19.     var textareas = document.getElementsByTagName('textarea');
  20.     if (textareas && textareas.length) {
  21.         for (var i = 0; i < textareas.length; i++) {
  22.             var textarea = textareas[i];
  23.             var textarea_style = getComputedStyle(textarea, "" );
  24.             var width = parseFloat(textarea_style.width);
  25.             var left = parseFloat(textarea_style.left);
  26.             if (textarea_style.display != "none"
  27.                  && textarea_style.visibility != "hidden"
  28.                  && textarea_style.height != "0px"
  29.                  && textarea.getAttribute("readonly") == null
  30.                  && textarea.getAttribute("disabled") == null
  31.                  && (!((isNaN(left) != true) && (left < 0)
  32.                      && Math.abs(left) > width))
  33.                 ) {
  34.                 div = document.createElement('div');
  35.                 button = document.createElement('button');
  36.                 button.setAttribute('type', 'button')
  37.                 button.innerHTML = 'Markdown';
  38.                 button.addEventListener('click', function(e){
  39.                     var converter = new Showdown.converter();
  40.                     e.target.parentNode.firstChild.value = converter.makeHtml(e.target.parentNode.firstChild.value);
  41.                 }, false);
  42.                 textareas[i].parentNode.insertBefore(div, textareas[i]);
  43.                 div.appendChild(textareas[i]);
  44.                 div.appendChild(document.createElement('br'));
  45.                 div.appendChild(button);
  46.             }
  47.         }
  48.     }
  49.  
  50.     //
  51.     // showdown.js -- A javascript port of Markdown.
  52.     //
  53.     // Copyright (c) 2007 John Fraser.
  54.     //
  55.     // Original Markdown Copyright (c) 2004-2005 John Gruber
  56.     //   <http://daringfireball.net/projects/markdown/>
  57.     //
  58.     // Redistributable under a BSD-style open source license.
  59.     // See license.txt for more information.
  60.     //
  61.     // The full source distribution is at:
  62.     //
  63.     //				A A L
  64.     //				T C A
  65.     //				T K B
  66.     //
  67.     //   <http://www.attacklab.net/>
  68.     //
  69.     
  70.     //
  71.     // Wherever possible, Showdown is a straight, line-by-line port
  72.     // of the Perl version of Markdown.
  73.     //
  74.     // This is not a normal parser design; it's basically just a
  75.     // series of string substitutions.  It's hard to read and
  76.     // maintain this way,  but keeping Showdown close to the original
  77.     // design makes it easier to port new features.
  78.     //
  79.     // More importantly, Showdown behaves like markdown.pl in most
  80.     // edge cases.  So web applications can do client-side preview
  81.     // in Javascript, and then build identical HTML on the server.
  82.     //
  83.     // This port needs the new RegExp functionality of ECMA 262,
  84.     // 3rd Edition (i.e. Javascript 1.5).  Most modern web browsers
  85.     // should do fine.  Even with the new regular expression features,
  86.     // We do a lot of work to emulate Perl's regex functionality
  87.     // We do a lot of work to emulate Perl's regex functionality.
  88.     // The tricky changes in this file mostly have the "attacklab:"
  89.     // label. Major or self-explanatory changes don't.
  90.     //
  91.     // Smart diff tools like Araxis Merge will be able to match up
  92.     // this file with markdown.pl in a useful way. A little tweaking
  93.     // helps: in a copy of markdown.pl, replace "#" with "//" and
  94.     // replace "$text" with "text". Be sure to ignore whitespace
  95.     // and line endings.
  96.     //
  97.     
  98.     
  99.     //
  100.     // Showdown usage:
  101.     //
  102.     // var text = "Markdown *rocks*.";
  103.     //
  104.     // var converter = new Showdown.converter();
  105.     // var html = converter.makeHtml(text);
  106.     //
  107.     // alert(html);
  108.     //
  109.     // Note: move the sample code to the bottom of this
  110.     // file before uncommenting it.
  111.     //
  112.     
  113.     
  114.     //
  115.     // Showdown namespace
  116.     //
  117.     var Showdown = {};
  118.     
  119.     //
  120.     // converter
  121.     //
  122.     // Wraps all "globals" so that the only thing
  123.     // exposed is makeHtml().
  124.     //
  125.     Showdown.converter = function() {
  126.     
  127.     //
  128.     // Globals:
  129.     //
  130.     
  131.     // Global hashes, used by various utility routines
  132.     var g_urls;
  133.     var g_titles;
  134.     var g_html_blocks;
  135.     
  136.     // Used to track when we're inside an ordered or unordered list
  137.     // (see _ProcessListItems() for details):
  138.     var g_list_level = 0;
  139.     
  140.     
  141.     this.makeHtml = function(text) {
  142.     //
  143.     // Main function. The order in which other subs are called here is
  144.     // essential. Link and image substitutions need to happen before
  145.     // _EscapeSpecialCharsWithinTagAttributes(), so that any *'s or _'s in the <a>
  146.     // and <img> tags get encoded.
  147.     //
  148.     
  149.     // Clear the global hashes. If we don't clear these, you get conflicts
  150.     // from other articles when generating a page which contains more than
  151.     // one article (e.g. an index page that shows the N most recent
  152.     // articles):
  153.     g_urls = new Array();
  154.     g_titles = new Array();
  155.     g_html_blocks = new Array();
  156.     
  157.     // attacklab: Replace ~ with ~T
  158.     // This lets us use tilde as an escape char to avoid md5 hashes
  159.     // The choice of character is arbitray; anything that isn't
  160.     // magic in Markdown will work.
  161.     text = text.replace(/~/g,"~T");
  162.     
  163.     // attacklab: Replace $ with ~D
  164.     // RegExp interprets $ as a special character
  165.     // when it's in a replacement string
  166.     text = text.replace(/\$/g,"~D");
  167.     
  168.     // Standardize line endings
  169.     text = text.replace(/\r\n/g,"\n"); // DOS to Unix
  170.     text = text.replace(/\r/g,"\n"); // Mac to Unix
  171.     
  172.     // Make sure text begins and ends with a couple of newlines:
  173.     text = "\n\n" + text + "\n\n";
  174.     
  175.     // Convert all tabs to spaces.
  176.     text = _Detab(text);
  177.     
  178.     // Strip any lines consisting only of spaces and tabs.
  179.     // This makes subsequent regexen easier to write, because we can
  180.     // match consecutive blank lines with /\n+/ instead of something
  181.     // contorted like /[ \t]*\n+/ .
  182.     text = text.replace(/^[ \t]+$/mg,"");
  183.     
  184.     // Turn block-level HTML blocks into hash entries
  185.     text = _HashHTMLBlocks(text);
  186.     
  187.     // Strip link definitions, store in hashes.
  188.     text = _StripLinkDefinitions(text);
  189.     
  190.     text = _RunBlockGamut(text);
  191.     
  192.     text = _UnescapeSpecialChars(text);
  193.     
  194.     // attacklab: Restore dollar signs
  195.     text = text.replace(/~D/g,"$$");
  196.     
  197.     // attacklab: Restore tildes
  198.     text = text.replace(/~T/g,"~");
  199.     
  200.     return text;
  201.     }
  202.     
  203.     
  204.     var _StripLinkDefinitions = function(text) {
  205.     //
  206.     // Strips link definitions from text, stores the URLs and titles in
  207.     // hash references.
  208.     //
  209.     
  210.     // Link defs are in the form: ^[id]: url "optional title"
  211.     
  212.     /*
  213.     var text = text.replace(/
  214.     ^[ ]{0,3}\[(.+)\]: // id = $1 attacklab: g_tab_width - 1
  215.     [ \t]*
  216.     \n? // maybe *one* newline
  217.     [ \t]*
  218.     <?(\S+?)>? // url = $2
  219.     [ \t]*
  220.     \n? // maybe one newline
  221.     [ \t]*
  222.     (?:
  223.     (\n*) // any lines skipped = $3 attacklab: lookbehind removed
  224.     ["(]
  225.     (.+?) // title = $4
  226.     [")]
  227.     [ \t]*
  228.     )? // title is optional
  229.     (?:\n+|$)
  230.     /gm,
  231.     function(){...});
  232.     */
  233.     var text = text.replace(/^[ ]{0,3}\[(.+)\]:[ \t]*\n?[ \t]*<?(\S+?)>?[ \t]*\n?[ \t]*(?:(\n*)["(](.+?)[")][ \t]*)?(?:\n+|\Z)/gm,
  234.     function (wholeMatch,m1,m2,m3,m4) {
  235.     m1 = m1.toLowerCase();
  236.     g_urls[m1] = _EncodeAmpsAndAngles(m2); // Link IDs are case-insensitive
  237.     if (m3) {
  238.     // Oops, found blank lines, so it's not a title.
  239.     // Put back the parenthetical statement we stole.
  240.     return m3+m4;
  241.     } else if (m4) {
  242.     g_titles[m1] = m4.replace(/"/g,"&quot;");
  243.     }
  244.     
  245.     // Completely remove the definition from the text
  246.     return "";
  247.     }
  248.     );
  249.     
  250.     return text;
  251.     }
  252.     
  253.     
  254.     var _HashHTMLBlocks = function(text) {
  255.     // attacklab: Double up blank lines to reduce lookaround
  256.     text = text.replace(/\n/g,"\n\n");
  257.     
  258.     // Hashify HTML blocks:
  259.     // We only want to do this for block-level HTML tags, such as headers,
  260.     // lists, and tables. That's because we still want to wrap <p>s around
  261.     // "paragraphs" that are wrapped in non-block-level tags, such as anchors,
  262.     // phrase emphasis, and spans. The list of tags we're looking for is
  263.     // hard-coded:
  264.     var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del"
  265.     var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math"
  266.     
  267.     // First, look for nested blocks, e.g.:
  268.     // <div>
  269.     // <div>
  270.     // tags for inner block must be indented.
  271.     // </div>
  272.     // </div>
  273.     //
  274.     // The outermost tags must start at the left margin for this to match, and
  275.     // the inner nested divs must be indented.
  276.     // We need to do this before the next, more liberal match, because the next
  277.     // match will start at the first `<div>` and stop at the first `</div>`.
  278.     
  279.     // attacklab: This regex can be expensive when it fails.
  280.     /*
  281.     var text = text.replace(/
  282.     ( // save in $1
  283.     ^ // start of line (with /m)
  284.     <($block_tags_a) // start tag = $2
  285.     \b // word break
  286.     // attacklab: hack around khtml/pcre bug...
  287.     [^\r]*?\n // any number of lines, minimally matching
  288.     </\2> // the matching end tag
  289.     [ \t]* // trailing spaces/tabs
  290.     (?=\n+) // followed by a newline
  291.     ) // attacklab: there are sentinel newlines at end of document
  292.     /gm,function(){...}};
  293.     */
  294.     text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del)\b[^\r]*?\n<\/\2>[ \t]*(?=\n+))/gm,hashElement);
  295.     
  296.     //
  297.     // Now match more liberally, simply from `\n<tag>` to `</tag>\n`
  298.     //
  299.     
  300.     /*
  301.     var text = text.replace(/
  302.     ( // save in $1
  303.     ^ // start of line (with /m)
  304.     <($block_tags_b) // start tag = $2
  305.     \b // word break
  306.     // attacklab: hack around khtml/pcre bug...
  307.     [^\r]*? // any number of lines, minimally matching
  308.     .*</\2> // the matching end tag
  309.     [ \t]* // trailing spaces/tabs
  310.     (?=\n+) // followed by a newline
  311.     ) // attacklab: there are sentinel newlines at end of document
  312.     /gm,function(){...}};
  313.     */
  314.     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);
  315.     
  316.     // Special case just for <hr />. It was easier to make a special case than
  317.     // to make the other regex more complicated.
  318.     
  319.     /*
  320.     text = text.replace(/
  321.     ( // save in $1
  322.     \n\n // Starting after a blank line
  323.     [ ]{0,3}
  324.     (<(hr) // start tag = $2
  325.     \b // word break
  326.     ([^<>])*? //
  327.     \/?>) // the matching end tag
  328.     [ \t]*
  329.     (?=\n{2,}) // followed by a blank line
  330.     )
  331.     /g,hashElement);
  332.     */
  333.     text = text.replace(/(\n[ ]{0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,hashElement);
  334.     
  335.     // Special case for standalone HTML comments:
  336.     
  337.     /*
  338.     text = text.replace(/
  339.     ( // save in $1
  340.     \n\n // Starting after a blank line
  341.     [ ]{0,3} // attacklab: g_tab_width - 1
  342.     <!
  343.     (--[^\r]*?--\s*)+
  344.     >
  345.     [ \t]*
  346.     (?=\n{2,}) // followed by a blank line
  347.     )
  348.     /g,hashElement);
  349.     */
  350.     text = text.replace(/(\n\n[ ]{0,3}<!(--[^\r]*?--\s*)+>[ \t]*(?=\n{2,}))/g,hashElement);
  351.     
  352.     // PHP and ASP-style processor instructions (<?...?> and <%...%>)
  353.     
  354.     /*
  355.     text = text.replace(/
  356.     (?:
  357.     \n\n // Starting after a blank line
  358.     )
  359.     ( // save in $1
  360.     [ ]{0,3} // attacklab: g_tab_width - 1
  361.     (?:
  362.     <([?%]) // $2
  363.     [^\r]*?
  364.     \2>
  365.     )
  366.     [ \t]*
  367.     (?=\n{2,}) // followed by a blank line
  368.     )
  369.     /g,hashElement);
  370.     */
  371.     text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,hashElement);
  372.     
  373.     // attacklab: Undo double lines (see comment at top of this function)
  374.     text = text.replace(/\n\n/g,"\n");
  375.     return text;
  376.     }
  377.     
  378.     var hashElement = function(wholeMatch,m1) {
  379.     var blockText = m1;
  380.     
  381.     // Undo double lines
  382.     blockText = blockText.replace(/\n\n/g,"\n");
  383.     blockText = blockText.replace(/^\n/,"");
  384.     
  385.     // strip trailing blank lines
  386.     blockText = blockText.replace(/\n+$/g,"");
  387.     
  388.     // Replace the element text with a marker ("~KxK" where x is its key)
  389.     blockText = "\n\n~K" + (g_html_blocks.push(blockText)-1) + "K\n\n";
  390.     
  391.     return blockText;
  392.     };
  393.     
  394.     var _RunBlockGamut = function(text) {
  395.     //
  396.     // These are all the transformations that form block-level
  397.     // tags like paragraphs, headers, and list items.
  398.     //
  399.     text = _DoHeaders(text);
  400.     
  401.     // Do Horizontal Rules:
  402.     var key = hashBlock("<hr />");
  403.     text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm,key);
  404.     text = text.replace(/^[ ]{0,2}([ ]?\-[ ]?){3,}[ \t]*$/gm,key);
  405.     text = text.replace(/^[ ]{0,2}([ ]?\_[ ]?){3,}[ \t]*$/gm,key);
  406.     
  407.     text = _DoLists(text);
  408.     text = _DoCodeBlocks(text);
  409.     text = _DoBlockQuotes(text);
  410.     
  411.     // We already ran _HashHTMLBlocks() before, in Markdown(), but that
  412.     // was to escape raw HTML in the original Markdown source. This time,
  413.     // we're escaping the markup we've just created, so that we don't wrap
  414.     // <p> tags around block-level tags.
  415.     text = _HashHTMLBlocks(text);
  416.     text = _FormParagraphs(text);
  417.     
  418.     return text;
  419.     }
  420.     
  421.     
  422.     var _RunSpanGamut = function(text) {
  423.     //
  424.     // These are all the transformations that occur *within* block-level
  425.     // tags like paragraphs, headers, and list items.
  426.     //
  427.     
  428.     text = _DoCodeSpans(text);
  429.     text = _EscapeSpecialCharsWithinTagAttributes(text);
  430.     text = _EncodeBackslashEscapes(text);
  431.     
  432.     // Process anchor and image tags. Images must come first,
  433.     // because ![foo][f] looks like an anchor.
  434.     text = _DoImages(text);
  435.     text = _DoAnchors(text);
  436.     
  437.     // Make links out of things like `<http://example.com/>`
  438.     // Must come after _DoAnchors(), because you can use < and >
  439.     // delimiters in inline links like [this](<url>).
  440.     text = _DoAutoLinks(text);
  441.     text = _EncodeAmpsAndAngles(text);
  442.     text = _DoItalicsAndBold(text);
  443.     
  444.     // Do hard breaks:
  445.     text = text.replace(/ +\n/g," <br />\n");
  446.     
  447.     return text;
  448.     }
  449.     
  450.     var _EscapeSpecialCharsWithinTagAttributes = function(text) {
  451.     //
  452.     // Within tags -- meaning between < and > -- encode [\ ` * _] so they
  453.     // don't conflict with their use in Markdown for code, italics and strong.
  454.     //
  455.     
  456.     // Build a regex to find HTML tags and comments. See Friedl's
  457.     // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
  458.     var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|<!(--.*?--\s*)+>)/gi;
  459.     
  460.     text = text.replace(regex, function(wholeMatch) {
  461.     var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g,"$1`");
  462.     tag = escapeCharacters(tag,"\\`*_");
  463.     return tag;
  464.     });
  465.     
  466.     return text;
  467.     }
  468.     
  469.     var _DoAnchors = function(text) {
  470.     //
  471.     // Turn Markdown link shortcuts into XHTML <a> tags.
  472.     //
  473.     //
  474.     // First, handle reference-style links: [link text] [id]
  475.     //
  476.     
  477.     /*
  478.     text = text.replace(/
  479.     ( // wrap whole match in $1
  480.     \[
  481.     (
  482.     (?:
  483.     \[[^\]]*\] // allow brackets nested one level
  484.     |
  485.     [^\[] // or anything else
  486.     )*
  487.     )
  488.     \]
  489.     
  490.     [ ]? // one optional space
  491.     (?:\n[ ]*)? // one optional newline followed by spaces
  492.     
  493.     \[
  494.     (.*?) // id = $3
  495.     \]
  496.     )()()()() // pad remaining backreferences
  497.     /g,_DoAnchors_callback);
  498.     */
  499.     text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeAnchorTag);
  500.     
  501.     //
  502.     // Next, inline-style links: [link text](url "optional title")
  503.     //
  504.     
  505.     /*
  506.     text = text.replace(/
  507.     ( // wrap whole match in $1
  508.     \[
  509.     (
  510.     (?:
  511.     \[[^\]]*\] // allow brackets nested one level
  512.     |
  513.     [^\[\]] // or anything else
  514.     )
  515.     )
  516.     \]
  517.     \( // literal paren
  518.     [ \t]*
  519.     () // no id, so leave $3 empty
  520.     <?(.*?)>? // href = $4
  521.     [ \t]*
  522.     ( // $5
  523.     (['"]) // quote char = $6
  524.     (.*?) // Title = $7
  525.     \6 // matching quote
  526.     [ \t]* // ignore any spaces/tabs between closing quote and )
  527.     )? // title is optional
  528.     \)
  529.     )
  530.     /g,writeAnchorTag);
  531.     */
  532.     text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()<?(.*?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeAnchorTag);
  533.     
  534.     //
  535.     // Last, handle reference-style shortcuts: [link text]
  536.     // These must come last in case you've also got [link test][1]
  537.     // or [link test](/foo)
  538.     //
  539.     
  540.     /*
  541.     text = text.replace(/
  542.     ( // wrap whole match in $1
  543.     \[
  544.     ([^\[\]]+) // link text = $2; can't contain '[' or ']'
  545.     \]
  546.     )()()()()() // pad rest of backreferences
  547.     /g, writeAnchorTag);
  548.     */
  549.     text = text.replace(/(\[([^\[\]]+)\])()()()()()/g, writeAnchorTag);
  550.     
  551.     return text;
  552.     }
  553.     
  554.     var writeAnchorTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
  555.     if (m7 == undefined) m7 = "";
  556.     var whole_match = m1;
  557.     var link_text = m2;
  558.     var link_id = m3.toLowerCase();
  559.     var url = m4;
  560.     var title = m7;
  561.     
  562.     if (url == "") {
  563.     if (link_id == "") {
  564.     // lower-case and turn embedded newlines into spaces
  565.     link_id = link_text.toLowerCase().replace(/ ?\n/g," ");
  566.     }
  567.     url = "#"+link_id;
  568.     
  569.     if (g_urls[link_id] != undefined) {
  570.     url = g_urls[link_id];
  571.     if (g_titles[link_id] != undefined) {
  572.     title = g_titles[link_id];
  573.     }
  574.     }
  575.     else {
  576.     if (whole_match.search(/\(\s*\)$/m)>-1) {
  577.     // Special case for explicit empty url
  578.     url = "";
  579.     } else {
  580.     return whole_match;
  581.     }
  582.     }
  583.     }
  584.     
  585.     url = escapeCharacters(url,"*_");
  586.     var result = "<a href=\"" + url + "\"";
  587.     
  588.     if (title != "") {
  589.     title = title.replace(/"/g,"&quot;");
  590.     title = escapeCharacters(title,"*_");
  591.     result += " title=\"" + title + "\"";
  592.     }
  593.     
  594.     result += ">" + link_text + "</a>";
  595.     
  596.     return result;
  597.     }
  598.     
  599.     
  600.     var _DoImages = function(text) {
  601.     //
  602.     // Turn Markdown image shortcuts into <img> tags.
  603.     //
  604.     
  605.     //
  606.     // First, handle reference-style labeled images: ![alt text][id]
  607.     //
  608.     
  609.     /*
  610.     text = text.replace(/
  611.     ( // wrap whole match in $1
  612.     !\[
  613.     (.*?) // alt text = $2
  614.     \]
  615.     
  616.     [ ]? // one optional space
  617.     (?:\n[ ]*)? // one optional newline followed by spaces
  618.     
  619.     \[
  620.     (.*?) // id = $3
  621.     \]
  622.     )()()()() // pad rest of backreferences
  623.     /g,writeImageTag);
  624.     */
  625.     text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeImageTag);
  626.     
  627.     //
  628.     // Next, handle inline images: ![alt text](url "optional title")
  629.     // Don't forget: encode * and _
  630.     
  631.     /*
  632.     text = text.replace(/
  633.     ( // wrap whole match in $1
  634.     !\[
  635.     (.*?) // alt text = $2
  636.     \]
  637.     \s? // One optional whitespace character
  638.     \( // literal paren
  639.     [ \t]*
  640.     () // no id, so leave $3 empty
  641.     <?(\S+?)>? // src url = $4
  642.     [ \t]*
  643.     ( // $5
  644.     (['"]) // quote char = $6
  645.     (.*?) // title = $7
  646.     \6 // matching quote
  647.     [ \t]*
  648.     )? // title is optional
  649.     \)
  650.     )
  651.     /g,writeImageTag);
  652.     */
  653.     text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()<?(\S+?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeImageTag);
  654.     
  655.     return text;
  656.     }
  657.     
  658.     var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
  659.     var whole_match = m1;
  660.     var alt_text = m2;
  661.     var link_id = m3.toLowerCase();
  662.     var url = m4;
  663.     var title = m7;
  664.     
  665.     if (!title) title = "";
  666.     
  667.     if (url == "") {
  668.     if (link_id == "") {
  669.     // lower-case and turn embedded newlines into spaces
  670.     link_id = alt_text.toLowerCase().replace(/ ?\n/g," ");
  671.     }
  672.     url = "#"+link_id;
  673.     
  674.     if (g_urls[link_id] != undefined) {
  675.     url = g_urls[link_id];
  676.     if (g_titles[link_id] != undefined) {
  677.     title = g_titles[link_id];
  678.     }
  679.     }
  680.     else {
  681.     return whole_match;
  682.     }
  683.     }
  684.     
  685.     alt_text = alt_text.replace(/"/g,"&quot;");
  686.     url = escapeCharacters(url,"*_");
  687.     var result = "<img src=\"" + url + "\" alt=\"" + alt_text + "\"";
  688.     
  689.     // attacklab: Markdown.pl adds empty title attributes to images.
  690.     // Replicate this bug.
  691.     
  692.     //if (title != "") {
  693.     title = title.replace(/"/g,"&quot;");
  694.     title = escapeCharacters(title,"*_");
  695.     result += " title=\"" + title + "\"";
  696.     //}
  697.     
  698.     result += " />";
  699.     
  700.     return result;
  701.     }
  702.     
  703.     
  704.     var _DoHeaders = function(text) {
  705.     
  706.     // Setext-style headers:
  707.     // Header 1
  708.     // ========
  709.     //
  710.     // Header 2
  711.     // --------
  712.     //
  713.     text = text.replace(/^(.+)[ \t]*\n=+[ \t]*\n+/gm,
  714.     function(wholeMatch,m1){return hashBlock("<h1>" + _RunSpanGamut(m1) + "</h1>");});
  715.     
  716.     text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
  717.     function(matchFound,m1){return hashBlock("<h2>" + _RunSpanGamut(m1) + "</h2>");});
  718.     
  719.     // atx-style headers:
  720.     // # Header 1
  721.     // ## Header 2
  722.     // ## Header 2 with closing hashes ##
  723.     // ...
  724.     // ###### Header 6
  725.     //
  726.     
  727.     /*
  728.     text = text.replace(/
  729.     ^(\#{1,6}) // $1 = string of #'s
  730.     [ \t]*
  731.     (.+?) // $2 = Header text
  732.     [ \t]*
  733.     \#* // optional closing #'s (not counted)
  734.     \n+
  735.     /gm, function() {...});
  736.     */
  737.     
  738.     text = text.replace(/^(\#{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
  739.     function(wholeMatch,m1,m2) {
  740.     var h_level = m1.length;
  741.     return hashBlock("<h" + h_level + ">" + _RunSpanGamut(m2) + "</h" + h_level + ">");
  742.     });
  743.     
  744.     return text;
  745.     }
  746.     
  747.     // This declaration keeps Dojo compressor from outputting garbage:
  748.     var _ProcessListItems;
  749.     
  750.     var _DoLists = function(text) {
  751.     //
  752.     // Form HTML ordered (numbered) and unordered (bulleted) lists.
  753.     //
  754.     
  755.     // attacklab: add sentinel to hack around khtml/safari bug:
  756.     // http://bugs.webkit.org/show_bug.cgi?id=11231
  757.     text += "~0";
  758.     
  759.     // Re-usable pattern to match any entirel ul or ol list:
  760.     
  761.     /*
  762.     var whole_list = /
  763.     ( // $1 = whole list
  764.     ( // $2
  765.     [ ]{0,3} // attacklab: g_tab_width - 1
  766.     ([*+-]|\d+[.]) // $3 = first list item marker
  767.     [ \t]+
  768.     )
  769.     [^\r]+?
  770.     ( // $4
  771.     ~0 // sentinel for workaround; should be $
  772.     |
  773.     \n{2,}
  774.     (?=\S)
  775.     (?! // Negative lookahead for another list item marker
  776.     [ \t]*
  777.     (?:[*+-]|\d+[.])[ \t]+
  778.     )
  779.     )
  780.     )/g
  781.     */
  782.     var whole_list = /^(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm;
  783.     
  784.     if (g_list_level) {
  785.     text = text.replace(whole_list,function(wholeMatch,m1,m2) {
  786.     var list = m1;
  787.     var list_type = (m2.search(/[*+-]/g)>-1) ? "ul" : "ol";
  788.     
  789.     // Turn double returns into triple returns, so that we can make a
  790.     // paragraph for the last item in a list, if necessary:
  791.     list = list.replace(/\n{2,}/g,"\n\n\n");;
  792.     var result = _ProcessListItems(list);
  793.     
  794.     // Trim any trailing whitespace, to put the closing `</$list_type>`
  795.     // up on the preceding line, to get it past the current stupid
  796.     // HTML block parser. This is a hack to work around the terrible
  797.     // hack that is the HTML block parser.
  798.     result = result.replace(/\s+$/,"");
  799.     result = "<"+list_type+">" + result + "</"+list_type+">\n";
  800.     return result;
  801.     });
  802.     } else {
  803.     whole_list = /(\n\n|^\n?)(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/g;
  804.     text = text.replace(whole_list,function(wholeMatch,m1,m2,m3) {
  805.     var runup = m1;
  806.     var list = m2;
  807.     
  808.     var list_type = (m3.search(/[*+-]/g)>-1) ? "ul" : "ol";
  809.     // Turn double returns into triple returns, so that we can make a
  810.     // paragraph for the last item in a list, if necessary:
  811.     var list = list.replace(/\n{2,}/g,"\n\n\n");;
  812.     var result = _ProcessListItems(list);
  813.     result = runup + "<"+list_type+">\n" + result + "</"+list_type+">\n";
  814.     return result;
  815.     });
  816.     }
  817.     
  818.     // attacklab: strip sentinel
  819.     text = text.replace(/~0/,"");
  820.     
  821.     return text;
  822.     }
  823.     
  824.     _ProcessListItems = function(list_str) {
  825.     //
  826.     // Process the contents of a single ordered or unordered list, splitting it
  827.     // into individual list items.
  828.     //
  829.     // The $g_list_level global keeps track of when we're inside a list.
  830.     // Each time we enter a list, we increment it; when we leave a list,
  831.     // we decrement. If it's zero, we're not in a list anymore.
  832.     //
  833.     // We do this because when we're not inside a list, we want to treat
  834.     // something like this:
  835.     //
  836.     // I recommend upgrading to version
  837.     // 8. Oops, now this line is treated
  838.     // as a sub-list.
  839.     //
  840.     // As a single paragraph, despite the fact that the second line starts
  841.     // with a digit-period-space sequence.
  842.     //
  843.     // Whereas when we're inside a list (or sub-list), that line will be
  844.     // treated as the start of a sub-list. What a kludge, huh? This is
  845.     // an aspect of Markdown's syntax that's hard to parse perfectly
  846.     // without resorting to mind-reading. Perhaps the solution is to
  847.     // change the syntax rules such that sub-lists must start with a
  848.     // starting cardinal number; e.g. "1." or "a.".
  849.     
  850.     g_list_level++;
  851.     
  852.     // trim trailing blank lines:
  853.     list_str = list_str.replace(/\n{2,}$/,"\n");
  854.     
  855.     // attacklab: add sentinel to emulate \z
  856.     list_str += "~0";
  857.     
  858.     /*
  859.     list_str = list_str.replace(/
  860.     (\n)? // leading line = $1
  861.     (^[ \t]*) // leading whitespace = $2
  862.     ([*+-]|\d+[.]) [ \t]+ // list marker = $3
  863.     ([^\r]+? // list item text = $4
  864.     (\n{1,2}))
  865.     (?= \n* (~0 | \2 ([*+-]|\d+[.]) [ \t]+))
  866.     /gm, function(){...});
  867.     */
  868.     list_str = list_str.replace(/(\n)?(^[ \t]*)([*+-]|\d+[.])[ \t]+([^\r]+?(\n{1,2}))(?=\n*(~0|\2([*+-]|\d+[.])[ \t]+))/gm,
  869.     function(wholeMatch,m1,m2,m3,m4){
  870.     var item = m4;
  871.     var leading_line = m1;
  872.     var leading_space = m2;
  873.     
  874.     if (leading_line || (item.search(/\n{2,}/)>-1)) {
  875.     item = _RunBlockGamut(_Outdent(item));
  876.     }
  877.     else {
  878.     // Recursion for sub-lists:
  879.     item = _DoLists(_Outdent(item));
  880.     item = item.replace(/\n$/,""); // chomp(item)
  881.     item = _RunSpanGamut(item);
  882.     }
  883.     
  884.     return "<li>" + item + "</li>\n";
  885.     }
  886.     );
  887.     
  888.     // attacklab: strip sentinel
  889.     list_str = list_str.replace(/~0/g,"");
  890.     
  891.     g_list_level--;
  892.     return list_str;
  893.     }
  894.     
  895.     
  896.     var _DoCodeBlocks = function(text) {
  897.     //
  898.     // Process Markdown `<pre><code>` blocks.
  899.     //
  900.     
  901.     /*
  902.     text = text.replace(text,
  903.     /(?:\n\n|^)
  904.     ( // $1 = the code block -- one or more lines, starting with a space/tab
  905.     (?:
  906.     (?:[ ]{4}|\t) // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
  907.     .*\n+
  908.     )+
  909.     )
  910.     (\n*[ ]{0,3}[^ \t\n]|(?=~0)) // attacklab: g_tab_width
  911.     /g,function(){...});
  912.     */
  913.     
  914.     // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
  915.     text += "~0";
  916.     
  917.     text = text.replace(/(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
  918.     function(wholeMatch,m1,m2) {
  919.     var codeblock = m1;
  920.     var nextChar = m2;
  921.     
  922.     codeblock = _EncodeCode( _Outdent(codeblock));
  923.     codeblock = _Detab(codeblock);
  924.     codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
  925.     codeblock = codeblock.replace(/\n+$/g,""); // trim trailing whitespace
  926.     
  927.     codeblock = "<pre><code>" + codeblock + "\n</code></pre>";
  928.     
  929.     return hashBlock(codeblock) + nextChar;
  930.     }
  931.     );
  932.     
  933.     // attacklab: strip sentinel
  934.     text = text.replace(/~0/,"");
  935.     
  936.     return text;
  937.     }
  938.     
  939.     var hashBlock = function(text) {
  940.     text = text.replace(/(^\n+|\n+$)/g,"");
  941.     return "\n\n~K" + (g_html_blocks.push(text)-1) + "K\n\n";
  942.     }
  943.     
  944.     
  945.     var _DoCodeSpans = function(text) {
  946.     //
  947.     // * Backtick quotes are used for <code></code> spans.
  948.     //
  949.     // * You can use multiple backticks as the delimiters if you want to
  950.     // include literal backticks in the code span. So, this input:
  951.     //
  952.     // Just type ``foo `bar` baz`` at the prompt.
  953.     //
  954.     // Will translate to:
  955.     //
  956.     // <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
  957.     //
  958.     // There's no arbitrary limit to the number of backticks you
  959.     // can use as delimters. If you need three consecutive backticks
  960.     // in your code, use four for delimiters, etc.
  961.     //
  962.     // * You can use spaces to get literal backticks at the edges:
  963.     //
  964.     // ... type `` `bar` `` ...
  965.     //
  966.     // Turns to:
  967.     //
  968.     // ... type <code>`bar`</code> ...
  969.     //
  970.     
  971.     /*
  972.     text = text.replace(/
  973.     (^|[^\\]) // Character before opening ` can't be a backslash
  974.     (`+) // $2 = Opening run of `
  975.     ( // $3 = The code block
  976.     [^\r]*?
  977.     [^`] // attacklab: work around lack of lookbehind
  978.     )
  979.     \2 // Matching closer
  980.     (?!`)
  981.     /gm, function(){...});
  982.     */
  983.     
  984.     text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
  985.     function(wholeMatch,m1,m2,m3,m4) {
  986.     var c = m3;
  987.     c = c.replace(/^([ \t]*)/g,""); // leading whitespace
  988.     c = c.replace(/[ \t]*$/g,""); // trailing whitespace
  989.     c = _EncodeCode(c);
  990.     return m1+"<code>"+c+"</code>";
  991.     });
  992.     
  993.     return text;
  994.     }
  995.     
  996.     
  997.     var _EncodeCode = function(text) {
  998.     //
  999.     // Encode/escape certain characters inside Markdown code runs.
  1000.     // The point is that in code, these characters are literals,
  1001.     // and lose their special Markdown meanings.
  1002.     //
  1003.     // Encode all ampersands; HTML entities are not
  1004.     // entities within a Markdown code span.
  1005.     text = text.replace(/&/g,"&amp;");
  1006.     
  1007.     // Do the angle bracket song and dance:
  1008.     text = text.replace(/</g,"&lt;");
  1009.     text = text.replace(/>/g,"&gt;");
  1010.     
  1011.     // Now, escape characters that are magic in Markdown:
  1012.     text = escapeCharacters(text,"\*_{}[]\\",false);
  1013.     
  1014.     // jj the line above breaks this:
  1015.     //---
  1016.     
  1017.     //* Item
  1018.     
  1019.     // 1. Subitem
  1020.     
  1021.     // special char: *
  1022.     //---
  1023.     
  1024.     return text;
  1025.     }
  1026.     
  1027.     
  1028.     var _DoItalicsAndBold = function(text) {
  1029.     
  1030.     // <strong> must go first:
  1031.     text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[*_]*)\1/g,
  1032.     "<strong>$2</strong>");
  1033.     
  1034.     text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g,
  1035.     "<em>$2</em>");
  1036.     
  1037.     return text;
  1038.     }
  1039.     
  1040.     
  1041.     var _DoBlockQuotes = function(text) {
  1042.     
  1043.     /*
  1044.     text = text.replace(/
  1045.     ( // Wrap whole match in $1
  1046.     (
  1047.     ^[ \t]*>[ \t]? // '>' at the start of a line
  1048.     .+\n // rest of the first line
  1049.     (.+\n)* // subsequent consecutive lines
  1050.     \n* // blanks
  1051.     )+
  1052.     )
  1053.     /gm, function(){...});
  1054.     */
  1055.     
  1056.     text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
  1057.     function(wholeMatch,m1) {
  1058.     var bq = m1;
  1059.     
  1060.     // attacklab: hack around Konqueror 3.5.4 bug:
  1061.     // "----------bug".replace(/^-/g,"") == "bug"
  1062.     
  1063.     bq = bq.replace(/^[ \t]*>[ \t]?/gm,"~0"); // trim one level of quoting
  1064.     
  1065.     // attacklab: clean up hack
  1066.     bq = bq.replace(/~0/g,"");
  1067.     
  1068.     bq = bq.replace(/^[ \t]+$/gm,""); // trim whitespace-only lines
  1069.     bq = _RunBlockGamut(bq); // recurse
  1070.     
  1071.     bq = bq.replace(/(^|\n)/g,"$1 ");
  1072.     // These leading spaces screw with <pre> content, so we need to fix that:
  1073.     bq = bq.replace(
  1074.     /(\s*<pre>[^\r]+?<\/pre>)/gm,
  1075.     function(wholeMatch,m1) {
  1076.     var pre = m1;
  1077.     // attacklab: hack around Konqueror 3.5.4 bug:
  1078.     pre = pre.replace(/^ /mg,"~0");
  1079.     pre = pre.replace(/~0/g,"");
  1080.     return pre;
  1081.     });
  1082.     
  1083.     return hashBlock("<blockquote>\n" + bq + "\n</blockquote>");
  1084.     });
  1085.     return text;
  1086.     }
  1087.     
  1088.     
  1089.     var _FormParagraphs = function(text) {
  1090.     //
  1091.     // Params:
  1092.     // $text - string to process with html <p> tags
  1093.     //
  1094.     
  1095.     // Strip leading and trailing lines:
  1096.     text = text.replace(/^\n+/g,"");
  1097.     text = text.replace(/\n+$/g,"");
  1098.     
  1099.     var grafs = text.split(/\n{2,}/g);
  1100.     var grafsOut = new Array();
  1101.     
  1102.     //
  1103.     // Wrap <p> tags.
  1104.     //
  1105.     var end = grafs.length;
  1106.     for (var i=0; i<end; i++) {
  1107.     var str = grafs[i];
  1108.     
  1109.     // if this is an HTML marker, copy it
  1110.     if (str.search(/~K(\d+)K/g) >= 0) {
  1111.     grafsOut.push(str);
  1112.     }
  1113.     else if (str.search(/\S/) >= 0) {
  1114.     str = _RunSpanGamut(str);
  1115.     str = str.replace(/^([ \t]*)/g,"<p>");
  1116.     str += "</p>"
  1117.     grafsOut.push(str);
  1118.     }
  1119.     
  1120.     }
  1121.     
  1122.     //
  1123.     // Unhashify HTML blocks
  1124.     //
  1125.     end = grafsOut.length;
  1126.     for (var i=0; i<end; i++) {
  1127.     // if this is a marker for an html block...
  1128.     while (grafsOut[i].search(/~K(\d+)K/) >= 0) {
  1129.     var blockText = g_html_blocks[RegExp.$1];
  1130.     blockText = blockText.replace(/\$/g,"$$$$"); // Escape any dollar signs
  1131.     grafsOut[i] = grafsOut[i].replace(/~K\d+K/,blockText);
  1132.     }
  1133.     }
  1134.     
  1135.     return grafsOut.join("\n\n");
  1136.     }
  1137.     
  1138.     
  1139.     var _EncodeAmpsAndAngles = function(text) {
  1140.     // Smart processing for ampersands and angle brackets that need to be encoded.
  1141.     
  1142.     // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
  1143.     // http://bumppo.net/projects/amputator/
  1144.     text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g,"&amp;");
  1145.     
  1146.     // Encode naked <'s
  1147.     text = text.replace(/<(?![a-z\/?\$!])/gi,"&lt;");
  1148.     
  1149.     return text;
  1150.     }
  1151.     
  1152.     
  1153.     var _EncodeBackslashEscapes = function(text) {
  1154.     //
  1155.     // Parameter: String.
  1156.     // Returns: The string, with after processing the following backslash
  1157.     // escape sequences.
  1158.     //
  1159.     
  1160.     // attacklab: The polite way to do this is with the new
  1161.     // escapeCharacters() function:
  1162.     //
  1163.     // text = escapeCharacters(text,"\\",true);
  1164.     // text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
  1165.     //
  1166.     // ...but we're sidestepping its use of the (slow) RegExp constructor
  1167.     // as an optimization for Firefox. This function gets called a LOT.
  1168.     
  1169.     text = text.replace(/\\(\\)/g,escapeCharacters_callback);
  1170.     text = text.replace(/\\([`*_{}\[\]()>#+-.!])/g,escapeCharacters_callback);
  1171.     return text;
  1172.     }
  1173.     
  1174.     
  1175.     var _DoAutoLinks = function(text) {
  1176.     
  1177.     text = text.replace(/<((https?|ftp|dict):[^'">\s]+)>/gi,"<a href=\"$1\">$1</a>");
  1178.     
  1179.     // Email addresses: <address@domain.foo>
  1180.     
  1181.     /*
  1182.     text = text.replace(/
  1183.     <
  1184.     (?:mailto:)?
  1185.     (
  1186.     [-.\w]+
  1187.     \@
  1188.     [-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+
  1189.     )
  1190.     >
  1191.     /gi, _DoAutoLinks_callback());
  1192.     */
  1193.     text = text.replace(/<(?:mailto:)?([-.\w]+\@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)>/gi,
  1194.     function(wholeMatch,m1) {
  1195.     return _EncodeEmailAddress( _UnescapeSpecialChars(m1) );
  1196.     }
  1197.     );
  1198.     
  1199.     return text;
  1200.     }
  1201.     
  1202.     
  1203.     var _EncodeEmailAddress = function(addr) {
  1204.     //
  1205.     // Input: an email address, e.g. "foo@example.com"
  1206.     //
  1207.     // Output: the email address as a mailto link, with each character
  1208.     // of the address encoded as either a decimal or hex entity, in
  1209.     // the hopes of foiling most address harvesting spam bots. E.g.:
  1210.     //
  1211.     // <a href="&#x6D;&#97;&#105;&#108;&#x74;&#111;:&#102;&#111;&#111;&#64;&#101;
  1212.     // x&#x61;&#109;&#x70;&#108;&#x65;&#x2E;&#99;&#111;&#109;">&#102;&#111;&#111;
  1213.     // &#64;&#101;x&#x61;&#109;&#x70;&#108;&#x65;&#x2E;&#99;&#111;&#109;</a>
  1214.     //
  1215.     // Based on a filter by Matthew Wickline, posted to the BBEdit-Talk
  1216.     // mailing list: <http://tinyurl.com/yu7ue>
  1217.     //
  1218.     
  1219.     // attacklab: why can't javascript speak hex?
  1220.     function char2hex(ch) {
  1221.     var hexDigits = '0123456789ABCDEF';
  1222.     var dec = ch.charCodeAt(0);
  1223.     return(hexDigits.charAt(dec>>4) + hexDigits.charAt(dec&15));
  1224.     }
  1225.     
  1226.     var encode = [
  1227.     function(ch){return "&#"+ch.charCodeAt(0)+";";},
  1228.     function(ch){return "&#x"+char2hex(ch)+";";},
  1229.     function(ch){return ch;}
  1230.     ];
  1231.     
  1232.     addr = "mailto:" + addr;
  1233.     
  1234.     addr = addr.replace(/./g, function(ch) {
  1235.     if (ch == "@") {
  1236.     // this *must* be encoded. I insist.
  1237.     ch = encode[Math.floor(Math.random()*2)](ch);
  1238.     } else if (ch !=":") {
  1239.     // leave ':' alone (to spot mailto: later)
  1240.     var r = Math.random();
  1241.     // roughly 10% raw, 45% hex, 45% dec
  1242.     ch = (
  1243.     r > .9 ? encode[2](ch) :
  1244.     r > .45 ? encode[1](ch) :
  1245.     encode[0](ch)
  1246.     );
  1247.     }
  1248.     return ch;
  1249.     });
  1250.     
  1251.     addr = "<a href=\"" + addr + "\">" + addr + "</a>";
  1252.     addr = addr.replace(/">.+:/g,"\">"); // strip the mailto: from the visible part
  1253.     
  1254.     return addr;
  1255.     }
  1256.     
  1257.     
  1258.     var _UnescapeSpecialChars = function(text) {
  1259.     //
  1260.     // Swap back in all the special characters we've hidden.
  1261.     //
  1262.     text = text.replace(/~E(\d+)E/g,
  1263.     function(wholeMatch,m1) {
  1264.     var charCodeToReplace = parseInt(m1);
  1265.     return String.fromCharCode(charCodeToReplace);
  1266.     }
  1267.     );
  1268.     return text;
  1269.     }
  1270.     
  1271.     
  1272.     var _Outdent = function(text) {
  1273.     //
  1274.     // Remove one level of line-leading tabs or spaces
  1275.     //
  1276.     
  1277.     // attacklab: hack around Konqueror 3.5.4 bug:
  1278.     // "----------bug".replace(/^-/g,"") == "bug"
  1279.     
  1280.     text = text.replace(/^(\t|[ ]{1,4})/gm,"~0"); // attacklab: g_tab_width
  1281.     
  1282.     // attacklab: clean up hack
  1283.     text = text.replace(/~0/g,"")
  1284.     
  1285.     return text;
  1286.     }
  1287.     
  1288.     var _Detab = function(text) {
  1289.     // attacklab: Detab's completely rewritten for speed.
  1290.     // In perl we could fix it by anchoring the regexp with \G.
  1291.     // In javascript we're less fortunate.
  1292.     
  1293.     // expand first n-1 tabs
  1294.     text = text.replace(/\t(?=\t)/g," "); // attacklab: g_tab_width
  1295.     
  1296.     // replace the nth with two sentinels
  1297.     text = text.replace(/\t/g,"~A~B");
  1298.     
  1299.     // use the sentinel to anchor our regex so it doesn't explode
  1300.     text = text.replace(/~B(.+?)~A/g,
  1301.     function(wholeMatch,m1,m2) {
  1302.     var leadingText = m1;
  1303.     var numSpaces = 4 - leadingText.length % 4; // attacklab: g_tab_width
  1304.     
  1305.     // there *must* be a better way to do this:
  1306.     for (var i=0; i<numSpaces; i++) leadingText+=" ";
  1307.     
  1308.     return leadingText;
  1309.     }
  1310.     );
  1311.     
  1312.     // clean up sentinels
  1313.     text = text.replace(/~A/g," "); // attacklab: g_tab_width
  1314.     text = text.replace(/~B/g,"");
  1315.     
  1316.     return text;
  1317.     }
  1318.     
  1319.     
  1320.     //
  1321.     // attacklab: Utility functions
  1322.     //
  1323.     
  1324.     
  1325.     var escapeCharacters = function(text, charsToEscape, afterBackslash) {
  1326.     // First we have to escape the escape characters so that
  1327.     // we can build a character class out of them
  1328.     var regexString = "([" + charsToEscape.replace(/([\[\]\\])/g,"\\$1") + "])";
  1329.     
  1330.     if (afterBackslash) {
  1331.     regexString = "\\\\" + regexString;
  1332.     }
  1333.     
  1334.     var regex = new RegExp(regexString,"g");
  1335.     text = text.replace(regex,escapeCharacters_callback);
  1336.     
  1337.     return text;
  1338.     }
  1339.     
  1340.     
  1341.     var escapeCharacters_callback = function(wholeMatch,m1) {
  1342.     var charCodeToEscape = m1.charCodeAt(0);
  1343.     return "~E"+charCodeToEscape+"E";
  1344.     }
  1345.     
  1346.     } // end of Showdown.converter
  1347.  
  1348. }),
  1349. true);