\n
Alphabetical Index
\n\n ";
200 | foundHelper = helpers.documents;
201 | stack1 = foundHelper || depth0.documents;
202 | stack1 = (stack1 === null || stack1 === undefined || stack1 === false ? stack1 : stack1.length);
203 | stack2 = helpers['if'];
204 | tmp1 = self.program(1, program1, data);
205 | tmp1.hash = {};
206 | tmp1.fn = tmp1;
207 | tmp1.inverse = self.noop;
208 | stack1 = stack2.call(depth0, stack1, tmp1);
209 | if(stack1 || stack1 === 0) { buffer += stack1; }
210 | buffer += "\n\n \n
\n
Class Index
\n
\n ";
211 | foundHelper = helpers.modules;
212 | stack1 = foundHelper || depth0.modules;
213 | tmp1 = self.program(4, program4, data);
214 | tmp1.hash = {};
215 | tmp1.fn = tmp1;
216 | tmp1.inverse = self.noop;
217 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
218 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
219 | if(stack1 || stack1 === 0) { buffer += stack1; }
220 | buffer += "\n
\n \n\n \n
\n
Method Index
\n
\n ";
221 | foundHelper = helpers.methods;
222 | stack1 = foundHelper || depth0.methods;
223 | tmp1 = self.program(6, program6, data);
224 | tmp1.hash = {};
225 | tmp1.fn = tmp1;
226 | tmp1.inverse = self.noop;
227 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
228 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
229 | if(stack1 || stack1 === 0) { buffer += stack1; }
230 | buffer += "\n
\n
\n
\n\n";
231 | return buffer;});
232 | templates['method'] = template(function (Handlebars,depth0,helpers,partials,data) {
233 | helpers = helpers || Handlebars.helpers;
234 | var buffer = "", stack1, stack2, foundHelper, tmp1, self=this, functionType="function", helperMissing=helpers.helperMissing, undef=void 0, escapeExpression=this.escapeExpression, blockHelperMissing=helpers.blockHelperMissing;
235 |
236 | function program1(depth0,data) {
237 |
238 |
239 | return "method-alias";}
240 |
241 | function program3(depth0,data) {
242 |
243 | var buffer = "", stack1;
244 | buffer += "\n
";
245 | foundHelper = helpers.signature;
246 | stack1 = foundHelper || depth0.signature;
247 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
248 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "signature", { hash: {} }); }
249 | buffer += escapeExpression(stack1) + "\n ";
250 | return buffer;}
251 |
252 | function program5(depth0,data) {
253 |
254 | var buffer = "", stack1, stack2, stack3;
255 | buffer += "\n ";
256 | foundHelper = helpers.format;
257 | stack1 = foundHelper || depth0.format;
258 | foundHelper = helpers.comment;
259 | stack2 = foundHelper || depth0.comment;
260 | foundHelper = helpers.markup;
261 | stack3 = foundHelper || depth0.markup;
262 | if(typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, { hash: {} }); }
263 | else if(stack3=== undef) { stack1 = helperMissing.call(depth0, "markup", stack2, stack1, { hash: {} }); }
264 | else { stack1 = stack3; }
265 | buffer += escapeExpression(stack1) + "\n ";
266 | return buffer;}
267 |
268 | function program7(depth0,data) {
269 |
270 |
271 | return "\n
\n ";}
272 |
273 | function program9(depth0,data) {
274 |
275 | var buffer = "", stack1;
276 | buffer += "\n
\n Also aliased as:\n ";
277 | foundHelper = helpers.aliases;
278 | stack1 = foundHelper || depth0.aliases;
279 | tmp1 = self.program(10, program10, data);
280 | tmp1.hash = {};
281 | tmp1.fn = tmp1;
282 | tmp1.inverse = self.noop;
283 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
284 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
285 | if(stack1 || stack1 === 0) { buffer += stack1; }
286 | buffer += "\n
\n ";
287 | return buffer;}
288 | function program10(depth0,data) {
289 |
290 | var buffer = "", stack1, stack2;
291 | buffer += "\n
";
300 | foundHelper = helpers.name;
301 | stack1 = foundHelper || depth0.name;
302 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
303 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
304 | buffer += escapeExpression(stack1) + "\n ";
305 | return buffer;}
306 |
307 | buffer += "\n\n
\n
\n\n
\n \n ";
333 | foundHelper = helpers.interfaces;
334 | stack1 = foundHelper || depth0.interfaces;
335 | tmp1 = self.program(3, program3, data);
336 | tmp1.hash = {};
337 | tmp1.fn = tmp1;
338 | tmp1.inverse = self.noop;
339 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
340 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
341 | if(stack1 || stack1 === 0) { buffer += stack1; }
342 | buffer += "\n click to toggle source\n
\n\n
\n ";
343 | foundHelper = helpers.comment;
344 | stack1 = foundHelper || depth0.comment;
345 | stack2 = helpers['if'];
346 | tmp1 = self.program(5, program5, data);
347 | tmp1.hash = {};
348 | tmp1.fn = tmp1;
349 | tmp1.inverse = self.program(7, program7, data);
350 | stack1 = stack2.call(depth0, stack1, tmp1);
351 | if(stack1 || stack1 === 0) { buffer += stack1; }
352 | buffer += "\n\n
\n
";
358 | foundHelper = helpers.source;
359 | stack1 = foundHelper || depth0.source;
360 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
361 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "source", { hash: {} }); }
362 | buffer += escapeExpression(stack1) + "\n
\n
\n\n ";
363 | foundHelper = helpers.aliases;
364 | stack1 = foundHelper || depth0.aliases;
365 | stack1 = (stack1 === null || stack1 === undefined || stack1 === false ? stack1 : stack1.length);
366 | stack2 = helpers['if'];
367 | tmp1 = self.program(9, program9, data);
368 | tmp1.hash = {};
369 | tmp1.fn = tmp1;
370 | tmp1.inverse = self.noop;
371 | stack1 = stack2.call(depth0, stack1, tmp1);
372 | if(stack1 || stack1 === 0) { buffer += stack1; }
373 | buffer += "\n
\n\n";
374 | return buffer;});
375 | templates['module'] = template(function (Handlebars,depth0,helpers,partials,data) {
376 | helpers = helpers || Handlebars.helpers; partials = partials || Handlebars.partials;
377 | var buffer = "", stack1, stack2, stack3, foundHelper, tmp1, self=this, functionType="function", helperMissing=helpers.helperMissing, undef=void 0, escapeExpression=this.escapeExpression, blockHelperMissing=helpers.blockHelperMissing;
378 |
379 | function program1(depth0,data) {
380 |
381 | var buffer = "", stack1;
382 | buffer += "\n
";
383 | foundHelper = helpers.name;
384 | stack1 = foundHelper || depth0.name;
385 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
386 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
387 | buffer += escapeExpression(stack1) + "
\n ";
388 | return buffer;}
389 |
390 | function program3(depth0,data) {
391 |
392 | var buffer = "", stack1, stack2;
393 | buffer += "\n
\n \n
\n ";
394 | foundHelper = helpers.superclass;
395 | stack1 = foundHelper || depth0.superclass;
396 | stack2 = helpers['if'];
397 | tmp1 = self.program(4, program4, data);
398 | tmp1.hash = {};
399 | tmp1.fn = tmp1;
400 | tmp1.inverse = self.noop;
401 | stack1 = stack2.call(depth0, stack1, tmp1);
402 | if(stack1 || stack1 === 0) { buffer += stack1; }
403 | buffer += "\n
\n
\n ";
404 | return buffer;}
405 | function program4(depth0,data) {
406 |
407 | var buffer = "", stack1, stack2;
408 | buffer += "\n
\n \n ";
417 | foundHelper = helpers.superclass;
418 | stack1 = foundHelper || depth0.superclass;
419 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
420 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "superclass", { hash: {} }); }
421 | buffer += escapeExpression(stack1) + "\n \n ";
422 | return buffer;}
423 |
424 | function program6(depth0,data) {
425 |
426 | var buffer = "", stack1, stack2;
427 | buffer += "\n
\n \n
\n ";
428 | foundHelper = helpers.modules;
429 | stack1 = foundHelper || depth0.modules;
430 | foundHelper = helpers.doc;
431 | stack2 = foundHelper || depth0.doc;
432 | tmp1 = self.program(7, program7, data);
433 | tmp1.hash = {};
434 | tmp1.fn = tmp1;
435 | tmp1.inverse = self.noop;
436 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
437 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
438 | if(stack1 || stack1 === 0) { buffer += stack1; }
439 | buffer += "\n\n ";
440 | foundHelper = helpers.classes;
441 | stack1 = foundHelper || depth0.classes;
442 | foundHelper = helpers.doc;
443 | stack2 = foundHelper || depth0.doc;
444 | tmp1 = self.program(9, program9, data);
445 | tmp1.hash = {};
446 | tmp1.fn = tmp1;
447 | tmp1.inverse = self.noop;
448 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
449 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
450 | if(stack1 || stack1 === 0) { buffer += stack1; }
451 | buffer += "\n
\n
\n ";
452 | return buffer;}
453 | function program7(depth0,data) {
454 |
455 | var buffer = "", stack1;
456 | buffer += "\n
";
467 | foundHelper = helpers.name;
468 | stack1 = foundHelper || depth0.name;
469 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
470 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
471 | buffer += escapeExpression(stack1) + "\n ";
472 | return buffer;}
473 |
474 | function program9(depth0,data) {
475 |
476 | var buffer = "", stack1;
477 | buffer += "\n
";
488 | foundHelper = helpers.name;
489 | stack1 = foundHelper || depth0.name;
490 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
491 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
492 | buffer += escapeExpression(stack1) + "\n ";
493 | return buffer;}
494 |
495 | function program11(depth0,data) {
496 |
497 | var buffer = "", stack1, stack2;
498 | buffer += "\n
\n \n
\n ";
499 | foundHelper = helpers.includes;
500 | stack1 = foundHelper || depth0.includes;
501 | foundHelper = helpers.doc;
502 | stack2 = foundHelper || depth0.doc;
503 | tmp1 = self.program(12, program12, data);
504 | tmp1.hash = {};
505 | tmp1.fn = tmp1;
506 | tmp1.inverse = self.noop;
507 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
508 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
509 | if(stack1 || stack1 === 0) { buffer += stack1; }
510 | buffer += "\n
\n
\n ";
511 | return buffer;}
512 | function program12(depth0,data) {
513 |
514 | var buffer = "", stack1;
515 | buffer += "\n
";
521 | foundHelper = helpers.name;
522 | stack1 = foundHelper || depth0.name;
523 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
524 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
525 | buffer += escapeExpression(stack1) + "\n ";
526 | return buffer;}
527 |
528 | function program14(depth0,data) {
529 |
530 | var buffer = "", stack1, stack2;
531 | buffer += "\n
\n \n
\n ";
532 | foundHelper = helpers.extensions;
533 | stack1 = foundHelper || depth0.extensions;
534 | foundHelper = helpers.doc;
535 | stack2 = foundHelper || depth0.doc;
536 | tmp1 = self.program(15, program15, data);
537 | tmp1.hash = {};
538 | tmp1.fn = tmp1;
539 | tmp1.inverse = self.noop;
540 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
541 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
542 | if(stack1 || stack1 === 0) { buffer += stack1; }
543 | buffer += "\n
\n
\n ";
544 | return buffer;}
545 | function program15(depth0,data) {
546 |
547 | var buffer = "", stack1;
548 | buffer += "\n
";
554 | foundHelper = helpers.name;
555 | stack1 = foundHelper || depth0.name;
556 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
557 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
558 | buffer += escapeExpression(stack1) + "\n ";
559 | return buffer;}
560 |
561 | function program17(depth0,data) {
562 |
563 | var buffer = "", stack1, stack2;
564 | buffer += "\n
\n \n
\n ";
565 | foundHelper = helpers.constants;
566 | stack1 = foundHelper || depth0.constants;
567 | foundHelper = helpers.doc;
568 | stack2 = foundHelper || depth0.doc;
569 | tmp1 = self.program(18, program18, data);
570 | tmp1.hash = {};
571 | tmp1.fn = tmp1;
572 | tmp1.inverse = self.noop;
573 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
574 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
575 | if(stack1 || stack1 === 0) { buffer += stack1; }
576 | buffer += "\n
\n
\n ";
577 | return buffer;}
578 | function program18(depth0,data) {
579 |
580 | var buffer = "", stack1;
581 | buffer += "\n
";
592 | foundHelper = helpers.name;
593 | stack1 = foundHelper || depth0.name;
594 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
595 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
596 | buffer += escapeExpression(stack1) + "\n
";
597 | foundHelper = helpers.comment;
598 | stack1 = foundHelper || depth0.comment;
599 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
600 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "comment", { hash: {} }); }
601 | buffer += escapeExpression(stack1) + "\n ";
602 | return buffer;}
603 |
604 | function program20(depth0,data) {
605 |
606 | var buffer = "", stack1, stack2;
607 | buffer += "\n
\n \n\n ";
608 | foundHelper = helpers.accessors;
609 | stack1 = foundHelper || depth0.accessors;
610 | stack2 = helpers.each;
611 | tmp1 = self.program(21, program21, data);
612 | tmp1.hash = {};
613 | tmp1.fn = tmp1;
614 | tmp1.inverse = self.noop;
615 | stack1 = stack2.call(depth0, stack1, tmp1);
616 | if(stack1 || stack1 === 0) { buffer += stack1; }
617 | buffer += "\n
\n ";
618 | return buffer;}
619 | function program21(depth0,data) {
620 |
621 | var buffer = "", stack1;
622 | buffer += "\n ";
623 | foundHelper = helpers.reader;
624 | stack1 = foundHelper || depth0.reader;
625 | tmp1 = self.program(22, program22, data);
626 | tmp1.hash = {};
627 | tmp1.fn = tmp1;
628 | tmp1.inverse = self.noop;
629 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
630 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
631 | if(stack1 || stack1 === 0) { buffer += stack1; }
632 | buffer += "\n\n ";
633 | foundHelper = helpers.writer;
634 | stack1 = foundHelper || depth0.writer;
635 | tmp1 = self.program(24, program24, data);
636 | tmp1.hash = {};
637 | tmp1.fn = tmp1;
638 | tmp1.inverse = self.noop;
639 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
640 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
641 | if(stack1 || stack1 === 0) { buffer += stack1; }
642 | buffer += "\n ";
643 | return buffer;}
644 | function program22(depth0,data) {
645 |
646 | var buffer = "", stack1;
647 | buffer += "\n
\n
\n
\n
\n
";
668 | foundHelper = helpers.comment;
669 | stack1 = foundHelper || depth0.comment;
670 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
671 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "comment", { hash: {} }); }
672 | buffer += escapeExpression(stack1) + "
\n
\n
\n ";
673 | return buffer;}
674 |
675 | function program24(depth0,data) {
676 |
677 | var buffer = "", stack1;
678 | buffer += "\n
\n
\n
\n
\n
";
699 | foundHelper = helpers.comment;
700 | stack1 = foundHelper || depth0.comment;
701 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
702 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "comment", { hash: {} }); }
703 | buffer += escapeExpression(stack1) + "
\n
\n
\n ";
704 | return buffer;}
705 |
706 | function program26(depth0,data) {
707 |
708 | var buffer = "", stack1, stack2, stack3;
709 | buffer += "\n
\n ";
710 | stack1 = "public";
711 | stack2 = "class";
712 | foundHelper = helpers.if_methods_by;
713 | stack3 = foundHelper || depth0.if_methods_by;
714 | tmp1 = self.program(27, program27, data);
715 | tmp1.hash = {};
716 | tmp1.fn = tmp1;
717 | tmp1.inverse = self.noop;
718 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
719 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
720 | if(stack1 || stack1 === 0) { buffer += stack1; }
721 | buffer += "\n\n ";
722 | stack1 = "private";
723 | stack2 = "class";
724 | foundHelper = helpers.if_methods_by;
725 | stack3 = foundHelper || depth0.if_methods_by;
726 | tmp1 = self.program(30, program30, data);
727 | tmp1.hash = {};
728 | tmp1.fn = tmp1;
729 | tmp1.inverse = self.noop;
730 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
731 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
732 | if(stack1 || stack1 === 0) { buffer += stack1; }
733 | buffer += "\n\n ";
734 | stack1 = "protected";
735 | stack2 = "class";
736 | foundHelper = helpers.if_methods_by;
737 | stack3 = foundHelper || depth0.if_methods_by;
738 | tmp1 = self.program(33, program33, data);
739 | tmp1.hash = {};
740 | tmp1.fn = tmp1;
741 | tmp1.inverse = self.noop;
742 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
743 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
744 | if(stack1 || stack1 === 0) { buffer += stack1; }
745 | buffer += "\n\n ";
746 | stack1 = "public";
747 | stack2 = "instance";
748 | foundHelper = helpers.if_methods_by;
749 | stack3 = foundHelper || depth0.if_methods_by;
750 | tmp1 = self.program(36, program36, data);
751 | tmp1.hash = {};
752 | tmp1.fn = tmp1;
753 | tmp1.inverse = self.noop;
754 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
755 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
756 | if(stack1 || stack1 === 0) { buffer += stack1; }
757 | buffer += "\n\n ";
758 | stack1 = "private";
759 | stack2 = "instance";
760 | foundHelper = helpers.if_methods_by;
761 | stack3 = foundHelper || depth0.if_methods_by;
762 | tmp1 = self.program(39, program39, data);
763 | tmp1.hash = {};
764 | tmp1.fn = tmp1;
765 | tmp1.inverse = self.noop;
766 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
767 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
768 | if(stack1 || stack1 === 0) { buffer += stack1; }
769 | buffer += "\n\n ";
770 | stack1 = "protected";
771 | stack2 = "instance";
772 | foundHelper = helpers.if_methods_by;
773 | stack3 = foundHelper || depth0.if_methods_by;
774 | tmp1 = self.program(42, program42, data);
775 | tmp1.hash = {};
776 | tmp1.fn = tmp1;
777 | tmp1.inverse = self.noop;
778 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
779 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
780 | if(stack1 || stack1 === 0) { buffer += stack1; }
781 | buffer += "\n
\n ";
782 | return buffer;}
783 | function program27(depth0,data) {
784 |
785 | var buffer = "", stack1, stack2, stack3;
786 | buffer += "\n
\n \n ";
787 | stack1 = "public";
788 | stack2 = "class";
789 | foundHelper = helpers.methods_by;
790 | stack3 = foundHelper || depth0.methods_by;
791 | tmp1 = self.program(28, program28, data);
792 | tmp1.hash = {};
793 | tmp1.fn = tmp1;
794 | tmp1.inverse = self.noop;
795 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
796 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
797 | if(stack1 || stack1 === 0) { buffer += stack1; }
798 | buffer += "\n
\n ";
799 | return buffer;}
800 | function program28(depth0,data) {
801 |
802 | var buffer = "", stack1;
803 | buffer += "\n ";
804 | stack1 = depth0;
805 | stack1 = self.invokePartial(partials.method, 'method', stack1, helpers, partials);;
806 | if(stack1 || stack1 === 0) { buffer += stack1; }
807 | buffer += "\n ";
808 | return buffer;}
809 |
810 | function program30(depth0,data) {
811 |
812 | var buffer = "", stack1, stack2, stack3;
813 | buffer += "\n
\n \n ";
814 | stack1 = "private";
815 | stack2 = "class";
816 | foundHelper = helpers.methods_by;
817 | stack3 = foundHelper || depth0.methods_by;
818 | tmp1 = self.program(31, program31, data);
819 | tmp1.hash = {};
820 | tmp1.fn = tmp1;
821 | tmp1.inverse = self.noop;
822 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
823 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
824 | if(stack1 || stack1 === 0) { buffer += stack1; }
825 | buffer += "\n
\n ";
826 | return buffer;}
827 | function program31(depth0,data) {
828 |
829 | var buffer = "", stack1;
830 | buffer += "\n ";
831 | stack1 = depth0;
832 | stack1 = self.invokePartial(partials.method, 'method', stack1, helpers, partials);;
833 | if(stack1 || stack1 === 0) { buffer += stack1; }
834 | buffer += "\n ";
835 | return buffer;}
836 |
837 | function program33(depth0,data) {
838 |
839 | var buffer = "", stack1, stack2, stack3;
840 | buffer += "\n
\n \n ";
841 | stack1 = "protected";
842 | stack2 = "class";
843 | foundHelper = helpers.methods_by;
844 | stack3 = foundHelper || depth0.methods_by;
845 | tmp1 = self.program(34, program34, data);
846 | tmp1.hash = {};
847 | tmp1.fn = tmp1;
848 | tmp1.inverse = self.noop;
849 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
850 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
851 | if(stack1 || stack1 === 0) { buffer += stack1; }
852 | buffer += "\n
\n ";
853 | return buffer;}
854 | function program34(depth0,data) {
855 |
856 | var buffer = "", stack1;
857 | buffer += "\n ";
858 | stack1 = depth0;
859 | stack1 = self.invokePartial(partials.method, 'method', stack1, helpers, partials);;
860 | if(stack1 || stack1 === 0) { buffer += stack1; }
861 | buffer += "\n ";
862 | return buffer;}
863 |
864 | function program36(depth0,data) {
865 |
866 | var buffer = "", stack1, stack2, stack3;
867 | buffer += "\n
\n \n ";
868 | stack1 = "public";
869 | stack2 = "instance";
870 | foundHelper = helpers.methods_by;
871 | stack3 = foundHelper || depth0.methods_by;
872 | tmp1 = self.program(37, program37, data);
873 | tmp1.hash = {};
874 | tmp1.fn = tmp1;
875 | tmp1.inverse = self.noop;
876 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
877 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
878 | if(stack1 || stack1 === 0) { buffer += stack1; }
879 | buffer += "\n
\n ";
880 | return buffer;}
881 | function program37(depth0,data) {
882 |
883 | var buffer = "", stack1;
884 | buffer += "\n ";
885 | stack1 = depth0;
886 | stack1 = self.invokePartial(partials.method, 'method', stack1, helpers, partials);;
887 | if(stack1 || stack1 === 0) { buffer += stack1; }
888 | buffer += "\n ";
889 | return buffer;}
890 |
891 | function program39(depth0,data) {
892 |
893 | var buffer = "", stack1, stack2, stack3;
894 | buffer += "\n
\n \n ";
895 | stack1 = "private";
896 | stack2 = "instance";
897 | foundHelper = helpers.methods_by;
898 | stack3 = foundHelper || depth0.methods_by;
899 | tmp1 = self.program(40, program40, data);
900 | tmp1.hash = {};
901 | tmp1.fn = tmp1;
902 | tmp1.inverse = self.noop;
903 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
904 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
905 | if(stack1 || stack1 === 0) { buffer += stack1; }
906 | buffer += "\n
\n ";
907 | return buffer;}
908 | function program40(depth0,data) {
909 |
910 | var buffer = "", stack1;
911 | buffer += "\n ";
912 | stack1 = depth0;
913 | stack1 = self.invokePartial(partials.method, 'method', stack1, helpers, partials);;
914 | if(stack1 || stack1 === 0) { buffer += stack1; }
915 | buffer += "\n ";
916 | return buffer;}
917 |
918 | function program42(depth0,data) {
919 |
920 | var buffer = "", stack1, stack2, stack3;
921 | buffer += "\n
\n \n ";
922 | stack1 = "protected";
923 | stack2 = "instance";
924 | foundHelper = helpers.methods_by;
925 | stack3 = foundHelper || depth0.methods_by;
926 | tmp1 = self.program(43, program43, data);
927 | tmp1.hash = {};
928 | tmp1.fn = tmp1;
929 | tmp1.inverse = self.noop;
930 | if(foundHelper && typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, tmp1); }
931 | else { stack1 = blockHelperMissing.call(depth0, stack3, stack2, stack1, tmp1); }
932 | if(stack1 || stack1 === 0) { buffer += stack1; }
933 | buffer += "\n
\n ";
934 | return buffer;}
935 | function program43(depth0,data) {
936 |
937 | var buffer = "", stack1;
938 | buffer += "\n ";
939 | stack1 = depth0;
940 | stack1 = self.invokePartial(partials.method, 'method', stack1, helpers, partials);;
941 | if(stack1 || stack1 === 0) { buffer += stack1; }
942 | buffer += "\n ";
943 | return buffer;}
944 |
945 | function program45(depth0,data) {
946 |
947 | var buffer = "", stack1, stack2;
948 | buffer += "\n
\n ";
949 | foundHelper = helpers.uri;
950 | stack1 = foundHelper || depth0.uri;
951 | stack2 = helpers['if'];
952 | tmp1 = self.program(46, program46, data);
953 | tmp1.hash = {};
954 | tmp1.fn = tmp1;
955 | tmp1.inverse = self.program(48, program48, data);
956 | stack1 = stack2.call(depth0, stack1, tmp1);
957 | if(stack1 || stack1 === 0) { buffer += stack1; }
958 | buffer += "\n \n ";
959 | return buffer;}
960 | function program46(depth0,data) {
961 |
962 | var buffer = "", stack1;
963 | buffer += "\n
\n ";
974 | foundHelper = helpers.path;
975 | stack1 = foundHelper || depth0.path;
976 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
977 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "path", { hash: {} }); }
978 | buffer += escapeExpression(stack1) + "\n \n ";
979 | return buffer;}
980 |
981 | function program48(depth0,data) {
982 |
983 | var buffer = "", stack1;
984 | buffer += "\n
\n ";
995 | foundHelper = helpers.path;
996 | stack1 = foundHelper || depth0.path;
997 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
998 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "path", { hash: {} }); }
999 | buffer += escapeExpression(stack1) + "\n \n ";
1000 | return buffer;}
1001 |
1002 | buffer += "\n\n
\n\n
\n ";
1003 | foundHelper = helpers.unless_header;
1004 | stack1 = foundHelper || depth0.unless_header;
1005 | tmp1 = self.program(1, program1, data);
1006 | tmp1.hash = {};
1007 | tmp1.fn = tmp1;
1008 | tmp1.inverse = self.noop;
1009 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
1010 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
1011 | if(stack1 || stack1 === 0) { buffer += stack1; }
1012 | buffer += "\n ";
1013 | foundHelper = helpers.format;
1014 | stack1 = foundHelper || depth0.format;
1015 | foundHelper = helpers.comment;
1016 | stack2 = foundHelper || depth0.comment;
1017 | foundHelper = helpers.markup;
1018 | stack3 = foundHelper || depth0.markup;
1019 | if(typeof stack3 === functionType) { stack1 = stack3.call(depth0, stack2, stack1, { hash: {} }); }
1020 | else if(stack3=== undef) { stack1 = helperMissing.call(depth0, "markup", stack2, stack1, { hash: {} }); }
1021 | else { stack1 = stack3; }
1022 | buffer += escapeExpression(stack1) + "\n
\n\n \n ";
1023 | foundHelper = helpers.if_class;
1024 | stack1 = foundHelper || depth0.if_class;
1025 | tmp1 = self.program(3, program3, data);
1026 | tmp1.hash = {};
1027 | tmp1.fn = tmp1;
1028 | tmp1.inverse = self.noop;
1029 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
1030 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
1031 | if(stack1 || stack1 === 0) { buffer += stack1; }
1032 | buffer += "\n\n \n ";
1033 | foundHelper = helpers.if_namespaces;
1034 | stack1 = foundHelper || depth0.if_namespaces;
1035 | tmp1 = self.program(6, program6, data);
1036 | tmp1.hash = {};
1037 | tmp1.fn = tmp1;
1038 | tmp1.inverse = self.noop;
1039 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
1040 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
1041 | if(stack1 || stack1 === 0) { buffer += stack1; }
1042 | buffer += "\n\n \n ";
1043 | foundHelper = helpers.includes;
1044 | stack1 = foundHelper || depth0.includes;
1045 | stack1 = (stack1 === null || stack1 === undefined || stack1 === false ? stack1 : stack1.length);
1046 | stack2 = helpers['if'];
1047 | tmp1 = self.program(11, program11, data);
1048 | tmp1.hash = {};
1049 | tmp1.fn = tmp1;
1050 | tmp1.inverse = self.noop;
1051 | stack1 = stack2.call(depth0, stack1, tmp1);
1052 | if(stack1 || stack1 === 0) { buffer += stack1; }
1053 | buffer += "\n\n \n ";
1054 | foundHelper = helpers.extensions;
1055 | stack1 = foundHelper || depth0.extensions;
1056 | stack1 = (stack1 === null || stack1 === undefined || stack1 === false ? stack1 : stack1.length);
1057 | stack2 = helpers['if'];
1058 | tmp1 = self.program(14, program14, data);
1059 | tmp1.hash = {};
1060 | tmp1.fn = tmp1;
1061 | tmp1.inverse = self.noop;
1062 | stack1 = stack2.call(depth0, stack1, tmp1);
1063 | if(stack1 || stack1 === 0) { buffer += stack1; }
1064 | buffer += "\n\n \n ";
1065 | foundHelper = helpers.constants;
1066 | stack1 = foundHelper || depth0.constants;
1067 | stack1 = (stack1 === null || stack1 === undefined || stack1 === false ? stack1 : stack1.length);
1068 | stack2 = helpers['if'];
1069 | tmp1 = self.program(17, program17, data);
1070 | tmp1.hash = {};
1071 | tmp1.fn = tmp1;
1072 | tmp1.inverse = self.noop;
1073 | stack1 = stack2.call(depth0, stack1, tmp1);
1074 | if(stack1 || stack1 === 0) { buffer += stack1; }
1075 | buffer += "\n\n \n ";
1076 | foundHelper = helpers.accessors;
1077 | stack1 = foundHelper || depth0.accessors;
1078 | stack1 = (stack1 === null || stack1 === undefined || stack1 === false ? stack1 : stack1.length);
1079 | stack2 = helpers['if'];
1080 | tmp1 = self.program(20, program20, data);
1081 | tmp1.hash = {};
1082 | tmp1.fn = tmp1;
1083 | tmp1.inverse = self.noop;
1084 | stack1 = stack2.call(depth0, stack1, tmp1);
1085 | if(stack1 || stack1 === 0) { buffer += stack1; }
1086 | buffer += "\n\n \n ";
1087 | foundHelper = helpers.methods_categorized;
1088 | stack1 = foundHelper || depth0.methods_categorized;
1089 | tmp1 = self.program(26, program26, data);
1090 | tmp1.hash = {};
1091 | tmp1.fn = tmp1;
1092 | tmp1.inverse = self.noop;
1093 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
1094 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
1095 | if(stack1 || stack1 === 0) { buffer += stack1; }
1096 | buffer += "\n\n \n
\n \n
\n
\n ";
1097 | foundHelper = helpers.files;
1098 | stack1 = foundHelper || depth0.files;
1099 | foundHelper = helpers.doc;
1100 | stack2 = foundHelper || depth0.doc;
1101 | tmp1 = self.program(45, program45, data);
1102 | tmp1.hash = {};
1103 | tmp1.fn = tmp1;
1104 | tmp1.inverse = self.noop;
1105 | if(foundHelper && typeof stack2 === functionType) { stack1 = stack2.call(depth0, stack1, tmp1); }
1106 | else { stack1 = blockHelperMissing.call(depth0, stack2, stack1, tmp1); }
1107 | if(stack1 || stack1 === 0) { buffer += stack1; }
1108 | buffer += "\n
\n
\n
\n\n
\n";
1109 | return buffer;});
1110 | templates['navigation'] = template(function (Handlebars,depth0,helpers,partials,data) {
1111 | helpers = helpers || Handlebars.helpers;
1112 | var buffer = "", stack1, stack2, foundHelper, tmp1, self=this, functionType="function", helperMissing=helpers.helperMissing, undef=void 0, escapeExpression=this.escapeExpression, blockHelperMissing=helpers.blockHelperMissing;
1113 |
1114 | function program1(depth0,data) {
1115 |
1116 | var buffer = "", stack1;
1117 | buffer += "\n
\n \n \n ";
1118 | foundHelper = helpers.documents;
1119 | stack1 = foundHelper || depth0.documents;
1120 | tmp1 = self.program(2, program2, data);
1121 | tmp1.hash = {};
1122 | tmp1.fn = tmp1;
1123 | tmp1.inverse = self.noop;
1124 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
1125 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
1126 | if(stack1 || stack1 === 0) { buffer += stack1; }
1127 | buffer += "\n \n | \n ";
1128 | return buffer;}
1129 | function program2(depth0,data) {
1130 |
1131 | var buffer = "", stack1, stack2;
1132 | buffer += "\n
\n ";
1141 | foundHelper = helpers.name;
1142 | stack1 = foundHelper || depth0.name;
1143 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
1144 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
1145 | buffer += escapeExpression(stack1) + "\n \n ";
1146 | return buffer;}
1147 |
1148 | function program4(depth0,data) {
1149 |
1150 | var buffer = "", stack1;
1151 | buffer += "\n
\n ";
1162 | foundHelper = helpers.path;
1163 | stack1 = foundHelper || depth0.path;
1164 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
1165 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "path", { hash: {} }); }
1166 | buffer += escapeExpression(stack1) + "\n \n ";
1167 | return buffer;}
1168 |
1169 | function program6(depth0,data) {
1170 |
1171 | var buffer = "", stack1, stack2;
1172 | buffer += "\n
\n ";
1183 | foundHelper = helpers.namespace;
1184 | stack1 = foundHelper || depth0.namespace;
1185 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
1186 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "namespace", { hash: {} }); }
1187 | buffer += escapeExpression(stack1) + "\n ";
1193 | foundHelper = helpers.name;
1194 | stack1 = foundHelper || depth0.name;
1195 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
1196 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
1197 | buffer += escapeExpression(stack1) + "\n \n ";
1198 | return buffer;}
1199 | function program7(depth0,data) {
1200 |
1201 |
1202 | return "singleton";}
1203 |
1204 | function program9(depth0,data) {
1205 |
1206 |
1207 | return "method";}
1208 |
1209 | buffer += "\n\n\n\n\n\n
\n\n
\n
\n \n \n ";
1210 | foundHelper = helpers.documents;
1211 | stack1 = foundHelper || depth0.documents;
1212 | stack1 = (stack1 === null || stack1 === undefined || stack1 === false ? stack1 : stack1.length);
1213 | stack2 = helpers['if'];
1214 | tmp1 = self.program(1, program1, data);
1215 | tmp1.hash = {};
1216 | tmp1.fn = tmp1;
1217 | tmp1.inverse = self.noop;
1218 | stack1 = stack2.call(depth0, stack1, tmp1);
1219 | if(stack1 || stack1 === 0) { buffer += stack1; }
1220 | buffer += "\n\n \n \n \n \n\n \n ";
1221 | foundHelper = helpers.modules;
1222 | stack1 = foundHelper || depth0.modules;
1223 | tmp1 = self.program(4, program4, data);
1224 | tmp1.hash = {};
1225 | tmp1.fn = tmp1;
1226 | tmp1.inverse = self.noop;
1227 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
1228 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
1229 | if(stack1 || stack1 === 0) { buffer += stack1; }
1230 | buffer += "\n \n No matching classes. \n | \n\n \n \n \n \n \n ";
1231 | foundHelper = helpers.methods;
1232 | stack1 = foundHelper || depth0.methods;
1233 | tmp1 = self.program(6, program6, data);
1234 | tmp1.hash = {};
1235 | tmp1.fn = tmp1;
1236 | tmp1.inverse = self.noop;
1237 | if(foundHelper && typeof stack1 === functionType) { stack1 = stack1.call(depth0, tmp1); }
1238 | else { stack1 = blockHelperMissing.call(depth0, stack1, tmp1); }
1239 | if(stack1 || stack1 === 0) { buffer += stack1; }
1240 | buffer += "\n \n | \n\n
\n
\n
\n";
1241 | return buffer;});
1242 | templates['script'] = template(function (Handlebars,depth0,helpers,partials,data) {
1243 | helpers = helpers || Handlebars.helpers; partials = partials || Handlebars.partials;
1244 | var buffer = "", stack1, stack2, foundHelper, tmp1, self=this, functionType="function", helperMissing=helpers.helperMissing, undef=void 0, escapeExpression=this.escapeExpression;
1245 |
1246 | function program1(depth0,data) {
1247 |
1248 | var buffer = "", stack1;
1249 | buffer += "\n
\n ";
1255 | return buffer;}
1256 |
1257 | function program3(depth0,data) {
1258 |
1259 | var buffer = "", stack1;
1260 | buffer += "\n
\n \n ";
1261 | foundHelper = helpers.source;
1262 | stack1 = foundHelper || depth0.source;
1263 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
1264 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "source", { hash: {} }); }
1265 | buffer += escapeExpression(stack1) + "\n \n
\n ";
1266 | return buffer;}
1267 |
1268 | buffer += "\n\n
\n ";
1269 | stack1 = depth0;
1270 | stack1 = self.invokePartial(partials.file_stats, 'file_stats', stack1, helpers, partials);;
1271 | if(stack1 || stack1 === 0) { buffer += stack1; }
1272 | buffer += "\n
";
1273 | foundHelper = helpers.name;
1274 | stack1 = foundHelper || depth0.name;
1275 | if(typeof stack1 === functionType) { stack1 = stack1.call(depth0, { hash: {} }); }
1276 | else if(stack1=== undef) { stack1 = helperMissing.call(depth0, "name", { hash: {} }); }
1277 | buffer += escapeExpression(stack1) + "
\n
\n ";
1278 | foundHelper = helpers.uri;
1279 | stack1 = foundHelper || depth0.uri;
1280 | stack2 = helpers['if'];
1281 | tmp1 = self.program(1, program1, data);
1282 | tmp1.hash = {};
1283 | tmp1.fn = tmp1;
1284 | tmp1.inverse = self.noop;
1285 | stack1 = stack2.call(depth0, stack1, tmp1);
1286 | if(stack1 || stack1 === 0) { buffer += stack1; }
1287 | buffer += "\n ";
1288 | foundHelper = helpers.source;
1289 | stack1 = foundHelper || depth0.source;
1290 | stack2 = helpers['if'];
1291 | tmp1 = self.program(3, program3, data);
1292 | tmp1.hash = {};
1293 | tmp1.fn = tmp1;
1294 | tmp1.inverse = self.noop;
1295 | stack1 = stack2.call(depth0, stack1, tmp1);
1296 | if(stack1 || stack1 === 0) { buffer += stack1; }
1297 | buffer += "\n\n\n";
1298 | return buffer;});
1299 | templates['title'] = template(function (Handlebars,depth0,helpers,partials,data) {
1300 | helpers = helpers || Handlebars.helpers;
1301 | var buffer = "", stack1, foundHelper, self=this, functionType="function", helperMissing=helpers.helperMissing, undef=void 0, escapeExpression=this.escapeExpression;
1302 |
1303 |
1304 | buffer += "\n\n
\n
\n\n";
1310 | return buffer;});
1311 | })();
--------------------------------------------------------------------------------
![[Validate]](assets/images/icons/check.png){kind=icon}
15 | 
6 | README
7 | ![[Debug]](assets/images/icons/bug.png){kind=icon}
5 | ![\"[Debug]\"](\"assets/images/icons/bug.png\"){kind=icon}
\n ![\"[Validate]\"](\"assets/images/icons/check.png\"){kind=icon}
\n \n ![[+]](assets/images/icons/find.png "show/hide quicksearch"){kind=icon}
42 | ![\"[+]\"](\"assets/images/icons/find.png\" "\\"show/hide"){kind=icon}
\n ![](\"assets/images/icons/project.png\"){kind=icon}
\n README\n