";
545 |
546 | return result;
547 | }
548 |
549 |
550 | var _DoImages = function(text) {
551 | //
552 | // Turn Markdown image shortcuts into ![]()
tags.
553 | //
554 |
555 | //
556 | // First, handle reference-style labeled images: ![alt text][id]
557 | //
558 |
559 | /*
560 | text = text.replace(/
561 | ( // wrap whole match in $1
562 | !\[
563 | (.*?) // alt text = $2
564 | \]
565 |
566 | [ ]? // one optional space
567 | (?:\n[ ]*)? // one optional newline followed by spaces
568 |
569 | \[
570 | (.*?) // id = $3
571 | \]
572 | )()()()() // pad rest of backreferences
573 | /g,writeImageTag);
574 | */
575 | text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeImageTag);
576 |
577 | //
578 | // Next, handle inline images: 
579 | // Don't forget: encode * and _
580 |
581 | /*
582 | text = text.replace(/
583 | ( // wrap whole match in $1
584 | !\[
585 | (.*?) // alt text = $2
586 | \]
587 | \s? // One optional whitespace character
588 | \( // literal paren
589 | [ \t]*
590 | () // no id, so leave $3 empty
591 | ? // src url = $4
592 | [ \t]*
593 | ( // $5
594 | (['"]) // quote char = $6
595 | (.*?) // title = $7
596 | \6 // matching quote
597 | [ \t]*
598 | )? // title is optional
599 | \)
600 | )
601 | /g,writeImageTag);
602 | */
603 | text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeImageTag);
604 |
605 | return text;
606 | }
607 |
608 | var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
609 | var whole_match = m1;
610 | var alt_text = m2;
611 | var link_id = m3.toLowerCase();
612 | var url = m4;
613 | var title = m7;
614 |
615 | if (!title) title = "";
616 |
617 | if (url == "") {
618 | if (link_id == "") {
619 | // lower-case and turn embedded newlines into spaces
620 | link_id = alt_text.toLowerCase().replace(/ ?\n/g," ");
621 | }
622 | url = "#"+link_id;
623 |
624 | if (g_urls[link_id] != undefined) {
625 | url = g_urls[link_id];
626 | if (g_titles[link_id] != undefined) {
627 | title = g_titles[link_id];
628 | }
629 | }
630 | else {
631 | return whole_match;
632 | }
633 | }
634 |
635 | alt_text = alt_text.replace(/"/g,""");
636 | url = escapeCharacters(url,"*_");
637 | var result = "![\""](\"")
" + _RunSpanGamut(m1) + "");});
665 |
666 | text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
667 | function(matchFound,m1){return hashBlock("" + _RunSpanGamut(m1) + "
");});
668 |
669 | // atx-style headers:
670 | // # Header 1
671 | // ## Header 2
672 | // ## Header 2 with closing hashes ##
673 | // ...
674 | // ###### Header 6
675 | //
676 |
677 | /*
678 | text = text.replace(/
679 | ^(\#{1,6}) // $1 = string of #'s
680 | [ \t]*
681 | (.+?) // $2 = Header text
682 | [ \t]*
683 | \#* // optional closing #'s (not counted)
684 | \n+
685 | /gm, function() {...});
686 | */
687 |
688 | text = text.replace(/^(\#{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
689 | function(wholeMatch,m1,m2) {
690 | var h_level = m1.length;
691 | return hashBlock("" + _RunSpanGamut(m2) + "");
692 | });
693 |
694 | return text;
695 | }
696 |
697 | // This declaration keeps Dojo compressor from outputting garbage:
698 | var _ProcessListItems;
699 |
700 | var _DoLists = function(text) {
701 | //
702 | // Form HTML ordered (numbered) and unordered (bulleted) lists.
703 | //
704 |
705 | // attacklab: add sentinel to hack around khtml/safari bug:
706 | // http://bugs.webkit.org/show_bug.cgi?id=11231
707 | text += "~0";
708 |
709 | // Re-usable pattern to match any entirel ul or ol list:
710 |
711 | /*
712 | var whole_list = /
713 | ( // $1 = whole list
714 | ( // $2
715 | [ ]{0,3} // attacklab: g_tab_width - 1
716 | ([*+-]|\d+[.]) // $3 = first list item marker
717 | [ \t]+
718 | )
719 | [^\r]+?
720 | ( // $4
721 | ~0 // sentinel for workaround; should be $
722 | |
723 | \n{2,}
724 | (?=\S)
725 | (?! // Negative lookahead for another list item marker
726 | [ \t]*
727 | (?:[*+-]|\d+[.])[ \t]+
728 | )
729 | )
730 | )/g
731 | */
732 | var whole_list = /^(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm;
733 |
734 | if (g_list_level) {
735 | text = text.replace(whole_list,function(wholeMatch,m1,m2) {
736 | var list = m1;
737 | var list_type = (m2.search(/[*+-]/g)>-1) ? "ul" : "ol";
738 |
739 | // Turn double returns into triple returns, so that we can make a
740 | // paragraph for the last item in a list, if necessary:
741 | list = list.replace(/\n{2,}/g,"\n\n\n");;
742 | var result = _ProcessListItems(list);
743 |
744 | // Trim any trailing whitespace, to put the closing ``
745 | // up on the preceding line, to get it past the current stupid
746 | // HTML block parser. This is a hack to work around the terrible
747 | // hack that is the HTML block parser.
748 | result = result.replace(/\s+$/,"");
749 | result = "<"+list_type+">" + result + "\n";
750 | return result;
751 | });
752 | } else {
753 | whole_list = /(\n\n|^\n?)(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/g;
754 | text = text.replace(whole_list,function(wholeMatch,m1,m2,m3) {
755 | var runup = m1;
756 | var list = m2;
757 |
758 | var list_type = (m3.search(/[*+-]/g)>-1) ? "ul" : "ol";
759 | // Turn double returns into triple returns, so that we can make a
760 | // paragraph for the last item in a list, if necessary:
761 | var list = list.replace(/\n{2,}/g,"\n\n\n");;
762 | var result = _ProcessListItems(list);
763 | result = runup + "<"+list_type+">\n" + result + "\n";
764 | return result;
765 | });
766 | }
767 |
768 | // attacklab: strip sentinel
769 | text = text.replace(/~0/,"");
770 |
771 | return text;
772 | }
773 |
774 | _ProcessListItems = function(list_str) {
775 | //
776 | // Process the contents of a single ordered or unordered list, splitting it
777 | // into individual list items.
778 | //
779 | // The $g_list_level global keeps track of when we're inside a list.
780 | // Each time we enter a list, we increment it; when we leave a list,
781 | // we decrement. If it's zero, we're not in a list anymore.
782 | //
783 | // We do this because when we're not inside a list, we want to treat
784 | // something like this:
785 | //
786 | // I recommend upgrading to version
787 | // 8. Oops, now this line is treated
788 | // as a sub-list.
789 | //
790 | // As a single paragraph, despite the fact that the second line starts
791 | // with a digit-period-space sequence.
792 | //
793 | // Whereas when we're inside a list (or sub-list), that line will be
794 | // treated as the start of a sub-list. What a kludge, huh? This is
795 | // an aspect of Markdown's syntax that's hard to parse perfectly
796 | // without resorting to mind-reading. Perhaps the solution is to
797 | // change the syntax rules such that sub-lists must start with a
798 | // starting cardinal number; e.g. "1." or "a.".
799 |
800 | g_list_level++;
801 |
802 | // trim trailing blank lines:
803 | list_str = list_str.replace(/\n{2,}$/,"\n");
804 |
805 | // attacklab: add sentinel to emulate \z
806 | list_str += "~0";
807 |
808 | /*
809 | list_str = list_str.replace(/
810 | (\n)? // leading line = $1
811 | (^[ \t]*) // leading whitespace = $2
812 | ([*+-]|\d+[.]) [ \t]+ // list marker = $3
813 | ([^\r]+? // list item text = $4
814 | (\n{1,2}))
815 | (?= \n* (~0 | \2 ([*+-]|\d+[.]) [ \t]+))
816 | /gm, function(){...});
817 | */
818 | list_str = list_str.replace(/(\n)?(^[ \t]*)([*+-]|\d+[.])[ \t]+([^\r]+?(\n{1,2}))(?=\n*(~0|\2([*+-]|\d+[.])[ \t]+))/gm,
819 | function(wholeMatch,m1,m2,m3,m4){
820 | var item = m4;
821 | var leading_line = m1;
822 | var leading_space = m2;
823 |
824 | if (leading_line || (item.search(/\n{2,}/)>-1)) {
825 | item = _RunBlockGamut(_Outdent(item));
826 | }
827 | else {
828 | // Recursion for sub-lists:
829 | item = _DoLists(_Outdent(item));
830 | item = item.replace(/\n$/,""); // chomp(item)
831 | item = _RunSpanGamut(item);
832 | }
833 |
834 | return "" + item + "\n";
835 | }
836 | );
837 |
838 | // attacklab: strip sentinel
839 | list_str = list_str.replace(/~0/g,"");
840 |
841 | g_list_level--;
842 | return list_str;
843 | }
844 |
845 |
846 | var _DoCodeBlocks = function(text) {
847 | //
848 | // Process Markdown `` blocks.
849 | //
850 |
851 | /*
852 | text = text.replace(text,
853 | /(?:\n\n|^)
854 | ( // $1 = the code block -- one or more lines, starting with a space/tab
855 | (?:
856 | (?:[ ]{4}|\t) // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
857 | .*\n+
858 | )+
859 | )
860 | (\n*[ ]{0,3}[^ \t\n]|(?=~0)) // attacklab: g_tab_width
861 | /g,function(){...});
862 | */
863 |
864 | // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
865 | text += "~0";
866 |
867 | text = text.replace(/(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
868 | function(wholeMatch,m1,m2) {
869 | var codeblock = m1;
870 | var nextChar = m2;
871 |
872 | codeblock = _EncodeCode( _Outdent(codeblock));
873 | codeblock = _Detab(codeblock);
874 | codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
875 | codeblock = codeblock.replace(/\n+$/g,""); // trim trailing whitespace
876 |
877 | codeblock = "" + codeblock + "\n
";
878 |
879 | return hashBlock(codeblock) + nextChar;
880 | }
881 | );
882 |
883 | // attacklab: strip sentinel
884 | text = text.replace(/~0/,"");
885 |
886 | return text;
887 | }
888 |
889 | var hashBlock = function(text) {
890 | text = text.replace(/(^\n+|\n+$)/g,"");
891 | return "\n\n~K" + (g_html_blocks.push(text)-1) + "K\n\n";
892 | }
893 |
894 |
895 | var _DoCodeSpans = function(text) {
896 | //
897 | // * Backtick quotes are used for Just type foo `bar` baz at the prompt.
907 | //
908 | // There's no arbitrary limit to the number of backticks you
909 | // can use as delimters. If you need three consecutive backticks
910 | // in your code, use four for delimiters, etc.
911 | //
912 | // * You can use spaces to get literal backticks at the edges:
913 | //
914 | // ... type `` `bar` `` ...
915 | //
916 | // Turns to:
917 | //
918 | // ... type `bar` ...
919 | //
920 |
921 | /*
922 | text = text.replace(/
923 | (^|[^\\]) // Character before opening ` can't be a backslash
924 | (`+) // $2 = Opening run of `
925 | ( // $3 = The code block
926 | [^\r]*?
927 | [^`] // attacklab: work around lack of lookbehind
928 | )
929 | \2 // Matching closer
930 | (?!`)
931 | /gm, function(){...});
932 | */
933 |
934 | text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
935 | function(wholeMatch,m1,m2,m3,m4) {
936 | var c = m3;
937 | c = c.replace(/^([ \t]*)/g,""); // leading whitespace
938 | c = c.replace(/[ \t]*$/g,""); // trailing whitespace
939 | c = _EncodeCode(c);
940 | return m1+""+c+"";
941 | });
942 |
943 | return text;
944 | }
945 |
946 |
947 | var _EncodeCode = function(text) {
948 | //
949 | // Encode/escape certain characters inside Markdown code runs.
950 | // The point is that in code, these characters are literals,
951 | // and lose their special Markdown meanings.
952 | //
953 | // Encode all ampersands; HTML entities are not
954 | // entities within a Markdown code span.
955 | text = text.replace(/&/g,"&");
956 |
957 | // Do the angle bracket song and dance:
958 | text = text.replace(//g,">");
960 |
961 | // Now, escape characters that are magic in Markdown:
962 | text = escapeCharacters(text,"\*_{}[]\\",false);
963 |
964 | // jj the line above breaks this:
965 | //---
966 |
967 | //* Item
968 |
969 | // 1. Subitem
970 |
971 | // special char: *
972 | //---
973 |
974 | return text;
975 | }
976 |
977 |
978 | var _DoItalicsAndBold = function(text) {
979 |
980 | // must go first:
981 | text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[\*_]*)\1/g,
982 | "$2");
983 |
984 | text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g,
985 | "$2");
986 |
987 | return text;
988 | }
989 |
990 |
991 | var _DoBlockQuotes = function(text) {
992 |
993 | /*
994 | text = text.replace(/
995 | ( // Wrap whole match in $1
996 | (
997 | ^[ \t]*>[ \t]? // '>' at the start of a line
998 | .+\n // rest of the first line
999 | (.+\n)* // subsequent consecutive lines
1000 | \n* // blanks
1001 | )+
1002 | )
1003 | /gm, function(){...});
1004 | */
1005 |
1006 | text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
1007 | function(wholeMatch,m1) {
1008 | var bq = m1;
1009 |
1010 | // attacklab: hack around Konqueror 3.5.4 bug:
1011 | // "----------bug".replace(/^-/g,"") == "bug"
1012 |
1013 | bq = bq.replace(/^[ \t]*>[ \t]?/gm,"~0"); // trim one level of quoting
1014 |
1015 | // attacklab: clean up hack
1016 | bq = bq.replace(/~0/g,"");
1017 |
1018 | bq = bq.replace(/^[ \t]+$/gm,""); // trim whitespace-only lines
1019 | bq = _RunBlockGamut(bq); // recurse
1020 |
1021 | bq = bq.replace(/(^|\n)/g,"$1 ");
1022 | // These leading spaces screw with content, so we need to fix that:
1023 | bq = bq.replace(
1024 | /(\s*[^\r]+?<\/pre>)/gm,
1025 | function(wholeMatch,m1) {
1026 | var pre = m1;
1027 | // attacklab: hack around Konqueror 3.5.4 bug:
1028 | pre = pre.replace(/^ /mg,"~0");
1029 | pre = pre.replace(/~0/g,"");
1030 | return pre;
1031 | });
1032 |
1033 | return hashBlock("\n" + bq + "\n
");
1034 | });
1035 | return text;
1036 | }
1037 |
1038 |
1039 | var _FormParagraphs = function(text) {
1040 | //
1041 | // Params:
1042 | // $text - string to process with html tags
1043 | //
1044 |
1045 | // Strip leading and trailing lines:
1046 | text = text.replace(/^\n+/g,"");
1047 | text = text.replace(/\n+$/g,"");
1048 |
1049 | var grafs = text.split(/\n{2,}/g);
1050 | var grafsOut = new Array();
1051 |
1052 | //
1053 | // Wrap
tags.
1054 | //
1055 | var end = grafs.length;
1056 | for (var i=0; i= 0) {
1061 | grafsOut.push(str);
1062 | }
1063 | else if (str.search(/\S/) >= 0) {
1064 | str = _RunSpanGamut(str);
1065 | str = str.replace(/^([ \t]*)/g,"");
1066 | str += "
"
1067 | grafsOut.push(str);
1068 | }
1069 |
1070 | }
1071 |
1072 | //
1073 | // Unhashify HTML blocks
1074 | //
1075 | end = grafsOut.length;
1076 | for (var i=0; i= 0) {
1079 | var blockText = g_html_blocks[RegExp.$1];
1080 | blockText = blockText.replace(/\$/g,"$$$$"); // Escape any dollar signs
1081 | grafsOut[i] = grafsOut[i].replace(/~K\d+K/,blockText);
1082 | }
1083 | }
1084 |
1085 | return grafsOut.join("\n\n");
1086 | }
1087 |
1088 |
1089 | var _EncodeAmpsAndAngles = function(text) {
1090 | // Smart processing for ampersands and angle brackets that need to be encoded.
1091 |
1092 | // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
1093 | // http://bumppo.net/projects/amputator/
1094 | text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g,"&");
1095 |
1096 | // Encode naked <'s
1097 | text = text.replace(/<(?![a-z\/?\$!])/gi,"<");
1098 |
1099 | return text;
1100 | }
1101 |
1102 |
1103 | var _EncodeBackslashEscapes = function(text) {
1104 | //
1105 | // Parameter: String.
1106 | // Returns: The string, with after processing the following backslash
1107 | // escape sequences.
1108 | //
1109 |
1110 | // attacklab: The polite way to do this is with the new
1111 | // escapeCharacters() function:
1112 | //
1113 | // text = escapeCharacters(text,"\\",true);
1114 | // text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
1115 | //
1116 | // ...but we're sidestepping its use of the (slow) RegExp constructor
1117 | // as an optimization for Firefox. This function gets called a LOT.
1118 |
1119 | text = text.replace(/\\(\\)/g,escapeCharacters_callback);
1120 | text = text.replace(/\\([`*_{}\[\]()>#+-.!])/g,escapeCharacters_callback);
1121 | return text;
1122 | }
1123 |
1124 |
1125 | var _DoAutoLinks = function(text) {
1126 |
1127 | text = text.replace(/<((https?|ftp|dict):[^'">\s]+)>/gi,"$1");
1128 |
1129 | // Email addresses:
1130 |
1131 | /*
1132 | text = text.replace(/
1133 | <
1134 | (?:mailto:)?
1135 | (
1136 | [-.\w]+
1137 | \@
1138 | [-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+
1139 | )
1140 | >
1141 | /gi, _DoAutoLinks_callback());
1142 | */
1143 | text = text.replace(/<(?:mailto:)?([-.\w]+\@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)>/gi,
1144 | function(wholeMatch,m1) {
1145 | return _EncodeEmailAddress( _UnescapeSpecialChars(m1) );
1146 | }
1147 | );
1148 |
1149 | return text;
1150 | }
1151 |
1152 |
1153 | var _EncodeEmailAddress = function(addr) {
1154 | //
1155 | // Input: an email address, e.g. "foo@example.com"
1156 | //
1157 | // Output: the email address as a mailto link, with each character
1158 | // of the address encoded as either a decimal or hex entity, in
1159 | // the hopes of foiling most address harvesting spam bots. E.g.:
1160 | //
1161 | // foo
1163 | // @example.com
1164 | //
1165 | // Based on a filter by Matthew Wickline, posted to the BBEdit-Talk
1166 | // mailing list:
1167 | //
1168 |
1169 | // attacklab: why can't javascript speak hex?
1170 | function char2hex(ch) {
1171 | var hexDigits = '0123456789ABCDEF';
1172 | var dec = ch.charCodeAt(0);
1173 | return(hexDigits.charAt(dec>>4) + hexDigits.charAt(dec&15));
1174 | }
1175 |
1176 | var encode = [
1177 | function(ch){return "&#"+ch.charCodeAt(0)+";";},
1178 | function(ch){return "&#x"+char2hex(ch)+";";},
1179 | function(ch){return ch;}
1180 | ];
1181 |
1182 | addr = "mailto:" + addr;
1183 |
1184 | addr = addr.replace(/./g, function(ch) {
1185 | if (ch == "@") {
1186 | // this *must* be encoded. I insist.
1187 | ch = encode[Math.floor(Math.random()*2)](ch);
1188 | } else if (ch !=":") {
1189 | // leave ':' alone (to spot mailto: later)
1190 | var r = Math.random();
1191 | // roughly 10% raw, 45% hex, 45% dec
1192 | ch = (
1193 | r > .9 ? encode[2](ch) :
1194 | r > .45 ? encode[1](ch) :
1195 | encode[0](ch)
1196 | );
1197 | }
1198 | return ch;
1199 | });
1200 |
1201 | addr = "" + addr + "";
1202 | addr = addr.replace(/">.+:/g,"\">"); // strip the mailto: from the visible part
1203 |
1204 | return addr;
1205 | }
1206 |
1207 |
1208 | var _UnescapeSpecialChars = function(text) {
1209 | //
1210 | // Swap back in all the special characters we've hidden.
1211 | //
1212 | text = text.replace(/~E(\d+)E/g,
1213 | function(wholeMatch,m1) {
1214 | var charCodeToReplace = parseInt(m1);
1215 | return String.fromCharCode(charCodeToReplace);
1216 | }
1217 | );
1218 | return text;
1219 | }
1220 |
1221 |
1222 | var _Outdent = function(text) {
1223 | //
1224 | // Remove one level of line-leading tabs or spaces
1225 | //
1226 |
1227 | // attacklab: hack around Konqueror 3.5.4 bug:
1228 | // "----------bug".replace(/^-/g,"") == "bug"
1229 |
1230 | text = text.replace(/^(\t|[ ]{1,4})/gm,"~0"); // attacklab: g_tab_width
1231 |
1232 | // attacklab: clean up hack
1233 | text = text.replace(/~0/g,"")
1234 |
1235 | return text;
1236 | }
1237 |
1238 | var _Detab = function(text) {
1239 | // attacklab: Detab's completely rewritten for speed.
1240 | // In perl we could fix it by anchoring the regexp with \G.
1241 | // In javascript we're less fortunate.
1242 |
1243 | // expand first n-1 tabs
1244 | text = text.replace(/\t(?=\t)/g," "); // attacklab: g_tab_width
1245 |
1246 | // replace the nth with two sentinels
1247 | text = text.replace(/\t/g,"~A~B");
1248 |
1249 | // use the sentinel to anchor our regex so it doesn't explode
1250 | text = text.replace(/~B(.+?)~A/g,
1251 | function(wholeMatch,m1,m2) {
1252 | var leadingText = m1;
1253 | var numSpaces = 4 - leadingText.length % 4; // attacklab: g_tab_width
1254 |
1255 | // there *must* be a better way to do this:
1256 | for (var i=0; i