| Class | 4 |Instance | 5 |
|---|---|
| 8 | 15 | | 16 |17 | 29 | | 30 |
33 |
|
43 |
44 |
|
54 |
56 |
|
66 |
67 |
|
77 |
| Constants | 82 |||
|---|---|---|
85 |
|
93 | ||
| In Scripts | 96 |||
99 |
|
107 | ||
68 |
| Search | 74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 | |
83 |
|---|---|
| FILES | 85 |86 | 91 | | 92 |
| CLASSES | 94 |95 | 100 | | 101 |
| METHODS | 103 |104 | 109 | | 110 |
doc.json
123 |- ';
193 | for (var k in data) {
194 | if (data[k] instanceof Object) {
195 | html = html + '
- ' + k + ' ' + HyperVisor.viewMetaRecursive(data[k]); 196 | } else { 197 | html = html + '
- ' + k + '
' + ('' + data[k]).escapeHTML() + ''; 198 | } 199 | html = html + ' ';
200 | }
201 | html = html + '
s around 228 | // "paragraphs" that are wrapped in non-block-level tags, such as anchors, 229 | // phrase emphasis, and spans. The list of tags we're looking for is 230 | // hard-coded: 231 | var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del" 232 | var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math" 233 | 234 | // First, look for nested blocks, e.g.: 235 | //
. It was easier to make a special case than 284 | // to make the other regex more complicated. 285 | 286 | /* 287 | text = text.replace(/ 288 | ( // save in $1 289 | \n\n // Starting after a blank line 290 | [ ]{0,3} 291 | (<(hr) // start tag = $2 292 | \b // word break 293 | ([^<>])*? // 294 | \/?>) // the matching end tag 295 | [ \t]* 296 | (?=\n{2,}) // followed by a blank line 297 | ) 298 | /g,hashElement); 299 | */ 300 | text = text.replace(/(\n[ ]{0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,hashElement); 301 | 302 | // Special case for standalone HTML comments: 303 | 304 | /* 305 | text = text.replace(/ 306 | ( // save in $1 307 | \n\n // Starting after a blank line 308 | [ ]{0,3} // attacklab: g_tab_width - 1 309 | 312 | [ \t]* 313 | (?=\n{2,}) // followed by a blank line 314 | ) 315 | /g,hashElement); 316 | */ 317 | text = text.replace(/(\n\n[ ]{0,3}[ \t]*(?=\n{2,}))/g,hashElement); 318 | 319 | // PHP and ASP-style processor instructions ( and <%...%>) 320 | 321 | /* 322 | text = text.replace(/ 323 | (?: 324 | \n\n // Starting after a blank line 325 | ) 326 | ( // save in $1 327 | [ ]{0,3} // attacklab: g_tab_width - 1 328 | (?: 329 | <([?%]) // $2 330 | [^\r]*? 331 | \2> 332 | ) 333 | [ \t]* 334 | (?=\n{2,}) // followed by a blank line 335 | ) 336 | /g,hashElement); 337 | */ 338 | text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,hashElement); 339 | 340 | // attacklab: Undo double lines (see comment at top of this function) 341 | text = text.replace(/\n\n/g,"\n"); 342 | return text; 343 | } 344 | 345 | var hashElement = function(wholeMatch,m1) { 346 | var blockText = m1; 347 | 348 | // Undo double lines 349 | blockText = blockText.replace(/\n\n/g,"\n"); 350 | blockText = blockText.replace(/^\n/,""); 351 | 352 | // strip trailing blank lines 353 | blockText = blockText.replace(/\n+$/g,""); 354 | 355 | // Replace the element text with a marker ("~KxK" where x is its key) 356 | blockText = "\n\n~K" + (g_html_blocks.push(blockText)-1) + "K\n\n"; 357 | 358 | return blockText; 359 | }; 360 | 361 | var _RunBlockGamut = function(text) { 362 | // 363 | // These are all the transformations that form block-level 364 | // tags like paragraphs, headers, and list items. 365 | // 366 | text = _DoHeaders(text); 367 | 368 | // Do Horizontal Rules: 369 | var key = hashBlock("
"); 370 | text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm,key); 371 | text = text.replace(/^[ ]{0,2}([ ]?-[ ]?){3,}[ \t]*$/gm,key); 372 | text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ \t]*$/gm,key); 373 | 374 | text = _DoLists(text); 375 | text = _DoCodeBlocks(text); 376 | text = _DoBlockQuotes(text); 377 | 378 | // We already ran _HashHTMLBlocks() before, in Markdown(), but that 379 | // was to escape raw HTML in the original Markdown source. This time, 380 | // we're escaping the markup we've just created, so that we don't wrap 381 | //
tags around block-level tags.
382 | text = _HashHTMLBlocks(text);
383 | text = _FormParagraphs(text);
384 |
385 | return text;
386 | }
387 |
388 |
389 | var _RunSpanGamut = function(text) {
390 | //
391 | // These are all the transformations that occur *within* block-level
392 | // tags like paragraphs, headers, and list items.
393 | //
394 |
395 | text = _DoCodeSpans(text);
396 | text = _EscapeSpecialCharsWithinTagAttributes(text);
397 | text = _EncodeBackslashEscapes(text);
398 |
399 | // Process anchor and image tags. Images must come first,
400 | // because ![foo][f] looks like an anchor.
401 | text = _DoImages(text);
402 | text = _DoAnchors(text);
403 |
404 | // Make links out of things like ` Just type tags
1060 | //
1061 |
1062 | // Strip leading and trailing lines:
1063 | text = text.replace(/^\n+/g,"");
1064 | text = text.replace(/\n+$/g,"");
1065 |
1066 | var grafs = text.split(/\n{2,}/g);
1067 | var grafsOut = new Array();
1068 |
1069 | //
1070 | // Wrap tags.
1071 | //
1072 | var end = grafs.length;
1073 | for (var i=0; i ");
1083 | str += " s around
236 | // "paragraphs" that are wrapped in non-block-level tags, such as anchors,
237 | // phrase emphasis, and spans. The list of tags we're looking for is
238 | // hard-coded:
239 | var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del"
240 | var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math"
241 |
242 | // First, look for nested blocks, e.g.:
243 | // tags around block-level tags.
390 | text = _HashHTMLBlocks(text);
391 | text = _FormParagraphs(text);
392 |
393 | return text;
394 | }
395 |
396 |
397 | var _RunSpanGamut = function(text) {
398 | //
399 | // These are all the transformations that occur *within* block-level
400 | // tags like paragraphs, headers, and list items.
401 | //
402 |
403 | text = _DoCodeSpans(text);
404 | text = _EscapeSpecialCharsWithinTagAttributes(text);
405 | text = _EncodeBackslashEscapes(text);
406 |
407 | // Process anchor and image tags. Images must come first,
408 | // because ![foo][f] looks like an anchor.
409 | text = _DoImages(text);
410 | text = _DoAnchors(text);
411 |
412 | // Make links out of things like ` Just type tags
1071 | //
1072 |
1073 | // Strip leading and trailing lines:
1074 | text = text.replace(/^\n+/g,"");
1075 | text = text.replace(/\n+$/g,"");
1076 |
1077 | var grafs = text.split(/\n{2,}/g);
1078 | var grafsOut = new Array();
1079 |
1080 | //
1081 | // Wrap tags.
1082 | //
1083 | var end = grafs.length;
1084 | for (var i=0; i ");
1094 | str += " ";
386 | foundHelper = helpers.render_comment;
387 | stack1 = foundHelper || depth0.render_comment;
388 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
389 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "render_comment", { hash: {} }); }
390 | buffer += escapeExpression(stack1) + " ";
450 | foundHelper = helpers.render_comment;
451 | stack1 = foundHelper || depth0.render_comment;
452 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
453 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "render_comment", { hash: {} }); }
454 | buffer += escapeExpression(stack1) + " ";
487 | foundHelper = helpers.render_comment;
488 | stack1 = foundHelper || depth0.render_comment;
489 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
490 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "render_comment", { hash: {} }); }
491 | buffer += escapeExpression(stack1) + " ";
524 | foundHelper = helpers.value;
525 | stack1 = foundHelper || depth0.value;
526 | foundHelper = helpers.render;
527 | stack2 = foundHelper || depth0.render;
528 | if(typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, { hash: {} }); }
529 | else if(stack2=== undef) { stack1 = helperMissing.call(depth0, "render", stack1, { hash: {} }); }
530 | else { stack1 = stack2; }
531 | buffer += escapeExpression(stack1) + " ";
624 | foundHelper = helpers.render_comment;
625 | stack1 = foundHelper || depth0.render_comment;
626 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
627 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "render_comment", { hash: {} }); }
628 | buffer += escapeExpression(stack1) + " ";
665 | foundHelper = helpers.render_comment;
666 | stack1 = foundHelper || depth0.render_comment;
667 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
668 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "render_comment", { hash: {} }); }
669 | buffer += escapeExpression(stack1) + "
\n");
413 |
414 | return text;
415 | }
416 |
417 | var _EscapeSpecialCharsWithinTagAttributes = function(text) {
418 | //
419 | // Within tags -- meaning between < and > -- encode [\ ` * _] so they
420 | // don't conflict with their use in Markdown for code, italics and strong.
421 | //
422 |
423 | // Build a regex to find HTML tags and comments. See Friedl's
424 | // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
425 | var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|)/gi;
426 |
427 | text = text.replace(regex, function(wholeMatch) {
428 | var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g,"$1`");
429 | tag = escapeCharacters(tag,"\\`*_");
430 | return tag;
431 | });
432 |
433 | return text;
434 | }
435 |
436 | var _DoAnchors = function(text) {
437 | //
438 | // Turn Markdown link shortcuts into XHTML tags.
439 | //
440 | //
441 | // First, handle reference-style links: [link text] [id]
442 | //
443 |
444 | /*
445 | text = text.replace(/
446 | ( // wrap whole match in $1
447 | \[
448 | (
449 | (?:
450 | \[[^\]]*\] // allow brackets nested one level
451 | |
452 | [^\[] // or anything else
453 | )*
454 | )
455 | \]
456 |
457 | [ ]? // one optional space
458 | (?:\n[ ]*)? // one optional newline followed by spaces
459 |
460 | \[
461 | (.*?) // id = $3
462 | \]
463 | )()()()() // pad remaining backreferences
464 | /g,_DoAnchors_callback);
465 | */
466 | text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeAnchorTag);
467 |
468 | //
469 | // Next, inline-style links: [link text](url "optional title")
470 | //
471 |
472 | /*
473 | text = text.replace(/
474 | ( // wrap whole match in $1
475 | \[
476 | (
477 | (?:
478 | \[[^\]]*\] // allow brackets nested one level
479 | |
480 | [^\[\]] // or anything else
481 | )
482 | )
483 | \]
484 | \( // literal paren
485 | [ \t]*
486 | () // no id, so leave $3 empty
487 | ? // href = $4
488 | [ \t]*
489 | ( // $5
490 | (['"]) // quote char = $6
491 | (.*?) // Title = $7
492 | \6 // matching quote
493 | [ \t]* // ignore any spaces/tabs between closing quote and )
494 | )? // title is optional
495 | \)
496 | )
497 | /g,writeAnchorTag);
498 | */
499 | text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeAnchorTag);
500 |
501 | //
502 | // Last, handle reference-style shortcuts: [link text]
503 | // These must come last in case you've also got [link test][1]
504 | // or [link test](/foo)
505 | //
506 |
507 | /*
508 | text = text.replace(/
509 | ( // wrap whole match in $1
510 | \[
511 | ([^\[\]]+) // link text = $2; can't contain '[' or ']'
512 | \]
513 | )()()()()() // pad rest of backreferences
514 | /g, writeAnchorTag);
515 | */
516 | text = text.replace(/(\[([^\[\]]+)\])()()()()()/g, writeAnchorTag);
517 |
518 | return text;
519 | }
520 |
521 | var writeAnchorTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
522 | if (m7 == undefined) m7 = "";
523 | var whole_match = m1;
524 | var link_text = m2;
525 | var link_id = m3.toLowerCase();
526 | var url = m4;
527 | var title = m7;
528 |
529 | if (url == "") {
530 | if (link_id == "") {
531 | // lower-case and turn embedded newlines into spaces
532 | link_id = link_text.toLowerCase().replace(/ ?\n/g," ");
533 | }
534 | url = "#"+link_id;
535 |
536 | if (g_urls.get(link_id) != undefined) {
537 | url = g_urls.get(link_id);
538 | if (g_titles.get(link_id) != undefined) {
539 | title = g_titles.get(link_id);
540 | }
541 | }
542 | else {
543 | if (whole_match.search(/\(\s*\)$/m)>-1) {
544 | // Special case for explicit empty url
545 | url = "";
546 | } else {
547 | return whole_match;
548 | }
549 | }
550 | }
551 |
552 | url = escapeCharacters(url,"*_");
553 | var result = "";
562 |
563 | return result;
564 | }
565 |
566 |
567 | var _DoImages = function(text) {
568 | //
569 | // Turn Markdown image shortcuts into tags.
570 | //
571 |
572 | //
573 | // First, handle reference-style labeled images: ![alt text][id]
574 | //
575 |
576 | /*
577 | text = text.replace(/
578 | ( // wrap whole match in $1
579 | !\[
580 | (.*?) // alt text = $2
581 | \]
582 |
583 | [ ]? // one optional space
584 | (?:\n[ ]*)? // one optional newline followed by spaces
585 |
586 | \[
587 | (.*?) // id = $3
588 | \]
589 | )()()()() // pad rest of backreferences
590 | /g,writeImageTag);
591 | */
592 | text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeImageTag);
593 |
594 | //
595 | // Next, handle inline images: 
596 | // Don't forget: encode * and _
597 |
598 | /*
599 | text = text.replace(/
600 | ( // wrap whole match in $1
601 | !\[
602 | (.*?) // alt text = $2
603 | \]
604 | \s? // One optional whitespace character
605 | \( // literal paren
606 | [ \t]*
607 | () // no id, so leave $3 empty
608 | ? // src url = $4
609 | [ \t]*
610 | ( // $5
611 | (['"]) // quote char = $6
612 | (.*?) // title = $7
613 | \6 // matching quote
614 | [ \t]*
615 | )? // title is optional
616 | \)
617 | )
618 | /g,writeImageTag);
619 | */
620 | text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeImageTag);
621 |
622 | return text;
623 | }
624 |
625 | var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
626 | var whole_match = m1;
627 | var alt_text = m2;
628 | var link_id = m3.toLowerCase();
629 | var url = m4;
630 | var title = m7;
631 |
632 | if (!title) title = "";
633 |
634 | if (url == "") {
635 | if (link_id == "") {
636 | // lower-case and turn embedded newlines into spaces
637 | link_id = alt_text.toLowerCase().replace(/ ?\n/g," ");
638 | }
639 | url = "#"+link_id;
640 |
641 | if (g_urls.get(link_id) != undefined) {
642 | url = g_urls.get(link_id);
643 | if (g_titles.get(link_id) != undefined) {
644 | title = g_titles.get(link_id);
645 | }
646 | }
647 | else {
648 | return whole_match;
649 | }
650 | }
651 |
652 | alt_text = alt_text.replace(/"/g,""");
653 | url = escapeCharacters(url,"*_");
654 | var result = "
" + _RunSpanGamut(m1) + "");});
682 |
683 | text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
684 | function(matchFound,m1){return hashBlock("
" + _RunSpanGamut(m1) + "
");});
685 |
686 | // atx-style headers:
687 | // # Header 1
688 | // ## Header 2
689 | // ## Header 2 with closing hashes ##
690 | // ...
691 | // ###### Header 6
692 | //
693 |
694 | /*
695 | text = text.replace(/
696 | ^(\#{1,6}) // $1 = string of #'s
697 | [ \t]*
698 | (.+?) // $2 = Header text
699 | [ \t]*
700 | \#* // optional closing #'s (not counted)
701 | \n+
702 | /gm, function() {...});
703 | */
704 |
705 | text = text.replace(/^([#=]{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
706 | function(wholeMatch,m1,m2) {
707 | var h_level = m1.length;
708 | return hashBlock("` blocks.
866 | //
867 |
868 | /*
869 | text = text.replace(text,
870 | /(?:\n\n|^)
871 | ( // $1 = the code block -- one or more lines, starting with a space/tab
872 | (?:
873 | (?:[ ]{4}|\t) // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
874 | .*\n+
875 | )+
876 | )
877 | (\n*[ ]{0,3}[^ \t\n]|(?=~0)) // attacklab: g_tab_width
878 | /g,function(){...});
879 | */
880 |
881 | // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
882 | text += "~0";
883 |
884 | text = text.replace(/(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
885 | function(wholeMatch,m1,m2) {
886 | var codeblock = m1;
887 | var nextChar = m2;
888 |
889 | codeblock = _EncodeCode( _Outdent(codeblock));
890 | codeblock = _Detab(codeblock);
891 | codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
892 | codeblock = codeblock.replace(/\n+$/g,""); // trim trailing whitespace
893 |
894 | codeblock = "
";
895 |
896 | return hashBlock(codeblock) + nextChar;
897 | }
898 | );
899 |
900 | // attacklab: strip sentinel
901 | text = text.replace(/~0/,"");
902 |
903 | return text;
904 | }
905 |
906 | var hashBlock = function(text) {
907 | text = text.replace(/(^\n+|\n+$)/g,"");
908 | return "\n\n~K" + (g_html_blocks.push(text)-1) + "K\n\n";
909 | }
910 |
911 |
912 | var _DoCodeSpans = function(text) {
913 | //
914 | // * Backtick quotes are used for " + codeblock + "\n spans.
915 | //
916 | // * You can use multiple backticks as the delimiters if you want to
917 | // include literal backticks in the code span. So, this input:
918 | //
919 | // Just type ``foo `bar` baz`` at the prompt.
920 | //
921 | // Will translate to:
922 | //
923 | // foo `bar` baz at the prompt.`bar` ...
936 | //
937 |
938 | /*
939 | text = text.replace(/
940 | (^|[^\\]) // Character before opening ` can't be a backslash
941 | (`+) // $2 = Opening run of `
942 | ( // $3 = The code block
943 | [^\r]*?
944 | [^`] // attacklab: work around lack of lookbehind
945 | )
946 | \2 // Matching closer
947 | (?!`)
948 | /gm, function(){...});
949 | */
950 |
951 | text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
952 | function(wholeMatch,m1,m2,m3,m4) {
953 | var c = m3;
954 | c = c.replace(/^([ \t]*)/g,""); // leading whitespace
955 | c = c.replace(/[ \t]*$/g,""); // trailing whitespace
956 | c = _EncodeCode(c);
957 | return m1+""+c+"";
958 | });
959 |
960 | return text;
961 | }
962 |
963 |
964 | var _EncodeCode = function(text) {
965 | //
966 | // Encode/escape certain characters inside Markdown code runs.
967 | // The point is that in code, these characters are literals,
968 | // and lose their special Markdown meanings.
969 | //
970 | // Encode all ampersands; HTML entities are not
971 | // entities within a Markdown code span.
972 | text = text.replace(/&/g,"&");
973 |
974 | // Do the angle bracket song and dance:
975 | text = text.replace(//g,">");
977 |
978 | // Now, escape characters that are magic in Markdown:
979 | text = escapeCharacters(text,"\*_{}[]\\",false);
980 |
981 | // jj the line above breaks this:
982 | //---
983 |
984 | //* Item
985 |
986 | // 1. Subitem
987 |
988 | // special char: *
989 | //---
990 |
991 | return text;
992 | }
993 |
994 |
995 | var _DoItalicsAndBold = function(text) {
996 |
997 | // must go first:
998 | text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[\*_]*)\1/g,
999 | "$2");
1000 |
1001 | text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g,
1002 | "$2");
1003 |
1004 | return text;
1005 | }
1006 |
1007 |
1008 | var _DoBlockQuotes = function(text) {
1009 |
1010 | /*
1011 | text = text.replace(/
1012 | ( // Wrap whole match in $1
1013 | (
1014 | ^[ \t]*>[ \t]? // '>' at the start of a line
1015 | .+\n // rest of the first line
1016 | (.+\n)* // subsequent consecutive lines
1017 | \n* // blanks
1018 | )+
1019 | )
1020 | /gm, function(){...});
1021 | */
1022 |
1023 | text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
1024 | function(wholeMatch,m1) {
1025 | var bq = m1;
1026 |
1027 | // attacklab: hack around Konqueror 3.5.4 bug:
1028 | // "----------bug".replace(/^-/g,"") == "bug"
1029 |
1030 | bq = bq.replace(/^[ \t]*>[ \t]?/gm,"~0"); // trim one level of quoting
1031 |
1032 | // attacklab: clean up hack
1033 | bq = bq.replace(/~0/g,"");
1034 |
1035 | bq = bq.replace(/^[ \t]+$/gm,""); // trim whitespace-only lines
1036 | bq = _RunBlockGamut(bq); // recurse
1037 |
1038 | bq = bq.replace(/(^|\n)/g,"$1 ");
1039 | // These leading spaces screw with content, so we need to fix that:
1040 | bq = bq.replace(
1041 | /(\s*
[^\r]+?<\/pre>)/gm,
1042 | function(wholeMatch,m1) {
1043 | var pre = m1;
1044 | // attacklab: hack around Konqueror 3.5.4 bug:
1045 | pre = pre.replace(/^ /mg,"~0");
1046 | pre = pre.replace(/~0/g,"");
1047 | return pre;
1048 | });
1049 |
1050 | return hashBlock("\n" + bq + "\n
");
1051 | });
1052 | return text;
1053 | }
1054 |
1055 |
1056 | var _FormParagraphs = function(text) {
1057 | //
1058 | // Params:
1059 | // $text - string to process with html tags get encoded.
118 | //
119 |
120 | // Clear the global hashes. If we don't clear these, you get conflicts
121 | // from other articles when generating a page which contains more than
122 | // one article (e.g. an index page that shows the N most recent
123 | // articles):
124 | g_urls = new SaveHash();
125 | g_titles = new SaveHash();
126 | g_html_blocks = new Array();
127 |
128 | // attacklab: Replace ~ with ~T
129 | // This lets us use tilde as an escape char to avoid md5 hashes
130 | // The choice of character is arbitray; anything that isn't
131 | // magic in Markdown will work.
132 | text = text.replace(/~/g,"~T");
133 |
134 | // attacklab: Replace $ with ~D
135 | // RegExp interprets $ as a special character
136 | // when it's in a replacement string
137 | text = text.replace(/\$/g,"~D");
138 |
139 | // Standardize line endings
140 | text = text.replace(/\r\n/g,"\n"); // DOS to Unix
141 | text = text.replace(/\r/g,"\n"); // Mac to Unix
142 |
143 | // Make sure text begins and ends with a couple of newlines:
144 | text = "\n\n" + text + "\n\n";
145 |
146 | // Convert all tabs to spaces.
147 | text = _Detab(text);
148 |
149 | // Strip any lines consisting only of spaces and tabs.
150 | // This makes subsequent regexen easier to write, because we can
151 | // match consecutive blank lines with /\n+/ instead of something
152 | // contorted like /[ \t]*\n+/ .
153 | text = text.replace(/^[ \t]+$/mg,"");
154 |
155 | // Turn block-level HTML blocks into hash entries
156 | text = _HashHTMLBlocks(text);
157 |
158 | // Strip link definitions, store in hashes.
159 | text = _StripLinkDefinitions(text);
160 |
161 | text = _RunBlockGamut(text);
162 |
163 | text = _UnescapeSpecialChars(text);
164 |
165 | // attacklab: Restore dollar signs
166 | text = text.replace(/~D/g,"$$");
167 |
168 | // attacklab: Restore tildes
169 | text = text.replace(/~T/g,"~");
170 |
171 | return text;
172 | }
173 |
174 | var _RE_StripLinkDefinitions = new RegExp(
175 | '^[ ]{0,' + (g_tab_width-1) + '}\[(.+)\]:[ \t]*\n?[ \t]*?[ \t]*\n?[ \t]*(?:(\n*)["(](.+?)[")][ \t]*)?(?:\n+)', 'gm'
176 | );
177 |
178 | var _StripLinkDefinitions = function(text) {
179 | //
180 | // Strips link definitions from text, stores the URLs and titles in
181 | // hash references.
182 | //
183 |
184 | // Link defs are in the form: ^[id]: url "optional title"
185 |
186 | /*
187 | var text = text.replace(/
188 | ^[ ]{0,1}\[(.+)\]: // id = $1 attacklab: g_tab_width - 1
189 | [ \t]*
190 | \n? // maybe *one* newline
191 | [ \t]*
192 | ? // url = $2
193 | [ \t]*
194 | \n? // maybe one newline
195 | [ \t]*
196 | (?:
197 | (\n*) // any lines skipped = $3 attacklab: lookbehind removed
198 | ["(]
199 | (.+?) // title = $4
200 | [")]
201 | [ \t]*
202 | )? // title is optional
203 | (?:\n+|$)
204 | /gm,
205 | function(){...});
206 | */
207 |
208 | //var text = text.replace(/^[ ]{0,3}\[(.+)\]:[ \t]*\n?[ \t]*?[ \t]*\n?[ \t]*(?:(\n*)["(](.+?)[")][ \t]*)?(?:\n+)/gm,
209 | var text = text.replace(_RE_StripLinkDefinitions,
210 | function (wholeMatch,m1,m2,m3,m4) {
211 | m1 = m1.toLowerCase();
212 | g_urls.set(m1, _EncodeAmpsAndAngles(m2)); // Link IDs are case-insensitive
213 | if (m3) {
214 | // Oops, found blank lines, so it's not a title.
215 | // Put back the parenthetical statement we stole.
216 | return m3+m4;
217 | } else if (m4) {
218 | g_titles.set(m1, m4.replace(/"/g,"""));
219 | }
220 |
221 | // Completely remove the definition from the text
222 | return "";
223 | }
224 | );
225 |
226 | return text;
227 | }
228 |
229 | var _HashHTMLBlocks = function(text) {
230 | // attacklab: Double up blank lines to reduce lookaround
231 | text = text.replace(/\n/g,"\n\n");
232 |
233 | // Hashify HTML blocks:
234 | // We only want to do this for block-level HTML tags, such as headers,
235 | // lists, and tables. That's because we still want to wrap
. It was easier to make a special case than
292 | // to make the other regex more complicated.
293 |
294 | /*
295 | text = text.replace(/
296 | ( // save in $1
297 | \n\n // Starting after a blank line
298 | [ ]{0,3}
299 | (<(hr) // start tag = $2
300 | \b // word break
301 | ([^<>])*? //
302 | \/?>) // the matching end tag
303 | [ \t]*
304 | (?=\n{2,}) // followed by a blank line
305 | )
306 | /g,hashElement);
307 | */
308 | text = text.replace(/(\n[ ]{0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,hashElement);
309 |
310 | // Special case for standalone HTML comments:
311 |
312 | /*
313 | text = text.replace(/
314 | ( // save in $1
315 | \n\n // Starting after a blank line
316 | [ ]{0,1} // attacklab: g_tab_width - 1
317 |
320 | [ \t]*
321 | (?=\n{2,}) // followed by a blank line
322 | )
323 | /g,hashElement);
324 | */
325 | text = text.replace(/(\n\n[ ]{0,3}[ \t]*(?=\n{2,}))/g,hashElement);
326 |
327 | // PHP and ASP-style processor instructions ( and <%...%>)
328 |
329 | /*
330 | text = text.replace(/
331 | (?:
332 | \n\n // Starting after a blank line
333 | )
334 | ( // save in $1
335 | [ ]{0,1} // attacklab: g_tab_width - 1
336 | (?:
337 | <([?%]) // $2
338 | [^\r]*?
339 | \2>
340 | )
341 | [ \t]*
342 | (?=\n{2,}) // followed by a blank line
343 | )
344 | /g,hashElement);
345 | */
346 | text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,hashElement);
347 |
348 | // attacklab: Undo double lines (see comment at top of this function)
349 | text = text.replace(/\n\n/g,"\n");
350 | return text;
351 | }
352 |
353 | var hashElement = function(wholeMatch,m1) {
354 | var blockText = m1;
355 |
356 | // Undo double lines
357 | blockText = blockText.replace(/\n\n/g,"\n");
358 | blockText = blockText.replace(/^\n/,"");
359 |
360 | // strip trailing blank lines
361 | blockText = blockText.replace(/\n+$/g,"");
362 |
363 | // Replace the element text with a marker ("~KxK" where x is its key)
364 | blockText = "\n\n~K" + (g_html_blocks.push(blockText)-1) + "K\n\n";
365 |
366 | return blockText;
367 | };
368 |
369 | var _RunBlockGamut = function(text) {
370 | //
371 | // These are all the transformations that form block-level
372 | // tags like paragraphs, headers, and list items.
373 | //
374 | text = _DoHeaders(text);
375 |
376 | // Do Horizontal Rules:
377 | var key = hashBlock("
");
378 | text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm,key);
379 | text = text.replace(/^[ ]{0,2}([ ]?-[ ]?){3,}[ \t]*$/gm,key);
380 | text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ \t]*$/gm,key);
381 |
382 | text = _DoLists(text);
383 | text = _DoCodeBlocks(text);
384 | text = _DoBlockQuotes(text);
385 |
386 | // We already ran _HashHTMLBlocks() before, in Markdown(), but that
387 | // was to escape raw HTML in the original Markdown source. This time,
388 | // we're escaping the markup we've just created, so that we don't wrap
389 | //
\n");
421 |
422 | return text;
423 | }
424 |
425 | var _EscapeSpecialCharsWithinTagAttributes = function(text) {
426 | //
427 | // Within tags -- meaning between < and > -- encode [\ ` * _] so they
428 | // don't conflict with their use in Markdown for code, italics and strong.
429 | //
430 |
431 | // Build a regex to find HTML tags and comments. See Friedl's
432 | // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
433 | var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|)/gi;
434 |
435 | text = text.replace(regex, function(wholeMatch) {
436 | var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g,"$1`");
437 | tag = escapeCharacters(tag,"\\`*_");
438 | return tag;
439 | });
440 |
441 | return text;
442 | }
443 |
444 | var _DoAnchors = function(text) {
445 | //
446 | // Turn Markdown link shortcuts into XHTML tags.
447 | //
448 | //
449 | // First, handle reference-style links: [link text] [id]
450 | //
451 |
452 | /*
453 | text = text.replace(/
454 | ( // wrap whole match in $1
455 | \[
456 | (
457 | (?:
458 | \[[^\]]*\] // allow brackets nested one level
459 | |
460 | [^\[] // or anything else
461 | )*
462 | )
463 | \]
464 |
465 | [ ]? // one optional space
466 | (?:\n[ ]*)? // one optional newline followed by spaces
467 |
468 | \[
469 | (.*?) // id = $3
470 | \]
471 | )()()()() // pad remaining backreferences
472 | /g,_DoAnchors_callback);
473 | */
474 | text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeAnchorTag);
475 |
476 | //
477 | // Next, inline-style links: [link text](url "optional title")
478 | //
479 |
480 | /*
481 | text = text.replace(/
482 | ( // wrap whole match in $1
483 | \[
484 | (
485 | (?:
486 | \[[^\]]*\] // allow brackets nested one level
487 | |
488 | [^\[\]] // or anything else
489 | )
490 | )
491 | \]
492 | \( // literal paren
493 | [ \t]*
494 | () // no id, so leave $3 empty
495 | ? // href = $4
496 | [ \t]*
497 | ( // $5
498 | (['"]) // quote char = $6
499 | (.*?) // Title = $7
500 | \6 // matching quote
501 | [ \t]* // ignore any spaces/tabs between closing quote and )
502 | )? // title is optional
503 | \)
504 | )
505 | /g,writeAnchorTag);
506 | */
507 | text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeAnchorTag);
508 |
509 | //
510 | // Last, handle reference-style shortcuts: [link text]
511 | // These must come last in case you've also got [link test][1]
512 | // or [link test](/foo)
513 | //
514 |
515 | /*
516 | text = text.replace(/
517 | ( // wrap whole match in $1
518 | \[
519 | ([^\[\]]+) // link text = $2; can't contain '[' or ']'
520 | \]
521 | )()()()()() // pad rest of backreferences
522 | /g, writeAnchorTag);
523 | */
524 | text = text.replace(/(\[([^\[\]]+)\])()()()()()/g, writeAnchorTag);
525 |
526 | return text;
527 | }
528 |
529 | var writeAnchorTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
530 | if (m7 == undefined) m7 = "";
531 | var whole_match = m1;
532 | var link_text = m2;
533 | var link_id = m3.toLowerCase();
534 | var url = m4;
535 | var title = m7;
536 |
537 | if (url == "") {
538 | if (link_id == "") {
539 | // lower-case and turn embedded newlines into spaces
540 | link_id = link_text.toLowerCase().replace(/ ?\n/g," ");
541 | }
542 | url = "#"+link_id;
543 |
544 | if (g_urls.get(link_id) != undefined) {
545 | url = g_urls.get(link_id);
546 | if (g_titles.get(link_id) != undefined) {
547 | title = g_titles.get(link_id);
548 | }
549 | }
550 | else {
551 | if (whole_match.search(/\(\s*\)$/m)>-1) {
552 | // Special case for explicit empty url
553 | url = "";
554 | } else {
555 | return whole_match;
556 | }
557 | }
558 | }
559 |
560 | url = escapeCharacters(url,"*_");
561 | var result = "";
570 |
571 | return result;
572 | }
573 |
574 |
575 | var _DoImages = function(text) {
576 | //
577 | // Turn Markdown image shortcuts into tags.
578 | //
579 |
580 | //
581 | // First, handle reference-style labeled images: ![alt text][id]
582 | //
583 |
584 | /*
585 | text = text.replace(/
586 | ( // wrap whole match in $1
587 | !\[
588 | (.*?) // alt text = $2
589 | \]
590 |
591 | [ ]? // one optional space
592 | (?:\n[ ]*)? // one optional newline followed by spaces
593 |
594 | \[
595 | (.*?) // id = $3
596 | \]
597 | )()()()() // pad rest of backreferences
598 | /g,writeImageTag);
599 | */
600 | text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g,writeImageTag);
601 |
602 | //
603 | // Next, handle inline images: 
604 | // Don't forget: encode * and _
605 |
606 | /*
607 | text = text.replace(/
608 | ( // wrap whole match in $1
609 | !\[
610 | (.*?) // alt text = $2
611 | \]
612 | \s? // One optional whitespace character
613 | \( // literal paren
614 | [ \t]*
615 | () // no id, so leave $3 empty
616 | ? // src url = $4
617 | [ \t]*
618 | ( // $5
619 | (['"]) // quote char = $6
620 | (.*?) // title = $7
621 | \6 // matching quote
622 | [ \t]*
623 | )? // title is optional
624 | \)
625 | )
626 | /g,writeImageTag);
627 | */
628 | text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,writeImageTag);
629 |
630 | return text;
631 | }
632 |
633 | var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) {
634 | var whole_match = m1;
635 | var alt_text = m2;
636 | var link_id = m3.toLowerCase();
637 | var url = m4;
638 | var title = m7;
639 |
640 | if (!title) title = "";
641 |
642 | if (url == "") {
643 | if (link_id == "") {
644 | // lower-case and turn embedded newlines into spaces
645 | link_id = alt_text.toLowerCase().replace(/ ?\n/g," ");
646 | }
647 | url = "#"+link_id;
648 |
649 | if (g_urls.get(link_id) != undefined) {
650 | url = g_urls.get(link_id);
651 | if (g_titles.get(link_id) != undefined) {
652 | title = g_titles.get(link_id);
653 | }
654 | }
655 | else {
656 | return whole_match;
657 | }
658 | }
659 |
660 | alt_text = alt_text.replace(/"/g,""");
661 | url = escapeCharacters(url,"*_");
662 | var result = "
" + _RunSpanGamut(m1) + "");});
690 |
691 | text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
692 | function(matchFound,m1){return hashBlock("
" + _RunSpanGamut(m1) + "
");});
693 |
694 | // atx-style headers:
695 | // # Header 1
696 | // ## Header 2
697 | // ## Header 2 with closing hashes ##
698 | // ...
699 | // ###### Header 6
700 | //
701 |
702 | /*
703 | text = text.replace(/
704 | ^(\#{1,6}) // $1 = string of #'s
705 | [ \t]*
706 | (.+?) // $2 = Header text
707 | [ \t]*
708 | \#* // optional closing #'s (not counted)
709 | \n+
710 | /gm, function() {...});
711 | */
712 |
713 | text = text.replace(/^([#=]{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
714 | function(wholeMatch,m1,m2) {
715 | var h_level = m1.length;
716 | return hashBlock("` blocks.
889 | //
890 |
891 | // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
892 | text += "~0";
893 |
894 | //text = text.replace(/(?:\n\n|^)((?:(?:[ ]{2}|\t).*\n+)+)(\n*[ ]{0,1}[^ \t\n]|(?=~0))/g,
895 | text = text.replace(_RE_DoCodeBlocks,
896 | function(wholeMatch,m1,m2) {
897 | var codeblock = m1;
898 | var nextChar = m2;
899 |
900 | codeblock = _EncodeCode( _Outdent(codeblock));
901 | codeblock = _Detab(codeblock);
902 | codeblock = codeblock.replace(/^\n+/g,""); // trim leading newlines
903 | codeblock = codeblock.replace(/\n+$/g,""); // trim trailing whitespace
904 |
905 | codeblock = "
";
906 |
907 | return hashBlock(codeblock) + nextChar;
908 | }
909 | );
910 |
911 | // attacklab: strip sentinel
912 | text = text.replace(/~0/,"");
913 |
914 | return text;
915 | }
916 |
917 | var hashBlock = function(text) {
918 | text = text.replace(/(^\n+|\n+$)/g,"");
919 | return "\n\n~K" + (g_html_blocks.push(text)-1) + "K\n\n";
920 | }
921 |
922 |
923 | var _DoCodeSpans = function(text) {
924 | //
925 | // * Backtick quotes are used for " + codeblock + "\n spans.
926 | //
927 | // * You can use multiple backticks as the delimiters if you want to
928 | // include literal backticks in the code span. So, this input:
929 | //
930 | // Just type ``foo `bar` baz`` at the prompt.
931 | //
932 | // Will translate to:
933 | //
934 | // foo `bar` baz at the prompt.`bar` ...
947 | //
948 |
949 | /*
950 | text = text.replace(/
951 | (^|[^\\]) // Character before opening ` can't be a backslash
952 | (`+) // $2 = Opening run of `
953 | ( // $3 = The code block
954 | [^\r]*?
955 | [^`] // attacklab: work around lack of lookbehind
956 | )
957 | \2 // Matching closer
958 | (?!`)
959 | /gm, function(){...});
960 | */
961 |
962 | text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
963 | function(wholeMatch,m1,m2,m3,m4) {
964 | var c = m3;
965 | c = c.replace(/^([ \t]*)/g,""); // leading whitespace
966 | c = c.replace(/[ \t]*$/g,""); // trailing whitespace
967 | c = _EncodeCode(c);
968 | return m1+""+c+"";
969 | });
970 |
971 | return text;
972 | }
973 |
974 |
975 | var _EncodeCode = function(text) {
976 | //
977 | // Encode/escape certain characters inside Markdown code runs.
978 | // The point is that in code, these characters are literals,
979 | // and lose their special Markdown meanings.
980 | //
981 | // Encode all ampersands; HTML entities are not
982 | // entities within a Markdown code span.
983 | text = text.replace(/&/g,"&");
984 |
985 | // Do the angle bracket song and dance:
986 | text = text.replace(//g,">");
988 |
989 | // Now, escape characters that are magic in Markdown:
990 | text = escapeCharacters(text,"\*_{}[]\\",false);
991 |
992 | // jj the line above breaks this:
993 | //---
994 |
995 | //* Item
996 |
997 | // 1. Subitem
998 |
999 | // special char: *
1000 | //---
1001 |
1002 | return text;
1003 | }
1004 |
1005 |
1006 | var _DoItalicsAndBold = function(text) {
1007 |
1008 | // must go first:
1009 | text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[\*_]*)\1/g,
1010 | "$2");
1011 |
1012 | text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g,
1013 | "$2");
1014 |
1015 | return text;
1016 | }
1017 |
1018 |
1019 | var _DoBlockQuotes = function(text) {
1020 |
1021 | /*
1022 | text = text.replace(/
1023 | ( // Wrap whole match in $1
1024 | (
1025 | ^[ \t]*>[ \t]? // '>' at the start of a line
1026 | .+\n // rest of the first line
1027 | (.+\n)* // subsequent consecutive lines
1028 | \n* // blanks
1029 | )+
1030 | )
1031 | /gm, function(){...});
1032 | */
1033 |
1034 | text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
1035 | function(wholeMatch,m1) {
1036 | var bq = m1;
1037 |
1038 | // attacklab: hack around Konqueror 3.5.4 bug:
1039 | // "----------bug".replace(/^-/g,"") == "bug"
1040 |
1041 | bq = bq.replace(/^[ \t]*>[ \t]?/gm,"~0"); // trim one level of quoting
1042 |
1043 | // attacklab: clean up hack
1044 | bq = bq.replace(/~0/g,"");
1045 |
1046 | bq = bq.replace(/^[ \t]+$/gm,""); // trim whitespace-only lines
1047 | bq = _RunBlockGamut(bq); // recurse
1048 |
1049 | bq = bq.replace(/(^|\n)/g,"$1 ");
1050 | // These leading spaces screw with content, so we need to fix that:
1051 | bq = bq.replace(
1052 | /(\s*
[^\r]+?<\/pre>)/gm,
1053 | function(wholeMatch,m1) {
1054 | var pre = m1;
1055 | // attacklab: hack around Konqueror 3.5.4 bug:
1056 | pre = pre.replace(/^ /mg,"~0");
1057 | pre = pre.replace(/~0/g,"");
1058 | return pre;
1059 | });
1060 |
1061 | return hashBlock("\n" + bq + "\n
");
1062 | });
1063 | return text;
1064 | }
1065 |
1066 |
1067 | var _FormParagraphs = function(text) {
1068 | //
1069 | // Params:
1070 | // $text - string to process with html \n
\n\n \n Class \n Instance \n \n \n \n \n \n ";
253 | foundHelper = helpers.extensions;
254 | stack1 = foundHelper || depth0.extensions;
255 | foundHelper = helpers.doc;
256 | stack2 = foundHelper || depth0.doc;
257 | tmp1 = self.program(1, program1, data);
258 | tmp1.hash = {};
259 | tmp1.fn = tmp1;
260 | tmp1.inverse = self.noop;
261 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
262 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
263 | if(stack1 || stack1 === 0) { buffer += stack1; }
264 | buffer += "\n
\n \n \n \n ";
265 | foundHelper = helpers.includes;
266 | stack1 = foundHelper || depth0.includes;
267 | foundHelper = helpers.doc;
268 | stack2 = foundHelper || depth0.doc;
269 | tmp1 = self.program(3, program3, data);
270 | tmp1.hash = {};
271 | tmp1.fn = tmp1;
272 | tmp1.inverse = self.noop;
273 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
274 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
275 | if(stack1 || stack1 === 0) { buffer += stack1; }
276 | buffer += "\n
\n \n \n \n \n ";
277 | foundHelper = helpers.accessors;
278 | stack1 = foundHelper || depth0.accessors;
279 | foundHelper = helpers.doc;
280 | stack2 = foundHelper || depth0.doc;
281 | tmp1 = self.program(8, program8, data);
282 | tmp1.hash = {};
283 | tmp1.fn = tmp1;
284 | tmp1.inverse = self.noop;
285 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
286 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
287 | if(stack1 || stack1 === 0) { buffer += stack1; }
288 | buffer += "\n
\n \n \n \n ";
289 | foundHelper = helpers.accessors;
290 | stack1 = foundHelper || depth0.accessors;
291 | foundHelper = helpers.doc;
292 | stack2 = foundHelper || depth0.doc;
293 | tmp1 = self.program(11, program11, data);
294 | tmp1.hash = {};
295 | tmp1.fn = tmp1;
296 | tmp1.inverse = self.noop;
297 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
298 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
299 | if(stack1 || stack1 === 0) { buffer += stack1; }
300 | buffer += "\n
\n \n \n\n \n \n ";
301 | foundHelper = helpers.methods;
302 | stack1 = foundHelper || depth0.methods;
303 | foundHelper = helpers.doc;
304 | stack2 = foundHelper || depth0.doc;
305 | tmp1 = self.program(14, program14, data);
306 | tmp1.hash = {};
307 | tmp1.fn = tmp1;
308 | tmp1.inverse = self.noop;
309 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
310 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
311 | if(stack1 || stack1 === 0) { buffer += stack1; }
312 | buffer += "\n
\n \n \n \n ";
313 | foundHelper = helpers.methods;
314 | stack1 = foundHelper || depth0.methods;
315 | foundHelper = helpers.doc;
316 | stack2 = foundHelper || depth0.doc;
317 | tmp1 = self.program(17, program17, data);
318 | tmp1.hash = {};
319 | tmp1.fn = tmp1;
320 | tmp1.inverse = self.noop;
321 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
322 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
323 | if(stack1 || stack1 === 0) { buffer += stack1; }
324 | buffer += "\n
\n \n
\n";
349 | return buffer;});
350 | templates['info_attribute'] = template(function (Handlebars,depth0,helpers,partials,data) {
351 | helpers = helpers || Handlebars.helpers;
352 | var buffer = "", stack1, foundHelper, self=this, functionType="function", helperMissing=helpers.helperMissing, undef=void 0, escapeExpression=this.escapeExpression;
353 |
354 |
355 | buffer += "\n \n Constants \n \n \n \n \n \n ";
325 | foundHelper = helpers.constants;
326 | stack1 = foundHelper || depth0.constants;
327 | foundHelper = helpers.doc;
328 | stack2 = foundHelper || depth0.doc;
329 | tmp1 = self.program(20, program20, data);
330 | tmp1.hash = {};
331 | tmp1.fn = tmp1;
332 | tmp1.inverse = self.noop;
333 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
334 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
335 | if(stack1 || stack1 === 0) { buffer += stack1; }
336 | buffer += "\n
\n \n \n In Scripts \n \n \n\n \n \n ";
337 | foundHelper = helpers.files;
338 | stack1 = foundHelper || depth0.files;
339 | foundHelper = helpers.doc;
340 | stack2 = foundHelper || depth0.doc;
341 | tmp1 = self.program(22, program22, data);
342 | tmp1.hash = {};
343 | tmp1.fn = tmp1;
344 | tmp1.inverse = self.noop;
345 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
346 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
347 | if(stack1 || stack1 === 0) { buffer += stack1; }
348 | buffer += "\n
\n ";
366 | foundHelper = helpers['!'];
367 | stack1 = foundHelper || depth0['!'];
368 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
369 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
370 | buffer += escapeExpression(stack1) + " (";
371 | foundHelper = helpers.rw;
372 | stack1 = foundHelper || depth0.rw;
373 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
374 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "rw", { hash: {} }); }
375 | buffer += escapeExpression(stack1) + ")
\n ";
376 | foundHelper = helpers.namespace;
377 | stack1 = foundHelper || depth0.namespace;
378 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
379 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "namespace", { hash: {} }); }
380 | buffer += escapeExpression(stack1) + "#";
381 | foundHelper = helpers.name;
382 | stack1 = foundHelper || depth0.name;
383 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
384 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
385 | buffer += escapeExpression(stack1) + "
\n \n
";
421 | foundHelper = helpers['!'];
422 | stack1 = foundHelper || depth0['!'];
423 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
424 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
425 | buffer += escapeExpression(stack1) + "
\n \n ";
426 | foundHelper = helpers.namespace;
427 | stack1 = foundHelper || depth0.namespace;
428 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
429 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "namespace", { hash: {} }); }
430 | buffer += escapeExpression(stack1) + "::";
431 | foundHelper = helpers.name;
432 | stack1 = foundHelper || depth0.name;
433 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
434 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
435 | buffer += escapeExpression(stack1) + "\n < ";
436 | foundHelper = helpers.superclass;
437 | stack1 = foundHelper || depth0.superclass;
438 | stack2 = helpers['if'];
439 | tmp1 = self.program(1, program1, data);
440 | tmp1.hash = {};
441 | tmp1.fn = tmp1;
442 | tmp1.inverse = self.program(3, program3, data);
443 | stack1 = stack2.call(depth0, stack1, tmp1);
444 | if(stack1 || stack1 === 0) { buffer += stack1; }
445 | buffer += "\n
\n \n
\n";
472 | foundHelper = helpers['!'];
473 | stack1 = foundHelper || depth0['!'];
474 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
475 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
476 | buffer += escapeExpression(stack1) + "
\n ";
477 | foundHelper = helpers.namespace;
478 | stack1 = foundHelper || depth0.namespace;
479 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
480 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "namespace", { hash: {} }); }
481 | buffer += escapeExpression(stack1) + ".";
482 | foundHelper = helpers.name;
483 | stack1 = foundHelper || depth0.name;
484 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
485 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
486 | buffer += escapeExpression(stack1) + "
\n \n
";
509 | foundHelper = helpers['!'];
510 | stack1 = foundHelper || depth0['!'];
511 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
512 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
513 | buffer += escapeExpression(stack1) + "
\n \n ";
514 | foundHelper = helpers.namespace;
515 | stack1 = foundHelper || depth0.namespace;
516 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
517 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "namespace", { hash: {} }); }
518 | buffer += escapeExpression(stack1) + "::";
519 | foundHelper = helpers.name;
520 | stack1 = foundHelper || depth0.name;
521 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
522 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
523 | buffer += escapeExpression(stack1) + "\n \n
\n \n
\n";
562 | foundHelper = helpers['!'];
563 | stack1 = foundHelper || depth0['!'];
564 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
565 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
566 | buffer += escapeExpression(stack1) + "
\n ";
567 | foundHelper = helpers.path;
568 | stack1 = foundHelper || depth0.path;
569 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
570 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "path", { hash: {} }); }
571 | buffer += escapeExpression(stack1) + "
\n ";
577 | foundHelper = helpers.modified;
578 | stack1 = foundHelper || depth0.modified;
579 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
580 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "modified", { hash: {} }); }
581 | buffer += escapeExpression(stack1) + "
\n ";
609 | foundHelper = helpers['!'];
610 | stack1 = foundHelper || depth0['!'];
611 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
612 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
613 | buffer += escapeExpression(stack1) + "
\n ";
614 | foundHelper = helpers.namespace;
615 | stack1 = foundHelper || depth0.namespace;
616 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
617 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "namespace", { hash: {} }); }
618 | buffer += escapeExpression(stack1) + "#";
619 | foundHelper = helpers.name;
620 | stack1 = foundHelper || depth0.name;
621 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
622 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
623 | buffer += escapeExpression(stack1) + "
\n \n
";
646 | foundHelper = helpers['!'];
647 | stack1 = foundHelper || depth0['!'];
648 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
649 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
650 | buffer += escapeExpression(stack1) + "
\n \n ";
651 | foundHelper = helpers.namespace;
652 | stack1 = foundHelper || depth0.namespace;
653 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
654 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "namespace", { hash: {} }); }
655 | buffer += escapeExpression(stack1) + "::";
656 | foundHelper = helpers.name;
657 | stack1 = foundHelper || depth0.name;
658 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
659 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
660 | buffer += escapeExpression(stack1) + "\n \n
\n \n
\n
\n ";
695 | return buffer;}
696 |
697 | buffer += "";
690 | foundHelper = helpers.source;
691 | stack1 = foundHelper || depth0.source;
692 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
693 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "source", { hash: {} }); }
694 | buffer += escapeExpression(stack1) + "";
708 | foundHelper = helpers['!'];
709 | stack1 = foundHelper || depth0['!'];
710 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
711 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "!", { hash: {} }); }
712 | buffer += escapeExpression(stack1) + "
\n ";
713 | foundHelper = helpers.path;
714 | stack1 = foundHelper || depth0.path;
715 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
716 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "path", { hash: {} }); }
717 | buffer += escapeExpression(stack1) + "
\n ";
718 | foundHelper = helpers.modified;
719 | stack1 = foundHelper || depth0.modified;
720 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
721 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "modified", { hash: {} }); }
722 | buffer += escapeExpression(stack1) + "
\n ";
907 | foundHelper = helpers.title;
908 | stack1 = foundHelper || depth0.title;
909 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
910 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "title", { hash: {} }); }
911 | buffer += escapeExpression(stack1) + "
\n";
912 | foundHelper = helpers.summary;
913 | stack1 = foundHelper || depth0.summary;
914 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
915 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "summary", { hash: {} }); }
916 | buffer += escapeExpression(stack1) + "
\n\n";
917 | return buffer;});
918 | })();
--------------------------------------------------------------------------------