===================================================================
JsFile: recursiveClassReferenceTest.js
mapUrl: recursiveClassReferenceTest.js.map
sourceRoot: 
sources: recursiveClassReferenceTest.ts
===================================================================
-------------------------------------------------------------------
emittedFile:tests/cases/compiler/recursiveClassReferenceTest.js
sourceFile:recursiveClassReferenceTest.ts
-------------------------------------------------------------------
>>>// Scenario 1: Test reqursive function call with "this" parameter
1 >
2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                                                 ^^^^^^^^^^->
1 >
2 >// Scenario 1: Test reqursive function call with "this" parameter
1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
2 >Emitted(1, 66) Source(1, 66) + SourceIndex(0)
---
>>>// Scenario 2: Test recursive function call with cast and "this" parameter
1->
2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
  >
2 >// Scenario 2: Test recursive function call with cast and "this" parameter
1->Emitted(2, 1) Source(2, 1) + SourceIndex(0)
2 >Emitted(2, 75) Source(2, 75) + SourceIndex(0)
---
>>>var __extends = this.__extends || function (d, b) {
>>>    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
>>>    function __() { this.constructor = d; }
>>>    __.prototype = b.prototype;
>>>    d.prototype = new __();
>>>};
>>>var Sample;
1 >
2 >^^^^
3 >    ^^^^^^
4 >          ^
5 >           ^^^^^^^^^^->
1 >
  >
  >
  >
  >declare module Sample.Thing {
  >
  >	export interface IWidget {
  >		getDomNode(): any;
  >		destroy();
  >		gar(runner:(widget:Sample.Thing.IWidget)=>any):any;
  >	}
  >
  >	export interface ICodeThing {
  >  
  >  		getDomNode(): Element;
  >		
  >		addWidget(widgetId:string, widget:IWidget);
  >
  >		
  >		focus(); 
  >		
  >		//addWidget(widget: Sample.Thing.Widgets.IWidget);
  >	}
  >
  >	export interface IAction {
  >		run(Thing:ICodeThing):boolean;
  >		getId():string;
  >	}	
  >}
  >
  >
2 >module 
3 >    Sample
4 >          .Actions.Thing.Find {
  >          	export class StartFindAction implements Sample.Thing.IAction {
  >          		
  >          		public getId() { return "yo"; }
  >          		
  >          		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >          
  >          			return true;
  >          		}
  >          	}
  >          }
1 >Emitted(9, 1) Source(32, 1) + SourceIndex(0)
2 >Emitted(9, 5) Source(32, 8) + SourceIndex(0)
3 >Emitted(9, 11) Source(32, 14) + SourceIndex(0)
4 >Emitted(9, 12) Source(42, 2) + SourceIndex(0)
---
>>>(function (Sample) {
1->
2 >^^^^^^^^^^^
3 >           ^^^^^^
1->
2 >module 
3 >           Sample
1->Emitted(10, 1) Source(32, 1) + SourceIndex(0)
2 >Emitted(10, 12) Source(32, 8) + SourceIndex(0)
3 >Emitted(10, 18) Source(32, 14) + SourceIndex(0)
---
>>>    var Actions;
1 >^^^^
2 >    ^^^^
3 >        ^^^^^^^
4 >               ^
5 >                ^^^^^^^^^^->
1 >.
2 >    
3 >        Actions
4 >               .Thing.Find {
  >               	export class StartFindAction implements Sample.Thing.IAction {
  >               		
  >               		public getId() { return "yo"; }
  >               		
  >               		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >               
  >               			return true;
  >               		}
  >               	}
  >               }
1 >Emitted(11, 5) Source(32, 15) + SourceIndex(0) name (Sample)
2 >Emitted(11, 9) Source(32, 15) + SourceIndex(0) name (Sample)
3 >Emitted(11, 16) Source(32, 22) + SourceIndex(0) name (Sample)
4 >Emitted(11, 17) Source(42, 2) + SourceIndex(0) name (Sample)
---
>>>    (function (Actions) {
1->^^^^
2 >    ^^^^^^^^^^^
3 >               ^^^^^^^
1->
2 >    
3 >               Actions
1->Emitted(12, 5) Source(32, 15) + SourceIndex(0) name (Sample)
2 >Emitted(12, 16) Source(32, 15) + SourceIndex(0) name (Sample)
3 >Emitted(12, 23) Source(32, 22) + SourceIndex(0) name (Sample)
---
>>>        var Thing;
1 >^^^^^^^^
2 >        ^^^^
3 >            ^^^^^
4 >                 ^
5 >                  ^^^^^^^^^^^->
1 >.
2 >        
3 >            Thing
4 >                 .Find {
  >                 	export class StartFindAction implements Sample.Thing.IAction {
  >                 		
  >                 		public getId() { return "yo"; }
  >                 		
  >                 		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                 
  >                 			return true;
  >                 		}
  >                 	}
  >                 }
1 >Emitted(13, 9) Source(32, 23) + SourceIndex(0) name (Sample.Actions)
2 >Emitted(13, 13) Source(32, 23) + SourceIndex(0) name (Sample.Actions)
3 >Emitted(13, 18) Source(32, 28) + SourceIndex(0) name (Sample.Actions)
4 >Emitted(13, 19) Source(42, 2) + SourceIndex(0) name (Sample.Actions)
---
>>>        (function (_Thing) {
1->^^^^^^^^
2 >        ^^^^^^^^^^^
3 >                   ^^^^^^
1->
2 >        
3 >                   Thing
1->Emitted(14, 9) Source(32, 23) + SourceIndex(0) name (Sample.Actions)
2 >Emitted(14, 20) Source(32, 23) + SourceIndex(0) name (Sample.Actions)
3 >Emitted(14, 26) Source(32, 28) + SourceIndex(0) name (Sample.Actions)
---
>>>            var Find;
1 >^^^^^^^^^^^^
2 >            ^^^^
3 >                ^^^^
4 >                    ^
5 >                     ^^^^^^^^^^->
1 >.
2 >            
3 >                Find
4 >                     {
  >                    	export class StartFindAction implements Sample.Thing.IAction {
  >                    		
  >                    		public getId() { return "yo"; }
  >                    		
  >                    		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                    
  >                    			return true;
  >                    		}
  >                    	}
  >                    }
1 >Emitted(15, 13) Source(32, 29) + SourceIndex(0) name (Sample.Actions.Thing)
2 >Emitted(15, 17) Source(32, 29) + SourceIndex(0) name (Sample.Actions.Thing)
3 >Emitted(15, 21) Source(32, 33) + SourceIndex(0) name (Sample.Actions.Thing)
4 >Emitted(15, 22) Source(42, 2) + SourceIndex(0) name (Sample.Actions.Thing)
---
>>>            (function (Find) {
1->^^^^^^^^^^^^
2 >            ^^^^^^^^^^^
3 >                       ^^^^
4 >                           ^^
5 >                             ^
6 >                              ^^^^^^^^^^^^^^^^^^^^^^^->
1->
2 >            
3 >                       Find
4 >                            
5 >                             {
1->Emitted(16, 13) Source(32, 29) + SourceIndex(0) name (Sample.Actions.Thing)
2 >Emitted(16, 24) Source(32, 29) + SourceIndex(0) name (Sample.Actions.Thing)
3 >Emitted(16, 28) Source(32, 33) + SourceIndex(0) name (Sample.Actions.Thing)
4 >Emitted(16, 30) Source(32, 34) + SourceIndex(0) name (Sample.Actions.Thing)
5 >Emitted(16, 31) Source(32, 35) + SourceIndex(0) name (Sample.Actions.Thing)
---
>>>                var StartFindAction = (function () {
1->^^^^^^^^^^^^^^^^
2 >                ^^^^
3 >                    ^^^^^^^^^^^^^^^
4 >                                   ^^^^^^^^^^^^^^->
1->
  >	
2 >                export class 
3 >                    StartFindAction
1->Emitted(17, 17) Source(33, 2) + SourceIndex(0) name (Sample.Actions.Thing.Find)
2 >Emitted(17, 21) Source(33, 15) + SourceIndex(0) name (Sample.Actions.Thing.Find)
3 >Emitted(17, 36) Source(33, 30) + SourceIndex(0) name (Sample.Actions.Thing.Find)
---
>>>                    function StartFindAction() {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^
3 >                             ^^^^^^^^^^^^^^^
1->
2 >                    export class 
3 >                             StartFindAction
1->Emitted(18, 21) Source(33, 2) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
2 >Emitted(18, 30) Source(33, 15) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
3 >Emitted(18, 45) Source(33, 30) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
---
>>>                    }
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 > implements Sample.Thing.IAction {
  >		
  >		public getId() { return "yo"; }
  >		
  >		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >
  >			return true;
  >		}
  >	
2 >                    }
1 >Emitted(19, 21) Source(41, 2) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.constructor)
2 >Emitted(19, 22) Source(41, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.constructor)
---
>>>                    StartFindAction.prototype.getId = function () {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                                   ^^^
1->
2 >                    getId
3 >                                                   
1->Emitted(20, 21) Source(35, 10) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
2 >Emitted(20, 52) Source(35, 15) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
3 >Emitted(20, 55) Source(35, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
---
>>>                        return "yo";
1 >^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^
3 >                              ^
4 >                               ^^^^
5 >                                   ^
1 >public getId() { 
2 >                        return
3 >                               
4 >                               "yo"
5 >                                   ;
1 >Emitted(21, 25) Source(35, 20) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.getId)
2 >Emitted(21, 31) Source(35, 26) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.getId)
3 >Emitted(21, 32) Source(35, 27) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.getId)
4 >Emitted(21, 36) Source(35, 31) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.getId)
5 >Emitted(21, 37) Source(35, 32) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.getId)
---
>>>                    };
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 > 
2 >                    }
1 >Emitted(22, 21) Source(35, 33) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.getId)
2 >Emitted(22, 22) Source(35, 34) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.getId)
---
>>>                    StartFindAction.prototype.run = function (Thing) {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                                 ^^^
4 >                                                    ^^^^^^^^^^
5 >                                                              ^^^^^
1->
  >		
  >		public 
2 >                    run
3 >                                                 
4 >                                                    public run(
5 >                                                              Thing:Sample.Thing.ICodeThing
1->Emitted(23, 21) Source(37, 10) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
2 >Emitted(23, 50) Source(37, 13) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
3 >Emitted(23, 53) Source(37, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
4 >Emitted(23, 63) Source(37, 14) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
5 >Emitted(23, 68) Source(37, 43) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
---
>>>                        return true;
1 >^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^
3 >                              ^
4 >                               ^^^^
5 >                                   ^
1 >):boolean {
  >
  >			
2 >                        return
3 >                               
4 >                               true
5 >                                   ;
1 >Emitted(24, 25) Source(39, 4) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.run)
2 >Emitted(24, 31) Source(39, 10) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.run)
3 >Emitted(24, 32) Source(39, 11) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.run)
4 >Emitted(24, 36) Source(39, 15) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.run)
5 >Emitted(24, 37) Source(39, 16) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.run)
---
>>>                    };
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >		
2 >                    }
1 >Emitted(25, 21) Source(40, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.run)
2 >Emitted(25, 22) Source(40, 4) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction.run)
---
>>>                    return StartFindAction;
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^^^^^^^^^
1->
  >	
2 >                    }
1->Emitted(26, 21) Source(41, 2) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
2 >Emitted(26, 43) Source(41, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
---
>>>                })();
1 >^^^^^^^^^^^^^^^^
2 >                ^
3 >                 
4 >                 ^^^^
5 >                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
2 >                }
3 >                 
4 >                 export class StartFindAction implements Sample.Thing.IAction {
  >                 		
  >                 		public getId() { return "yo"; }
  >                 		
  >                 		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                 
  >                 			return true;
  >                 		}
  >                 	}
1 >Emitted(27, 17) Source(41, 2) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
2 >Emitted(27, 18) Source(41, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find.StartFindAction)
3 >Emitted(27, 18) Source(33, 2) + SourceIndex(0) name (Sample.Actions.Thing.Find)
4 >Emitted(27, 22) Source(41, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find)
---
>>>                Find.StartFindAction = StartFindAction;
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^^^^^^^^^^^^
3 >                                    ^^^
4 >                                       ^^^^^^^^^^^^^^^
5 >                                                      ^
6 >                                                       ^^^->
1->
2 >                StartFindAction
3 >                                    
4 >                                       StartFindAction implements Sample.Thing.IAction {
  >                                       		
  >                                       		public getId() { return "yo"; }
  >                                       		
  >                                       		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                                       
  >                                       			return true;
  >                                       		}
  >                                       	}
5 >                                                      
1->Emitted(28, 17) Source(33, 15) + SourceIndex(0) name (Sample.Actions.Thing.Find)
2 >Emitted(28, 37) Source(33, 30) + SourceIndex(0) name (Sample.Actions.Thing.Find)
3 >Emitted(28, 40) Source(33, 15) + SourceIndex(0) name (Sample.Actions.Thing.Find)
4 >Emitted(28, 55) Source(41, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find)
5 >Emitted(28, 56) Source(41, 3) + SourceIndex(0) name (Sample.Actions.Thing.Find)
---
>>>            })(Find = _Thing.Find || (_Thing.Find = {}));
1->^^^^^^^^^^^^
2 >            ^
3 >             ^^
4 >               ^^^^
5 >                   ^^^
6 >                      ^^^^^^^^^^^
7 >                                 ^^^^^
8 >                                      ^^^^^^^^^^^
9 >                                                 ^^^^^^^^
10>                                                         ^^->
1->
  >
2 >            }
3 >             
4 >               Find
5 >                   
6 >                      Find
7 >                                 
8 >                                      Find
9 >                                                  {
  >                                                 	export class StartFindAction implements Sample.Thing.IAction {
  >                                                 		
  >                                                 		public getId() { return "yo"; }
  >                                                 		
  >                                                 		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                                                 
  >                                                 			return true;
  >                                                 		}
  >                                                 	}
  >                                                 }
1->Emitted(29, 13) Source(42, 1) + SourceIndex(0) name (Sample.Actions.Thing.Find)
2 >Emitted(29, 14) Source(42, 2) + SourceIndex(0) name (Sample.Actions.Thing.Find)
3 >Emitted(29, 16) Source(32, 29) + SourceIndex(0) name (Sample.Actions.Thing)
4 >Emitted(29, 20) Source(32, 33) + SourceIndex(0) name (Sample.Actions.Thing)
5 >Emitted(29, 23) Source(32, 29) + SourceIndex(0) name (Sample.Actions.Thing)
6 >Emitted(29, 34) Source(32, 33) + SourceIndex(0) name (Sample.Actions.Thing)
7 >Emitted(29, 39) Source(32, 29) + SourceIndex(0) name (Sample.Actions.Thing)
8 >Emitted(29, 50) Source(32, 33) + SourceIndex(0) name (Sample.Actions.Thing)
9 >Emitted(29, 58) Source(42, 2) + SourceIndex(0) name (Sample.Actions.Thing)
---
>>>        })(Thing = Actions.Thing || (Actions.Thing = {}));
1->^^^^^^^^
2 >        ^
3 >         ^^
4 >           ^^^^^
5 >                ^^^
6 >                   ^^^^^^^^^^^^^
7 >                                ^^^^^
8 >                                     ^^^^^^^^^^^^^
9 >                                                  ^^^^^^^^
10>                                                          ^->
1->
2 >        }
3 >         
4 >           Thing
5 >                
6 >                   Thing
7 >                                
8 >                                     Thing
9 >                                                  .Find {
  >                                                  	export class StartFindAction implements Sample.Thing.IAction {
  >                                                  		
  >                                                  		public getId() { return "yo"; }
  >                                                  		
  >                                                  		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                                                  
  >                                                  			return true;
  >                                                  		}
  >                                                  	}
  >                                                  }
1->Emitted(30, 9) Source(42, 1) + SourceIndex(0) name (Sample.Actions.Thing)
2 >Emitted(30, 10) Source(42, 2) + SourceIndex(0) name (Sample.Actions.Thing)
3 >Emitted(30, 12) Source(32, 23) + SourceIndex(0) name (Sample.Actions)
4 >Emitted(30, 17) Source(32, 28) + SourceIndex(0) name (Sample.Actions)
5 >Emitted(30, 20) Source(32, 23) + SourceIndex(0) name (Sample.Actions)
6 >Emitted(30, 33) Source(32, 28) + SourceIndex(0) name (Sample.Actions)
7 >Emitted(30, 38) Source(32, 23) + SourceIndex(0) name (Sample.Actions)
8 >Emitted(30, 51) Source(32, 28) + SourceIndex(0) name (Sample.Actions)
9 >Emitted(30, 59) Source(42, 2) + SourceIndex(0) name (Sample.Actions)
---
>>>    })(Actions = Sample.Actions || (Sample.Actions = {}));
1->^^^^
2 >    ^
3 >     ^^
4 >       ^^^^^^^
5 >              ^^^
6 >                 ^^^^^^^^^^^^^^
7 >                               ^^^^^
8 >                                    ^^^^^^^^^^^^^^
9 >                                                  ^^^^^^^^
1->
2 >    }
3 >     
4 >       Actions
5 >              
6 >                 Actions
7 >                               
8 >                                    Actions
9 >                                                  .Thing.Find {
  >                                                  	export class StartFindAction implements Sample.Thing.IAction {
  >                                                  		
  >                                                  		public getId() { return "yo"; }
  >                                                  		
  >                                                  		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                                                  
  >                                                  			return true;
  >                                                  		}
  >                                                  	}
  >                                                  }
1->Emitted(31, 5) Source(42, 1) + SourceIndex(0) name (Sample.Actions)
2 >Emitted(31, 6) Source(42, 2) + SourceIndex(0) name (Sample.Actions)
3 >Emitted(31, 8) Source(32, 15) + SourceIndex(0) name (Sample)
4 >Emitted(31, 15) Source(32, 22) + SourceIndex(0) name (Sample)
5 >Emitted(31, 18) Source(32, 15) + SourceIndex(0) name (Sample)
6 >Emitted(31, 32) Source(32, 22) + SourceIndex(0) name (Sample)
7 >Emitted(31, 37) Source(32, 15) + SourceIndex(0) name (Sample)
8 >Emitted(31, 51) Source(32, 22) + SourceIndex(0) name (Sample)
9 >Emitted(31, 59) Source(42, 2) + SourceIndex(0) name (Sample)
---
>>>})(Sample || (Sample = {}));
1 >
2 >^
3 > ^^
4 >   ^^^^^^
5 >         ^^^^^
6 >              ^^^^^^
7 >                    ^^^^^^^^
1 >
2 >}
3 > 
4 >   Sample
5 >         
6 >              Sample
7 >                    .Actions.Thing.Find {
  >                    	export class StartFindAction implements Sample.Thing.IAction {
  >                    		
  >                    		public getId() { return "yo"; }
  >                    		
  >                    		public run(Thing:Sample.Thing.ICodeThing):boolean {
  >                    
  >                    			return true;
  >                    		}
  >                    	}
  >                    }
1 >Emitted(32, 1) Source(42, 1) + SourceIndex(0) name (Sample)
2 >Emitted(32, 2) Source(42, 2) + SourceIndex(0) name (Sample)
3 >Emitted(32, 4) Source(32, 8) + SourceIndex(0)
4 >Emitted(32, 10) Source(32, 14) + SourceIndex(0)
5 >Emitted(32, 15) Source(32, 8) + SourceIndex(0)
6 >Emitted(32, 21) Source(32, 14) + SourceIndex(0)
7 >Emitted(32, 29) Source(42, 2) + SourceIndex(0)
---
>>>var Sample;
1 >
2 >^^^^
3 >    ^^^^^^
4 >          ^
5 >           ^^^^^^^^^^->
1 >
  >
  >
2 >module 
3 >    Sample
4 >          .Thing.Widgets {
  >          	export class FindWidget implements Sample.Thing.IWidget {
  >          
  >          		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >          			
  >          		private domNode:any = null;
  >          		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >          		    // scenario 1
  >          		    codeThing.addWidget("addWidget", this);
  >          		}
  >          		
  >          		public getDomNode() {
  >          			return domNode;
  >          		}
  >          		
  >          		public destroy() {
  >          
  >          		}
  >          
  >          	}
  >          }
1 >Emitted(33, 1) Source(44, 1) + SourceIndex(0)
2 >Emitted(33, 5) Source(44, 8) + SourceIndex(0)
3 >Emitted(33, 11) Source(44, 14) + SourceIndex(0)
4 >Emitted(33, 12) Source(64, 2) + SourceIndex(0)
---
>>>(function (Sample) {
1->
2 >^^^^^^^^^^^
3 >           ^^^^^^
1->
2 >module 
3 >           Sample
1->Emitted(34, 1) Source(44, 1) + SourceIndex(0)
2 >Emitted(34, 12) Source(44, 8) + SourceIndex(0)
3 >Emitted(34, 18) Source(44, 14) + SourceIndex(0)
---
>>>    var Thing;
1 >^^^^
2 >    ^^^^
3 >        ^^^^^
4 >             ^
5 >              ^^^^^^^^^^->
1 >.
2 >    
3 >        Thing
4 >             .Widgets {
  >             	export class FindWidget implements Sample.Thing.IWidget {
  >             
  >             		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >             			
  >             		private domNode:any = null;
  >             		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >             		    // scenario 1
  >             		    codeThing.addWidget("addWidget", this);
  >             		}
  >             		
  >             		public getDomNode() {
  >             			return domNode;
  >             		}
  >             		
  >             		public destroy() {
  >             
  >             		}
  >             
  >             	}
  >             }
1 >Emitted(35, 5) Source(44, 15) + SourceIndex(0) name (Sample)
2 >Emitted(35, 9) Source(44, 15) + SourceIndex(0) name (Sample)
3 >Emitted(35, 14) Source(44, 20) + SourceIndex(0) name (Sample)
4 >Emitted(35, 15) Source(64, 2) + SourceIndex(0) name (Sample)
---
>>>    (function (Thing) {
1->^^^^
2 >    ^^^^^^^^^^^
3 >               ^^^^^
4 >                    ^->
1->
2 >    
3 >               Thing
1->Emitted(36, 5) Source(44, 15) + SourceIndex(0) name (Sample)
2 >Emitted(36, 16) Source(44, 15) + SourceIndex(0) name (Sample)
3 >Emitted(36, 21) Source(44, 20) + SourceIndex(0) name (Sample)
---
>>>        var Widgets;
1->^^^^^^^^
2 >        ^^^^
3 >            ^^^^^^^
4 >                   ^
5 >                    ^^^^^^^^^^->
1->.
2 >        
3 >            Widgets
4 >                    {
  >                   	export class FindWidget implements Sample.Thing.IWidget {
  >                   
  >                   		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >                   			
  >                   		private domNode:any = null;
  >                   		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >                   		    // scenario 1
  >                   		    codeThing.addWidget("addWidget", this);
  >                   		}
  >                   		
  >                   		public getDomNode() {
  >                   			return domNode;
  >                   		}
  >                   		
  >                   		public destroy() {
  >                   
  >                   		}
  >                   
  >                   	}
  >                   }
1->Emitted(37, 9) Source(44, 21) + SourceIndex(0) name (Sample.Thing)
2 >Emitted(37, 13) Source(44, 21) + SourceIndex(0) name (Sample.Thing)
3 >Emitted(37, 20) Source(44, 28) + SourceIndex(0) name (Sample.Thing)
4 >Emitted(37, 21) Source(64, 2) + SourceIndex(0) name (Sample.Thing)
---
>>>        (function (Widgets) {
1->^^^^^^^^
2 >        ^^^^^^^^^^^
3 >                   ^^^^^^^
4 >                          ^^
5 >                            ^
6 >                             ^^^^^^^^^^^^^^^->
1->
2 >        
3 >                   Widgets
4 >                           
5 >                            {
1->Emitted(38, 9) Source(44, 21) + SourceIndex(0) name (Sample.Thing)
2 >Emitted(38, 20) Source(44, 21) + SourceIndex(0) name (Sample.Thing)
3 >Emitted(38, 27) Source(44, 28) + SourceIndex(0) name (Sample.Thing)
4 >Emitted(38, 29) Source(44, 29) + SourceIndex(0) name (Sample.Thing)
5 >Emitted(38, 30) Source(44, 30) + SourceIndex(0) name (Sample.Thing)
---
>>>            var FindWidget = (function () {
1->^^^^^^^^^^^^
2 >            ^^^^
3 >                ^^^^^^^^^^
4 >                          ^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >	
2 >            export class 
3 >                FindWidget
1->Emitted(39, 13) Source(45, 2) + SourceIndex(0) name (Sample.Thing.Widgets)
2 >Emitted(39, 17) Source(45, 15) + SourceIndex(0) name (Sample.Thing.Widgets)
3 >Emitted(39, 27) Source(45, 25) + SourceIndex(0) name (Sample.Thing.Widgets)
---
>>>                function FindWidget(codeThing) {
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^
3 >                         ^^^^^^^^^^
4 >                                   ^
5 >                                    ^^^^^^^^^
6 >                                             ^^^->
1-> implements Sample.Thing.IWidget {
  >
  >		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >			
  >		private domNode:any = null;
  >		
2 >                
3 >                         FindWidget
4 >                                    implements Sample.Thing.IWidget {
  >                                   
  >                                   		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >                                   			
  >                                   		private domNode:any = null;
  >                                   		constructor(private 
5 >                                    codeThing: Sample.Thing.ICodeThing
1->Emitted(40, 17) Source(50, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
2 >Emitted(40, 26) Source(45, 15) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
3 >Emitted(40, 36) Source(45, 25) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
4 >Emitted(40, 37) Source(50, 23) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
5 >Emitted(40, 46) Source(50, 57) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
---
>>>                    this.codeThing = codeThing;
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^
3 >                                  ^^^
4 >                                     ^^^^^^^^^
5 >                                              ^
1->
2 >                    codeThing
3 >                                  
4 >                                     codeThing
5 >                                              : Sample.Thing.ICodeThing
1->Emitted(41, 21) Source(50, 23) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
2 >Emitted(41, 35) Source(50, 32) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
3 >Emitted(41, 38) Source(50, 23) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
4 >Emitted(41, 47) Source(50, 32) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
5 >Emitted(41, 48) Source(50, 57) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
---
>>>                    this.domNode = null;
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^
3 >                                ^^^
4 >                                   ^^^^
5 >                                       ^
1 >
2 >                    domNode
3 >                                :any = 
4 >                                   null
5 >                                       ;
1 >Emitted(42, 21) Source(49, 11) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
2 >Emitted(42, 33) Source(49, 18) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
3 >Emitted(42, 36) Source(49, 25) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
4 >Emitted(42, 40) Source(49, 29) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
5 >Emitted(42, 41) Source(49, 30) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
---
>>>                    // scenario 1
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    
3 >                    ^^^^^^^^^^^^^
4 >                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >		    // scenario 1
  >		    
2 >                    
3 >                    // scenario 1
1 >Emitted(43, 21) Source(52, 7) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
2 >Emitted(43, 21) Source(51, 7) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
3 >Emitted(43, 34) Source(51, 20) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
---
>>>                    codeThing.addWidget("addWidget", this);
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^
3 >                             ^
4 >                              ^^^^^^^^^
5 >                                       ^
6 >                                        ^^^^^^^^^^^
7 >                                                   ^^
8 >                                                     ^^^^
9 >                                                         ^
10>                                                          ^
1->
  >		    
2 >                    codeThing
3 >                             .
4 >                              addWidget
5 >                                       (
6 >                                        "addWidget"
7 >                                                   , 
8 >                                                     this
9 >                                                         )
10>                                                          ;
1->Emitted(44, 21) Source(52, 7) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
2 >Emitted(44, 30) Source(52, 16) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
3 >Emitted(44, 31) Source(52, 17) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
4 >Emitted(44, 40) Source(52, 26) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
5 >Emitted(44, 41) Source(52, 27) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
6 >Emitted(44, 52) Source(52, 38) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
7 >Emitted(44, 54) Source(52, 40) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
8 >Emitted(44, 58) Source(52, 44) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
9 >Emitted(44, 59) Source(52, 45) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
10>Emitted(44, 60) Source(52, 46) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
---
>>>                }
1 >^^^^^^^^^^^^^^^^
2 >                ^
3 >                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >		
2 >                }
1 >Emitted(45, 17) Source(53, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
2 >Emitted(45, 18) Source(53, 4) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.constructor)
---
>>>                FindWidget.prototype.gar = function (runner) {
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                        ^^^
4 >                                           ^^^^^^^^^^
5 >                                                     ^^^^^^
1->
2 >                gar
3 >                                        
4 >                                           public gar(
5 >                                                     runner:(widget:Sample.Thing.IWidget)=>any
1->Emitted(46, 17) Source(47, 10) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
2 >Emitted(46, 41) Source(47, 13) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
3 >Emitted(46, 44) Source(47, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
4 >Emitted(46, 54) Source(47, 14) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
5 >Emitted(46, 60) Source(47, 55) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
---
>>>                    if (true) {
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^^
3 >                      ^
4 >                       ^
5 >                        ^^^^
6 >                            ^
7 >                             ^
8 >                              ^
9 >                               ^^^^^^^^^^^^^^->
1 >) { 
2 >                    if
3 >                       
4 >                       (
5 >                        true
6 >                            )
7 >                              
8 >                              {
1 >Emitted(47, 21) Source(47, 59) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
2 >Emitted(47, 23) Source(47, 61) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
3 >Emitted(47, 24) Source(47, 62) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
4 >Emitted(47, 25) Source(47, 63) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
5 >Emitted(47, 29) Source(47, 67) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
6 >Emitted(47, 30) Source(47, 68) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
7 >Emitted(47, 31) Source(47, 69) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
8 >Emitted(47, 32) Source(47, 70) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
---
>>>                        return runner(this);
1->^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^
3 >                              ^
4 >                               ^^^^^^
5 >                                     ^
6 >                                      ^^^^
7 >                                          ^
8 >                                           ^
1->
2 >                        return
3 >                               
4 >                               runner
5 >                                     (
6 >                                      this
7 >                                          )
8 >                                           ;
1->Emitted(48, 25) Source(47, 70) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
2 >Emitted(48, 31) Source(47, 76) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
3 >Emitted(48, 32) Source(47, 77) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
4 >Emitted(48, 38) Source(47, 83) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
5 >Emitted(48, 39) Source(47, 84) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
6 >Emitted(48, 43) Source(47, 88) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
7 >Emitted(48, 44) Source(47, 89) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
8 >Emitted(48, 45) Source(47, 90) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
---
>>>                    }
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
1 >
2 >                    }
1 >Emitted(49, 21) Source(47, 90) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
2 >Emitted(49, 22) Source(47, 91) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
---
>>>                };
1 >^^^^^^^^^^^^^^^^
2 >                ^
3 >                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
2 >                }
1 >Emitted(50, 17) Source(47, 91) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
2 >Emitted(50, 18) Source(47, 92) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.gar)
---
>>>                FindWidget.prototype.getDomNode = function () {
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                               ^^^
1->
  >			
  >		private domNode:any = null;
  >		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >		    // scenario 1
  >		    codeThing.addWidget("addWidget", this);
  >		}
  >		
  >		public 
2 >                getDomNode
3 >                                               
1->Emitted(51, 17) Source(55, 10) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
2 >Emitted(51, 48) Source(55, 20) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
3 >Emitted(51, 51) Source(55, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
---
>>>                    return domNode;
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^
3 >                          ^
4 >                           ^^^^^^^
5 >                                  ^
1 >public getDomNode() {
  >			
2 >                    return
3 >                           
4 >                           domNode
5 >                                  ;
1 >Emitted(52, 21) Source(56, 4) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.getDomNode)
2 >Emitted(52, 27) Source(56, 10) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.getDomNode)
3 >Emitted(52, 28) Source(56, 11) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.getDomNode)
4 >Emitted(52, 35) Source(56, 18) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.getDomNode)
5 >Emitted(52, 36) Source(56, 19) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.getDomNode)
---
>>>                };
1 >^^^^^^^^^^^^^^^^
2 >                ^
3 >                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >		
2 >                }
1 >Emitted(53, 17) Source(57, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.getDomNode)
2 >Emitted(53, 18) Source(57, 4) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.getDomNode)
---
>>>                FindWidget.prototype.destroy = function () {
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                            ^^^
1->
  >		
  >		public 
2 >                destroy
3 >                                            
1->Emitted(54, 17) Source(59, 10) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
2 >Emitted(54, 45) Source(59, 17) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
3 >Emitted(54, 48) Source(59, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
---
>>>                };
1 >^^^^^^^^^^^^^^^^
2 >                ^
3 >                 ^^^^^^^^^^^^^^^^^^->
1 >public destroy() {
  >
  >		
2 >                }
1 >Emitted(55, 17) Source(61, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.destroy)
2 >Emitted(55, 18) Source(61, 4) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget.destroy)
---
>>>                return FindWidget;
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^^^^^^^^^
1->
  >
  >	
2 >                }
1->Emitted(56, 17) Source(63, 2) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
2 >Emitted(56, 34) Source(63, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
---
>>>            })();
1 >^^^^^^^^^^^^
2 >            ^
3 >             
4 >             ^^^^
5 >                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
2 >            }
3 >             
4 >             export class FindWidget implements Sample.Thing.IWidget {
  >             
  >             		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >             			
  >             		private domNode:any = null;
  >             		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >             		    // scenario 1
  >             		    codeThing.addWidget("addWidget", this);
  >             		}
  >             		
  >             		public getDomNode() {
  >             			return domNode;
  >             		}
  >             		
  >             		public destroy() {
  >             
  >             		}
  >             
  >             	}
1 >Emitted(57, 13) Source(63, 2) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
2 >Emitted(57, 14) Source(63, 3) + SourceIndex(0) name (Sample.Thing.Widgets.FindWidget)
3 >Emitted(57, 14) Source(45, 2) + SourceIndex(0) name (Sample.Thing.Widgets)
4 >Emitted(57, 18) Source(63, 3) + SourceIndex(0) name (Sample.Thing.Widgets)
---
>>>            Widgets.FindWidget = FindWidget;
1->^^^^^^^^^^^^
2 >            ^^^^^^^^^^^^^^^^^^
3 >                              ^^^
4 >                                 ^^^^^^^^^^
5 >                                           ^
6 >                                            ^^^^^^^^^^^^^^^^^->
1->
2 >            FindWidget
3 >                              
4 >                                 FindWidget implements Sample.Thing.IWidget {
  >                                 
  >                                 		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >                                 			
  >                                 		private domNode:any = null;
  >                                 		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >                                 		    // scenario 1
  >                                 		    codeThing.addWidget("addWidget", this);
  >                                 		}
  >                                 		
  >                                 		public getDomNode() {
  >                                 			return domNode;
  >                                 		}
  >                                 		
  >                                 		public destroy() {
  >                                 
  >                                 		}
  >                                 
  >                                 	}
5 >                                           
1->Emitted(58, 13) Source(45, 15) + SourceIndex(0) name (Sample.Thing.Widgets)
2 >Emitted(58, 31) Source(45, 25) + SourceIndex(0) name (Sample.Thing.Widgets)
3 >Emitted(58, 34) Source(45, 15) + SourceIndex(0) name (Sample.Thing.Widgets)
4 >Emitted(58, 44) Source(63, 3) + SourceIndex(0) name (Sample.Thing.Widgets)
5 >Emitted(58, 45) Source(63, 3) + SourceIndex(0) name (Sample.Thing.Widgets)
---
>>>        })(Widgets = Thing.Widgets || (Thing.Widgets = {}));
1->^^^^^^^^
2 >        ^
3 >         ^^
4 >           ^^^^^^^
5 >                  ^^^
6 >                     ^^^^^^^^^^^^^
7 >                                  ^^^^^
8 >                                       ^^^^^^^^^^^^^
9 >                                                    ^^^^^^^^
1->
  >
2 >        }
3 >         
4 >           Widgets
5 >                  
6 >                     Widgets
7 >                                  
8 >                                       Widgets
9 >                                                     {
  >                                                    	export class FindWidget implements Sample.Thing.IWidget {
  >                                                    
  >                                                    		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >                                                    			
  >                                                    		private domNode:any = null;
  >                                                    		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >                                                    		    // scenario 1
  >                                                    		    codeThing.addWidget("addWidget", this);
  >                                                    		}
  >                                                    		
  >                                                    		public getDomNode() {
  >                                                    			return domNode;
  >                                                    		}
  >                                                    		
  >                                                    		public destroy() {
  >                                                    
  >                                                    		}
  >                                                    
  >                                                    	}
  >                                                    }
1->Emitted(59, 9) Source(64, 1) + SourceIndex(0) name (Sample.Thing.Widgets)
2 >Emitted(59, 10) Source(64, 2) + SourceIndex(0) name (Sample.Thing.Widgets)
3 >Emitted(59, 12) Source(44, 21) + SourceIndex(0) name (Sample.Thing)
4 >Emitted(59, 19) Source(44, 28) + SourceIndex(0) name (Sample.Thing)
5 >Emitted(59, 22) Source(44, 21) + SourceIndex(0) name (Sample.Thing)
6 >Emitted(59, 35) Source(44, 28) + SourceIndex(0) name (Sample.Thing)
7 >Emitted(59, 40) Source(44, 21) + SourceIndex(0) name (Sample.Thing)
8 >Emitted(59, 53) Source(44, 28) + SourceIndex(0) name (Sample.Thing)
9 >Emitted(59, 61) Source(64, 2) + SourceIndex(0) name (Sample.Thing)
---
>>>    })(Thing = Sample.Thing || (Sample.Thing = {}));
1 >^^^^
2 >    ^
3 >     ^^
4 >       ^^^^^
5 >            ^^^
6 >               ^^^^^^^^^^^^
7 >                           ^^^^^
8 >                                ^^^^^^^^^^^^
9 >                                            ^^^^^^^^
1 >
2 >    }
3 >     
4 >       Thing
5 >            
6 >               Thing
7 >                           
8 >                                Thing
9 >                                            .Widgets {
  >                                            	export class FindWidget implements Sample.Thing.IWidget {
  >                                            
  >                                            		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >                                            			
  >                                            		private domNode:any = null;
  >                                            		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >                                            		    // scenario 1
  >                                            		    codeThing.addWidget("addWidget", this);
  >                                            		}
  >                                            		
  >                                            		public getDomNode() {
  >                                            			return domNode;
  >                                            		}
  >                                            		
  >                                            		public destroy() {
  >                                            
  >                                            		}
  >                                            
  >                                            	}
  >                                            }
1 >Emitted(60, 5) Source(64, 1) + SourceIndex(0) name (Sample.Thing)
2 >Emitted(60, 6) Source(64, 2) + SourceIndex(0) name (Sample.Thing)
3 >Emitted(60, 8) Source(44, 15) + SourceIndex(0) name (Sample)
4 >Emitted(60, 13) Source(44, 20) + SourceIndex(0) name (Sample)
5 >Emitted(60, 16) Source(44, 15) + SourceIndex(0) name (Sample)
6 >Emitted(60, 28) Source(44, 20) + SourceIndex(0) name (Sample)
7 >Emitted(60, 33) Source(44, 15) + SourceIndex(0) name (Sample)
8 >Emitted(60, 45) Source(44, 20) + SourceIndex(0) name (Sample)
9 >Emitted(60, 53) Source(64, 2) + SourceIndex(0) name (Sample)
---
>>>})(Sample || (Sample = {}));
1 >
2 >^
3 > ^^
4 >   ^^^^^^
5 >         ^^^^^
6 >              ^^^^^^
7 >                    ^^^^^^^^
8 >                            ^^^^^^->
1 >
2 >}
3 > 
4 >   Sample
5 >         
6 >              Sample
7 >                    .Thing.Widgets {
  >                    	export class FindWidget implements Sample.Thing.IWidget {
  >                    
  >                    		public gar(runner:(widget:Sample.Thing.IWidget)=>any) { if (true) {return runner(this);}}
  >                    			
  >                    		private domNode:any = null;
  >                    		constructor(private codeThing: Sample.Thing.ICodeThing) {
  >                    		    // scenario 1
  >                    		    codeThing.addWidget("addWidget", this);
  >                    		}
  >                    		
  >                    		public getDomNode() {
  >                    			return domNode;
  >                    		}
  >                    		
  >                    		public destroy() {
  >                    
  >                    		}
  >                    
  >                    	}
  >                    }
1 >Emitted(61, 1) Source(64, 1) + SourceIndex(0) name (Sample)
2 >Emitted(61, 2) Source(64, 2) + SourceIndex(0) name (Sample)
3 >Emitted(61, 4) Source(44, 8) + SourceIndex(0)
4 >Emitted(61, 10) Source(44, 14) + SourceIndex(0)
5 >Emitted(61, 15) Source(44, 8) + SourceIndex(0)
6 >Emitted(61, 21) Source(44, 14) + SourceIndex(0)
7 >Emitted(61, 29) Source(64, 2) + SourceIndex(0)
---
>>>var AbstractMode = (function () {
1->
2 >^^^^
3 >    ^^^^^^^^^^^^
4 >                ^^^^^^^^^^^^^^->
1->
  >
  >interface IMode { getInitialState(): IState;} 
  >
2 >class 
3 >    AbstractMode
1->Emitted(62, 1) Source(67, 1) + SourceIndex(0)
2 >Emitted(62, 5) Source(67, 7) + SourceIndex(0)
3 >Emitted(62, 17) Source(67, 19) + SourceIndex(0)
---
>>>    function AbstractMode() {
1->^^^^
2 >    ^^^^^^^^^
3 >             ^^^^^^^^^^^^
1->
2 >    class 
3 >             AbstractMode
1->Emitted(63, 5) Source(67, 1) + SourceIndex(0) name (AbstractMode)
2 >Emitted(63, 14) Source(67, 7) + SourceIndex(0) name (AbstractMode)
3 >Emitted(63, 26) Source(67, 19) + SourceIndex(0) name (AbstractMode)
---
>>>    }
1 >^^^^
2 >    ^
3 >     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 > implements IMode { public getInitialState(): IState { return null;} 
2 >    }
1 >Emitted(64, 5) Source(67, 88) + SourceIndex(0) name (AbstractMode.constructor)
2 >Emitted(64, 6) Source(67, 89) + SourceIndex(0) name (AbstractMode.constructor)
---
>>>    AbstractMode.prototype.getInitialState = function () {
1->^^^^
2 >    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                          ^^^
1->
2 >    getInitialState
3 >                                          
1->Emitted(65, 5) Source(67, 46) + SourceIndex(0) name (AbstractMode)
2 >Emitted(65, 43) Source(67, 61) + SourceIndex(0) name (AbstractMode)
3 >Emitted(65, 46) Source(67, 39) + SourceIndex(0) name (AbstractMode)
---
>>>        return null;
1 >^^^^^^^^
2 >        ^^^^^^
3 >              ^
4 >               ^^^^
5 >                   ^
1 >public getInitialState(): IState { 
2 >        return
3 >               
4 >               null
5 >                   ;
1 >Emitted(66, 9) Source(67, 74) + SourceIndex(0) name (AbstractMode.getInitialState)
2 >Emitted(66, 15) Source(67, 80) + SourceIndex(0) name (AbstractMode.getInitialState)
3 >Emitted(66, 16) Source(67, 81) + SourceIndex(0) name (AbstractMode.getInitialState)
4 >Emitted(66, 20) Source(67, 85) + SourceIndex(0) name (AbstractMode.getInitialState)
5 >Emitted(66, 21) Source(67, 86) + SourceIndex(0) name (AbstractMode.getInitialState)
---
>>>    };
1 >^^^^
2 >    ^
3 >     ^^^^^^^^^^^^^^^^^^^^->
1 >
2 >    }
1 >Emitted(67, 5) Source(67, 86) + SourceIndex(0) name (AbstractMode.getInitialState)
2 >Emitted(67, 6) Source(67, 87) + SourceIndex(0) name (AbstractMode.getInitialState)
---
>>>    return AbstractMode;
1->^^^^
2 >    ^^^^^^^^^^^^^^^^^^^
1-> 
2 >    }
1->Emitted(68, 5) Source(67, 88) + SourceIndex(0) name (AbstractMode)
2 >Emitted(68, 24) Source(67, 89) + SourceIndex(0) name (AbstractMode)
---
>>>})();
1 >
2 >^
3 > 
4 > ^^^^
5 >     ^^^^^^^->
1 >
2 >}
3 > 
4 > class AbstractMode implements IMode { public getInitialState(): IState { return null;} }
1 >Emitted(69, 1) Source(67, 88) + SourceIndex(0) name (AbstractMode)
2 >Emitted(69, 2) Source(67, 89) + SourceIndex(0) name (AbstractMode)
3 >Emitted(69, 2) Source(67, 1) + SourceIndex(0)
4 >Emitted(69, 6) Source(67, 89) + SourceIndex(0)
---
>>>var Sample;
1->
2 >^^^^
3 >    ^^^^^^
4 >          ^
5 >           ^^^^^^^^^^->
1->
  >
  >interface IState {}
  >
  >interface Window {
  >    opener: Window;
  >}
  >declare var self: Window;
  >
  >
2 >module 
3 >    Sample
4 >          .Thing.Languages.PlainText {
  >          	
  >          	export class State implements IState {		
  >                  constructor(private mode: IMode) { }
  >          		public clone():IState {
  >          			return this;
  >          		}
  >          
  >          		public equals(other:IState):boolean {
  >          			return this === other;
  >          		}
  >          		
  >          		public getMode(): IMode { return mode; }
  >          	}
  >          	
  >          	export class Mode extends AbstractMode {
  >          
  >          		// scenario 2
  >          		public getInitialState(): IState {
  >          			return new State(self);
  >          		}
  >          
  >          
  >          	}
  >          }
1->Emitted(70, 1) Source(76, 1) + SourceIndex(0)
2 >Emitted(70, 5) Source(76, 8) + SourceIndex(0)
3 >Emitted(70, 11) Source(76, 14) + SourceIndex(0)
4 >Emitted(70, 12) Source(100, 2) + SourceIndex(0)
---
>>>(function (Sample) {
1->
2 >^^^^^^^^^^^
3 >           ^^^^^^
1->
2 >module 
3 >           Sample
1->Emitted(71, 1) Source(76, 1) + SourceIndex(0)
2 >Emitted(71, 12) Source(76, 8) + SourceIndex(0)
3 >Emitted(71, 18) Source(76, 14) + SourceIndex(0)
---
>>>    var Thing;
1 >^^^^
2 >    ^^^^
3 >        ^^^^^
4 >             ^
5 >              ^^^^^^^^^^->
1 >.
2 >    
3 >        Thing
4 >             .Languages.PlainText {
  >             	
  >             	export class State implements IState {		
  >                     constructor(private mode: IMode) { }
  >             		public clone():IState {
  >             			return this;
  >             		}
  >             
  >             		public equals(other:IState):boolean {
  >             			return this === other;
  >             		}
  >             		
  >             		public getMode(): IMode { return mode; }
  >             	}
  >             	
  >             	export class Mode extends AbstractMode {
  >             
  >             		// scenario 2
  >             		public getInitialState(): IState {
  >             			return new State(self);
  >             		}
  >             
  >             
  >             	}
  >             }
1 >Emitted(72, 5) Source(76, 15) + SourceIndex(0) name (Sample)
2 >Emitted(72, 9) Source(76, 15) + SourceIndex(0) name (Sample)
3 >Emitted(72, 14) Source(76, 20) + SourceIndex(0) name (Sample)
4 >Emitted(72, 15) Source(100, 2) + SourceIndex(0) name (Sample)
---
>>>    (function (Thing) {
1->^^^^
2 >    ^^^^^^^^^^^
3 >               ^^^^^
4 >                    ^^^->
1->
2 >    
3 >               Thing
1->Emitted(73, 5) Source(76, 15) + SourceIndex(0) name (Sample)
2 >Emitted(73, 16) Source(76, 15) + SourceIndex(0) name (Sample)
3 >Emitted(73, 21) Source(76, 20) + SourceIndex(0) name (Sample)
---
>>>        var Languages;
1->^^^^^^^^
2 >        ^^^^
3 >            ^^^^^^^^^
4 >                     ^
5 >                      ^^^^^^^^^^->
1->.
2 >        
3 >            Languages
4 >                     .PlainText {
  >                     	
  >                     	export class State implements IState {		
  >                             constructor(private mode: IMode) { }
  >                     		public clone():IState {
  >                     			return this;
  >                     		}
  >                     
  >                     		public equals(other:IState):boolean {
  >                     			return this === other;
  >                     		}
  >                     		
  >                     		public getMode(): IMode { return mode; }
  >                     	}
  >                     	
  >                     	export class Mode extends AbstractMode {
  >                     
  >                     		// scenario 2
  >                     		public getInitialState(): IState {
  >                     			return new State(self);
  >                     		}
  >                     
  >                     
  >                     	}
  >                     }
1->Emitted(74, 9) Source(76, 21) + SourceIndex(0) name (Sample.Thing)
2 >Emitted(74, 13) Source(76, 21) + SourceIndex(0) name (Sample.Thing)
3 >Emitted(74, 22) Source(76, 30) + SourceIndex(0) name (Sample.Thing)
4 >Emitted(74, 23) Source(100, 2) + SourceIndex(0) name (Sample.Thing)
---
>>>        (function (Languages) {
1->^^^^^^^^
2 >        ^^^^^^^^^^^
3 >                   ^^^^^^^^^
1->
2 >        
3 >                   Languages
1->Emitted(75, 9) Source(76, 21) + SourceIndex(0) name (Sample.Thing)
2 >Emitted(75, 20) Source(76, 21) + SourceIndex(0) name (Sample.Thing)
3 >Emitted(75, 29) Source(76, 30) + SourceIndex(0) name (Sample.Thing)
---
>>>            var PlainText;
1 >^^^^^^^^^^^^
2 >            ^^^^
3 >                ^^^^^^^^^
4 >                         ^
5 >                          ^^^^^^^^^^->
1 >.
2 >            
3 >                PlainText
4 >                          {
  >                         	
  >                         	export class State implements IState {		
  >                                 constructor(private mode: IMode) { }
  >                         		public clone():IState {
  >                         			return this;
  >                         		}
  >                         
  >                         		public equals(other:IState):boolean {
  >                         			return this === other;
  >                         		}
  >                         		
  >                         		public getMode(): IMode { return mode; }
  >                         	}
  >                         	
  >                         	export class Mode extends AbstractMode {
  >                         
  >                         		// scenario 2
  >                         		public getInitialState(): IState {
  >                         			return new State(self);
  >                         		}
  >                         
  >                         
  >                         	}
  >                         }
1 >Emitted(76, 13) Source(76, 31) + SourceIndex(0) name (Sample.Thing.Languages)
2 >Emitted(76, 17) Source(76, 31) + SourceIndex(0) name (Sample.Thing.Languages)
3 >Emitted(76, 26) Source(76, 40) + SourceIndex(0) name (Sample.Thing.Languages)
4 >Emitted(76, 27) Source(100, 2) + SourceIndex(0) name (Sample.Thing.Languages)
---
>>>            (function (PlainText) {
1->^^^^^^^^^^^^
2 >            ^^^^^^^^^^^
3 >                       ^^^^^^^^^
4 >                                ^^
5 >                                  ^
6 >                                   ^^^^^^^^->
1->
2 >            
3 >                       PlainText
4 >                                 
5 >                                  {
1->Emitted(77, 13) Source(76, 31) + SourceIndex(0) name (Sample.Thing.Languages)
2 >Emitted(77, 24) Source(76, 31) + SourceIndex(0) name (Sample.Thing.Languages)
3 >Emitted(77, 33) Source(76, 40) + SourceIndex(0) name (Sample.Thing.Languages)
4 >Emitted(77, 35) Source(76, 41) + SourceIndex(0) name (Sample.Thing.Languages)
5 >Emitted(77, 36) Source(76, 42) + SourceIndex(0) name (Sample.Thing.Languages)
---
>>>                var State = (function () {
1->^^^^^^^^^^^^^^^^
2 >                ^^^^
3 >                    ^^^^^
4 >                         ^^^^^^^^^^^^^^^^^^->
1->
  >	
  >	
2 >                export class 
3 >                    State
1->Emitted(78, 17) Source(78, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
2 >Emitted(78, 21) Source(78, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
3 >Emitted(78, 26) Source(78, 20) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
---
>>>                    function State(mode) {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^
3 >                             ^^^^^
4 >                                  ^
5 >                                   ^^^^
6 >                                       ^^^->
1-> implements IState {		
  >        
2 >                    
3 >                             State
4 >                                   implements IState {		
  >                                          constructor(private 
5 >                                   mode: IMode
1->Emitted(79, 21) Source(79, 9) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
2 >Emitted(79, 30) Source(78, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
3 >Emitted(79, 35) Source(78, 20) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
4 >Emitted(79, 36) Source(79, 29) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
5 >Emitted(79, 40) Source(79, 40) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
---
>>>                        this.mode = mode;
1->^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^^^^
3 >                                 ^^^
4 >                                    ^^^^
5 >                                        ^
1->
2 >                        mode
3 >                                 
4 >                                    mode
5 >                                        : IMode
1->Emitted(80, 25) Source(79, 29) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.constructor)
2 >Emitted(80, 34) Source(79, 33) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.constructor)
3 >Emitted(80, 37) Source(79, 29) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.constructor)
4 >Emitted(80, 41) Source(79, 33) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.constructor)
5 >Emitted(80, 42) Source(79, 40) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.constructor)
---
>>>                    }
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >) { 
2 >                    }
1 >Emitted(81, 21) Source(79, 44) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.constructor)
2 >Emitted(81, 22) Source(79, 45) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.constructor)
---
>>>                    State.prototype.clone = function () {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^^^^^^^^
3 >                                         ^^^
1->
  >		public 
2 >                    clone
3 >                                         
1->Emitted(82, 21) Source(80, 10) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
2 >Emitted(82, 42) Source(80, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
3 >Emitted(82, 45) Source(80, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
---
>>>                        return this;
1 >^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^
3 >                              ^
4 >                               ^^^^
5 >                                   ^
1 >public clone():IState {
  >			
2 >                        return
3 >                               
4 >                               this
5 >                                   ;
1 >Emitted(83, 25) Source(81, 4) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.clone)
2 >Emitted(83, 31) Source(81, 10) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.clone)
3 >Emitted(83, 32) Source(81, 11) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.clone)
4 >Emitted(83, 36) Source(81, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.clone)
5 >Emitted(83, 37) Source(81, 16) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.clone)
---
>>>                    };
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >		
2 >                    }
1 >Emitted(84, 21) Source(82, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.clone)
2 >Emitted(84, 22) Source(82, 4) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.clone)
---
>>>                    State.prototype.equals = function (other) {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^^^^^^^^^
3 >                                          ^^^
4 >                                             ^^^^^^^^^^
5 >                                                       ^^^^^
1->
  >
  >		public 
2 >                    equals
3 >                                          
4 >                                             public equals(
5 >                                                       other:IState
1->Emitted(85, 21) Source(84, 10) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
2 >Emitted(85, 43) Source(84, 16) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
3 >Emitted(85, 46) Source(84, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
4 >Emitted(85, 56) Source(84, 17) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
5 >Emitted(85, 61) Source(84, 29) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
---
>>>                        return this === other;
1 >^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^
3 >                              ^
4 >                               ^^^^
5 >                                   ^^^^^
6 >                                        ^^^^^
7 >                                             ^
1 >):boolean {
  >			
2 >                        return
3 >                               
4 >                               this
5 >                                    === 
6 >                                        other
7 >                                             ;
1 >Emitted(86, 25) Source(85, 4) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
2 >Emitted(86, 31) Source(85, 10) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
3 >Emitted(86, 32) Source(85, 11) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
4 >Emitted(86, 36) Source(85, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
5 >Emitted(86, 41) Source(85, 20) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
6 >Emitted(86, 46) Source(85, 25) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
7 >Emitted(86, 47) Source(85, 26) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
---
>>>                    };
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >		
2 >                    }
1 >Emitted(87, 21) Source(86, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
2 >Emitted(87, 22) Source(86, 4) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.equals)
---
>>>                    State.prototype.getMode = function () {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^^^^^^^^^^
3 >                                           ^^^
1->
  >		
  >		public 
2 >                    getMode
3 >                                           
1->Emitted(88, 21) Source(88, 10) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
2 >Emitted(88, 44) Source(88, 17) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
3 >Emitted(88, 47) Source(88, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
---
>>>                        return mode;
1 >^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^
3 >                              ^
4 >                               ^^^^
5 >                                   ^
1 >public getMode(): IMode { 
2 >                        return
3 >                               
4 >                               mode
5 >                                   ;
1 >Emitted(89, 25) Source(88, 29) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.getMode)
2 >Emitted(89, 31) Source(88, 35) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.getMode)
3 >Emitted(89, 32) Source(88, 36) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.getMode)
4 >Emitted(89, 36) Source(88, 40) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.getMode)
5 >Emitted(89, 37) Source(88, 41) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.getMode)
---
>>>                    };
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^->
1 > 
2 >                    }
1 >Emitted(90, 21) Source(88, 42) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.getMode)
2 >Emitted(90, 22) Source(88, 43) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State.getMode)
---
>>>                    return State;
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^
1->
  >	
2 >                    }
1->Emitted(91, 21) Source(89, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
2 >Emitted(91, 33) Source(89, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
---
>>>                })();
1 >^^^^^^^^^^^^^^^^
2 >                ^
3 >                 
4 >                 ^^^^
5 >                     ^^^^^^^^^^^^^^^^^^^^->
1 >
2 >                }
3 >                 
4 >                 export class State implements IState {		
  >                         constructor(private mode: IMode) { }
  >                 		public clone():IState {
  >                 			return this;
  >                 		}
  >                 
  >                 		public equals(other:IState):boolean {
  >                 			return this === other;
  >                 		}
  >                 		
  >                 		public getMode(): IMode { return mode; }
  >                 	}
1 >Emitted(92, 17) Source(89, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
2 >Emitted(92, 18) Source(89, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.State)
3 >Emitted(92, 18) Source(78, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
4 >Emitted(92, 22) Source(89, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
---
>>>                PlainText.State = State;
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^^^^^^^
3 >                               ^^^
4 >                                  ^^^^^
5 >                                       ^
6 >                                        ^^^^^^^^->
1->
2 >                State
3 >                               
4 >                                  State implements IState {		
  >                                          constructor(private mode: IMode) { }
  >                                  		public clone():IState {
  >                                  			return this;
  >                                  		}
  >                                  
  >                                  		public equals(other:IState):boolean {
  >                                  			return this === other;
  >                                  		}
  >                                  		
  >                                  		public getMode(): IMode { return mode; }
  >                                  	}
5 >                                       
1->Emitted(93, 17) Source(78, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
2 >Emitted(93, 32) Source(78, 20) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
3 >Emitted(93, 35) Source(78, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
4 >Emitted(93, 40) Source(89, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
5 >Emitted(93, 41) Source(89, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
---
>>>                var Mode = (function (_super) {
1->^^^^^^^^^^^^^^^^
2 >                ^^^^
3 >                    ^^^^
4 >                        ^^^^^^^^^^^^^^^^^^^^^->
1->
  >	
  >	
2 >                export class 
3 >                    Mode
1->Emitted(94, 17) Source(91, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
2 >Emitted(94, 21) Source(91, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
3 >Emitted(94, 25) Source(91, 19) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
---
>>>                    __extends(Mode, _super);
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^
3 >                              ^^^^
4 >                                  ^^^^^^^^^^
1-> extends 
2 >                    
3 >                              Mode
4 >                                   extends AbstractMode
1->Emitted(95, 21) Source(91, 28) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
2 >Emitted(95, 31) Source(91, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
3 >Emitted(95, 35) Source(91, 19) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
4 >Emitted(95, 45) Source(91, 40) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
---
>>>                    function Mode() {
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^
3 >                             ^^^^
4 >                                 ^^^^^^^^^^^^^^^^^^^^^^->
1 >
2 >                    export class 
3 >                             Mode
1 >Emitted(96, 21) Source(91, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
2 >Emitted(96, 30) Source(91, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
3 >Emitted(96, 34) Source(91, 19) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
---
>>>                        _super.apply(this, arguments);
1->^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1-> extends 
2 >                        AbstractMode
1->Emitted(97, 25) Source(91, 28) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.constructor)
2 >Emitted(97, 55) Source(91, 40) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.constructor)
---
>>>                    }
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^^->
1 > {
  >
  >		// scenario 2
  >		public getInitialState(): IState {
  >			return new State(self);
  >		}
  >
  >
  >	
2 >                    }
1 >Emitted(98, 21) Source(99, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.constructor)
2 >Emitted(98, 22) Source(99, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.constructor)
---
>>>                    // scenario 2
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^
3 >                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
2 >                    // scenario 2
1->Emitted(99, 21) Source(93, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
2 >Emitted(99, 34) Source(93, 16) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
---
>>>                    Mode.prototype.getInitialState = function () {
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3 >                                                  ^^^
1->
  >		public 
2 >                    getInitialState
3 >                                                  
1->Emitted(100, 21) Source(94, 10) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
2 >Emitted(100, 51) Source(94, 25) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
3 >Emitted(100, 54) Source(94, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
---
>>>                        return new State(self);
1 >^^^^^^^^^^^^^^^^^^^^^^^^
2 >                        ^^^^^^
3 >                              ^
4 >                               ^^^^
5 >                                   ^^^^^
6 >                                        ^
7 >                                         ^^^^
8 >                                             ^
9 >                                              ^
1 >public getInitialState(): IState {
  >			
2 >                        return
3 >                               
4 >                               new 
5 >                                   State
6 >                                        (
7 >                                         self
8 >                                             )
9 >                                              ;
1 >Emitted(101, 25) Source(95, 4) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
2 >Emitted(101, 31) Source(95, 10) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
3 >Emitted(101, 32) Source(95, 11) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
4 >Emitted(101, 36) Source(95, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
5 >Emitted(101, 41) Source(95, 20) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
6 >Emitted(101, 42) Source(95, 21) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
7 >Emitted(101, 46) Source(95, 25) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
8 >Emitted(101, 47) Source(95, 26) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
9 >Emitted(101, 48) Source(95, 27) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
---
>>>                    };
1 >^^^^^^^^^^^^^^^^^^^^
2 >                    ^
3 >                     ^^^^^^^^^^^^->
1 >
  >		
2 >                    }
1 >Emitted(102, 21) Source(96, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
2 >Emitted(102, 22) Source(96, 4) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode.getInitialState)
---
>>>                    return Mode;
1->^^^^^^^^^^^^^^^^^^^^
2 >                    ^^^^^^^^^^^
3 >                               ^^^->
1->
  >
  >
  >	
2 >                    }
1->Emitted(103, 21) Source(99, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
2 >Emitted(103, 32) Source(99, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
---
>>>                })(AbstractMode);
1->^^^^^^^^^^^^^^^^
2 >                ^
3 >                 
4 >                 ^^
5 >                   ^^^^^^^^^^^^
6 >                               ^^
7 >                                 ^^^^^^->
1->
2 >                }
3 >                 
4 >                 export class Mode extends 
5 >                   AbstractMode
6 >                                {
  >                               
  >                               		// scenario 2
  >                               		public getInitialState(): IState {
  >                               			return new State(self);
  >                               		}
  >                               
  >                               
  >                               	}
1->Emitted(104, 17) Source(99, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
2 >Emitted(104, 18) Source(99, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText.Mode)
3 >Emitted(104, 18) Source(91, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
4 >Emitted(104, 20) Source(91, 28) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
5 >Emitted(104, 32) Source(91, 40) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
6 >Emitted(104, 34) Source(99, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
---
>>>                PlainText.Mode = Mode;
1->^^^^^^^^^^^^^^^^
2 >                ^^^^^^^^^^^^^^
3 >                              ^^^
4 >                                 ^^^^
5 >                                     ^
6 >                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
2 >                Mode
3 >                              
4 >                                 Mode extends AbstractMode {
  >                                 
  >                                 		// scenario 2
  >                                 		public getInitialState(): IState {
  >                                 			return new State(self);
  >                                 		}
  >                                 
  >                                 
  >                                 	}
5 >                                     
1->Emitted(105, 17) Source(91, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
2 >Emitted(105, 31) Source(91, 19) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
3 >Emitted(105, 34) Source(91, 15) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
4 >Emitted(105, 38) Source(99, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
5 >Emitted(105, 39) Source(99, 3) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
---
>>>            })(PlainText = Languages.PlainText || (Languages.PlainText = {}));
1->^^^^^^^^^^^^
2 >            ^
3 >             ^^
4 >               ^^^^^^^^^
5 >                        ^^^
6 >                           ^^^^^^^^^^^^^^^^^^^
7 >                                              ^^^^^
8 >                                                   ^^^^^^^^^^^^^^^^^^^
9 >                                                                      ^^^^^^^^
1->
  >
2 >            }
3 >             
4 >               PlainText
5 >                        
6 >                           PlainText
7 >                                              
8 >                                                   PlainText
9 >                                                                       {
  >                                                                      	
  >                                                                      	export class State implements IState {		
  >                                                                              constructor(private mode: IMode) { }
  >                                                                      		public clone():IState {
  >                                                                      			return this;
  >                                                                      		}
  >                                                                      
  >                                                                      		public equals(other:IState):boolean {
  >                                                                      			return this === other;
  >                                                                      		}
  >                                                                      		
  >                                                                      		public getMode(): IMode { return mode; }
  >                                                                      	}
  >                                                                      	
  >                                                                      	export class Mode extends AbstractMode {
  >                                                                      
  >                                                                      		// scenario 2
  >                                                                      		public getInitialState(): IState {
  >                                                                      			return new State(self);
  >                                                                      		}
  >                                                                      
  >                                                                      
  >                                                                      	}
  >                                                                      }
1->Emitted(106, 13) Source(100, 1) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
2 >Emitted(106, 14) Source(100, 2) + SourceIndex(0) name (Sample.Thing.Languages.PlainText)
3 >Emitted(106, 16) Source(76, 31) + SourceIndex(0) name (Sample.Thing.Languages)
4 >Emitted(106, 25) Source(76, 40) + SourceIndex(0) name (Sample.Thing.Languages)
5 >Emitted(106, 28) Source(76, 31) + SourceIndex(0) name (Sample.Thing.Languages)
6 >Emitted(106, 47) Source(76, 40) + SourceIndex(0) name (Sample.Thing.Languages)
7 >Emitted(106, 52) Source(76, 31) + SourceIndex(0) name (Sample.Thing.Languages)
8 >Emitted(106, 71) Source(76, 40) + SourceIndex(0) name (Sample.Thing.Languages)
9 >Emitted(106, 79) Source(100, 2) + SourceIndex(0) name (Sample.Thing.Languages)
---
>>>        })(Languages = Thing.Languages || (Thing.Languages = {}));
1 >^^^^^^^^
2 >        ^
3 >         ^^
4 >           ^^^^^^^^^
5 >                    ^^^
6 >                       ^^^^^^^^^^^^^^^
7 >                                      ^^^^^
8 >                                           ^^^^^^^^^^^^^^^
9 >                                                          ^^^^^^^^
1 >
2 >        }
3 >         
4 >           Languages
5 >                    
6 >                       Languages
7 >                                      
8 >                                           Languages
9 >                                                          .PlainText {
  >                                                          	
  >                                                          	export class State implements IState {		
  >                                                                  constructor(private mode: IMode) { }
  >                                                          		public clone():IState {
  >                                                          			return this;
  >                                                          		}
  >                                                          
  >                                                          		public equals(other:IState):boolean {
  >                                                          			return this === other;
  >                                                          		}
  >                                                          		
  >                                                          		public getMode(): IMode { return mode; }
  >                                                          	}
  >                                                          	
  >                                                          	export class Mode extends AbstractMode {
  >                                                          
  >                                                          		// scenario 2
  >                                                          		public getInitialState(): IState {
  >                                                          			return new State(self);
  >                                                          		}
  >                                                          
  >                                                          
  >                                                          	}
  >                                                          }
1 >Emitted(107, 9) Source(100, 1) + SourceIndex(0) name (Sample.Thing.Languages)
2 >Emitted(107, 10) Source(100, 2) + SourceIndex(0) name (Sample.Thing.Languages)
3 >Emitted(107, 12) Source(76, 21) + SourceIndex(0) name (Sample.Thing)
4 >Emitted(107, 21) Source(76, 30) + SourceIndex(0) name (Sample.Thing)
5 >Emitted(107, 24) Source(76, 21) + SourceIndex(0) name (Sample.Thing)
6 >Emitted(107, 39) Source(76, 30) + SourceIndex(0) name (Sample.Thing)
7 >Emitted(107, 44) Source(76, 21) + SourceIndex(0) name (Sample.Thing)
8 >Emitted(107, 59) Source(76, 30) + SourceIndex(0) name (Sample.Thing)
9 >Emitted(107, 67) Source(100, 2) + SourceIndex(0) name (Sample.Thing)
---
>>>    })(Thing = Sample.Thing || (Sample.Thing = {}));
1 >^^^^
2 >    ^
3 >     ^^
4 >       ^^^^^
5 >            ^^^
6 >               ^^^^^^^^^^^^
7 >                           ^^^^^
8 >                                ^^^^^^^^^^^^
9 >                                            ^^^^^^^^
1 >
2 >    }
3 >     
4 >       Thing
5 >            
6 >               Thing
7 >                           
8 >                                Thing
9 >                                            .Languages.PlainText {
  >                                            	
  >                                            	export class State implements IState {		
  >                                                    constructor(private mode: IMode) { }
  >                                            		public clone():IState {
  >                                            			return this;
  >                                            		}
  >                                            
  >                                            		public equals(other:IState):boolean {
  >                                            			return this === other;
  >                                            		}
  >                                            		
  >                                            		public getMode(): IMode { return mode; }
  >                                            	}
  >                                            	
  >                                            	export class Mode extends AbstractMode {
  >                                            
  >                                            		// scenario 2
  >                                            		public getInitialState(): IState {
  >                                            			return new State(self);
  >                                            		}
  >                                            
  >                                            
  >                                            	}
  >                                            }
1 >Emitted(108, 5) Source(100, 1) + SourceIndex(0) name (Sample.Thing)
2 >Emitted(108, 6) Source(100, 2) + SourceIndex(0) name (Sample.Thing)
3 >Emitted(108, 8) Source(76, 15) + SourceIndex(0) name (Sample)
4 >Emitted(108, 13) Source(76, 20) + SourceIndex(0) name (Sample)
5 >Emitted(108, 16) Source(76, 15) + SourceIndex(0) name (Sample)
6 >Emitted(108, 28) Source(76, 20) + SourceIndex(0) name (Sample)
7 >Emitted(108, 33) Source(76, 15) + SourceIndex(0) name (Sample)
8 >Emitted(108, 45) Source(76, 20) + SourceIndex(0) name (Sample)
9 >Emitted(108, 53) Source(100, 2) + SourceIndex(0) name (Sample)
---
>>>})(Sample || (Sample = {}));
1 >
2 >^
3 > ^^
4 >   ^^^^^^
5 >         ^^^^^
6 >              ^^^^^^
7 >                    ^^^^^^^^
8 >                            ^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
2 >}
3 > 
4 >   Sample
5 >         
6 >              Sample
7 >                    .Thing.Languages.PlainText {
  >                    	
  >                    	export class State implements IState {		
  >                            constructor(private mode: IMode) { }
  >                    		public clone():IState {
  >                    			return this;
  >                    		}
  >                    
  >                    		public equals(other:IState):boolean {
  >                    			return this === other;
  >                    		}
  >                    		
  >                    		public getMode(): IMode { return mode; }
  >                    	}
  >                    	
  >                    	export class Mode extends AbstractMode {
  >                    
  >                    		// scenario 2
  >                    		public getInitialState(): IState {
  >                    			return new State(self);
  >                    		}
  >                    
  >                    
  >                    	}
  >                    }
1 >Emitted(109, 1) Source(100, 1) + SourceIndex(0) name (Sample)
2 >Emitted(109, 2) Source(100, 2) + SourceIndex(0) name (Sample)
3 >Emitted(109, 4) Source(76, 8) + SourceIndex(0)
4 >Emitted(109, 10) Source(76, 14) + SourceIndex(0)
5 >Emitted(109, 15) Source(76, 8) + SourceIndex(0)
6 >Emitted(109, 21) Source(76, 14) + SourceIndex(0)
7 >Emitted(109, 29) Source(100, 2) + SourceIndex(0)
---
>>>//# sourceMappingURL=recursiveClassReferenceTest.js.map