s around 276 | // "paragraphs" that are wrapped in non-block-level tags, such as anchors, 277 | // phrase emphasis, and spans. The list of tags we're looking for is 278 | // hard-coded: 279 | var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del" 280 | var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math" 281 | 282 | // First, look for nested blocks, e.g.: 283 | //
. It was easier to make a special case than 333 | // to make the other regex more complicated. 334 | 335 | /* 336 | text = text.replace(/ 337 | \n // Starting after a blank line 338 | [ ]{0,3} 339 | ( // save in $1 340 | (<(hr) // start tag = $2 341 | \b // word break 342 | ([^<>])*? 343 | \/?>) // the matching end tag 344 | [ \t]* 345 | (?=\n{2,}) // followed by a blank line 346 | ) 347 | /g,hashElement); 348 | */ 349 | text = text.replace(/\n[ ]{0,3}((<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g, hashElement); 350 | 351 | // Special case for standalone HTML comments: 352 | 353 | /* 354 | text = text.replace(/ 355 | \n\n // Starting after a blank line 356 | [ ]{0,3} // attacklab: g_tab_width - 1 357 | ( // save in $1 358 | -]|-[^>])(?:[^-]|-[^-])*)--) // see http://www.w3.org/TR/html-markup/syntax.html#comments and http://meta.stackoverflow.com/q/95256 360 | > 361 | [ \t]* 362 | (?=\n{2,}) // followed by a blank line 363 | ) 364 | /g,hashElement); 365 | */ 366 | text = text.replace(/\n\n[ ]{0,3}(-]|-[^>])(?:[^-]|-[^-])*)--)>[ \t]*(?=\n{2,}))/g, hashElement); 367 | 368 | // PHP and ASP-style processor instructions ( and <%...%>) 369 | 370 | /* 371 | text = text.replace(/ 372 | (?: 373 | \n\n // Starting after a blank line 374 | ) 375 | ( // save in $1 376 | [ ]{0,3} // attacklab: g_tab_width - 1 377 | (?: 378 | <([?%]) // $2 379 | [^\r]*? 380 | \2> 381 | ) 382 | [ \t]* 383 | (?=\n{2,}) // followed by a blank line 384 | ) 385 | /g,hashElement); 386 | */ 387 | text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g, hashElement); 388 | 389 | return text; 390 | } 391 | 392 | function hashElement(wholeMatch, m1) { 393 | var blockText = m1; 394 | 395 | // Undo double lines 396 | blockText = blockText.replace(/^\n+/, ""); 397 | 398 | // strip trailing blank lines 399 | blockText = blockText.replace(/\n+$/g, ""); 400 | 401 | // Replace the element text with a marker ("~KxK" where x is its key) 402 | blockText = "\n\n~K" + (g_html_blocks.push(blockText) - 1) + "K\n\n"; 403 | 404 | return blockText; 405 | } 406 | 407 | var blockGamutHookCallback = function (t) { return _RunBlockGamut(t); } 408 | 409 | function _RunBlockGamut(text, doNotUnhash) { 410 | // 411 | // These are all the transformations that form block-level 412 | // tags like paragraphs, headers, and list items. 413 | // 414 | 415 | text = pluginHooks.preBlockGamut(text, blockGamutHookCallback); 416 | 417 | text = _DoHeaders(text); 418 | 419 | // Do Horizontal Rules: 420 | var replacement = "
\n"; 421 | text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm, replacement); 422 | text = text.replace(/^[ ]{0,2}([ ]?-[ ]?){3,}[ \t]*$/gm, replacement); 423 | text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ \t]*$/gm, replacement); 424 | 425 | text = _DoLists(text); 426 | text = _DoCodeBlocks(text); 427 | text = _DoBlockQuotes(text); 428 | 429 | text = pluginHooks.postBlockGamut(text, blockGamutHookCallback); 430 | 431 | // We already ran _HashHTMLBlocks() before, in Markdown(), but that 432 | // was to escape raw HTML in the original Markdown source. This time, 433 | // we're escaping the markup we've just created, so that we don't wrap 434 | //
tags around block-level tags.
435 | text = _HashHTMLBlocks(text);
436 | text = _FormParagraphs(text, doNotUnhash);
437 |
438 | return text;
439 | }
440 |
441 | function _RunSpanGamut(text) {
442 | //
443 | // These are all the transformations that occur *within* block-level
444 | // tags like paragraphs, headers, and list items.
445 | //
446 |
447 | text = pluginHooks.preSpanGamut(text);
448 |
449 | text = _DoCodeSpans(text);
450 | text = _EscapeSpecialCharsWithinTagAttributes(text);
451 | text = _EncodeBackslashEscapes(text);
452 |
453 | // Process anchor and image tags. Images must come first,
454 | // because ![foo][f] looks like an anchor.
455 | text = _DoImages(text);
456 | text = _DoAnchors(text);
457 |
458 | // Make links out of things like ` Just type tags
1151 | //
1152 |
1153 | // Strip leading and trailing lines:
1154 | text = text.replace(/^\n+/g, "");
1155 | text = text.replace(/\n+$/g, "");
1156 |
1157 | var grafs = text.split(/\n{2,}/g);
1158 | var grafsOut = [];
1159 |
1160 | var markerRe = /~K(\d+)K/;
1161 |
1162 | //
1163 | // Wrap tags.
1164 | //
1165 | var end = grafs.length;
1166 | for (var i = 0; i < end; i++) {
1167 | var str = grafs[i];
1168 |
1169 | // if this is an HTML marker, copy it
1170 | if (markerRe.test(str)) {
1171 | grafsOut.push(str);
1172 | }
1173 | else if (/\S/.test(str)) {
1174 | str = _RunSpanGamut(str);
1175 | str = str.replace(/^([ \t]*)/g, " ");
1176 | str += " tag here so Pagedown won't.
265 | Markdown.Extra.prototype.hashExtraBlock = function(block) {
266 | return '\n ~X' + (this.hashBlocks.push(block) - 1) + 'X )?~X(\d+)X(?:<\/p>)?/g, function(wholeMatch, m1) {
279 | hasHash = true;
280 | var key = parseInt(m1, 10);
281 | return self.hashBlocks[key];
282 | });
283 | if(hasHash === true) {
284 | recursiveUnHash();
285 | }
286 | }
287 | recursiveUnHash();
288 | return text;
289 | };
290 |
291 | // Wrap headers to make sure they won't be in def lists
292 | Markdown.Extra.prototype.wrapHeaders = function(text) {
293 | function wrap(text) {
294 | return '\n' + text + '\n';
295 | }
296 | text = text.replace(/^.+[ \t]*\n=+[ \t]*\n+/gm, wrap);
297 | text = text.replace(/^.+[ \t]*\n-+[ \t]*\n+/gm, wrap);
298 | text = text.replace(/^\#{1,6}[ \t]*.+?[ \t]*\#*\n+/gm, wrap);
299 | return text;
300 | };
301 |
302 |
303 | /******************************************************************
304 | * Attribute Blocks *
305 | *****************************************************************/
306 |
307 | // TODO: use sentinels. Should we just add/remove them in doConversion?
308 | // TODO: better matches for id / class attributes
309 | var attrBlock = "\\{[ \\t]*((?:[#.][-_:a-zA-Z0-9]+[ \\t]*)+)\\}";
310 | var hdrAttributesA = new RegExp("^(#{1,6}.*#{0,6})[ \\t]+" + attrBlock + "[ \\t]*(?:\\n|0x03)", "gm");
311 | var hdrAttributesB = new RegExp("^(.*)[ \\t]+" + attrBlock + "[ \\t]*\\n" +
312 | "(?=[\\-|=]+\\s*(?:\\n|0x03))", "gm"); // underline lookahead
313 | var fcbAttributes = new RegExp("^(```[ \\t]*[^{\\s]*)[ \\t]+" + attrBlock + "[ \\t]*\\n" +
314 | "(?=([\\s\\S]*?)\\n```[ \\t]*(\\n|0x03))", "gm");
315 |
316 | // Extract headers attribute blocks, move them above the element they will be
317 | // applied to, and hash them for later.
318 | Markdown.Extra.prototype.hashHeaderAttributeBlocks = function(text) {
319 |
320 | var self = this;
321 | function attributeCallback(wholeMatch, pre, attr) {
322 | return ' ~XX' + (self.hashBlocks.push(attr) - 1) + 'XX ~XX' + (self.hashBlocks.push(attr) - 1) + 'XX ~XX(\\d+)XX He said, "'Quoted' words in a larger quote."
\n");
470 |
471 | text = pluginHooks.postSpanGamut(text);
472 |
473 | return text;
474 | }
475 |
476 | function _EscapeSpecialCharsWithinTagAttributes(text) {
477 | //
478 | // Within tags -- meaning between < and > -- encode [\ ` * _] so they
479 | // don't conflict with their use in Markdown for code, italics and strong.
480 | //
481 |
482 | // Build a regex to find HTML tags and comments. See Friedl's
483 | // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
484 |
485 | // SE: changed the comment part of the regex
486 |
487 | var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|-]|-[^>])(?:[^-]|-[^-])*)--)>)/gi;
488 |
489 | text = text.replace(regex, function (wholeMatch) {
490 | var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g, "$1`");
491 | tag = escapeCharacters(tag, wholeMatch.charAt(1) == "!" ? "\\`*_/" : "\\`*_"); // also escape slashes in comments to prevent autolinking there -- http://meta.stackoverflow.com/questions/95987
492 | return tag;
493 | });
494 |
495 | return text;
496 | }
497 |
498 | function _DoAnchors(text) {
499 | //
500 | // Turn Markdown link shortcuts into XHTML tags.
501 | //
502 | //
503 | // First, handle reference-style links: [link text] [id]
504 | //
505 |
506 | /*
507 | text = text.replace(/
508 | ( // wrap whole match in $1
509 | \[
510 | (
511 | (?:
512 | \[[^\]]*\] // allow brackets nested one level
513 | |
514 | [^\[] // or anything else
515 | )*
516 | )
517 | \]
518 |
519 | [ ]? // one optional space
520 | (?:\n[ ]*)? // one optional newline followed by spaces
521 |
522 | \[
523 | (.*?) // id = $3
524 | \]
525 | )
526 | ()()()() // pad remaining backreferences
527 | /g, writeAnchorTag);
528 | */
529 | text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g, writeAnchorTag);
530 |
531 | //
532 | // Next, inline-style links: [link text](url "optional title")
533 | //
534 |
535 | /*
536 | text = text.replace(/
537 | ( // wrap whole match in $1
538 | \[
539 | (
540 | (?:
541 | \[[^\]]*\] // allow brackets nested one level
542 | |
543 | [^\[\]] // or anything else
544 | )*
545 | )
546 | \]
547 | \( // literal paren
548 | [ \t]*
549 | () // no id, so leave $3 empty
550 | ?
557 | [ \t]*
558 | ( // $5
559 | (['"]) // quote char = $6
560 | (.*?) // Title = $7
561 | \6 // matching quote
562 | [ \t]* // ignore any spaces/tabs between closing quote and )
563 | )? // title is optional
564 | \)
565 | )
566 | /g, writeAnchorTag);
567 | */
568 |
569 | text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g, writeAnchorTag);
570 |
571 | //
572 | // Last, handle reference-style shortcuts: [link text]
573 | // These must come last in case you've also got [link test][1]
574 | // or [link test](/foo)
575 | //
576 |
577 | /*
578 | text = text.replace(/
579 | ( // wrap whole match in $1
580 | \[
581 | ([^\[\]]+) // link text = $2; can't contain '[' or ']'
582 | \]
583 | )
584 | ()()()()() // pad rest of backreferences
585 | /g, writeAnchorTag);
586 | */
587 | text = text.replace(/(\[([^\[\]]+)\])()()()()()/g, writeAnchorTag);
588 |
589 | return text;
590 | }
591 |
592 | function writeAnchorTag(wholeMatch, m1, m2, m3, m4, m5, m6, m7) {
593 | if (m7 == undefined) m7 = "";
594 | var whole_match = m1;
595 | var link_text = m2.replace(/:\/\//g, "~P"); // to prevent auto-linking withing the link. will be converted back after the auto-linker runs
596 | var link_id = m3.toLowerCase();
597 | var url = m4;
598 | var title = m7;
599 |
600 | if (url == "") {
601 | if (link_id == "") {
602 | // lower-case and turn embedded newlines into spaces
603 | link_id = link_text.toLowerCase().replace(/ ?\n/g, " ");
604 | }
605 | url = "#" + link_id;
606 |
607 | if (g_urls.get(link_id) != undefined) {
608 | url = g_urls.get(link_id);
609 | if (g_titles.get(link_id) != undefined) {
610 | title = g_titles.get(link_id);
611 | }
612 | }
613 | else {
614 | if (whole_match.search(/\(\s*\)$/m) > -1) {
615 | // Special case for explicit empty url
616 | url = "";
617 | } else {
618 | return whole_match;
619 | }
620 | }
621 | }
622 | url = encodeProblemUrlChars(url);
623 | url = escapeCharacters(url, "*_");
624 | var result = "";
633 |
634 | return result;
635 | }
636 |
637 | function _DoImages(text) {
638 | //
639 | // Turn Markdown image shortcuts into tags.
640 | //
641 |
642 | //
643 | // First, handle reference-style labeled images: ![alt text][id]
644 | //
645 |
646 | /*
647 | text = text.replace(/
648 | ( // wrap whole match in $1
649 | !\[
650 | (.*?) // alt text = $2
651 | \]
652 |
653 | [ ]? // one optional space
654 | (?:\n[ ]*)? // one optional newline followed by spaces
655 |
656 | \[
657 | (.*?) // id = $3
658 | \]
659 | )
660 | ()()()() // pad rest of backreferences
661 | /g, writeImageTag);
662 | */
663 | text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g, writeImageTag);
664 |
665 | //
666 | // Next, handle inline images: 
667 | // Don't forget: encode * and _
668 |
669 | /*
670 | text = text.replace(/
671 | ( // wrap whole match in $1
672 | !\[
673 | (.*?) // alt text = $2
674 | \]
675 | \s? // One optional whitespace character
676 | \( // literal paren
677 | [ \t]*
678 | () // no id, so leave $3 empty
679 | ? // src url = $4
680 | [ \t]*
681 | ( // $5
682 | (['"]) // quote char = $6
683 | (.*?) // title = $7
684 | \6 // matching quote
685 | [ \t]*
686 | )? // title is optional
687 | \)
688 | )
689 | /g, writeImageTag);
690 | */
691 | text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g, writeImageTag);
692 |
693 | return text;
694 | }
695 |
696 | function attributeEncode(text) {
697 | // unconditionally replace angle brackets here -- what ends up in an attribute (e.g. alt or title)
698 | // never makes sense to have verbatim HTML in it (and the sanitizer would totally break it)
699 | return text.replace(/>/g, ">").replace(/" + _RunSpanGamut(m1) + "\n\n"; }
758 | );
759 |
760 | text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
761 | function (matchFound, m1) { return "
" + _RunSpanGamut(m1) + "
\n\n"; }
762 | );
763 |
764 | // atx-style headers:
765 | // # Header 1
766 | // ## Header 2
767 | // ## Header 2 with closing hashes ##
768 | // ...
769 | // ###### Header 6
770 | //
771 |
772 | /*
773 | text = text.replace(/
774 | ^(\#{1,6}) // $1 = string of #'s
775 | [ \t]*
776 | (.+?) // $2 = Header text
777 | [ \t]*
778 | \#* // optional closing #'s (not counted)
779 | \n+
780 | /gm, function() {...});
781 | */
782 |
783 | text = text.replace(/^(\#{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
784 | function (wholeMatch, m1, m2) {
785 | var h_level = m1.length;
786 | return "
'].join('');
603 |
604 | // replace codeblock with placeholder until postConversion step
605 | return self.hashExtraBlock(html);
606 | });
607 |
608 | return text;
609 | };
610 |
611 |
612 | /******************************************************************
613 | * SmartyPants *
614 | ******************************************************************/
615 |
616 | Markdown.Extra.prototype.educatePants = function(text) {
617 | var self = this;
618 | var result = '';
619 | var blockOffset = 0;
620 | // Here we parse HTML in a very bad manner
621 | text.replace(/(?:)|(<)([a-zA-Z1-6]+)([^\n]*?>)([\s\S]*?)(<\/\2>)/g, function(wholeMatch, m1, m2, m3, m4, m5, offset) {
622 | var token = text.substring(blockOffset, offset);
623 | result += self.applyPants(token);
624 | self.smartyPantsLastChar = result.substring(result.length - 1);
625 | blockOffset = offset + wholeMatch.length;
626 | if(!m1) {
627 | // Skip commentary
628 | result += wholeMatch;
629 | return;
630 | }
631 | // Skip special tags
632 | if(!/code|kbd|pre|script|noscript|iframe|math|ins|del|pre/i.test(m2)) {
633 | m4 = self.educatePants(m4);
634 | }
635 | else {
636 | self.smartyPantsLastChar = m4.substring(m4.length - 1);
637 | }
638 | result += m1 + m2 + m3 + m4 + m5;
639 | });
640 | var lastToken = text.substring(blockOffset);
641 | result += self.applyPants(lastToken);
642 | self.smartyPantsLastChar = result.substring(result.length - 1);
643 | return result;
644 | };
645 |
646 | function revertPants(wholeMatch, m1) {
647 | var blockText = m1;
648 | blockText = blockText.replace(/&\#8220;/g, "\"");
649 | blockText = blockText.replace(/&\#8221;/g, "\"");
650 | blockText = blockText.replace(/&\#8216;/g, "'");
651 | blockText = blockText.replace(/&\#8217;/g, "'");
652 | blockText = blockText.replace(/&\#8212;/g, "---");
653 | blockText = blockText.replace(/&\#8211;/g, "--");
654 | blockText = blockText.replace(/&\#8230;/g, "...");
655 | return blockText;
656 | }
657 |
658 | Markdown.Extra.prototype.applyPants = function(text) {
659 | // Dashes
660 | text = text.replace(/---/g, "—").replace(/--/g, "–");
661 | // Ellipses
662 | text = text.replace(/\.\.\./g, "…").replace(/\.\s\.\s\./g, "…");
663 | // Backticks
664 | text = text.replace(/``/g, "“").replace (/''/g, "”");
665 |
666 | if(/^'$/.test(text)) {
667 | // Special case: single-character ' token
668 | if(/\S/.test(this.smartyPantsLastChar)) {
669 | return "’";
670 | }
671 | return "‘";
672 | }
673 | if(/^"$/.test(text)) {
674 | // Special case: single-character " token
675 | if(/\S/.test(this.smartyPantsLastChar)) {
676 | return "”";
677 | }
678 | return "“";
679 | }
680 |
681 | // Special case if the very first character is a quote
682 | // followed by punctuation at a non-word-break. Close the quotes by brute force:
683 | text = text.replace (/^'(?=[!"#\$\%'()*+,\-.\/:;<=>?\@\[\\]\^_`{|}~]\B)/, "’");
684 | text = text.replace (/^"(?=[!"#\$\%'()*+,\-.\/:;<=>?\@\[\\]\^_`{|}~]\B)/, "”");
685 |
686 | // Special case for double sets of quotes, e.g.:
687 | // ` blocks.
959 | //
960 |
961 | /*
962 | text = text.replace(/
963 | (?:\n\n|^)
964 | ( // $1 = the code block -- one or more lines, starting with a space/tab
965 | (?:
966 | (?:[ ]{4}|\t) // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
967 | .*\n+
968 | )+
969 | )
970 | (\n*[ ]{0,3}[^ \t\n]|(?=~0)) // attacklab: g_tab_width
971 | /g ,function(){...});
972 | */
973 |
974 | // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
975 | text += "~0";
976 |
977 | text = text.replace(/(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
978 | function (wholeMatch, m1, m2) {
979 | var codeblock = m1;
980 | var nextChar = m2;
981 |
982 | codeblock = _EncodeCode(_Outdent(codeblock));
983 | codeblock = _Detab(codeblock);
984 | codeblock = codeblock.replace(/^\n+/g, ""); // trim leading newlines
985 | codeblock = codeblock.replace(/\n+$/g, ""); // trim trailing whitespace
986 |
987 | codeblock = "
";
988 |
989 | return "\n\n" + codeblock + "\n\n" + nextChar;
990 | }
991 | );
992 |
993 | // attacklab: strip sentinel
994 | text = text.replace(/~0/, "");
995 |
996 | return text;
997 | }
998 |
999 | function hashBlock(text) {
1000 | text = text.replace(/(^\n+|\n+$)/g, "");
1001 | return "\n\n~K" + (g_html_blocks.push(text) - 1) + "K\n\n";
1002 | }
1003 |
1004 | function _DoCodeSpans(text) {
1005 | //
1006 | // * Backtick quotes are used for " + codeblock + "\n spans.
1007 | //
1008 | // * You can use multiple backticks as the delimiters if you want to
1009 | // include literal backticks in the code span. So, this input:
1010 | //
1011 | // Just type ``foo `bar` baz`` at the prompt.
1012 | //
1013 | // Will translate to:
1014 | //
1015 | // foo `bar` baz at the prompt.`bar` ...
1028 | //
1029 |
1030 | /*
1031 | text = text.replace(/
1032 | (^|[^\\]) // Character before opening ` can't be a backslash
1033 | (`+) // $2 = Opening run of `
1034 | ( // $3 = The code block
1035 | [^\r]*?
1036 | [^`] // attacklab: work around lack of lookbehind
1037 | )
1038 | \2 // Matching closer
1039 | (?!`)
1040 | /gm, function(){...});
1041 | */
1042 |
1043 | text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
1044 | function (wholeMatch, m1, m2, m3, m4) {
1045 | var c = m3;
1046 | c = c.replace(/^([ \t]*)/g, ""); // leading whitespace
1047 | c = c.replace(/[ \t]*$/g, ""); // trailing whitespace
1048 | c = _EncodeCode(c);
1049 | c = c.replace(/:\/\//g, "~P"); // to prevent auto-linking. Not necessary in code *blocks*, but in code spans. Will be converted back after the auto-linker runs.
1050 | return m1 + "" + c + "";
1051 | }
1052 | );
1053 |
1054 | return text;
1055 | }
1056 |
1057 | function _EncodeCode(text) {
1058 | //
1059 | // Encode/escape certain characters inside Markdown code runs.
1060 | // The point is that in code, these characters are literals,
1061 | // and lose their special Markdown meanings.
1062 | //
1063 | // Encode all ampersands; HTML entities are not
1064 | // entities within a Markdown code span.
1065 | text = text.replace(/&/g, "&");
1066 |
1067 | // Do the angle bracket song and dance:
1068 | text = text.replace(//g, ">");
1070 |
1071 | // Now, escape characters that are magic in Markdown:
1072 | text = escapeCharacters(text, "\*_{}[]\\", false);
1073 |
1074 | // jj the line above breaks this:
1075 | //---
1076 |
1077 | //* Item
1078 |
1079 | // 1. Subitem
1080 |
1081 | // special char: *
1082 | //---
1083 |
1084 | return text;
1085 | }
1086 |
1087 | function _DoItalicsAndBold(text) {
1088 |
1089 | // must go first:
1090 | text = text.replace(/([\W_]|^)(\*\*|__)(?=\S)([^\r]*?\S[\*_]*)\2([\W_]|$)/g,
1091 | "$1$3$4");
1092 |
1093 | text = text.replace(/([\W_]|^)(\*|_)(?=\S)([^\r\*_]*?\S)\2([\W_]|$)/g,
1094 | "$1$3$4");
1095 |
1096 | return text;
1097 | }
1098 |
1099 | function _DoBlockQuotes(text) {
1100 |
1101 | /*
1102 | text = text.replace(/
1103 | ( // Wrap whole match in $1
1104 | (
1105 | ^[ \t]*>[ \t]? // '>' at the start of a line
1106 | .+\n // rest of the first line
1107 | (.+\n)* // subsequent consecutive lines
1108 | \n* // blanks
1109 | )+
1110 | )
1111 | /gm, function(){...});
1112 | */
1113 |
1114 | text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
1115 | function (wholeMatch, m1) {
1116 | var bq = m1;
1117 |
1118 | // attacklab: hack around Konqueror 3.5.4 bug:
1119 | // "----------bug".replace(/^-/g,"") == "bug"
1120 |
1121 | bq = bq.replace(/^[ \t]*>[ \t]?/gm, "~0"); // trim one level of quoting
1122 |
1123 | // attacklab: clean up hack
1124 | bq = bq.replace(/~0/g, "");
1125 |
1126 | bq = bq.replace(/^[ \t]+$/gm, ""); // trim whitespace-only lines
1127 | bq = _RunBlockGamut(bq); // recurse
1128 |
1129 | bq = bq.replace(/(^|\n)/g, "$1 ");
1130 | // These leading spaces screw with content, so we need to fix that:
1131 | bq = bq.replace(
1132 | /(\s*
[^\r]+?<\/pre>)/gm,
1133 | function (wholeMatch, m1) {
1134 | var pre = m1;
1135 | // attacklab: hack around Konqueror 3.5.4 bug:
1136 | pre = pre.replace(/^ /mg, "~0");
1137 | pre = pre.replace(/~0/g, "");
1138 | return pre;
1139 | });
1140 |
1141 | return hashBlock("\n" + bq + "\n
");
1142 | }
1143 | );
1144 | return text;
1145 | }
1146 |
1147 | function _FormParagraphs(text, doNotUnhash) {
1148 | //
1149 | // Params:
1150 | // $text - string to process with html \n'].join('');
456 |
457 | // build column headers.
458 | for (i = 0; i < colCount; i++) {
459 | var headerHtml = convertSpans(trim(headers[i]), self);
460 | html += [" \n\n";
463 |
464 | // build rows
465 | var rows = body.split('\n');
466 | for (i = 0; i < rows.length; i++) {
467 | if (rows[i].match(/^\s*$/)) // can apply to final row
468 | continue;
469 |
470 | // ensure number of rowCells matches colCount
471 | var rowCells = rows[i].split(/ *[|] */);
472 | var lenDiff = colCount - rowCells.length;
473 | for (var j = 0; j < lenDiff; j++)
474 | rowCells.push('');
475 |
476 | html += "\n";
477 | for (j = 0; j < colCount; j++) {
478 | var colHtml = convertSpans(trim(rowCells[j]), self);
479 | html += [" \n";
482 | }
483 |
484 | html += "\n";
485 |
486 | // replace html with placeholder until postConversion step
487 | return self.hashExtraBlock(html);
488 | }
489 |
490 | return text;
491 | };
492 |
493 |
494 | /******************************************************************
495 | * Footnotes *
496 | *****************************************************************/
497 |
498 | // Strip footnote, store in hashes.
499 | Markdown.Extra.prototype.stripFootnoteDefinitions = function(text) {
500 | var self = this;
501 |
502 | text = text.replace(
503 | /\n[ ]{0,3}\[\^(.+?)\]\:[ \t]*\n?([\s\S]*?)\n{1,2}((?=\n[ ]{0,3}\S)|$)/g,
504 | function(wholeMatch, m1, m2) {
505 | m1 = slugify(m1);
506 | m2 += "\n";
507 | m2 = m2.replace(/^[ ]{0,3}/g, "");
508 | self.footnotes[m1] = m2;
509 | return "\n";
510 | });
511 |
512 | return text;
513 | };
514 |
515 |
516 | // Find and convert footnotes references.
517 | Markdown.Extra.prototype.doFootnotes = function(text) {
518 | var self = this;
519 | if(self.isConvertingFootnote === true) {
520 | return text;
521 | }
522 |
523 | var footnoteCounter = 0;
524 | text = text.replace(/\[\^(.+?)\]/g, function(wholeMatch, m1) {
525 | var id = slugify(m1);
526 | var footnote = self.footnotes[id];
527 | if (footnote === undefined) {
528 | return wholeMatch;
529 | }
530 | footnoteCounter++;
531 | self.usedFootnotes.push(id);
532 | var html = '' + footnoteCounter
534 | + '';
535 | return self.hashExtraInline(html);
536 | });
537 |
538 | return text;
539 | };
540 |
541 | // Print footnotes at the end of the document
542 | Markdown.Extra.prototype.printFootnotes = function(text) {
543 | var self = this;
544 |
545 | if (self.usedFootnotes.length === 0) {
546 | return text;
547 | }
548 |
549 | text += '\n\n
\n\n\n';
550 | for(var i=0; i
\n\n" + result + "\n
";
771 | return pre + self.hashExtraBlock(result) + "\n\n";
772 | });
773 |
774 | return removeAnchors(text);
775 | };
776 |
777 | // Process the contents of a single definition list, splitting it
778 | // into individual term and definition list items.
779 | Markdown.Extra.prototype.processDefListItems = function(listStr) {
780 | var self = this;
781 |
782 | var dt = new RegExp(
783 | ['(\\x02\\n?|\\n\\n+)' , // leading line
784 | '(' , // definition terms = $1
785 | '[ ]{0,3}' , // leading whitespace
786 | '(?![:][ ]|[ ])' , // negative lookahead for a definition
787 | // mark (colon) or more whitespace
788 | '(?:\\S.*\\n)+?' , // actual term (not whitespace)
789 | ')' ,
790 | '(?=\\n?[ ]{0,3}:[ ])' // lookahead for following line feed
791 | ].join(''), // with a definition mark
792 | 'gm'
793 | );
794 |
795 | var dd = new RegExp(
796 | ['\\n(\\n+)?' , // leading line = $1
797 | '(' , // marker space = $2
798 | '[ ]{0,3}' , // whitespace before colon
799 | '[:][ ]+' , // definition mark (colon)
800 | ')' ,
801 | '([\\s\\S]+?)' , // definition text = $3
802 | '(?=\\n*' , // stop at next definition mark,
803 | '(?:' , // next term or end of text
804 | '\\n[ ]{0,3}[:][ ]|' ,
805 | '$2$3");
859 | };
860 |
861 |
862 | /***********************************************************
863 | * New lines *
864 | ************************************************************/
865 |
866 | Markdown.Extra.prototype.newlines = function(text) {
867 | // We have to ignore already converted newlines and line breaks in sub-list items
868 | return text.replace(/(<(?:br|\/li)>)?\n/g, function(wholeMatch, previousTag) {
869 | return previousTag ? wholeMatch : "
\n";
870 | });
871 | };
872 |
873 | })();
874 |
875 |
--------------------------------------------------------------------------------
/lib/markdown/Markdown.Sanitizer.js:
--------------------------------------------------------------------------------
1 | (function () {
2 | var output, Converter;
3 | if (typeof exports === "object" && typeof require === "function") { // we're in a CommonJS (e.g. Node.js) module
4 | output = exports;
5 | Converter = require("./Markdown.Converter").Converter;
6 | } else {
7 | output = window.Markdown;
8 | Converter = output.Converter;
9 | }
10 |
11 | output.getSanitizingConverter = function () {
12 | var converter = new Converter();
13 | converter.hooks.chain("postConversion", sanitizeHtml);
14 | converter.hooks.chain("postConversion", balanceTags);
15 | return converter;
16 | }
17 |
18 | function sanitizeHtml(html) {
19 | return html.replace(/<[^>]*>?/gi, sanitizeTag);
20 | }
21 |
22 | // (tags that can be opened/closed) | (tags that stand alone)
23 | var basic_tag_whitelist = /^(<\/?(b|blockquote|code|del|dd|dl|dt|em|h1|h2|h3|i|kbd|li|ol|p|pre|s|sup|sub|strong|strike|ul)>|<(br|hr)\s?\/?>)$/i;
24 | // |
25 | var a_white = /^(]*")?(\stitle="[^"<>]*")?\s?\/?>)$/i;
29 |
30 | function sanitizeTag(tag) {
31 | if (tag.match(basic_tag_whitelist) || tag.match(a_white) || tag.match(img_white))
32 | return tag;
33 | else
34 | return "";
35 | }
36 |
37 | ///
";
62 | var match;
63 | var tagpaired = [];
64 | var tagremove = [];
65 | var needsRemoval = false;
66 |
67 | // loop through matched tags in forward order
68 | for (var ctag = 0; ctag < tagcount; ctag++) {
69 | tagname = tags[ctag].replace(/<\/?(\w+).*/, "$1");
70 | // skip any already paired tags
71 | // and skip tags in our ignore list; assume they're self-closed
72 | if (tagpaired[ctag] || ignoredtags.search("<" + tagname + ">") > -1)
73 | continue;
74 |
75 | tag = tags[ctag];
76 | match = -1;
77 |
78 | if (!/^<\//.test(tag)) {
79 | // this is an opening tag
80 | // search forwards (next tags), look for closing tags
81 | for (var ntag = ctag + 1; ntag < tagcount; ntag++) {
82 | if (!tagpaired[ntag] && tags[ntag] == "") {
83 | match = ntag;
84 | break;
85 | }
86 | }
87 | }
88 |
89 | if (match == -1)
90 | needsRemoval = tagremove[ctag] = true; // mark for removal
91 | else
92 | tagpaired[match] = true; // mark paired
93 | }
94 |
95 | if (!needsRemoval)
96 | return html;
97 |
98 | // delete all orphaned tags from the string
99 |
100 | var ctag = 0;
101 | html = html.replace(re, function (match) {
102 | var res = tagremove[ctag] ? "" : match;
103 | ctag++;
104 | return res;
105 | });
106 | return html;
107 | }
108 | })();
109 |
--------------------------------------------------------------------------------
/lib/markdown/prettify.js:
--------------------------------------------------------------------------------
1 | var q=null;window.PR_SHOULD_USE_CONTINUATION=!0;
2 | (function(){function L(a){function m(a){var f=a.charCodeAt(0);if(f!==92)return f;var b=a.charAt(1);return(f=r[b])?f:"0"<=b&&b<="7"?parseInt(a.substring(1),8):b==="u"||b==="x"?parseInt(a.substring(2),16):a.charCodeAt(1)}function e(a){if(a<32)return(a<16?"\\x0":"\\x")+a.toString(16);a=String.fromCharCode(a);if(a==="\\"||a==="-"||a==="["||a==="]")a="\\"+a;return a}function h(a){for(var f=a.substring(1,a.length-1).match(/\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\[0-3][0-7]{0,2}|\\[0-7]{1,2}|\\[\S\s]|[^\\]/g),a=
3 | [],b=[],o=f[0]==="^",c=o?1:0,i=f.length;c